use super::{v_i64, v_opt_str, v_str, DbnexusUserRoleRepository};
use crate::dao::dao_session;
use crate::dao::repository::{make_statement, UserRoleRepository, UserRoleRow};
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use dbnexus::sea_orm::{ConnectionTrait, QueryResult};
use dbnexus::DbPool;
impl DbnexusUserRoleRepository {
pub fn new(pool: DbPool) -> Self {
Self { pool }
}
}
#[async_trait]
impl UserRoleRepository for DbnexusUserRoleRepository {
async fn find_by_user_id(
&self,
tenant_id: i64,
user_id: &str,
) -> GarrisonResult<Vec<UserRoleRow>> {
dao_session!(
self.pool,
"dao-app-user-role-find-by-user-id",
session,
conn
);
let sql = "SELECT user_id, role_id, scope, grant_time, tenant_id \
FROM app_user_role WHERE tenant_id = ? AND user_id = ?";
let stmt = make_statement(conn, sql, vec![v_i64(tenant_id), v_str(user_id)]);
let rows = conn.query_all_raw(stmt).await.map_err(|e| {
GarrisonError::Dao(format!("dao-app-user-role-find-by-user-id-query::{}", e))
})?;
rows.iter().map(parse_user_role_row).collect()
}
async fn find_by_role_id(
&self,
tenant_id: i64,
role_id: &str,
) -> GarrisonResult<Vec<UserRoleRow>> {
dao_session!(
self.pool,
"dao-app-user-role-find-by-role-id",
session,
conn
);
let sql = "SELECT user_id, role_id, scope, grant_time, tenant_id \
FROM app_user_role WHERE tenant_id = ? AND role_id = ?";
let stmt = make_statement(conn, sql, vec![v_i64(tenant_id), v_str(role_id)]);
let rows = conn.query_all_raw(stmt).await.map_err(|e| {
GarrisonError::Dao(format!("dao-app-user-role-find-by-role-id-query::{}", e))
})?;
rows.iter().map(parse_user_role_row).collect()
}
async fn assign(
&self,
tenant_id: i64,
user_id: &str,
role_id: &str,
scope: Option<String>,
) -> GarrisonResult<()> {
dao_session!(self.pool, "dao-app-user-role-assign", session, conn);
let sql = "INSERT OR IGNORE INTO app_user_role (user_id, role_id, scope, tenant_id) \
VALUES (?, ?, ?, ?)";
let stmt = make_statement(
conn,
sql,
vec![
v_str(user_id),
v_str(role_id),
v_opt_str(&scope),
v_i64(tenant_id),
],
);
conn.execute_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-role-assign-insert::{}", e)))?;
Ok(())
}
async fn revoke(&self, tenant_id: i64, user_id: &str, role_id: &str) -> GarrisonResult<()> {
dao_session!(self.pool, "dao-app-user-role-revoke", session, conn);
let sql = "DELETE FROM app_user_role WHERE tenant_id = ? AND user_id = ? AND role_id = ?";
let stmt = make_statement(
conn,
sql,
vec![v_i64(tenant_id), v_str(user_id), v_str(role_id)],
);
conn.execute_raw(stmt)
.await
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-role-revoke-delete::{}", e)))?;
Ok(())
}
async fn list(
&self,
tenant_id: i64,
offset: i64,
limit: i64,
) -> GarrisonResult<Vec<UserRoleRow>> {
dao_session!(self.pool, "dao-app-user-role-list", session, conn);
let sql = "SELECT user_id, role_id, scope, grant_time, tenant_id \
FROM app_user_role WHERE tenant_id = ? ORDER BY user_id, role_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-role-list-query::{}", e)))?;
rows.iter().map(parse_user_role_row).collect()
}
}
fn parse_user_role_row(row: &QueryResult) -> GarrisonResult<UserRoleRow> {
Ok(UserRoleRow {
user_id: row.try_get("", "user_id").map_err(|e| {
GarrisonError::Dao(format!("dao-app-user-role-row-parse-user-id::{}", e))
})?,
role_id: row.try_get("", "role_id").map_err(|e| {
GarrisonError::Dao(format!("dao-app-user-role-row-parse-role-id::{}", e))
})?,
scope: row
.try_get("", "scope")
.map_err(|e| GarrisonError::Dao(format!("dao-app-user-role-row-parse-scope::{}", e)))?,
grant_time: row.try_get("", "grant_time").map_err(|e| {
GarrisonError::Dao(format!("dao-app-user-role-row-parse-grant-time::{}", e))
})?,
tenant_id: row.try_get("", "tenant_id").map_err(|e| {
GarrisonError::Dao(format!("dao-app-user-role-row-parse-tenant-id::{}", e))
})?,
})
}
#[cfg(all(test, feature = "db-sqlite"))]
mod tests {
use super::super::{DbnexusRoleRepository, DbnexusUserRepository};
use super::*;
use crate::dao::repository::sqlite::test_support::setup_db;
use crate::dao::repository::{NewRole, NewUser, RoleRepository, UserRepository};
async fn setup_user_and_role(pool: &DbPool, tenant_id: i64) -> (String, String) {
let user_repo = DbnexusUserRepository::new(pool.clone());
let role_repo = DbnexusRoleRepository::new(pool.clone());
let user_id = user_repo
.create(
tenant_id,
NewUser {
username: format!("ur-user-{}", tenant_id),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("创建 user 应成功");
let role_id = role_repo
.create(
tenant_id,
NewRole {
code: format!("ur-role-{}", tenant_id),
name: "测试角色".to_string(),
description: None,
is_system: false,
},
)
.await
.expect("创建 role 应成功");
(user_id, role_id)
}
#[tokio::test(flavor = "multi_thread")]
async fn assign_and_find_by_user_id() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool.clone());
let (user_id, role_id) = setup_user_and_role(&pool, 1).await;
repo.assign(1, &user_id, &role_id, Some("read".to_string()))
.await
.expect("assign 应成功");
let rows = repo
.find_by_user_id(1, &user_id)
.await
.expect("find_by_user_id 应成功");
assert_eq!(rows.len(), 1);
assert_eq!(rows[0].user_id, user_id);
assert_eq!(rows[0].role_id, role_id);
assert_eq!(rows[0].scope.as_deref(), Some("read"));
assert_eq!(rows[0].tenant_id, 1);
}
#[tokio::test(flavor = "multi_thread")]
async fn find_by_role_id_returns_all_assignments() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool.clone());
let role_repo = DbnexusRoleRepository::new(pool.clone());
let user_repo = DbnexusUserRepository::new(pool.clone());
let role_id = role_repo
.create(
1,
NewRole {
code: "shared-role".to_string(),
name: "共享角色".to_string(),
description: None,
is_system: false,
},
)
.await
.expect("创建 role 应成功");
for i in 0..2 {
let user_id = user_repo
.create(
1,
NewUser {
username: format!("rbu-{}", i),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("创建 user 应成功");
repo.assign(1, &user_id, &role_id, None)
.await
.expect("assign 应成功");
}
let rows = repo
.find_by_role_id(1, &role_id)
.await
.expect("find_by_role_id 应成功");
assert_eq!(rows.len(), 2, "应有 2 条关联记录");
assert!(rows.iter().all(|r| r.role_id == role_id));
}
#[tokio::test(flavor = "multi_thread")]
async fn revoke_is_idempotent() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool.clone());
let (user_id, role_id) = setup_user_and_role(&pool, 1).await;
repo.assign(1, &user_id, &role_id, None)
.await
.expect("assign 应成功");
repo.revoke(1, &user_id, &role_id)
.await
.expect("首次 revoke 应成功");
let rows = repo
.find_by_user_id(1, &user_id)
.await
.expect("find_by_user_id 应成功");
assert!(rows.is_empty(), "revoke 后应查不到关联");
repo.revoke(1, &user_id, &role_id)
.await
.expect("幂等 revoke 应成功");
}
#[tokio::test(flavor = "multi_thread")]
async fn list_filters_by_tenant_id() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool.clone());
let (user_1, role_1) = setup_user_and_role(&pool, 1).await;
repo.assign(1, &user_1, &role_1, None)
.await
.expect("assign tenant 1 应成功");
let (user_2, role_2) = setup_user_and_role(&pool, 2).await;
repo.assign(2, &user_2, &role_2, None)
.await
.expect("assign 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_user_id_returns_empty_for_no_roles() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool.clone());
let (user_id, _) = setup_user_and_role(&pool, 1).await;
let rows = repo
.find_by_user_id(1, &user_id)
.await
.expect("find_by_user_id 应成功");
assert!(rows.is_empty(), "无角色关联的用户应返回空列表");
}
#[tokio::test(flavor = "multi_thread")]
async fn find_by_role_id_returns_empty_for_no_users() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool.clone());
let (_, role_id) = setup_user_and_role(&pool, 1).await;
let rows = repo
.find_by_role_id(1, &role_id)
.await
.expect("find_by_role_id 应成功");
assert!(rows.is_empty(), "无用户关联的角色应返回空列表");
}
#[tokio::test(flavor = "multi_thread")]
async fn assign_with_scope_none() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool.clone());
let (user_id, role_id) = setup_user_and_role(&pool, 1).await;
repo.assign(1, &user_id, &role_id, None)
.await
.expect("assign scope=None 应成功");
let rows = repo
.find_by_user_id(1, &user_id)
.await
.expect("find_by_user_id 应成功");
assert_eq!(rows.len(), 1);
assert!(rows[0].scope.is_none(), "scope 应为 None");
}
#[tokio::test(flavor = "multi_thread")]
async fn list_paginates_correctly() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool.clone());
let role_repo = DbnexusRoleRepository::new(pool.clone());
let user_repo = DbnexusUserRepository::new(pool.clone());
let role_id = role_repo
.create(
1,
NewRole {
code: "page-shared-role".to_string(),
name: "共享角色".to_string(),
description: None,
is_system: false,
},
)
.await
.expect("创建 role 应成功");
for i in 0..3 {
let user_id = user_repo
.create(
1,
NewUser {
username: format!("page-user-{}", i),
password_hash: "$argon2id$m=8,t=1,p=1$x".to_string(),
status: "active".to_string(),
},
)
.await
.expect("创建 user 应成功");
repo.assign(1, &user_id, &role_id, None)
.await
.expect("assign 应成功");
}
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_empty_returns_empty() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool);
let result = repo.list(1, 0, 100).await.expect("list 应成功");
assert!(result.is_empty(), "空表应返回空列表");
}
#[tokio::test(flavor = "multi_thread")]
async fn revoke_nonexistent_is_noop() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool);
repo.revoke(1, "nonexistent-user", "nonexistent-role")
.await
.expect("revoke 不存在的关联应为 no-op");
}
#[tokio::test(flavor = "multi_thread")]
async fn find_by_user_id_cross_tenant_returns_empty() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool.clone());
let (user_id, role_id) = setup_user_and_role(&pool, 1).await;
repo.assign(1, &user_id, &role_id, None)
.await
.expect("assign 应成功");
let cross = repo
.find_by_user_id(2, &user_id)
.await
.expect("find_by_user_id 应成功");
assert!(cross.is_empty(), "跨租户 find_by_user_id 应返回空");
}
#[tokio::test(flavor = "multi_thread")]
async fn find_by_role_id_cross_tenant_returns_empty() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool.clone());
let (user_id, role_id) = setup_user_and_role(&pool, 1).await;
repo.assign(1, &user_id, &role_id, None)
.await
.expect("assign 应成功");
let cross = repo
.find_by_role_id(2, &role_id)
.await
.expect("find_by_role_id 应成功");
assert!(cross.is_empty(), "跨租户 find_by_role_id 应返回空");
}
#[tokio::test(flavor = "multi_thread")]
async fn assign_duplicate_is_idempotent() {
let pool = setup_db().await;
let repo = DbnexusUserRoleRepository::new(pool.clone());
let (user_id, role_id) = setup_user_and_role(&pool, 1).await;
repo.assign(1, &user_id, &role_id, None)
.await
.expect("首次 assign 应成功");
repo.assign(1, &user_id, &role_id, None)
.await
.expect("重复 assign 应为 no-op");
let roles = repo
.find_by_user_id(1, &user_id)
.await
.expect("find 应成功");
assert_eq!(roles.len(), 1, "重复 assign 不应产生重复记录");
}
}