KeiSeiKit-1.0/_primitives/_rust/kei-agent-runtime/tests/pattern_gate_smoke.rs

//! Smoke tests for the generic `PatternGate` (Layer C convergence).
//!
//! Covers DenyIfMatch, AllowIfMatch, DenyIfUnmatched (scope), bypass env,
//! and non-applicable tool short-circuit.

use kei_agent_runtime::capability::{Capability, GateContext, GateDecision, TaskSpec};
use kei_agent_runtime::gates::pattern_gate::{GateMode, PatternGate, PatternSource};
use serde_json::json;
use std::collections::HashMap;

fn ctx<'a>(
    tool: &'a str,
    input: &'a serde_json::Value,
    task: &'a TaskSpec,
    env: &'a HashMap<String, String>,
) -> GateContext<'a> {
    GateContext { tool_name: tool, tool_input: input, task, env }
}

const TEST_GATE: PatternGate = PatternGate {
    name: "test::deny-if-match",
    tools: &["Bash"],
    field: "command",
    mode: GateMode::DenyIfMatch,
    patterns: PatternSource::StaticRegex(&[r"\bforbidden\b"]),
    bypass_env: Some("TEST_BYPASS"),
    deny_template: "{name} — {cmd} matched {pat}",
};

#[test]
fn deny_if_match_blocks_forbidden() {
    let task = TaskSpec::default();
    let env = HashMap::new();
    let input = json!({"command": "run forbidden action"});
    match TEST_GATE.check(&ctx("Bash", &input, &task, &env)) {
        GateDecision::Deny { .. } => {}
        other => panic!("expected Deny, got {other:?}"),
    }
}

#[test]
fn deny_if_match_allows_when_no_match() {
    let task = TaskSpec::default();
    let env = HashMap::new();
    let input = json!({"command": "echo hello"});
    assert_eq!(
        TEST_GATE.check(&ctx("Bash", &input, &task, &env)),
        GateDecision::Allow
    );
}

#[test]
fn allow_if_match_allows_on_match() {
    // Mirrors tools::bash-allowlist — use the real registry path.
    use kei_agent_runtime::registry;
    let g = registry::get_gate("tools::bash-allowlist").unwrap();
    let task = TaskSpec::default();
    let env = HashMap::new();
    let input = json!({"command": "cargo build"});
    assert_eq!(g.check(&ctx("Bash", &input, &task, &env)), GateDecision::Allow);
}

#[test]
fn allow_if_match_denies_on_miss() {
    use kei_agent_runtime::registry;
    let g = registry::get_gate("tools::bash-allowlist").unwrap();
    let task = TaskSpec::default();
    let env = HashMap::new();
    let input = json!({"command": "wget http://evil"});
    matches!(g.check(&ctx("Bash", &input, &task, &env)), GateDecision::Deny { .. });
}

#[test]
fn deny_if_unmatched_scope_whitelist_empty_allows() {
    // Empty whitelist = NotApplicable / Allow per spec.
    use kei_agent_runtime::registry;
    let g = registry::get_gate("scope::files-whitelist").unwrap();
    let task = TaskSpec::default(); // empty whitelist
    let env = HashMap::new();
    let input = json!({"file_path": "anywhere/foo.rs"});
    assert_eq!(g.check(&ctx("Edit", &input, &task, &env)), GateDecision::Allow);
}

#[test]
fn bypass_env_allows_even_on_match() {
    let task = TaskSpec::default();
    let mut env = HashMap::new();
    env.insert("TEST_BYPASS".into(), "1".into());
    let input = json!({"command": "run forbidden action"});
    assert_eq!(
        TEST_GATE.check(&ctx("Bash", &input, &task, &env)),
        GateDecision::Allow
    );
}

#[test]
fn non_matching_tool_is_not_applicable() {
    let task = TaskSpec::default();
    let env = HashMap::new();
    let input = json!({"command": "run forbidden action"});
    assert_eq!(
        TEST_GATE.check(&ctx("Read", &input, &task, &env)),
        GateDecision::NotApplicable
    );
}

#[test]
fn missing_field_is_not_applicable() {
    let task = TaskSpec::default();
    let env = HashMap::new();
    let input = json!({"not_the_field": "forbidden"});
    assert_eq!(
        TEST_GATE.check(&ctx("Bash", &input, &task, &env)),
        GateDecision::NotApplicable
    );
}

#[test]
fn safety_no_dep_bump_blocks_cargo_toml_path() {
    use kei_agent_runtime::registry;
    let g = registry::get_gate("safety::no-dep-bump").unwrap();
    let task = TaskSpec::default();
    let env = HashMap::new();
    let input = json!({"file_path": "nested/Cargo.toml"});
    match g.check(&ctx("Edit", &input, &task, &env)) {
        GateDecision::Deny { .. } => {}
        other => panic!("expected Deny, got {other:?}"),
    }
}

#[test]
fn safety_no_dep_bump_allows_bypass_env() {
    use kei_agent_runtime::registry;
    let g = registry::get_gate("safety::no-dep-bump").unwrap();
    let task = TaskSpec::default();
    let mut env = HashMap::new();
    env.insert("ALLOW_DEP_BUMP".into(), "1".into());
    let input = json!({"file_path": "Cargo.toml"});
    assert_eq!(g.check(&ctx("Edit", &input, &task, &env)), GateDecision::Allow);
}