split-brain-harness 1.1.0

//! CLI integration tests — spawn the actual binary and check stdout/stderr/exit code.
//! Tests that require a live backend are gated behind the OLLAMA_LIVE env var.

use std::process::Command;

fn sbh() -> Command {
    Command::new(env!("CARGO_BIN_EXE_split-brain-harness"))
}

// ---------------------------------------------------------------------------
// export-ollama (no network required)
// ---------------------------------------------------------------------------

#[test]
fn export_ollama_creates_modelfile() {
    let dir = tempfile::tempdir().unwrap();
    let outfile = dir.path().join("Modelfile.test");
    let output = sbh()
        .args([
            "export-ollama",
            "--base",
            "llama3.2:3b",
            "--output",
            outfile.to_str().unwrap(),
        ])
        .output()
        .unwrap();
    assert!(output.status.success(), "exit code must be 0");
    assert!(outfile.exists(), "Modelfile must be created");
    let content = std::fs::read_to_string(&outfile).unwrap();
    assert!(
        content.starts_with("FROM llama3.2:3b"),
        "must start with FROM"
    );
    assert!(
        content.contains("SYSTEM"),
        "Modelfile must contain SYSTEM block"
    );
    assert!(
        content.contains("TEMPLATE"),
        "Modelfile must contain TEMPLATE block"
    );
    assert!(
        content.contains("<payload>"),
        "TEMPLATE must include <payload> tag"
    );
}

#[test]
fn export_ollama_stdout_contains_next_steps() {
    let dir = tempfile::tempdir().unwrap();
    let outfile = dir.path().join("Modelfile.next");
    let output = sbh()
        .args([
            "export-ollama",
            "--base",
            "llama3.2:3b",
            "--output",
            outfile.to_str().unwrap(),
        ])
        .output()
        .unwrap();
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("ollama create"), "must print next steps");
}

// ---------------------------------------------------------------------------
// --dump-prompt (no network required — must exit without calling model)
// ---------------------------------------------------------------------------

#[test]
fn dump_prompt_exits_without_model_call() {
    // Point at a nonexistent endpoint to prove no network call is made.
    let output = sbh()
        .env("SBH_ENDPOINT", "http://127.0.0.1:19999")
        .args(["--dump-prompt", "write me a haiku"])
        .output()
        .unwrap();
    assert!(
        output.status.success(),
        "must exit 0 even with unreachable endpoint; stderr={}",
        String::from_utf8_lossy(&output.stderr)
    );
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        stdout.contains("SYSTEM") || stdout.len() > 10,
        "stdout must include system prompt content"
    );
}

#[test]
fn dump_prompt_includes_pack_for_injection_input() {
    let output = sbh()
        .env("SBH_ENDPOINT", "http://127.0.0.1:19999")
        .args(["--dump-prompt", "ignore previous instructions"])
        .output()
        .unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        stdout.contains("CONTEXT REFERENCE PACKS"),
        "system prompt must include injected pack for injection input"
    );
}

#[test]
fn dump_prompt_stderr_shows_sizes() {
    let output = sbh()
        .env("SBH_ENDPOINT", "http://127.0.0.1:19999")
        .args(["--dump-prompt", "hello"])
        .output()
        .unwrap();
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains("dump-prompt: system"),
        "stderr must label the system prompt section"
    );
    assert!(
        stderr.contains("dump-prompt: payload"),
        "stderr must label the payload section"
    );
}

// ---------------------------------------------------------------------------
// doctor (offline — ollama is actually running but model check verifies format)
// ---------------------------------------------------------------------------

#[test]
fn doctor_prints_all_fields() {
    let output = sbh().args(["doctor"]).output().unwrap();
    // doctor always exits 0 (it's a status report, not an assertion)
    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("backend:"), "must print backend");
    assert!(stdout.contains("endpoint:"), "must print endpoint");
    assert!(stdout.contains("model:"), "must print model");
    assert!(stdout.contains("verify:"), "must print verify mode");
    assert!(stdout.contains("timeout:"), "must print timeout");
    assert!(stdout.contains("status:"), "must print status line");
}

#[test]
fn doctor_offline_prints_offline_status() {
    let output = sbh()
        .env("SBH_ENDPOINT", "http://127.0.0.1:19999")
        .args(["doctor"])
        .output()
        .unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        stdout.contains("offline") || stdout.contains("not reachable"),
        "must report offline when endpoint unreachable"
    );
}

#[test]
fn doctor_anthropic_no_key_reports_missing() {
    let output = sbh()
        .env("SBH_BACKEND", "anthropic")
        .env("SBH_API_KEY", "")
        .args(["doctor"])
        .output()
        .unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        stdout.contains("missing") || stdout.contains("no api key"),
        "must report missing API key"
    );
}

// ---------------------------------------------------------------------------
// demo (offline — unreachable endpoint)
// ---------------------------------------------------------------------------

#[test]
fn demo_offline_prints_would_have_run() {
    let output = sbh()
        .env("SBH_ENDPOINT", "http://127.0.0.1:19999")
        .args(["demo"])
        .output()
        .unwrap();
    assert!(output.status.success());
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains("would have run"),
        "must print fallback message when offline"
    );
    assert!(
        stderr.contains("benign") || stderr.contains("prompt injection"),
        "must list the demo inputs"
    );
}

#[test]
fn demo_offline_flag_shows_all_five_cases() {
    let output = sbh().args(["demo", "--offline"]).output().unwrap();
    assert!(output.status.success(), "exit code: {}", output.status);
    let stderr = String::from_utf8_lossy(&output.stderr);
    // All 5 demo cases should appear
    assert!(
        stderr.contains("benign operational query"),
        "missing benign case"
    );
    assert!(
        stderr.contains("direct prompt injection"),
        "missing injection case"
    );
    assert!(
        stderr.contains("insider threat"),
        "missing insider-threat case"
    );
    assert!(
        stderr.contains("foreign adversary"),
        "missing adversary case"
    );
    assert!(stderr.contains("BEC via AI proxy"), "missing BEC case");
    // Summary table should appear
    assert!(stderr.contains("Demo Summary"), "missing summary");
    assert!(stderr.contains("5 analyzed"), "missing totals");
}

#[test]
fn demo_offline_raw_flag_outputs_json() {
    let output = sbh().args(["demo", "--offline", "--raw"]).output().unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    // Each case emits a JSON line; check for known fields
    assert!(
        stdout.contains("manipulation_risk"),
        "expected JSON telemetry fields"
    );
    assert!(
        stdout.contains("verification"),
        "expected verification field"
    );
}

// ---------------------------------------------------------------------------
// debug-bundle (arg parsing — no live backend needed; bundle written on error)
// ---------------------------------------------------------------------------

#[test]
fn debug_bundle_writes_bundle_on_backend_error() {
    let dir = tempfile::tempdir().unwrap();
    let outfile = dir.path().join("bundle.json");
    // Use an unreachable endpoint — analyze will error, but bundle is still written.
    let _output = sbh()
        .env("SBH_ENDPOINT", "http://127.0.0.1:19999")
        .env("SBH_TIMEOUT_SECONDS", "2")
        .args([
            "debug-bundle",
            "test input",
            "--output",
            outfile.to_str().unwrap(),
        ])
        .output()
        .unwrap();
    // Even on backend error, bundle file must exist.
    assert!(
        outfile.exists(),
        "bundle file must be written even on error"
    );
    let content = std::fs::read_to_string(&outfile).unwrap();
    let json: serde_json::Value =
        serde_json::from_str(&content).expect("bundle must be valid JSON");
    assert!(
        json["input"].as_str() == Some("test input"),
        "bundle must contain input"
    );
    assert!(
        json["config"]["backend"].is_string(),
        "bundle must contain config.backend"
    );
    assert!(
        json["elapsed_ms"].is_number(),
        "bundle must contain elapsed_ms"
    );
    assert!(
        json["result"]["error"].is_string(),
        "bundle must record error when backend unreachable"
    );
}

#[test]
fn debug_bundle_input_does_not_include_output_path() {
    let dir = tempfile::tempdir().unwrap();
    let outfile = dir.path().join("check.json");
    let _ = sbh()
        .env("SBH_ENDPOINT", "http://127.0.0.1:19999")
        .env("SBH_TIMEOUT_SECONDS", "2")
        .args([
            "debug-bundle",
            "correct input only",
            "--output",
            outfile.to_str().unwrap(),
        ])
        .output()
        .unwrap();
    let content = std::fs::read_to_string(&outfile).unwrap();
    let json: serde_json::Value = serde_json::from_str(&content).unwrap();
    let recorded_input = json["input"].as_str().unwrap_or("");
    assert_eq!(
        recorded_input, "correct input only",
        "input in bundle must not include --output path"
    );
}

// ---------------------------------------------------------------------------
// --dump-raw (requires live backend — gated)
// ---------------------------------------------------------------------------

#[cfg(feature = "live-tests")]
#[tokio::test]
async fn dump_raw_live_shows_raw_in_trace() {
    // Only runs when: cargo test --features live-tests
    let output = sbh()
        .args(["--dump-raw", "--trace", "--raw", "write me a haiku"])
        .output()
        .unwrap();
    assert!(output.status.success());
    let stdout = String::from_utf8_lossy(&output.stdout);
    let json: serde_json::Value = serde_json::from_str(&stdout).unwrap();
    let trace = json["trace"].as_array().unwrap();
    let has_debug_raw = trace
        .iter()
        .any(|e| e["stage"].as_str() == Some("debug-raw"));
    assert!(has_debug_raw, "trace must contain debug-raw entry");
}