#![allow(non_snake_case)]
use super::*;
fn wide_repo() -> tempfile::TempDir {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join("leaf.rs"), "fn leaf() {}\n").unwrap();
for (i, name) in ["one", "two", "three"].iter().enumerate() {
std::fs::write(
dir.path().join(format!("caller{i}.rs")),
format!("fn {name}() {{ leaf(); }}\n"),
)
.unwrap();
}
dir
}
fn write_policy(dir: &Path, body: &str) {
let bobbin = dir.join(".bobbin");
std::fs::create_dir_all(&bobbin).unwrap();
std::fs::write(bobbin.join("config.toml"), body).unwrap();
}
fn unique_session() -> String {
use std::sync::atomic::{AtomicU64, Ordering};
static COUNTER: AtomicU64 = AtomicU64::new(0);
format!(
"test-{}-{}",
std::process::id(),
COUNTER.fetch_add(1, Ordering::Relaxed)
)
}
fn edit_payload(dir: &Path, file: &str, old: &str) -> String {
serde_json::json!({
"session_id": unique_session(),
"cwd": dir.to_str().unwrap(),
"tool_name": "Edit",
"tool_input": {
"file_path": dir.join(file).to_str().unwrap(),
"old_string": old,
"new_string": "fn leaf() { changed(); }",
},
})
.to_string()
}
#[test]
fn allows_when_no_policy_is_configured() {
let dir = wide_repo();
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
assert_eq!(guard(&payload, dir.path(), Some("t"), None), Outcome::Allow);
}
#[test]
fn allows_when_mode_is_off_despite_a_scope() {
let dir = wide_repo();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"off\"\n[hank.policy.scopes.t]\nmax_impacted_symbols = 0\n",
);
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
assert_eq!(guard(&payload, dir.path(), Some("t"), None), Outcome::Allow);
}
#[test]
fn denies_an_out_of_scope_path() {
let dir = wide_repo();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"enforce\"\n\
[hank.policy.scopes.t]\nallow_paths = [\"caller*.rs\"]\n",
);
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
let Outcome::Deny(reason) = guard(&payload, dir.path(), Some("t"), None) else {
panic!("expected a deny");
};
assert!(reason.contains("leaf.rs"));
assert!(reason.contains("outside the writable capability scope"));
}
#[test]
fn denies_an_edit_that_exceeds_the_blast_radius() {
let dir = wide_repo();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"enforce\"\ndeadline_ms = 30000\n\
[hank.policy.scopes.t]\nmax_impacted_files = 1\n",
);
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
let Outcome::Deny(reason) = guard(&payload, dir.path(), Some("t"), None) else {
panic!("expected a deny");
};
assert!(reason.contains("3 files (ceiling 1)"), "got: {reason}");
}
#[test]
fn allows_an_edit_within_the_blast_radius() {
let dir = wide_repo();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"enforce\"\ndeadline_ms = 30000\n\
[hank.policy.scopes.t]\nmax_impacted_files = 10\n",
);
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
assert_eq!(guard(&payload, dir.path(), Some("t"), None), Outcome::Allow);
}
#[test]
fn advise_mode_never_denies() {
let dir = wide_repo();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"advise\"\ndeadline_ms = 30000\n\
[hank.policy.scopes.t]\nmax_impacted_files = 1\n",
);
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
let Outcome::Notify(message) = guard(&payload, dir.path(), Some("t"), None) else {
panic!("expected an advisory, not a block");
};
assert!(message.contains("not blocking"));
}
#[test]
fn an_untouched_tenant_is_unconstrained() {
let dir = wide_repo();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"enforce\"\n\
[hank.policy.scopes.other]\nallow_paths = [\"nothing/**\"]\n",
);
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
assert_eq!(guard(&payload, dir.path(), Some("t"), None), Outcome::Allow);
assert_eq!(guard(&payload, dir.path(), None, None), Outcome::Allow);
}
#[test]
fn a_blown_deadline_allows_the_edit_and_says_so() {
let dir = wide_repo();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"enforce\"\ndeadline_ms = 0\n\
[hank.policy.scopes.t]\nmax_impacted_files = 1\n",
);
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
match guard(&payload, dir.path(), Some("t"), None) {
Outcome::Notify(message) => {
assert!(message.contains("NOT EVALUATED"), "{message}");
assert!(message.contains("deadline_ms"), "{message}");
}
other => panic!("a blown deadline must be reported, got {other:?}"),
}
}
#[test]
fn a_path_check_still_applies_under_a_zero_deadline() {
let dir = wide_repo();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"enforce\"\ndeadline_ms = 0\n\
[hank.policy.scopes.t]\nallow_paths = [\"caller*.rs\"]\n",
);
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
assert!(matches!(
guard(&payload, dir.path(), Some("t"), None),
Outcome::Deny(_)
));
}
#[test]
fn garbage_and_unknown_payloads_allow() {
let dir = wide_repo();
assert_eq!(
guard("not json", dir.path(), Some("t"), None),
Outcome::Allow
);
let no_file = serde_json::json!({ "tool_input": {} }).to_string();
assert_eq!(guard(&no_file, dir.path(), Some("t"), None), Outcome::Allow);
}
#[test]
fn a_malformed_glob_fails_open_loudly() {
let dir = wide_repo();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"enforce\"\n\
[hank.policy.scopes.t]\nallow_paths = [\"src/[\"]\n",
);
let session = unique_session();
let payload = serde_json::json!({
"session_id": session,
"cwd": dir.path().to_str().unwrap(),
"tool_name": "Edit",
"tool_input": {
"file_path": dir.path().join("leaf.rs").to_str().unwrap(),
"old_string": "fn leaf() {}",
},
})
.to_string();
let Outcome::Notify(message) = guard(&payload, dir.path(), Some("t"), None) else {
panic!("expected a fail-open notice, not a block");
};
assert!(message.contains("UNGUARDED"));
assert!(message.contains("malformed path globs"));
assert_eq!(guard(&payload, dir.path(), Some("t"), None), Outcome::Allow);
let _ =
std::fs::remove_file(std::env::temp_dir().join(format!("hank-guard-failopen-{session}")));
}
#[test]
fn two_different_gaps_in_one_session_both_notify() {
let session = unique_session();
let mkpayload = |dir: &Path, file: &str| {
serde_json::json!({
"session_id": session,
"cwd": dir.to_str().unwrap(),
"tool_name": "Edit",
"tool_input": {
"file_path": dir.join(file).to_str().unwrap(),
"old_string": "fn leaf() {}",
"new_string": "fn leaf() { x(); }",
},
})
.to_string()
};
let a = tempfile::tempdir().unwrap();
std::fs::write(a.path().join("leaf.rs"), "fn leaf() {}\n").unwrap();
write_policy(a.path(), "this is not [[[ valid toml");
let Outcome::Notify(m1) = guard(&mkpayload(a.path(), "leaf.rs"), a.path(), Some("t"), None)
else {
panic!("gap 1 (config) must notify");
};
assert!(m1.contains("failed open"), "{m1}");
let b = wide_repo();
write_policy(
b.path(),
"[hank.policy]\nmode = \"enforce\"\ndeadline_ms = 0\n\
[hank.policy.scopes.t]\nmax_impacted_files = 1\n",
);
match guard(&mkpayload(b.path(), "leaf.rs"), b.path(), Some("t"), None) {
Outcome::Notify(m2) => assert!(m2.contains("NOT EVALUATED"), "{m2}"),
other => {
panic!("gap 2 (deadline) was SILENCED by gap 1's marker — the exact bug: {other:?}")
}
}
for kind in ["config", "unmeasured-deadline-leaf.rs"] {
let _ = std::fs::remove_file(
std::env::temp_dir().join(format!("hank-guard-failopen-{session}-{kind}")),
);
}
}
#[test]
fn an_unparseable_language_is_reported_unmeasured_not_silently_allowed() {
let dir = wide_repo();
std::fs::write(dir.path().join("notes.md"), "# hi\n").unwrap();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"enforce\"\ndeadline_ms = 30000\n\
[hank.policy.scopes.t]\nmax_impacted_files = 0\n",
);
let payload = edit_payload(dir.path(), "notes.md", "# hi");
match guard(&payload, dir.path(), Some("t"), None) {
Outcome::Notify(message) => {
assert!(message.contains("NOT EVALUATED"), "{message}");
assert!(message.contains("no grammar for `.md`"), "{message}");
assert!(message.contains("UNGUARDED"), "{message}");
}
other => panic!("an unparseable language must be reported, got {other:?}"),
}
}
#[cfg(feature = "langs-extra")]
#[test]
fn a_ceiling_that_denies_rust_denies_python_and_typescript_too() {
let cases: &[(&str, &str, &str, &str)] = &[
(
"py",
"def leaf():\n return 1\n",
"from leaf import leaf\ndef one():\n return leaf()\n",
"def leaf():",
),
(
"ts",
"export function leaf(): number { return 1; }\n",
"import { leaf } from \"./leaf\";\nexport function one() { return leaf(); }\n",
"export function leaf(): number { return 1; }",
),
];
for (ext, leaf_src, caller_src, anchor) in cases {
let dir = tempfile::tempdir().unwrap();
std::fs::write(dir.path().join(format!("leaf.{ext}")), leaf_src).unwrap();
std::fs::write(dir.path().join(format!("one.{ext}")), caller_src).unwrap();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"enforce\"\ndeadline_ms = 30000\n\
[hank.policy.scopes.t]\nmax_impacted_files = 0\n",
);
let payload = edit_payload(dir.path(), &format!("leaf.{ext}"), anchor);
match guard(&payload, dir.path(), Some("t"), None) {
Outcome::Deny(message) => assert!(
message.contains("reaches"),
".{ext}: denied, but not for reach: {message}"
),
other => panic!(
".{ext}: a zero ceiling did NOT deny an edit reaching another \
file — got {other:?}. The rule silently does not apply."
),
}
}
}
#[test]
fn a_config_override_scopes_the_guard() {
let dir = wide_repo(); let scope_file = dir.path().join("elsewhere").join("scope.toml");
std::fs::create_dir_all(scope_file.parent().unwrap()).unwrap();
std::fs::write(
&scope_file,
"[hank.policy]\nmode = \"enforce\"\n\
[hank.policy.scopes.t]\nallow_paths = [\"src/**\"]\n",
)
.unwrap();
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
assert_eq!(guard(&payload, dir.path(), Some("t"), None), Outcome::Allow);
let Outcome::Deny(reason) = guard(&payload, dir.path(), Some("t"), Some(&scope_file)) else {
panic!("the --config scope must govern the edit");
};
assert!(reason.contains("leaf.rs"));
assert!(reason.contains("outside the writable capability scope"));
}
#[test]
fn a_missing_config_override_fails_open_loudly() {
let dir = wide_repo();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"enforce\"\n\
[hank.policy.scopes.t]\nallow_paths = [\"src/**\"]\n",
);
let missing = dir.path().join("does-not-exist.toml");
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
let Outcome::Notify(message) = guard(&payload, dir.path(), Some("t"), Some(&missing)) else {
panic!("a bad --config must fail open loudly, not deny and not silently revert");
};
assert!(message.contains("UNGUARDED"));
assert!(message.contains("does not exist"));
}
const NO_TICKET_RULE: &str = "[hank.policy]\nmode = \"enforce\"\n\n\
[[hank.policy.rules]]\nname = \"no-ticket-in-comment\"\nlanguage = \"rust\"\n\
query = '(line_comment) @c'\nmatch_type = \"must-not-match\"\n\
pattern = '\\b[A-Z]+-[0-9]+\\b'\n";
fn rule_edit_payload(dir: &Path, new_string: &str) -> String {
serde_json::json!({
"session_id": unique_session(),
"cwd": dir.to_str().unwrap(),
"tool_name": "Edit",
"tool_input": {
"file_path": dir.join("leaf.rs").to_str().unwrap(),
"old_string": "fn leaf() {}",
"new_string": new_string,
},
})
.to_string()
}
#[test]
fn a_rule_denies_an_edit_introducing_a_forbidden_comment() {
let dir = wide_repo();
write_policy(dir.path(), NO_TICKET_RULE);
let payload = rule_edit_payload(dir.path(), "fn leaf() {} // see ABC-123");
let Outcome::Deny(reason) = guard(&payload, dir.path(), Some("t"), None) else {
panic!("a forbidden comment must be denied");
};
assert!(reason.contains("no-ticket-in-comment"), "{reason}");
assert!(reason.contains("ABC-123"), "{reason}");
assert!(reason.contains("treesitter tier"), "{reason}");
assert!(reason.contains("verdict freshness: fresh"), "{reason}");
}
#[test]
fn a_rule_allows_a_clean_edit() {
let dir = wide_repo();
write_policy(dir.path(), NO_TICKET_RULE);
let payload = rule_edit_payload(dir.path(), "fn leaf() {} // no ticket here");
assert_eq!(guard(&payload, dir.path(), Some("t"), None), Outcome::Allow);
}
#[test]
fn a_rule_applies_even_without_a_tenant_scope() {
let dir = wide_repo();
write_policy(dir.path(), NO_TICKET_RULE);
let payload = rule_edit_payload(dir.path(), "fn leaf() {} // ABC-123");
assert!(matches!(
guard(&payload, dir.path(), None, None),
Outcome::Deny(_)
));
}
#[test]
fn advise_mode_reports_a_rule_without_blocking() {
let dir = wide_repo();
write_policy(dir.path(), &NO_TICKET_RULE.replace("enforce", "advise"));
let payload = rule_edit_payload(dir.path(), "fn leaf() {} // ABC-123");
let Outcome::Notify(msg) = guard(&payload, dir.path(), Some("t"), None) else {
panic!("advise must not block");
};
assert!(msg.contains("not blocking"), "{msg}");
}
#[test]
fn a_pre_existing_comment_is_not_re_flagged_only_the_introduced_text_is() {
let dir = wide_repo();
std::fs::write(
dir.path().join("leaf.rs"),
"// legacy XYZ-999\nfn leaf() {}\n",
)
.unwrap();
write_policy(dir.path(), NO_TICKET_RULE);
let payload = rule_edit_payload(dir.path(), "fn leaf() {} // clean now");
assert_eq!(guard(&payload, dir.path(), Some("t"), None), Outcome::Allow);
}
#[test]
fn a_malformed_rule_fails_open_loudly() {
let dir = wide_repo();
let bad = "[hank.policy]\nmode = \"enforce\"\n\n\
[[hank.policy.rules]]\nname = \"broken\"\nlanguage = \"rust\"\n\
query = '(nonexistent_node) @x'\nmatch_type = \"must-not-match\"\npattern = 'x'\n";
write_policy(dir.path(), bad);
let payload = rule_edit_payload(dir.path(), "fn leaf() {} // whatever");
let Outcome::Notify(msg) = guard(&payload, dir.path(), Some("t"), None) else {
panic!("a malformed rule must fail open loudly, not block and not pass silently");
};
assert!(msg.contains("UNGUARDED"), "{msg}");
assert!(msg.contains("do not compile"), "{msg}");
}
#[cfg(feature = "quipu")]
#[test]
fn an_unreachable_quipu_projection_fails_open_loudly() {
let dir = wide_repo();
write_policy(
dir.path(),
"[hank.policy]\nmode = \"enforce\"\n\
[hank.quipu]\nenabled = true\nendpoint = \"http://127.0.0.1:1\"\n",
);
let payload = rule_edit_payload(dir.path(), "fn leaf() {} // whatever");
let Outcome::Notify(msg) = guard(&payload, dir.path(), Some("t"), None) else {
panic!("an unreachable quipu projection must fail open loudly, not pass silently");
};
assert!(msg.contains("UNGUARDED"), "{msg}");
assert!(msg.contains("could not project governed policy"), "{msg}");
}
const ALLOWS: &str = "[hank.policy.scopes.t]\nmax_impacted_files = 50\n";
const FORBIDS: &str = "[hank.policy.scopes.t]\nmax_impacted_files = 0\n";
fn policy_with_daemon(scope: &str, use_daemon: bool) -> String {
format!(
"[hank.policy]\nmode = \"enforce\"\ndeadline_ms = 30000\n{scope}\n\
[hank.serve]\nuse_daemon = {use_daemon}\nbind_address = \"127.0.0.1\"\n\
mcp_http_port = 1\n"
)
}
#[test]
fn no_daemon_expected_is_silent_transient_the_normal_case() {
let dir = wide_repo();
write_policy(dir.path(), &policy_with_daemon(ALLOWS, false));
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
assert_eq!(
guard(&payload, dir.path(), Some("t"), None),
Outcome::Allow,
"no daemon expected: transient build, allowed, silent"
);
}
#[test]
fn daemon_EXPECTED_but_DOWN_falls_back_and_is_LOUD_when_allowed() {
let dir = wide_repo();
write_policy(dir.path(), &policy_with_daemon(ALLOWS, true));
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
let Outcome::Notify(msg) = guard(&payload, dir.path(), Some("t"), None) else {
panic!("an allowed edit while the expected daemon is down must be LOUD, not silent");
};
assert!(msg.contains("daemon is DOWN"), "{msg}");
}
#[test]
fn daemon_EXPECTED_but_DOWN_still_DENIES_a_violation_block_wins() {
let dir = wide_repo(); write_policy(dir.path(), &policy_with_daemon(FORBIDS, true));
let payload = edit_payload(dir.path(), "leaf.rs", "fn leaf() {}");
assert!(
matches!(
guard(&payload, dir.path(), Some("t"), None),
Outcome::Deny(_)
),
"a violation must still be denied even with the expected daemon down"
);
}
#[test]
fn daemon_EXPECTED_but_DOWN_keeps_the_UNMEASURED_contract() {
let dir = wide_repo();
std::fs::write(dir.path().join("notes.md"), "# hi\n").unwrap();
write_policy(dir.path(), &policy_with_daemon(ALLOWS, true));
let payload = edit_payload(dir.path(), "notes.md", "# hi");
let Outcome::Notify(msg) = guard(&payload, dir.path(), Some("t"), None) else {
panic!("an unmeasurable file must stay UNMEASURED-loud");
};
assert!(msg.contains("NOT EVALUATED"), "{msg}");
}
#[cfg(feature = "quipu")]
fn text_violation(tier: crate::textrules::TextTier) -> crate::textrules::TextViolation {
crate::textrules::TextViolation {
rule: "pattern_internal-lan-host".into(),
tier,
message: "governed text rule `pattern_internal-lan-host`: the edit \
introduces `dolt.lan` (hostname) — internal .lan hostname."
.into(),
}
}
#[cfg(feature = "quipu")]
#[test]
fn a_block_tier_hit_in_a_public_repo_blocks() {
use crate::project::RepoExposure;
let (messages, blocks) = text_plane(
&[text_violation(crate::textrules::TextTier::Block)],
&RepoExposure::Public,
);
assert!(blocks, "this is the exact leak the rule exists to stop");
assert!(messages.iter().any(|m| m.contains("PUBLIC remote")));
}
#[cfg(feature = "quipu")]
#[test]
fn a_block_tier_hit_in_an_internal_repo_downgrades_and_says_why() {
use crate::project::RepoExposure;
let (messages, blocks) = text_plane(
&[text_violation(crate::textrules::TextTier::Block)],
&RepoExposure::Internal,
);
assert!(!blocks, "internal-only exposure must not block");
assert!(messages.iter().any(|m| m.contains("downgraded")));
assert!(messages
.iter()
.any(|m| m.contains("would BLOCK in a public repo")));
}
#[cfg(feature = "quipu")]
#[test]
fn an_unknown_repo_never_blocks_and_says_it_is_unknown() {
use crate::project::RepoExposure;
let (messages, blocks) = text_plane(
&[text_violation(crate::textrules::TextTier::Block)],
&RepoExposure::Unknown("repo `hank` is not in the graph".into()),
);
assert!(!blocks);
assert!(messages
.iter()
.any(|m| m.contains("never blocks on a guess")));
assert!(messages.iter().any(|m| m.contains("not in the graph")));
assert!(messages.iter().any(|m| m.contains("repo_<name>")));
}
#[cfg(feature = "quipu")]
#[test]
fn a_warn_tier_hit_never_blocks_even_in_a_public_repo() {
use crate::project::RepoExposure;
let (_, blocks) = text_plane(
&[text_violation(crate::textrules::TextTier::Warn)],
&RepoExposure::Public,
);
assert!(
!blocks,
"warn tier is advisory everywhere — per-pattern tier is data"
);
}