use super::mock::MockCredentialRepository;
use super::*;
use crate::dao::tests::MockDao;
#[test]
fn credential_trait_is_object_safe() {
fn _assert_object_safe(_cred: Box<dyn Credential>) {}
fn _assert_arc_object_safe(_cred: std::sync::Arc<dyn Credential>) {}
}
#[test]
fn credential_repository_trait_is_object_safe() {
fn _assert_object_safe(_repo: std::sync::Arc<dyn CredentialRepository>) {}
}
#[test]
fn credential_model_serializes_all_8_fields() {
let model = CredentialModel {
id: "cred-001".to_string(),
user_id: "alice".to_string(),
credential_type: "password".to_string(),
secret_data: "$argon2id$v=19$...".to_string(),
label: Some("主密码".to_string()),
created_at: 1700000000,
enabled: true,
priority: 0,
};
let json = serde_json::to_string(&model).expect("序列化应成功");
assert!(
json.contains("\"id\":\"cred-001\""),
"JSON 缺少 id 字段: {}",
json
);
assert!(
json.contains("\"user_id\":\"alice\""),
"JSON 缺少 user_id 字段: {}",
json
);
assert!(
json.contains("\"credential_type\":\"password\""),
"JSON 缺少 credential_type 字段: {}",
json
);
assert!(
json.contains("\"secret_data\""),
"JSON 缺少 secret_data 字段: {}",
json
);
assert!(
json.contains("\"label\":\"主密码\""),
"JSON 缺少 label 字段: {}",
json
);
assert!(
json.contains("\"created_at\":1700000000"),
"JSON 缺少 created_at 字段: {}",
json
);
assert!(
json.contains("\"enabled\":true"),
"JSON 缺少 enabled 字段: {}",
json
);
assert!(
json.contains("\"priority\":0"),
"JSON 缺少 priority 字段: {}",
json
);
}
#[test]
fn credential_model_deserializes_from_full_json() {
let json = r#"{
"id": "cred-002",
"user_id": "bob",
"credential_type": "totp",
"secret_data": "{\"secret\":\"JBSWY3DPEHPK3PXP\"}",
"label": null,
"created_at": 1700000001,
"enabled": false,
"priority": 1
}"#;
let model: CredentialModel = serde_json::from_str(json).expect("反序列化应成功");
assert_eq!(model.id, "cred-002");
assert_eq!(model.user_id, "bob");
assert_eq!(model.credential_type, "totp");
assert!(model.secret_data.contains("JBSWY3DPEHPK3PXP"));
assert!(model.label.is_none(), "label 应为 None");
assert_eq!(model.created_at, 1700000001);
assert!(!model.enabled, "enabled 应为 false");
assert_eq!(model.priority, 1);
}
#[test]
fn credential_model_label_none_serializes_as_null() {
let model = CredentialModel {
id: "cred-003".to_string(),
user_id: "carol".to_string(),
credential_type: "password".to_string(),
secret_data: "hash".to_string(),
label: None,
created_at: 0,
enabled: true,
priority: 0,
};
let json = serde_json::to_string(&model).expect("序列化应成功");
assert!(
json.contains("\"label\":null"),
"label 为 None 时应序列化为 null,实际: {}",
json
);
}
#[test]
fn credential_model_clone_preserves_fields() {
let model = CredentialModel {
id: "cred-004".to_string(),
user_id: "dave".to_string(),
credential_type: "webauthn".to_string(),
secret_data: "key".to_string(),
label: Some("YubiKey".to_string()),
created_at: 1700000002,
enabled: true,
priority: 5,
};
let cloned = model.clone();
assert_eq!(cloned.id, model.id);
assert_eq!(cloned.user_id, model.user_id);
assert_eq!(cloned.credential_type, model.credential_type);
assert_eq!(cloned.secret_data, model.secret_data);
assert_eq!(cloned.label, model.label);
assert_eq!(cloned.created_at, model.created_at);
assert_eq!(cloned.enabled, model.enabled);
assert_eq!(cloned.priority, model.priority);
}
fn make_model(id: &str, user: &str, cred_type: &str, priority: i32) -> CredentialModel {
CredentialModel {
id: id.to_string(),
user_id: user.to_string(),
credential_type: cred_type.to_string(),
secret_data: "$argon2id$m=8,t=1,p=1$x".to_string(),
label: None,
created_at: 0,
enabled: true,
priority,
}
}
#[tokio::test]
async fn repository_create_and_find_by_user() {
let repo = MockCredentialRepository::default();
let m1 = make_model("c1", "alice", "password", 0);
let m2 = make_model("c2", "alice", "totp", 1);
repo.create(m1.clone()).await.unwrap();
repo.create(m2.clone()).await.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(found.len(), 2);
assert_eq!(found[0].id, "c1");
assert_eq!(found[1].id, "c2");
}
#[tokio::test]
async fn repository_create_duplicate_returns_error() {
let repo = MockCredentialRepository::default();
let m = make_model("c1", "alice", "password", 0);
repo.create(m).await.unwrap();
let dup = make_model("c1", "alice", "password", 0);
let result = repo.create(dup).await;
assert!(result.is_err(), "重复 create 应返回错误");
}
#[tokio::test]
async fn repository_find_by_user_and_type_filters() {
let repo = MockCredentialRepository::default();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
repo.create(make_model("c2", "alice", "totp", 1))
.await
.unwrap();
repo.create(make_model("c3", "alice", "password", 2))
.await
.unwrap();
let passwords = repo
.find_by_user_and_type("alice", "password")
.await
.unwrap();
assert_eq!(passwords.len(), 2);
assert!(passwords.iter().all(|c| c.credential_type == "password"));
let totps = repo.find_by_user_and_type("alice", "totp").await.unwrap();
assert_eq!(totps.len(), 1);
assert_eq!(totps[0].id, "c2");
}
#[tokio::test]
async fn repository_update_overwrites_and_errors_on_missing() {
let repo = MockCredentialRepository::default();
let m = make_model("c1", "alice", "password", 0);
repo.create(m).await.unwrap();
let updated = CredentialModel {
id: "c1".to_string(),
user_id: "alice".to_string(),
credential_type: "password".to_string(),
secret_data: "new-hash".to_string(),
label: Some("updated".to_string()),
created_at: 100,
enabled: false,
priority: 5,
};
repo.update("alice", updated.clone()).await.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(found[0].secret_data, "new-hash");
assert_eq!(found[0].label, Some("updated".to_string()));
assert!(!found[0].enabled);
assert_eq!(found[0].priority, 5);
let missing = make_model("nonexistent", "alice", "password", 0);
let result = repo.update("alice", missing).await;
assert!(result.is_err(), "更新不存在的凭证应返回错误");
}
#[tokio::test]
async fn repository_delete_removes_and_errors_on_missing() {
let repo = MockCredentialRepository::default();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
repo.delete("alice", "c1").await.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(found.len(), 0, "删除后应查不到凭证");
let result = repo.delete("alice", "c1").await;
assert!(result.is_err(), "删除不存在的凭证应返回错误");
}
#[tokio::test]
async fn repository_multi_user_isolation() {
let repo = MockCredentialRepository::default();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
repo.create(make_model("c2", "bob", "password", 0))
.await
.unwrap();
let alice_creds = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(alice_creds.len(), 1);
assert_eq!(alice_creds[0].id, "c1");
let bob_creds = repo.find_by_user("bob", "bob").await.unwrap();
assert_eq!(bob_creds.len(), 1);
assert_eq!(bob_creds[0].id, "c2");
let empty = repo.find_by_user("carol", "carol").await.unwrap();
assert_eq!(empty.len(), 0);
}
#[tokio::test]
async fn repository_usable_as_trait_object() {
let repo: std::sync::Arc<dyn CredentialRepository> =
std::sync::Arc::new(MockCredentialRepository::default());
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(found.len(), 1);
}
fn make_dao_repo() -> DaoCredentialRepository {
DaoCredentialRepository::new(Arc::new(MockDao::new()))
}
#[tokio::test]
async fn dao_repo_create_and_find_by_user() {
let repo = make_dao_repo();
let m = make_model("c1", "alice", "password", 0);
repo.create(m.clone()).await.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(found.len(), 1);
assert_eq!(found[0].id, "c1");
assert_eq!(found[0].user_id, "alice");
assert_eq!(found[0].credential_type, "password");
}
#[tokio::test]
async fn dao_repo_find_by_user_returns_empty_for_unknown() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
let found = repo.find_by_user("bob", "bob").await.unwrap();
assert!(found.is_empty(), "未知用户应返回空 Vec");
}
#[tokio::test]
async fn dao_repo_find_by_user_and_type_filters() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
repo.create(make_model("c2", "alice", "totp", 1))
.await
.unwrap();
repo.create(make_model("c3", "alice", "password", 2))
.await
.unwrap();
let passwords = repo
.find_by_user_and_type("alice", "password")
.await
.unwrap();
assert_eq!(passwords.len(), 2);
assert!(passwords.iter().all(|c| c.credential_type == "password"));
let totps = repo.find_by_user_and_type("alice", "totp").await.unwrap();
assert_eq!(totps.len(), 1);
assert_eq!(totps[0].id, "c2");
}
#[tokio::test]
async fn dao_repo_update_overwrites_and_errors_on_missing() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
let updated = CredentialModel {
id: "c1".to_string(),
user_id: "alice".to_string(),
credential_type: "password".to_string(),
secret_data: "$argon2id$m=8,t=1,p=1$new".to_string(),
label: Some("updated".to_string()),
created_at: 100,
enabled: false,
priority: 5,
};
repo.update("alice", updated.clone()).await.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(found[0].secret_data, "$argon2id$m=8,t=1,p=1$new");
assert_eq!(found[0].label, Some("updated".to_string()));
assert!(!found[0].enabled);
assert_eq!(found[0].priority, 5);
let missing = make_model("nonexistent", "alice", "password", 0);
let result = repo.update("alice", missing).await;
assert!(result.is_err(), "更新不存在的凭证应返回错误");
}
#[tokio::test]
async fn dao_repo_create_rejects_out_of_range_password_hash() {
let repo = make_dao_repo();
let over = CredentialModel {
id: "c-over".to_string(),
user_id: "alice".to_string(),
credential_type: "password".to_string(),
secret_data: "$argon2id$v=19$m=2097152,t=2,p=1$c2FsdDEyMzQ1Njc4$MDEyMzQ1Njc4OWFiY2RlZg"
.to_string(),
label: None,
created_at: 0,
enabled: true,
priority: 0,
};
match repo.create(over).await {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("credential-create")
&& msg.contains(&crate::i18n::translate_detail(
"import-hash-argon2-m-cost",
&[("arg0", "2097152"), ("arg1", "1048576")],
)),
"错误应含入口与越界阶段标识,实际: {}",
msg
);
},
other => panic!(
"越界导入哈希应被 InvalidParam 拒绝,实际: {:?}",
other.map(|_| ())
),
}
}
#[tokio::test]
async fn dao_repo_update_rejects_out_of_range_password_hash() {
let repo = make_dao_repo();
let original = "$argon2id$v=19$m=19456,t=2,p=1$c2FsdDEyMzQ1Njc4$MDEyMzQ1Njc4OWFiY2RlZg";
let mut model = make_model("c-keep", "alice", "password", 0);
model.secret_data = original.to_string();
repo.create(model).await.unwrap();
let over = CredentialModel {
id: "c-keep".to_string(),
user_id: "alice".to_string(),
credential_type: "password".to_string(),
secret_data: "$argon2id$v=19$m=2097152,t=2,p=1$c2FsdDEyMzQ1Njc4$MDEyMzQ1Njc4OWFiY2RlZg"
.to_string(),
label: None,
created_at: 100,
enabled: true,
priority: 0,
};
match repo.update("alice", over).await {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("credential-update")
&& msg.contains(&crate::i18n::translate_detail(
"import-hash-argon2-m-cost",
&[("arg0", "2097152"), ("arg1", "1048576")],
)),
"错误应含入口与越界阶段标识,实际: {}",
msg
);
},
other => panic!(
"越界导入哈希应被 InvalidParam 拒绝,实际: {:?}",
other.map(|_| ())
),
}
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(found[0].secret_data, original, "被拒更新不得改动存量哈希");
}
#[tokio::test]
async fn dao_repo_create_skips_gate_for_non_password_types() {
let repo = make_dao_repo();
let mut seed = make_model("c-totp", "alice", "totp", 0);
seed.secret_data = "JBSWY3DPEHPK3PXP".to_string();
repo.create(seed).await.expect("TOTP seed 不应被哈希门拒绝");
}
#[tokio::test]
async fn dao_repo_delete_removes_and_errors_on_missing() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
repo.delete("alice", "c1").await.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert!(found.is_empty(), "删除后应查不到凭证");
let result = repo.delete("alice", "c1").await;
assert!(result.is_err(), "删除不存在的凭证应返回错误");
}
#[tokio::test]
async fn dao_repo_multi_user_isolation() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
repo.create(make_model("c2", "bob", "password", 0))
.await
.unwrap();
let alice = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(alice.len(), 1);
assert_eq!(alice[0].id, "c1");
let bob = repo.find_by_user("bob", "bob").await.unwrap();
assert_eq!(bob.len(), 1);
assert_eq!(bob[0].id, "c2");
let carol = repo.find_by_user("carol", "carol").await.unwrap();
assert!(carol.is_empty());
}
#[tokio::test]
async fn dao_repo_multi_credential_types_per_user() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
repo.create(make_model("c2", "alice", "totp", 1))
.await
.unwrap();
repo.create(make_model("c3", "alice", "webauthn", 2))
.await
.unwrap();
let all = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(all.len(), 3);
let types: Vec<&str> = all.iter().map(|c| c.credential_type.as_str()).collect();
assert!(types.contains(&"password"));
assert!(types.contains(&"totp"));
assert!(types.contains(&"webauthn"));
}
#[tokio::test]
async fn dao_repo_find_returns_disabled_credentials() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
let disabled = CredentialModel {
id: "c2".to_string(),
user_id: "alice".to_string(),
credential_type: "totp".to_string(),
secret_data: "secret".to_string(),
label: None,
created_at: 0,
enabled: false,
priority: 1,
};
repo.create(disabled).await.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(
found.len(),
2,
"find_by_user 应返回 enabled + disabled 凭证"
);
let disabled_cred = found.iter().find(|c| c.id == "c2").unwrap();
assert!(!disabled_cred.enabled, "disabled 凭证 enabled 应为 false");
}
#[tokio::test]
async fn dao_repo_priority_order_ascending() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 5))
.await
.unwrap();
repo.create(make_model("c2", "alice", "totp", 1))
.await
.unwrap();
repo.create(make_model("c3", "alice", "webauthn", 3))
.await
.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(found.len(), 3);
assert_eq!(found[0].id, "c2");
assert_eq!(found[0].priority, 1);
assert_eq!(found[1].id, "c3");
assert_eq!(found[1].priority, 3);
assert_eq!(found[2].id, "c1");
assert_eq!(found[2].priority, 5);
}
#[tokio::test]
async fn dao_repo_create_duplicate_returns_error() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
let dup = make_model("c1", "alice", "password", 0);
let result = repo.create(dup).await;
assert!(result.is_err(), "重复 create 应返回错误");
}
#[tokio::test]
async fn dao_repo_usable_as_trait_object() {
let repo: Arc<dyn CredentialRepository> = Arc::new(make_dao_repo());
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(found.len(), 1);
}
fn assert_idor_denied(err: GarrisonError, ctx: &str) {
assert!(
matches!(err, GarrisonError::NotPermission(_)),
"{} 应返回 NotPermission(IDOR 拒绝),实际: {:?}",
ctx,
err
);
}
#[tokio::test]
async fn mock_find_by_user_denied_when_caller_not_target() {
let repo = MockCredentialRepository::default();
repo.create(make_model("c1", "bob", "password", 0))
.await
.unwrap();
let err = repo
.find_by_user("alice", "bob")
.await
.expect_err("alice 查询 bob 凭证应被拒绝");
assert_idor_denied(err, "mock find_by_user alice→bob");
}
#[tokio::test]
async fn dao_find_by_user_denied_when_caller_not_target() {
let repo = make_dao_repo();
repo.create(make_model("c1", "bob", "password", 0))
.await
.unwrap();
let err = repo
.find_by_user("alice", "bob")
.await
.expect_err("alice 查询 bob 凭证应被拒绝");
assert_idor_denied(err, "dao find_by_user alice→bob");
}
#[tokio::test]
async fn dao_find_by_user_succeeds_when_caller_is_owner() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
repo.create(make_model("c2", "alice", "totp", 1))
.await
.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(found.len(), 2, "alice 查询自己的凭证应成功返回 2 条");
}
#[tokio::test]
async fn mock_delete_denied_when_caller_not_owner() {
let repo = MockCredentialRepository::default();
repo.create(make_model("c1", "bob", "password", 0))
.await
.unwrap();
let err = repo
.delete("alice", "c1")
.await
.expect_err("alice 删除 bob 的凭证应被拒绝");
assert_idor_denied(err, "mock delete alice→bob c1");
let remaining = repo.find_by_user("bob", "bob").await.unwrap();
assert_eq!(remaining.len(), 1, "拒绝后 bob 的凭证应仍存在");
assert_eq!(remaining[0].id, "c1");
}
#[tokio::test]
async fn dao_delete_denied_when_caller_not_owner() {
let repo = make_dao_repo();
repo.create(make_model("c1", "bob", "password", 0))
.await
.unwrap();
let err = repo
.delete("alice", "c1")
.await
.expect_err("alice 删除 bob 的凭证应被拒绝");
assert_idor_denied(err, "dao delete alice→bob c1");
let remaining = repo.find_by_user("bob", "bob").await.unwrap();
assert_eq!(remaining.len(), 1, "拒绝后 bob 的凭证应仍存在");
}
#[tokio::test]
async fn dao_delete_succeeds_when_caller_is_owner() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
repo.delete("alice", "c1").await.unwrap();
let remaining = repo.find_by_user("alice", "alice").await.unwrap();
assert!(remaining.is_empty(), "alice 删除自己的凭证后应查不到");
}
#[tokio::test]
async fn mock_update_denied_when_caller_not_owner() {
let repo = MockCredentialRepository::default();
repo.create(make_model("c1", "bob", "password", 0))
.await
.unwrap();
let forged = CredentialModel {
id: "c1".to_string(),
user_id: "bob".to_string(),
credential_type: "password".to_string(),
secret_data: "attacker-hash".to_string(),
label: None,
created_at: 0,
enabled: true,
priority: 0,
};
let err = repo
.update("alice", forged)
.await
.expect_err("alice 更新 bob 的凭证应被拒绝");
assert_idor_denied(err, "mock update alice→bob c1");
let remaining = repo.find_by_user("bob", "bob").await.unwrap();
assert_eq!(
remaining[0].secret_data, "$argon2id$m=8,t=1,p=1$x",
"凭证 secret_data 应未被攻击者覆盖(若为 attacker-hash 说明更新意外成功)"
);
}
#[tokio::test]
async fn dao_update_denied_when_caller_not_owner() {
let repo = make_dao_repo();
repo.create(make_model("c1", "bob", "password", 0))
.await
.unwrap();
let forged = CredentialModel {
id: "c1".to_string(),
user_id: "bob".to_string(),
credential_type: "password".to_string(),
secret_data: "attacker-hash".to_string(),
label: None,
created_at: 0,
enabled: true,
priority: 0,
};
let err = repo
.update("alice", forged)
.await
.expect_err("alice 更新 bob 的凭证应被拒绝");
assert_idor_denied(err, "dao update alice→bob c1");
let remaining = repo.find_by_user("bob", "bob").await.unwrap();
assert_eq!(
remaining[0].secret_data, "$argon2id$m=8,t=1,p=1$x",
"凭证 secret_data 应未被攻击者覆盖"
);
}
#[tokio::test]
async fn mock_update_denied_when_user_id_transferred() {
let repo = MockCredentialRepository::default();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
let transfer = CredentialModel {
id: "c1".to_string(),
user_id: "bob".to_string(), credential_type: "password".to_string(),
secret_data: "hash".to_string(),
label: None,
created_at: 0,
enabled: true,
priority: 0,
};
let err = repo
.update("alice", transfer)
.await
.expect_err("alice 转移凭证到 bob 应被拒绝");
assert_idor_denied(err, "mock update user_id transfer");
let alice_creds = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(alice_creds.len(), 1, "凭证应仍属于 alice");
assert_eq!(alice_creds[0].user_id, "alice");
}
#[tokio::test]
async fn dao_update_denied_when_user_id_transferred() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
let transfer = CredentialModel {
id: "c1".to_string(),
user_id: "bob".to_string(), credential_type: "password".to_string(),
secret_data: "hash".to_string(),
label: None,
created_at: 0,
enabled: true,
priority: 0,
};
let err = repo
.update("alice", transfer)
.await
.expect_err("alice 转移凭证到 bob 应被拒绝");
assert_idor_denied(err, "dao update user_id transfer");
let alice_creds = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(alice_creds.len(), 1, "凭证应仍属于 alice");
assert_eq!(alice_creds[0].user_id, "alice");
}
#[tokio::test]
async fn dao_update_succeeds_when_caller_is_owner_and_user_id_unchanged() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
let updated = CredentialModel {
id: "c1".to_string(),
user_id: "alice".to_string(), credential_type: "password".to_string(),
secret_data: "$argon2id$m=8,t=1,p=1$new".to_string(),
label: Some("updated".to_string()),
created_at: 100,
enabled: false,
priority: 5,
};
repo.update("alice", updated).await.unwrap();
let found = repo.find_by_user("alice", "alice").await.unwrap();
assert_eq!(found[0].secret_data, "$argon2id$m=8,t=1,p=1$new");
assert_eq!(found[0].label, Some("updated".to_string()));
assert!(!found[0].enabled);
assert_eq!(found[0].priority, 5);
}
#[tokio::test]
async fn trait_object_enforces_idor_on_delete() {
let repo: Arc<dyn CredentialRepository> = Arc::new(make_dao_repo());
repo.create(make_model("c1", "bob", "password", 0))
.await
.unwrap();
let err = repo
.delete("alice", "c1")
.await
.expect_err("trait object: alice 删除 bob 的凭证应被拒绝");
assert_idor_denied(err, "trait object delete alice→bob");
}
#[tokio::test]
async fn trait_object_enforces_idor_on_find_by_user() {
let repo: Arc<dyn CredentialRepository> = Arc::new(make_dao_repo());
repo.create(make_model("c1", "bob", "password", 0))
.await
.unwrap();
let err = repo
.find_by_user("alice", "bob")
.await
.expect_err("trait object: alice 查询 bob 凭证应被拒绝");
assert_idor_denied(err, "trait object find_by_user alice→bob");
}
#[tokio::test]
async fn mock_find_by_user_and_type_isolated_per_user() {
let repo = MockCredentialRepository::default();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
repo.create(make_model("c2", "bob", "password", 0))
.await
.unwrap();
repo.create(make_model("c3", "bob", "totp", 1))
.await
.unwrap();
let bob_passwords = repo.find_by_user_and_type("bob", "password").await.unwrap();
assert_eq!(
bob_passwords.len(),
1,
"bob 的 password 查询应只含 bob 的凭证"
);
assert_eq!(bob_passwords[0].id, "c2");
assert!(
bob_passwords.iter().all(|c| c.user_id == "bob"),
"find_by_user_and_type 不得返回其他用户的凭证(跨用户泄露)"
);
let alice_passwords = repo
.find_by_user_and_type("alice", "password")
.await
.unwrap();
assert_eq!(alice_passwords.len(), 1);
assert_eq!(alice_passwords[0].id, "c1");
}
#[tokio::test]
async fn dao_find_by_user_and_type_isolated_per_user() {
let repo = make_dao_repo();
repo.create(make_model("c1", "alice", "password", 0))
.await
.unwrap();
repo.create(make_model("c2", "bob", "password", 0))
.await
.unwrap();
repo.create(make_model("c3", "bob", "totp", 1))
.await
.unwrap();
let bob_passwords = repo.find_by_user_and_type("bob", "password").await.unwrap();
assert_eq!(
bob_passwords.len(),
1,
"DAO: bob 的 password 查询应只含 bob 的凭证"
);
assert_eq!(bob_passwords[0].id, "c2");
let carol = repo
.find_by_user_and_type("carol", "password")
.await
.unwrap();
assert!(carol.is_empty(), "无凭证用户应返回空 Vec");
}
#[tokio::test]
async fn dao_create_is_trusted_boundary_stores_model_as_given() {
let repo = make_dao_repo();
repo.create(make_model("c9", "bob", "password", 0))
.await
.unwrap();
let bob_creds = repo.find_by_user("bob", "bob").await.unwrap();
assert_eq!(bob_creds.len(), 1);
assert_eq!(bob_creds[0].id, "c9");
let err = repo
.find_by_user("alice", "bob")
.await
.expect_err("alice 查询 bob 凭证应被拒绝");
assert_idor_denied(err, "create trusted boundary: alice→bob find_by_user");
}
#[test]
fn argon2_default_policy_is_owasp_baseline() {
let hasher = crate::account::credential::password::Argon2Hasher::default();
let hash = hasher.hash("policy-lock-probe").unwrap();
assert!(
hash.starts_with("$argon2id$v=19$m=19456,t=2,p=1$"),
"默认策略应为 Argon2id m=19456/t=2/p=1,实际: {}",
&hash[..hash.len().min(48)]
);
}
#[test]
fn argon2_hash_phc_prefix_locks_algorithm_and_params() {
let hasher = crate::account::credential::password::Argon2Hasher::default();
let hash = hasher.hash("correct horse battery staple").unwrap();
assert!(
hash.starts_with("$argon2id$v=19$m=19456,t=2,p=1$"),
"PHC 前缀应为 $argon2id$v=19$m=19456,t=2,p=1$,实际: {}",
&hash[..hash.len().min(48)]
);
}