split-brain-harness 1.1.0

Soul-injected two-stage LLM telemetry pipeline. Wraps any LLM with affective/intent/cognitive analysis, deterministic verification, and a Stage 0 deobfuscation normalizer. Drop-in OpenAI-compatible proxy.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Integration tests for backend initialization and early-exit error paths.
//! These tests do not make real network calls — they verify that each backend
//! produces the expected error immediately for trivially-invalid config, and
//! that `init_engine` builds the right backend for each config variant.

use split_brain_harness::{
    backends,
    types::{BackendType, Config, VerifyMode},
};

fn make_config(backend: BackendType, api_key: Option<&str>) -> Config {
    Config {
        backend,
        endpoint: "http://localhost:1".into(), // unreachable — no real calls in these tests
        model_name: "test-model".into(),
        soul_path: String::new(),
        api_key: api_key.map(String::from),
        verify_mode: VerifyMode::Deterministic,
        timeout_secs: 5,
        dump_prompt: false,
        dump_raw: false,
        memory_path: None,
        audit_path: None,
        serve_key: None,
        serve_rate_limit: 60,
        serve_max_body_bytes: 1_048_576,
        session_log_path: None,
        context_path: None,
    }
}

// ---------------------------------------------------------------------------
// local-embedded — errors synchronously, no network
// ---------------------------------------------------------------------------

#[tokio::test]
async fn local_embedded_returns_not_implemented_error() {
    let cfg = make_config(BackendType::LocalEmbedded, None);
    let engine = backends::init_engine(&cfg);
    let err = engine.generate("sys", "payload").await.unwrap_err();
    assert!(
        err.contains("not yet implemented"),
        "expected 'not yet implemented' in error, got: {err}"
    );
}

#[tokio::test]
async fn local_embedded_error_mentions_model() {
    let cfg = make_config(BackendType::LocalEmbedded, None);
    let engine = backends::init_engine(&cfg);
    let err = engine.generate("sys", "payload").await.unwrap_err();
    assert!(
        err.contains("test-model"),
        "expected model name in error, got: {err}"
    );
}

// ---------------------------------------------------------------------------
// anthropic — errors synchronously when api_key is empty, no network
// ---------------------------------------------------------------------------

#[tokio::test]
async fn anthropic_empty_key_errors_before_network() {
    let cfg = make_config(BackendType::Anthropic, Some(""));
    let engine = backends::init_engine(&cfg);
    let err = engine.generate("sys", "payload").await.unwrap_err();
    assert!(
        err.contains("SBH_API_KEY"),
        "expected 'SBH_API_KEY' in error, got: {err}"
    );
}

#[tokio::test]
async fn anthropic_no_key_errors_before_network() {
    let cfg = make_config(BackendType::Anthropic, None);
    let engine = backends::init_engine(&cfg);
    let err = engine.generate("sys", "payload").await.unwrap_err();
    assert!(
        err.contains("SBH_API_KEY"),
        "expected 'SBH_API_KEY' in error, got: {err}"
    );
}

// ---------------------------------------------------------------------------
// init_engine — correct backend selected for each config variant
// ---------------------------------------------------------------------------
// We can't downcast Box<dyn InferenceEngine> directly, so we probe behavior:
// local-embedded and anthropic-no-key error immediately and deterministically;
// ollama and openai-compat will fail with a network error (not a logic error).

#[tokio::test]
async fn ollama_engine_errors_with_network_not_logic_error() {
    let cfg = make_config(BackendType::OllamaNative, None);
    let engine = backends::init_engine(&cfg);
    // Should attempt a network call and fail — error must NOT say "not yet implemented"
    let err = engine.generate("sys", "payload").await.unwrap_err();
    assert!(
        !err.contains("not yet implemented"),
        "ollama engine should not return stub error: {err}"
    );
}

#[tokio::test]
async fn openai_engine_errors_with_network_not_logic_error() {
    let cfg = make_config(BackendType::OpenAiCompat, None);
    let engine = backends::init_engine(&cfg);
    let err = engine.generate("sys", "payload").await.unwrap_err();
    assert!(
        !err.contains("not yet implemented"),
        "openai engine should not return stub error: {err}"
    );
}

// ---------------------------------------------------------------------------
// validate_config — covered more thoroughly in config.rs unit tests;
// these ensure it integrates correctly with real Config objects.
// ---------------------------------------------------------------------------

#[test]
fn validate_rejects_local_embedded() {
    let cfg = make_config(BackendType::LocalEmbedded, None);
    let errs = split_brain_harness::validate_config(&cfg).unwrap_err();
    assert!(errs.iter().any(|e| e.contains("local-embedded")));
}

#[test]
fn validate_rejects_anthropic_without_key() {
    let cfg = make_config(BackendType::Anthropic, None);
    let errs = split_brain_harness::validate_config(&cfg).unwrap_err();
    assert!(errs.iter().any(|e| e.contains("SBH_API_KEY")));
}

#[test]
fn validate_accepts_ollama_no_key() {
    let cfg = make_config(BackendType::OllamaNative, None);
    assert!(split_brain_harness::validate_config(&cfg).is_ok());
}