destructive_command_guard 0.4.3

//! Comprehensive testing for Agent-Specific Profiles (Epic 9).
//!
//! This test module verifies:
//! - Agent detection from environment variables and process inspection
//! - Profile loading from configuration files
//! - Trust level affects evaluation outcomes
//! - Agent-specific allowlists work correctly
//! - Unknown agents use safe defaults
//! - History correctly records agent type
//!
//! # Testing Strategy
//!
//! 1. **Unit Tests**: Test individual components in isolation
//! 2. **Integration Tests**: Test agent type flows through the full pipeline
//! 3. **E2E Tests**: Test complete scenarios with config files and CLI

#![allow(clippy::doc_markdown)]

use std::collections::HashMap;
use std::io::Write;
use std::process::{Command, Stdio};

// =============================================================================
// Test Utilities
// =============================================================================

/// Path to the DCG binary (uses same target directory as the test binary).
fn dcg_binary() -> std::path::PathBuf {
    let mut path = std::env::current_exe().unwrap();
    path.pop(); // Remove test binary name
    path.pop(); // Remove deps/
    path.push("dcg");
    path
}

/// Run DCG in hook mode with environment variables.
fn run_hook_mode_with_env(command: &str, env_vars: &[(&str, &str)]) -> (String, String, i32) {
    let input = format!(
        r#"{{"tool_name":"Bash","tool_input":{{"command":"{}"}}}}"#,
        command.replace('\\', "\\\\").replace('"', "\\\"")
    );

    let mut cmd = Command::new(dcg_binary());
    cmd.stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped());

    // Apply environment variables
    for (key, value) in env_vars {
        cmd.env(key, value);
    }

    let mut child = cmd.spawn().expect("failed to spawn dcg process");

    {
        let stdin = child.stdin.as_mut().expect("failed to get stdin");
        stdin
            .write_all(input.as_bytes())
            .expect("failed to write to stdin");
    }

    let output = child.wait_with_output().expect("failed to wait for dcg");

    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
    let exit_code = output.status.code().unwrap_or(-1);

    (stdout, stderr, exit_code)
}

/// Run DCG in robot mode for cleaner JSON output.
fn run_robot_mode_with_env(args: &[&str], env_vars: &[(&str, &str)]) -> (String, String, i32) {
    let mut cmd = Command::new(dcg_binary());
    cmd.args(["--robot"])
        .args(args)
        .stdout(Stdio::piped())
        .stderr(Stdio::piped());

    // Apply environment variables
    for (key, value) in env_vars {
        cmd.env(key, value);
    }

    let output = cmd.output().expect("failed to run dcg");

    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
    let exit_code = output.status.code().unwrap_or(-1);

    (stdout, stderr, exit_code)
}

/// Run DCG test command with agent type.
#[allow(dead_code)]
fn run_test_command_as_agent(command: &str, agent: &str) -> (String, String, i32) {
    let agent_env_var = match agent {
        "claude-code" | "claude_code" => "CLAUDE_CODE",
        "aider" => "AIDER_SESSION",
        "continue" => "CONTINUE_SESSION_ID",
        "codex" | "codex-cli" => "CODEX_CLI",
        "gemini" | "gemini-cli" => "GEMINI_CLI",
        "copilot" | "copilot-cli" => "COPILOT_CLI",
        _ => "DCG_AGENT_TYPE",
    };

    run_robot_mode_with_env(&["test", command], &[(agent_env_var, "1")])
}

// =============================================================================
// Agent Detection Tests
// =============================================================================

mod agent_detection_tests {
    use super::*;

    #[test]
    fn test_detects_claude_code_via_env() {
        let (_stdout, stderr, exit_code) =
            run_robot_mode_with_env(&["--version"], &[("CLAUDE_CODE", "1")]);

        // Version command should succeed; --version writes to stderr
        assert_eq!(exit_code, 0, "version command should succeed");
        assert!(
            stderr.contains("dcg") || !stderr.is_empty(),
            "should produce output on stderr"
        );
    }

    #[test]
    fn test_detects_aider_via_env() {
        let (_stdout, stderr, exit_code) =
            run_robot_mode_with_env(&["--version"], &[("AIDER_SESSION", "1")]);

        assert_eq!(exit_code, 0, "version command should succeed");
        assert!(
            stderr.contains("dcg") || !stderr.is_empty(),
            "should produce output on stderr"
        );
    }

    #[test]
    fn test_detects_continue_via_env() {
        let (_stdout, stderr, exit_code) = run_robot_mode_with_env(
            &["--version"],
            &[("CONTINUE_SESSION_ID", "test-session-123")],
        );

        assert_eq!(exit_code, 0, "version command should succeed");
        assert!(
            stderr.contains("dcg") || !stderr.is_empty(),
            "should produce output on stderr"
        );
    }

    #[test]
    fn test_detects_codex_via_env() {
        let (_stdout, stderr, exit_code) =
            run_robot_mode_with_env(&["--version"], &[("CODEX_CLI", "1")]);

        assert_eq!(exit_code, 0, "version command should succeed");
        assert!(
            stderr.contains("dcg") || !stderr.is_empty(),
            "should produce output on stderr"
        );
    }

    #[test]
    fn test_detects_gemini_via_env() {
        let (_stdout, stderr, exit_code) =
            run_robot_mode_with_env(&["--version"], &[("GEMINI_CLI", "1")]);

        assert_eq!(exit_code, 0, "version command should succeed");
        assert!(
            stderr.contains("dcg") || !stderr.is_empty(),
            "should produce output on stderr"
        );
    }

    #[test]
    fn test_detects_copilot_cli_via_env() {
        let (_stdout, stderr, exit_code) =
            run_robot_mode_with_env(&["--version"], &[("COPILOT_CLI", "1")]);

        assert_eq!(exit_code, 0, "version command should succeed");
        assert!(
            stderr.contains("dcg") || !stderr.is_empty(),
            "should produce output on stderr"
        );
    }

    #[test]
    fn test_detects_copilot_cli_via_start_time_env() {
        let (_stdout, stderr, exit_code) = run_robot_mode_with_env(
            &["--version"],
            &[("COPILOT_AGENT_START_TIME_SEC", "1709573241")],
        );

        assert_eq!(exit_code, 0, "version command should succeed");
        assert!(
            stderr.contains("dcg") || !stderr.is_empty(),
            "should produce output on stderr"
        );
    }

    #[test]
    fn test_unknown_agent_when_no_env_set() {
        // Clear all agent env vars by not setting any
        let (_stdout, stderr, exit_code) = run_robot_mode_with_env(&["--version"], &[]);

        assert_eq!(
            exit_code, 0,
            "version command should succeed without agent env"
        );
        assert!(
            stderr.contains("dcg") || !stderr.is_empty(),
            "should produce output on stderr"
        );
    }

    #[test]
    fn test_explicit_agent_flag_override() {
        // When --agent is specified, it should override env detection
        let (_stdout, stderr, exit_code) = run_robot_mode_with_env(
            &["--agent", "custom-agent", "--version"],
            &[("CLAUDE_CODE", "1")], // This should be ignored
        );

        assert_eq!(exit_code, 0, "version command should succeed");
        assert!(
            stderr.contains("dcg") || !stderr.is_empty(),
            "should produce output on stderr"
        );
    }
}

// =============================================================================
// Profile Loading Tests
// =============================================================================

mod profile_loading_tests {
    use super::*;

    #[test]
    fn test_loads_agent_profile_from_config() {
        // This test verifies that config files with agent profiles are parsed correctly
        // by checking that DCG runs without errors when a config is present
        let (stdout, stderr, exit_code) =
            run_robot_mode_with_env(&["config"], &[("CLAUDE_CODE", "1")]);

        assert_eq!(
            exit_code, 0,
            "config command should succeed. stderr: {stderr}"
        );
        // Config command outputs to stderr (human-readable) or stdout (robot/JSON mode)
        let combined = format!("{stdout}{stderr}");
        assert!(
            combined.contains('{') || combined.contains('[') || combined.contains("Config"),
            "config output should contain structured data. stdout: {stdout}, stderr: {stderr}"
        );
    }

    #[test]
    fn test_default_profile_when_no_agent_config() {
        // When no specific agent profile exists, should use defaults
        let (stdout, stderr, exit_code) = run_robot_mode_with_env(&["config"], &[]);

        assert_eq!(
            exit_code, 0,
            "config command should succeed without agent. stderr: {stderr}"
        );
        assert!(
            !stdout.is_empty(),
            "should produce config output. stdout: {stdout}"
        );
    }
}

// =============================================================================
// Trust Level Effects Tests
// =============================================================================

mod trust_level_tests {
    use super::*;

    #[test]
    fn test_destructive_command_blocked_regardless_of_agent() {
        // Critical severity commands should be blocked for ALL agents
        let destructive_commands = [
            "git reset --hard HEAD~5",
            "rm -rf /",
            "git clean -fd",
            "git push --force origin main",
        ];

        let agents = [
            ("CLAUDE_CODE", "1"),
            ("AIDER_SESSION", "1"),
            ("CODEX_CLI", "1"),
            ("GEMINI_CLI", "1"),
            ("COPILOT_CLI", "1"),
        ];

        for cmd in destructive_commands {
            for (agent_var, agent_val) in &agents {
                let (stdout, _stderr, exit_code) =
                    run_hook_mode_with_env(cmd, &[(agent_var, agent_val)]);

                // Hook mode always exits 0
                assert_eq!(
                    exit_code, 0,
                    "hook mode should exit 0 for cmd: {cmd} with agent: {agent_var}"
                );

                // But should produce denial JSON
                if !stdout.is_empty() {
                    let json: serde_json::Value = serde_json::from_str(&stdout)
                        .unwrap_or_else(|_| panic!("Invalid JSON for cmd '{cmd}': {stdout}"));

                    if let Some(hook_output) = json.get("hookSpecificOutput") {
                        let decision = hook_output
                            .get("permissionDecision")
                            .and_then(|v| v.as_str());

                        assert_eq!(
                            decision,
                            Some("deny"),
                            "Critical command '{cmd}' should be denied for agent {agent_var}"
                        );
                    }
                }
            }
        }
    }

    #[test]
    fn test_safe_command_allowed_for_all_agents() {
        // Safe commands should be allowed regardless of agent
        let safe_commands = [
            "git status",
            "git log --oneline",
            "ls -la",
            "git diff HEAD",
            "git branch -a",
        ];

        let agents = [
            ("CLAUDE_CODE", "1"),
            ("AIDER_SESSION", "1"),
            ("CODEX_CLI", "1"),
            ("GEMINI_CLI", "1"),
            ("COPILOT_CLI", "1"),
        ];

        for cmd in safe_commands {
            for (agent_var, agent_val) in &agents {
                let (stdout, _stderr, exit_code) =
                    run_hook_mode_with_env(cmd, &[(agent_var, agent_val)]);

                assert_eq!(exit_code, 0, "hook mode should exit 0 for safe cmd: {cmd}");

                // Safe commands should produce empty output (allowed)
                assert!(
                    stdout.trim().is_empty(),
                    "Safe command '{cmd}' should be allowed (empty output) for agent {agent_var}, got: {stdout}"
                );
            }
        }
    }

    #[test]
    fn test_trust_level_ordering() {
        // Verify that trust levels have correct semantic ordering
        // High > Medium > Low (higher trust = more permissive)

        // This is a conceptual test - we verify by checking that
        // the DCG binary understands trust levels in configuration
        let (stdout, stderr, exit_code) = run_robot_mode_with_env(&["config"], &[]);

        assert_eq!(
            exit_code, 0,
            "config command should succeed. stderr: {stderr}"
        );
        // The config output should be parseable
        assert!(
            !stdout.is_empty(),
            "config should produce output. stdout: {stdout}"
        );
    }
}

// =============================================================================
// Agent-Specific Allowlist Tests
// =============================================================================

mod agent_allowlist_tests {
    use super::*;

    #[test]
    fn test_command_evaluation_varies_by_agent() {
        // The same command might be treated differently by different agents
        // based on their trust levels and allowlists

        // For now, we verify that different agents can evaluate the same command
        let test_command = "npm run build";

        let agents = [
            ("CLAUDE_CODE", "1"),
            ("AIDER_SESSION", "1"),
            ("CODEX_CLI", "1"),
        ];

        let mut results: HashMap<&str, bool> = HashMap::new();

        for (agent_var, agent_val) in &agents {
            let (stdout, _stderr, exit_code) =
                run_hook_mode_with_env(test_command, &[(agent_var, agent_val)]);

            assert_eq!(exit_code, 0, "hook mode should exit 0");

            let is_allowed = stdout.trim().is_empty();
            results.insert(agent_var, is_allowed);
        }

        // All agents should get the same result for a non-destructive command
        // (since there's no agent-specific config in default setup)
        let all_same = results.values().all(|&v| v == results["CLAUDE_CODE"]);
        assert!(
            all_same,
            "Without agent-specific config, results should be consistent"
        );
    }
}

// =============================================================================
// Unknown Agent Handling Tests
// =============================================================================

mod unknown_agent_tests {
    use super::*;

    #[test]
    fn test_unknown_agent_uses_safe_defaults() {
        // When agent is unknown, DCG should use conservative defaults
        let destructive_cmd = "git reset --hard";

        // Run without any agent env var
        let (stdout, _stderr, exit_code) = run_hook_mode_with_env(destructive_cmd, &[]);

        assert_eq!(exit_code, 0, "hook mode should exit 0");

        // Destructive commands should still be blocked
        if !stdout.is_empty() {
            let json: serde_json::Value =
                serde_json::from_str(&stdout).expect("should be valid JSON");

            if let Some(hook_output) = json.get("hookSpecificOutput") {
                let decision = hook_output
                    .get("permissionDecision")
                    .and_then(|v| v.as_str());

                assert_eq!(
                    decision,
                    Some("deny"),
                    "Unknown agent should still have destructive commands blocked"
                );
            }
        }
    }

    #[test]
    fn test_custom_agent_name_handled() {
        // A custom/unknown agent name should be handled gracefully
        let (stdout, _stderr, exit_code) = run_robot_mode_with_env(
            &["test", "git status"],
            &[("DCG_AGENT_TYPE", "my-custom-agent")],
        );

        // Should not crash or error
        assert!(
            exit_code == 0 || exit_code == 1,
            "should handle custom agent name gracefully, got exit code: {exit_code}"
        );

        // If there's output, it should be valid JSON (in robot mode)
        if !stdout.trim().is_empty() {
            let _: serde_json::Value = serde_json::from_str(&stdout)
                .unwrap_or_else(|_| panic!("Invalid JSON for custom agent: {stdout}"));
        }
    }
}

// =============================================================================
// Integration Tests - Agent Type Flows Through Pipeline
// =============================================================================

mod integration_tests {
    use super::*;

    #[test]
    fn test_agent_type_in_verbose_output() {
        // When verbose mode is enabled, the detected agent should be shown
        let (stdout, stderr, exit_code) =
            run_robot_mode_with_env(&["-v", "test", "git status"], &[("CLAUDE_CODE", "1")]);

        // Should succeed
        assert!(
            exit_code == 0 || exit_code == 1,
            "test command should complete. stderr: {stderr}"
        );

        // The output or stderr should mention the agent in verbose mode
        // (depending on implementation)
        let combined = format!("{stdout}{stderr}");
        // This assertion is relaxed since verbose output format may vary
        assert!(
            !combined.is_empty() || exit_code == 0,
            "should produce some output or succeed"
        );
    }

    #[test]
    fn test_explain_shows_evaluation_context() {
        // The explain command should show how the command was evaluated
        let (stdout, stderr, exit_code) =
            run_robot_mode_with_env(&["explain", "git reset --hard"], &[("CLAUDE_CODE", "1")]);

        // Should succeed
        assert!(
            exit_code == 0 || exit_code == 1,
            "explain command should complete. stderr: {stderr}"
        );

        // Should produce detailed output
        assert!(
            !stdout.is_empty() || !stderr.is_empty(),
            "explain should produce output"
        );
    }

    #[test]
    fn test_consistent_results_across_multiple_calls() {
        // Running the same command multiple times should give consistent results
        let test_cmd = "git status";
        let agent_env = &[("CLAUDE_CODE", "1")];

        let mut results: Vec<bool> = Vec::new();

        for _ in 0..3 {
            let (stdout, _stderr, exit_code) = run_hook_mode_with_env(test_cmd, agent_env);
            assert_eq!(exit_code, 0);
            results.push(stdout.trim().is_empty()); // true if allowed
        }

        // All results should be the same
        assert!(
            results.iter().all(|&r| r == results[0]),
            "Results should be consistent across multiple calls"
        );
    }
}

// =============================================================================
// Edge Cases
// =============================================================================

mod edge_cases {
    use super::*;

    #[test]
    fn test_multiple_agent_env_vars_set() {
        // When multiple agent env vars are set, first one should win
        let (stdout, _stderr, exit_code) = run_hook_mode_with_env(
            "git status",
            &[("CLAUDE_CODE", "1"), ("AIDER_SESSION", "1")],
        );

        // Should not crash
        assert_eq!(exit_code, 0, "should handle multiple agent env vars");
        // Safe command should be allowed
        assert!(stdout.trim().is_empty(), "safe command should be allowed");
    }

    #[test]
    fn test_empty_agent_env_var_value() {
        // An empty env var value should be treated as unset
        let (stdout, _stderr, exit_code) =
            run_hook_mode_with_env("git status", &[("CLAUDE_CODE", "")]);

        assert_eq!(exit_code, 0, "should handle empty agent env var");
        assert!(stdout.trim().is_empty(), "safe command should be allowed");
    }

    #[test]
    fn test_agent_env_var_with_special_characters() {
        // Env var values with special characters should be handled
        let (stdout, _stderr, exit_code) = run_hook_mode_with_env(
            "git status",
            &[("CLAUDE_SESSION_ID", "session-123-test_value.abc")],
        );

        assert_eq!(exit_code, 0, "should handle special chars in env var");
        assert!(stdout.trim().is_empty(), "safe command should be allowed");
    }
}

// =============================================================================
// Performance Tests
// =============================================================================

mod performance_tests {
    use super::*;
    use std::time::Instant;

    #[test]
    fn test_agent_detection_does_not_add_significant_latency() {
        // Agent detection should be fast (< 50ms overhead)
        let iterations = 5;
        let mut total_time = std::time::Duration::ZERO;

        for _ in 0..iterations {
            let start = Instant::now();
            let (stdout, _stderr, exit_code) =
                run_hook_mode_with_env("git status", &[("CLAUDE_CODE", "1")]);
            let duration = start.elapsed();

            assert_eq!(exit_code, 0);
            assert!(stdout.trim().is_empty());

            total_time += duration;
        }

        let avg_time = total_time / iterations as u32;

        // Allow up to 100ms per call (generous for CI environments)
        assert!(
            avg_time.as_millis() < 100,
            "Average hook evaluation time should be < 100ms, got: {:?}",
            avg_time
        );
    }
}