在Axum中使用带断言的闭包测试数据库层的问题

核心问题拆解 #

你遇到的两个问题本质是Rust闭包的类型特性导致的：

• 捕获外部变量的闭包是匿名具体类型，不同捕获逻辑的闭包类型不同，直接使用会触发类型不匹配
• dyn Fn是动态大小类型（DST），而Axum的with_state要求状态实现Clone（因为状态可能被多个请求共享），DST无法满足Clone的Sized约束

可行解决方案 #

方案一：用Arc包裹闭包，规避DST问题 #

把闭包放在Arc<dyn Fn(...) -> () + Send + Sync + 'static>中，借助Arc的可克隆特性，让FakeDb能正常实现Clone，同时动态闭包的逻辑也能保留。

示例代码：

use std::sync::Arc;
use axum::extract::State;
use chrono::{DateTime, Utc};

// 定义Database trait
trait Database {
    fn create_user(&self, name: &str, created_at: DateTime<Utc>) -> Result<(), String>;
}

// 改进后的FakeDb
#[derive(Clone)]
struct FakeDb {
    create_user_check: Arc<dyn Fn(&str, DateTime<Utc>) -> () + Send + Sync + 'static>,
}

impl Database for FakeDb {
    fn create_user(&self, name: &str, created_at: DateTime<Utc>) -> Result<(), String> {
        // 执行校验闭包
        (self.create_user_check)(name, created_at);
        Ok(())
    }
}

// 测试用例
#[tokio::test]
async fn test_create_user_with_current_time() {
    let expected_time = Utc::now();
    let fake_db = FakeDb {
        create_user_check: Arc::new(move |name, created_at| {
            assert_eq!(name, "alice");
            // 允许毫秒级误差，避免时间精度问题
            assert!(created_at.signed_duration_since(expected_time).num_milliseconds().abs() < 100);
        }),
    };

    let app = axum::Router::new()
        .route("/users", axum::routing::post(create_user_handler))
        .with_state(fake_db);

    // 发送请求验证
    let client = axum::test::TestClient::new(app);
    let response = client.post("/users")
        .json(&serde_json::json!({"name": "alice"}))
        .send()
        .await;
    assert!(response.is_ok());
}

// 处理器示例
async fn create_user_handler(
    State(db): State<FakeDb>,
    axum::Json(payload): axum::Json<serde_json::Value>,
) -> axum::http::StatusCode {
    let name = payload["name"].as_str().unwrap();
    let now = Utc::now();
    db.create_user(name, now).unwrap();
    axum::http::StatusCode::CREATED
}

方案二：用枚举封装校验逻辑，放弃动态闭包 #

如果测试场景有限，可以用枚举定义所有需要的校验规则，把捕获的变量存在枚举变体里。这样FakeDb是具体类型，天然支持Clone，也不会有类型不匹配问题。

示例代码：

use chrono::{DateTime, Utc};

trait Database {
    fn create_user(&self, name: &str, created_at: DateTime<Utc>) -> Result<(), String>;
}

#[derive(Clone)]
enum CreateUserCheck {
    ExactTime { name: String, expected_time: DateTime<Utc> },
    NameOnly(String),
}

#[derive(Clone)]
struct FakeDb {
    create_user_check: CreateUserCheck,
}

impl Database for FakeDb {
    fn create_user(&self, name: &str, created_at: DateTime<Utc>) -> Result<(), String> {
        match &self.create_user_check {
            CreateUserCheck::ExactTime { name: expected_name, expected_time } => {
                assert_eq!(name, expected_name);
                assert!(created_at.signed_duration_since(*expected_time).num_milliseconds().abs() < 100);
            }
            CreateUserCheck::NameOnly(expected_name) => {
                assert_eq!(name, expected_name);
            }
        }
        Ok(())
    }
}

// 测试用例
#[tokio::test]
async fn test_create_user_exact_time() {
    let expected_time = Utc::now();
    let fake_db = FakeDb {
        create_user_check: CreateUserCheck::ExactTime {
            name: "alice".to_string(),
            expected_time,
        },
    };

    // 构建app和发送请求逻辑同方案一
}

更优测试思路建议 #

• 优先用真实数据库做集成测试：可以借助testcontainers启动临时Postgres实例，测试完成后销毁，这样能覆盖真实的SQL交互逻辑，避免模拟逻辑与生产环境不一致
• 模拟数据库仅用于单元测试：针对数据库层的具体函数写单元测试时，用Mockall这类框架自动生成Mock对象，集成测试尽量贴近生产依赖，减少维护成本

内容的提问来源于stack exchange，提问作者beta