use super::*;
fn openai_project_key_fixture() -> String {
format!("sk-proj-{}", "A".repeat(80))
}
#[test]
fn url_userinfo_placeholder_refusal_explains_effective_remedies() {
for content in [
"postgresql://dbuser:<PASSWORD>@db.example.com:5432/mydb",
"postgresql://<USER>:<PASSWORD>@db.example.com:5432/mydb",
"redis://:<PASSWORD>@cache.example.com:6379",
] {
let error = check(content).expect_err("URL credential placeholders still match");
let RuntimeError::SecretDetected(matched) = &error else {
panic!("expected a secret refusal, got {error}");
};
assert_eq!(matched.detector, "url-userinfo");
let rendered = error.to_string();
for guidance in [
"Placeholders in URL credential positions still match",
"Replace the whole URL",
"environment-variable name or config key",
"remove the entire user/password segment",
] {
assert!(
rendered.contains(guidance),
"missing {guidance:?}: {rendered}"
);
}
assert!(!rendered.contains(content), "refusal must not echo the URL");
}
}
#[test]
fn check_returns_err_for_secret() {
let fake = "AKIAFAKEKEY1234567890";
let result = check(fake);
assert!(result.is_err(), "check must fail for AKIA key");
let err = result.unwrap_err();
assert!(
matches!(err, RuntimeError::SecretDetected(_)),
"error variant must be SecretDetected"
);
}
#[test]
fn check_json_blocks_secret_in_object_value() {
let props = serde_json::json!({ "api_key": "AKIAFAKEKEY1234567890" });
assert!(
check_json(&props).is_err(),
"secret in properties object value must be blocked"
);
}
#[test]
fn check_json_blocks_secret_in_nested_object() {
let props = serde_json::json!({
"credentials": { "token": openai_project_key_fixture() }
});
assert!(
check_json(&props).is_err(),
"secret in nested properties object must be blocked"
);
}
#[test]
fn check_json_blocks_secret_in_array() {
let props = serde_json::json!(["normal", "AKIAFAKEKEY1234567890"]);
assert!(
check_json(&props).is_err(),
"secret in JSON array must be blocked"
);
}
#[test]
fn reject_reserved_key_passes_absent_properties() {
assert!(reject_reserved_secret_gate_property(None).is_ok());
}
#[test]
fn reject_reserved_key_passes_unrelated_properties() {
let props = serde_json::json!({"name": "value", "tags": ["a", "b"]});
assert!(reject_reserved_secret_gate_property(Some(&props)).is_ok());
}
#[test]
fn reject_reserved_key_passes_non_object_properties() {
let props = serde_json::json!("just a string");
assert!(reject_reserved_secret_gate_property(Some(&props)).is_ok());
let arr = serde_json::json!(["a", "b"]);
assert!(reject_reserved_secret_gate_property(Some(&arr)).is_ok());
}
#[test]
fn reject_reserved_key_blocks_top_level_key_creation() {
let props = serde_json::json!({"khive:secret_gate": "exempted:content-sha256-manifest-v1"});
let err = reject_reserved_secret_gate_property(Some(&props)).unwrap_err();
assert!(
matches!(err, RuntimeError::InvalidInput(ref msg) if msg.contains("khive:secret_gate") && msg.contains("runtime-owned")),
"unexpected error: {err:?}"
);
}
#[test]
fn reject_reserved_web_receipt_provenance_in_generic_properties() {
for value in [serde_json::json!("v1"), serde_json::Value::Null] {
let props = serde_json::json!({"khive:web_receipt": value});
let error = reject_reserved_secret_gate_property(Some(&props)).unwrap_err();
assert!(
matches!(error, RuntimeError::InvalidInput(message) if message.contains("khive:web_receipt"))
);
}
}
#[test]
fn reject_reserved_key_blocks_regardless_of_value_shape() {
for value in [
serde_json::json!(null),
serde_json::json!(42),
serde_json::json!({"nested": "object"}),
serde_json::json!("exempted:content-sha256-manifest-v1"),
] {
let props = serde_json::json!({"khive:secret_gate": value});
assert!(
reject_reserved_secret_gate_property(Some(&props)).is_err(),
"must reject value shape: {props:?}"
);
}
}
#[test]
fn reject_reserved_key_allows_nested_non_top_level_occurrence() {
let props = serde_json::json!({"notes": {"khive:secret_gate": "not-a-stamp"}});
assert!(reject_reserved_secret_gate_property(Some(&props)).is_ok());
}
#[test]
fn reject_reserved_key_blocks_alongside_other_legitimate_keys() {
let props = serde_json::json!({
"name": "value",
"khive:secret_gate": "exempted:content-sha256-manifest-v1",
});
assert!(reject_reserved_secret_gate_property(Some(&props)).is_err());
}
#[test]
fn check_json_passes_safe_properties() {
let props = serde_json::json!({
"domain": "attention",
"status": "researched",
"year": 2024
});
assert!(
check_json(&props).is_ok(),
"normal properties must pass; fired: {:?}",
check_json(&props).err()
);
}
#[test]
fn check_tags_blocks_credential_tag() {
let tags = vec![
"type:concept".to_string(),
"AKIAFAKEKEY1234567890".to_string(),
];
assert!(
check_tags(&tags).is_err(),
"credential-shaped tag must be blocked"
);
}
#[test]
fn check_tags_passes_normal_tags() {
let tags = vec!["type:concept".to_string(), "domain:attention".to_string()];
assert!(
check_tags(&tags).is_ok(),
"normal tags must pass; fired: {:?}",
check_tags(&tags).err()
);
}
#[test]
fn check_json_blocks_secret_in_object_key() {
let props = serde_json::json!({ "ghp_FakeGitHubToken0000000000000000000": "redacted" }); assert!(
check_json(&props).is_err(),
"credential as JSON object key must be blocked"
);
}
#[test]
fn check_json_blocks_nested_secret_key() {
let props = serde_json::json!({
"metadata": {
"AKIAFAKEKEY000000000": "value" }
});
assert!(
check_json(&props).is_err(),
"nested credential as JSON object key must be blocked"
);
}