use super::{v_i64, v_str, DbnexusUserRepository};
use crate::dao::dao_session;
use crate::dao::repository::{
make_statement, validate_imported_hash, NewUser, UpdateUser, UserListRow, UserRepository,
UserRow,
};
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use dbnexus::sea_orm::{ConnectionTrait, QueryResult};
use dbnexus::DbPool;
impl DbnexusUserRepository {
pub fn new(pool: DbPool) -> Self {
Self { pool }
}
}
#[async_trait]
impl UserRepository for DbnexusUserRepository {
async fn find_by_id(&self, tenant_id: i64, id: &str) -> GarrisonResult<Option<UserRow>> {
dao_session!(self.pool, "dao-app-user-find-by-id", session, conn);
let sql = "SELECT id, username, password_hash, status, tenant_id, created_at, updated_at, last_login_at \
FROM app_user WHERE tenant_id = ? AND id = ?";
let stmt = make_statement(conn, sql, vec![v_i64(tenant_id), v_str(id)]);
let row = conn
.query_one_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-find-by-id-query::{}", e)))?;
row.map(|r| parse_user_row(&r)).transpose()
}
async fn find_by_username(
&self,
tenant_id: i64,
username: &str,
) -> GarrisonResult<Option<UserRow>> {
dao_session!(self.pool, "dao-app-user-find-by-username", session, conn);
let sql = "SELECT id, username, password_hash, status, tenant_id, created_at, updated_at, last_login_at \
FROM app_user WHERE tenant_id = ? AND username = ?";
let stmt = make_statement(conn, sql, vec![v_i64(tenant_id), v_str(username)]);
let row = conn.query_one_raw(stmt).await.map_err(|e| {
GarrisonError::Dao(format!("dao-app-user-find-by-username-query::{}", e))
})?;
row.map(|r| parse_user_row(&r)).transpose()
}
async fn create(&self, tenant_id: i64, user: NewUser) -> GarrisonResult<String> {
validate_imported_hash(&user.password_hash).map_err(|e| {
GarrisonError::InvalidParam(format!("dao-app-user-create-hash-gate::{}", e))
})?;
let id = uuid::Uuid::new_v4().to_string();
dao_session!(self.pool, "dao-app-user-create", session, conn);
let sql = "INSERT INTO app_user (id, username, password_hash, status, tenant_id) \
VALUES (?, ?, ?, ?, ?)";
let stmt = make_statement(
conn,
sql,
vec![
v_str(&id),
v_str(&user.username),
v_str(&user.password_hash),
v_str(&user.status),
v_i64(tenant_id),
],
);
conn.execute_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-create-insert::{}", e)))?;
Ok(id)
}
async fn update(&self, tenant_id: i64, id: &str, user: UpdateUser) -> GarrisonResult<()> {
if let Some(password_hash) = &user.password_hash {
validate_imported_hash(password_hash).map_err(|e| {
GarrisonError::InvalidParam(format!("dao-app-user-update-hash-gate::{}", e))
})?;
}
let mut sets = Vec::new();
let mut params = Vec::new();
if let Some(username) = user.username {
sets.push("username = ?");
params.push(v_str(&username));
}
if let Some(password_hash) = user.password_hash {
sets.push("password_hash = ?");
params.push(v_str(&password_hash));
}
if let Some(status) = user.status {
sets.push("status = ?");
params.push(v_str(&status));
}
if let Some(last_login_at) = user.last_login_at {
sets.push("last_login_at = ?");
params.push(v_str(&last_login_at));
}
if sets.is_empty() {
return Ok(());
}
params.push(v_i64(tenant_id));
params.push(v_str(id));
let sql = format!(
"UPDATE app_user SET {} WHERE tenant_id = ? AND id = ?",
sets.join(", ")
);
dao_session!(self.pool, "dao-app-user-update", session, conn);
let stmt = make_statement(conn, &sql, params);
conn.execute_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-update-update::{}", e)))?;
Ok(())
}
async fn delete(&self, tenant_id: i64, id: &str) -> GarrisonResult<()> {
dao_session!(self.pool, "dao-app-user-delete", session, conn);
let sql = "DELETE FROM app_user WHERE tenant_id = ? AND id = ?";
let stmt = make_statement(conn, sql, vec![v_i64(tenant_id), v_str(id)]);
conn.execute_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-delete-delete::{}", e)))?;
Ok(())
}
async fn list(
&self,
tenant_id: i64,
offset: i64,
limit: i64,
) -> GarrisonResult<Vec<UserListRow>> {
dao_session!(self.pool, "dao-app-user-list", session, conn);
let sql = "SELECT id, username, status, tenant_id, created_at, updated_at, last_login_at \
FROM app_user WHERE tenant_id = ? ORDER BY id LIMIT ? OFFSET ?";
let stmt = make_statement(
conn,
sql,
vec![v_i64(tenant_id), v_i64(limit), v_i64(offset)],
);
let rows = conn
.query_all_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-list-query::{}", e)))?;
rows.iter().map(parse_user_list_row).collect()
}
}
fn parse_user_list_row(row: &QueryResult) -> GarrisonResult<UserListRow> {
Ok(UserListRow {
id: row
.try_get("", "id")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-id::{}", e)))?,
username: row
.try_get("", "username")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-username::{}", e)))?,
status: row
.try_get("", "status")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-status::{}", e)))?,
tenant_id: row
.try_get("", "tenant_id")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-tenant-id::{}", e)))?,
created_at: row
.try_get("", "created_at")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-created-at::{}", e)))?,
updated_at: row
.try_get("", "updated_at")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-updated-at::{}", e)))?,
last_login_at: row.try_get("", "last_login_at").map_err(|e| {
GarrisonError::Dao(format!("dao-app-user-row-parse-last-login-at::{}", e))
})?,
})
}
fn parse_user_row(row: &QueryResult) -> GarrisonResult<UserRow> {
Ok(UserRow {
id: row
.try_get("", "id")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-id::{}", e)))?,
username: row
.try_get("", "username")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-username::{}", e)))?,
password_hash: row.try_get("", "password_hash").map_err(|e| {
GarrisonError::Dao(format!("dao-app-user-row-parse-password-hash::{}", e))
})?,
status: row
.try_get("", "status")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-status::{}", e)))?,
tenant_id: row
.try_get("", "tenant_id")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-tenant-id::{}", e)))?,
created_at: row
.try_get("", "created_at")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-created-at::{}", e)))?,
updated_at: row
.try_get("", "updated_at")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-row-parse-updated-at::{}", e)))?,
last_login_at: row.try_get("", "last_login_at").map_err(|e| {
GarrisonError::Dao(format!("dao-app-user-row-parse-last-login-at::{}", e))
})?,
})
}
#[cfg(all(test, feature = "db-sqlite"))]
mod tests {
use super::*;
use crate::dao::repository::sqlite::test_support::setup_db;
#[tokio::test(flavor = "multi_thread")]
async fn create_and_find_by_id_roundtrip() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
let id = repo
.create(
1,
NewUser {
username: "alice".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$hash".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
let row = repo
.find_by_id(1, &id)
.await
.expect("find_by_id 应成功")
.expect("用户应存在");
assert_eq!(row.id, id);
assert_eq!(row.username, "alice");
assert_eq!(row.password_hash, "$argon2id$m=8,t=1,p=1$hash");
assert_eq!(row.status, "active");
assert_eq!(row.tenant_id, 1);
assert!(
row.last_login_at.is_none(),
"新用户 last_login_at 应为 None"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn find_by_id_returns_none_for_nonexistent() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
let result = repo
.find_by_id(1, "nonexistent-uuid")
.await
.expect("find_by_id 应成功");
assert!(result.is_none(), "不存在的 ID 应返回 None");
}
#[tokio::test(flavor = "multi_thread")]
async fn create_rejects_out_of_range_imported_hash() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
let over = "$argon2id$v=19$m=2097152,t=2,p=1$c2FsdDEyMzQ1Njc4$MDEyMzQ1Njc4OWFiY2RlZg";
let result = repo
.create(
1,
NewUser {
username: "mallory".to_string(),
password_hash: over.to_string(),
status: "active".to_string(),
},
)
.await;
match result {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("dao-app-user-create")
&& msg.contains(&crate::i18n::translate_detail(
"import-hash-argon2-m-cost",
&[("arg0", "2097152"), ("arg1", "1048576")],
)),
"错误应含入口与越界阶段标识,实际: {}",
msg
);
},
other => panic!(
"越界导入哈希应被 InvalidParam 拒绝,实际: {:?}",
other.map(|_| ())
),
}
let leftover = repo
.find_by_username(1, "mallory")
.await
.expect("查询应成功");
assert!(leftover.is_none(), "整体被拒后不得留下半成品行");
}
#[tokio::test(flavor = "multi_thread")]
async fn create_accepts_boundary_imported_hash() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
let at_limit = "$argon2id$v=19$m=1048576,t=10,p=4$c2FsdDEyMzQ1Njc4$MDEyMzQ1Njc4OWFiY2RlZg";
let id = repo
.create(
1,
NewUser {
username: "migrated".to_string(),
password_hash: at_limit.to_string(),
status: "active".to_string(),
},
)
.await
.expect("边界值导入应放行");
let row = repo
.find_by_id(1, &id)
.await
.expect("查询应成功")
.expect("用户应存在");
assert_eq!(row.password_hash, at_limit, "导入哈希应原样落库");
}
#[tokio::test(flavor = "multi_thread")]
async fn update_rejects_out_of_range_imported_hash() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
let existing = "$argon2id$v=19$m=19456,t=2,p=1$c2FsdDEyMzQ1Njc4$MDEyMzQ1Njc4OWFiY2RlZg";
let id = repo
.create(
1,
NewUser {
username: "carol".to_string(),
password_hash: existing.to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
let over = "$argon2id$v=19$m=2097152,t=2,p=1$c2FsdDEyMzQ1Njc4$MDEyMzQ1Njc4OWFiY2RlZg";
let result = repo
.update(
1,
&id,
UpdateUser {
password_hash: Some(over.to_string()),
..UpdateUser::default()
},
)
.await;
match result {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("dao-app-user-update")
&& msg.contains(&crate::i18n::translate_detail(
"import-hash-argon2-m-cost",
&[("arg0", "2097152"), ("arg1", "1048576")],
)),
"错误应含入口与越界阶段标识,实际: {}",
msg
);
},
other => panic!(
"越界导入哈希应被 InvalidParam 拒绝,实际: {:?}",
other.map(|_| ())
),
}
let row = repo
.find_by_id(1, &id)
.await
.expect("查询应成功")
.expect("用户应存在");
assert_eq!(row.password_hash, existing, "被拒更新不得改动存量哈希");
}
#[tokio::test(flavor = "multi_thread")]
async fn find_by_username_returns_user() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
repo.create(
1,
NewUser {
username: "bob".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
let row = repo
.find_by_username(1, "bob")
.await
.expect("find_by_username 应成功")
.expect("用户应存在");
assert_eq!(row.username, "bob");
}
#[tokio::test(flavor = "multi_thread")]
async fn find_by_username_returns_none_for_nonexistent() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
let result = repo
.find_by_username(1, "nonexistent-user")
.await
.expect("find_by_username 应成功");
assert!(result.is_none(), "不存在的用户名应返回 None");
}
#[tokio::test(flavor = "multi_thread")]
async fn update_changes_fields_and_noop_when_all_none() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
let id = repo
.create(
1,
NewUser {
username: "old-name".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$old".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
repo.update(1, &id, UpdateUser::default())
.await
.expect("全 None update 应为 no-op");
repo.update(
1,
&id,
UpdateUser {
username: Some("new-name".to_string()),
password_hash: Some("$argon2id$m=8,t=1,p=1$new".to_string()),
status: Some("suspended".to_string()),
last_login_at: Some("2026-07-14T00:00:00Z".to_string()),
},
)
.await
.expect("update 应成功");
let row = repo
.find_by_id(1, &id)
.await
.expect("find_by_id 应成功")
.expect("用户应存在");
assert_eq!(row.username, "new-name");
assert_eq!(row.password_hash, "$argon2id$m=8,t=1,p=1$new");
assert_eq!(row.status, "suspended");
assert_eq!(row.last_login_at.as_deref(), Some("2026-07-14T00:00:00Z"));
}
#[tokio::test(flavor = "multi_thread")]
async fn update_partial_only_status() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
let id = repo
.create(
1,
NewUser {
username: "partial-user".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
repo.update(
1,
&id,
UpdateUser {
status: Some("inactive".to_string()),
..Default::default()
},
)
.await
.expect("update 应成功");
let row = repo
.find_by_id(1, &id)
.await
.expect("find_by_id 应成功")
.expect("用户应存在");
assert_eq!(row.status, "inactive");
assert_eq!(row.username, "partial-user", "username 不应变");
assert_eq!(
row.password_hash, "$argon2id$m=8,t=1,p=1$x",
"password_hash 不应变"
);
}
#[tokio::test(flavor = "multi_thread")]
async fn update_partial_only_last_login_at() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
let id = repo
.create(
1,
NewUser {
username: "login-user".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
repo.update(
1,
&id,
UpdateUser {
last_login_at: Some("2026-07-14T12:00:00Z".to_string()),
..Default::default()
},
)
.await
.expect("update 应成功");
let row = repo
.find_by_id(1, &id)
.await
.expect("find_by_id 应成功")
.expect("用户应存在");
assert_eq!(row.last_login_at.as_deref(), Some("2026-07-14T12:00:00Z"));
}
#[tokio::test(flavor = "multi_thread")]
async fn delete_is_idempotent() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
let id = repo
.create(
1,
NewUser {
username: "temp-user".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
repo.delete(1, &id).await.expect("首次 delete 应成功");
let after = repo.find_by_id(1, &id).await.expect("find_by_id 应成功");
assert!(after.is_none(), "删除后应查不到");
repo.delete(1, &id).await.expect("幂等 delete 应成功");
}
#[tokio::test(flavor = "multi_thread")]
async fn list_paginates_correctly() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
for i in 0..3 {
repo.create(
1,
NewUser {
username: format!("user-{}", i),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
}
let all = repo.list(1, 0, 100).await.expect("list 应成功");
assert_eq!(all.len(), 3, "应有 3 条记录");
let page = repo.list(1, 1, 1).await.expect("list 分页应成功");
assert_eq!(page.len(), 1, "分页应返回 1 条");
let empty = repo.list(1, 100, 10).await.expect("list 超范围应成功");
assert!(empty.is_empty(), "超出范围的 offset 应返回空");
}
#[tokio::test(flavor = "multi_thread")]
async fn list_returns_rows_without_password_hash() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
repo.create(
1,
NewUser {
username: "hash-leak-check".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$secret".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
let rows = repo.list(1, 0, 100).await.expect("list 应成功");
assert_eq!(rows.len(), 1, "应有 1 条记录");
let json = serde_json::to_string(&rows[0]).expect("UserListRow 应可序列化");
assert!(
!json.contains("password_hash"),
"list 行序列化结果不应包含 password_hash,实际: {}",
json
);
assert_eq!(rows[0].username, "hash-leak-check");
assert_eq!(rows[0].tenant_id, 1);
}
#[tokio::test(flavor = "multi_thread")]
async fn find_by_username_same_name_in_different_tenants() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
repo.create(
1,
NewUser {
username: "shared-name".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x1".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create tenant 1 应成功");
repo.create(
2,
NewUser {
username: "shared-name".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x2".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create tenant 2 应成功");
let row_1 = repo
.find_by_username(1, "shared-name")
.await
.expect("find tenant 1 应成功")
.expect("tenant 1 应有该用户");
let row_2 = repo
.find_by_username(2, "shared-name")
.await
.expect("find tenant 2 应成功")
.expect("tenant 2 应有该用户");
assert_eq!(row_1.password_hash, "$argon2id$m=8,t=1,p=1$x1");
assert_eq!(row_2.password_hash, "$argon2id$m=8,t=1,p=1$x2");
assert_eq!(row_1.tenant_id, 1);
assert_eq!(row_2.tenant_id, 2);
assert_ne!(row_1.id, row_2.id, "不同租户的用户 ID 应不同");
}
#[tokio::test(flavor = "multi_thread")]
async fn list_filters_by_tenant_id() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
repo.create(
1,
NewUser {
username: "t1-user".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create tenant 1 应成功");
repo.create(
2,
NewUser {
username: "t2-user".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create tenant 2 应成功");
let list_1 = repo.list(1, 0, 100).await.expect("list tenant 1 应成功");
let list_2 = repo.list(2, 0, 100).await.expect("list tenant 2 应成功");
assert_eq!(list_1.len(), 1, "tenant 1 应有 1 条");
assert_eq!(list_2.len(), 1, "tenant 2 应有 1 条");
assert_eq!(list_1[0].tenant_id, 1);
assert_eq!(list_2[0].tenant_id, 2);
}
#[tokio::test(flavor = "multi_thread")]
async fn find_by_id_cross_tenant_returns_none() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
let id = repo
.create(
1,
NewUser {
username: "cross-user".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
let cross = repo.find_by_id(2, &id).await.expect("find_by_id 应成功");
assert!(cross.is_none(), "跨租户查询应返回 None");
}
#[tokio::test(flavor = "multi_thread")]
async fn delete_cross_tenant_is_noop() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool.clone());
let id = repo
.create(
1,
NewUser {
username: "del-cross".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
repo.delete(2, &id).await.expect("跨租户 delete 应为 no-op");
let still = repo.find_by_id(1, &id).await.expect("find 应成功");
assert!(still.is_some(), "跨租户 delete 不应影响其他租户");
}
#[tokio::test(flavor = "multi_thread")]
async fn update_cross_tenant_is_noop() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool.clone());
let id = repo
.create(
1,
NewUser {
username: "upd-cross".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
repo.update(
2,
&id,
UpdateUser {
username: None,
password_hash: None,
status: None,
last_login_at: None,
},
)
.await
.expect("跨租户 update 应为 no-op");
let still = repo.find_by_id(1, &id).await.expect("find 应成功").unwrap();
assert_eq!(still.username, "upd-cross");
assert_eq!(still.status, "active");
}
#[tokio::test(flavor = "multi_thread")]
async fn find_by_username_cross_tenant_returns_none() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool);
repo.create(
1,
NewUser {
username: "unique-cross-name".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("create 应成功");
let cross = repo
.find_by_username(2, "unique-cross-name")
.await
.expect("find_by_username 应成功");
assert!(cross.is_none(), "跨租户 find_by_username 应返回 None");
}
#[tokio::test(flavor = "multi_thread")]
async fn find_by_id_returns_error_when_table_dropped() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool.clone());
{
let session = pool.get_session("admin").await.expect("获取 session 失败");
let conn = session.connection().expect("获取 connection 失败");
conn.execute_unprepared("DROP TABLE IF EXISTS app_user")
.await
.expect("DROP TABLE 失败");
}
let result = repo.find_by_id(1, "some-id").await;
assert!(result.is_err(), "表删除后 find_by_id 应返回错误");
}
#[tokio::test(flavor = "multi_thread")]
async fn create_returns_error_when_table_dropped() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool.clone());
{
let session = pool.get_session("admin").await.expect("获取 session 失败");
let conn = session.connection().expect("获取 connection 失败");
conn.execute_unprepared("DROP TABLE IF EXISTS app_user")
.await
.expect("DROP TABLE 失败");
}
let result = repo
.create(
1,
NewUser {
username: "u1".to_string(),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await;
assert!(result.is_err(), "表删除后 create 应返回错误");
}
#[tokio::test(flavor = "multi_thread")]
async fn list_returns_error_when_table_dropped() {
let pool = setup_db().await;
let repo = DbnexusUserRepository::new(pool.clone());
{
let session = pool.get_session("admin").await.expect("获取 session 失败");
let conn = session.connection().expect("获取 connection 失败");
conn.execute_unprepared("DROP TABLE IF EXISTS app_user")
.await
.expect("DROP TABLE 失败");
}
let result = repo.list(1, 0, 100).await;
assert!(result.is_err(), "表删除后 list 应返回错误");
}
}