Skip to content
Python
18.8 KB
Raw Blame
use openworker_runtime::connections::{Choice, Manager};
use serde_json::json;
fn key(id: &str, secret: &str, persistence: &str) -> serde_json::Value {
    json!({"id":id,"label":"Test connection","provider":"openai","api_key":secret,"persistence":persistence})
}
#[test]
fn memory_keys_are_not_persisted_or_listed() {
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    m.set(key("test", "secret-for-test-only", "memory"))
        .unwrap();
    let chosen = m
        .resolve(&Choice {
            connection: "test".into(),
            model: "gpt-6-sol".into(),
        })
        .unwrap();
    assert_eq!(&**m.key(&chosen).unwrap(), "secret-for-test-only");
    assert!(!m
        .list()
        .unwrap()
        .to_string()
        .contains("secret-for-test-only"));
    drop(m);
    let bytes = std::fs::read(root.path().join("model-connections.sqlite")).unwrap();
    assert!(!bytes.windows(20).any(|w| w == b"secret-for-test-only"));
    let m = Manager::open(root.path()).unwrap();
    assert!(m.key(&chosen).is_err());
    assert_eq!(m.list().unwrap()["connections"][0]["configured"], false);
}
#[test]
fn rotation_preserves_identity_but_removal_and_recreation_does_not() {
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    m.set(key("test", "secret-one", "memory")).unwrap();
    let chosen = m
        .resolve(&Choice {
            connection: "test".into(),
            model: "gpt-6-sol".into(),
        })
        .unwrap();
    m.set(key("test", "secret-two", "memory")).unwrap();
    assert_eq!(&**m.key(&chosen).unwrap(), "secret-two");
    m.remove("test").unwrap();
    assert!(m.key(&chosen).is_err());
    m.set(key("test", "secret-three", "memory")).unwrap();
    assert!(m.key(&chosen).is_err());
}
#[test]
fn defaults_are_separate_validated_and_durable() {
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    m.set(key("test", "secret-one", "memory")).unwrap();
    m.set_defaults(json!({"agent":{"connection":"test","model":"gpt-6-sol"},"reviewer":{"connection":"test","model":"gpt-6-astra"}})).unwrap();
    drop(m);
    let m = Manager::open(root.path()).unwrap();
    assert_eq!(m.defaults().unwrap().reviewer.unwrap().model, "gpt-6-astra");
    assert!(m
        .set_defaults(
            json!({"agent":{"connection":"missing","model":"valid-model"},"reviewer":null})
        )
        .is_err());
    assert!(Choice {
        connection: "test".into(),
        model: "bad model".into()
    }
    .validate()
    .is_err());
}
#[test]
fn malformed_secret_requests_have_sanitized_errors() {
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    let err = m
        .set(json!({"api_key":"DO-NOT-ECHO-secret"}))
        .unwrap_err()
        .to_string();
    assert!(!err.contains("DO-NOT-ECHO"));
}

#[test]
fn anthropic_connection_is_pinned_and_cannot_be_retyped_or_cross_wired() {
    use openworker_runtime::provider::Kind;
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    let mut v = key("claude", "anthropic-test-key", "memory");
    v["provider"] = json!("anthropic");
    m.set(v.clone()).unwrap();
    let selected = m
        .resolve(&Choice {
            connection: "claude".into(),
            model: "claude-test".into(),
        })
        .unwrap();
    assert_eq!(selected.provider, Kind::Anthropic);
    assert_eq!(m.list().unwrap()["connections"][0]["provider"], "anthropic");
    v["provider"] = json!("openai");
    assert!(m.set(v).is_err());
    let mut changed = selected.clone();
    changed.provider = Kind::Openai;
    assert!(m.key(&changed).is_err());
    drop(m);
    let m = Manager::open(root.path()).unwrap();
    assert!(m.key(&selected).is_err());
    let mut v = key("claude", "new-anthropic-key", "memory");
    v["provider"] = json!("anthropic");
    m.set(v).unwrap();
    assert_eq!(&**m.key(&selected).unwrap(), "new-anthropic-key");
}

#[test]
fn server_connections_share_identity_across_nodes_without_persisting_keys() {
    use openworker_runtime::provider::Kind;
    let a = tempfile::tempdir().unwrap();
    let b = tempfile::tempdir().unwrap();
    let ma = Manager::open(a.path()).unwrap();
    let mb = Manager::open(b.path()).unwrap();
    ma.register_host_reference("claude", Kind::Anthropic, "deployment:connection-v1")
        .unwrap();
    let reference = ma
        .resolve(&Choice {
            connection: "claude".into(),
            model: "claude-test".into(),
        })
        .unwrap();
    assert!(ma.key(&reference).is_err());
    ma.register_host(
        "claude",
        Kind::Anthropic,
        "deployment:connection-v1",
        "test-key-one".to_owned().into(),
    )
    .unwrap();
    let selection = ma
        .resolve(&Choice {
            connection: "claude".into(),
            model: "claude-test".into(),
        })
        .unwrap();
    assert_eq!(selection.identity, reference.identity);
    mb.register_host(
        "claude",
        Kind::Anthropic,
        "deployment:connection-v1",
        "test-key-two".to_owned().into(),
    )
    .unwrap();
    assert_eq!(&**mb.key(&selection).unwrap(), "test-key-two");
    mb.register_host(
        "claude",
        Kind::Anthropic,
        "deployment:connection-v2",
        "test-key-three".to_owned().into(),
    )
    .unwrap();
    assert!(mb.key(&selection).is_err());
    assert!(mb
        .register_host(
            "claude",
            Kind::Openai,
            "deployment:connection-v1",
            "test-key-four".to_owned().into()
        )
        .is_err());
    drop(ma);
    drop(mb);
    for p in [a.path(), b.path()] {
        let bytes = std::fs::read(p.join("model-connections.sqlite")).unwrap();
        assert!(!bytes.windows(8).any(|w| w == b"test-key"));
    }
}
#[cfg(not(any(windows, target_os = "macos")))]
#[test]
fn no_plaintext_fallback() {
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    assert!(m.set(key("test", "secret-one", "secure")).is_err());
    assert_eq!(m.list().unwrap()["connections"], json!([]));
}
#[cfg(windows)]
#[test]
fn windows_secure_roundtrip_no_plaintext_and_scope_binding() {
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    m.set(key("test", "secret-for-test-only", "secure"))
        .unwrap();
    let chosen = m
        .resolve(&Choice {
            connection: "test".into(),
            model: "gpt-6-sol".into(),
        })
        .unwrap();
    drop(m);
    let bytes = std::fs::read(root.path().join("model-connections.sqlite")).unwrap();
    assert!(!bytes.windows(20).any(|w| w == b"secret-for-test-only"));
    let m = Manager::open(root.path()).unwrap();
    assert_eq!(&**m.key(&chosen).unwrap(), "secret-for-test-only");
    drop(m);
    let other = tempfile::tempdir().unwrap();
    std::fs::copy(
        root.path().join("model-connections.sqlite"),
        other.path().join("model-connections.sqlite"),
    )
    .unwrap();
    let m = Manager::open(other.path()).unwrap();
    assert!(m.key(&chosen).is_err());
}

#[test]
fn provider_endpoint_is_immutable_and_local_models_need_no_fake_key() {
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    let config =
        json!({"name":"Ollama","api":"chat-completions","base_url":"http://127.0.0.1:11434/v1"});
    assert!(m
        .set_provider(json!({"name":"LocalMissingUrl","api":"chat-completions"}))
        .is_err());
    m.set_provider(config.clone()).unwrap();
    assert!(m
        .register_host(
            "Ollama",
            openworker_runtime::provider::Kind::Openai,
            "deployment",
            zeroize::Zeroizing::new("test-only-key".into())
        )
        .is_err());
    let selected = m.resolve(&Choice::new("Ollama", "org/model:8b")).unwrap();
    assert!(m.key(&selected).unwrap().is_empty());
    assert_eq!(
        m.endpoint(&selected).unwrap().1,
        "http://127.0.0.1:11434/v1/chat/completions"
    );
    assert_eq!(m.list().unwrap()["connections"][0]["configured"], true);
    let mut changed = config.clone();
    changed["base_url"] = json!("https://different.example/v1");
    assert!(m.set_provider(changed).is_err());
    let mut changed = config.clone();
    changed["api"] = json!("responses");
    assert!(m.set_provider(changed).is_err());
    let mut rotated = config.clone();
    rotated["credentials"] = json!({"api_key":"new-test-key","storage":"memory"});
    m.set_provider(rotated).unwrap();
    assert_eq!(&**m.key(&selected).unwrap(), "new-test-key");
    drop(m);
    let m = Manager::open(root.path()).unwrap();
    assert!(m.key(&selected).is_err());
    m.set_provider(config.clone()).unwrap();
    assert!(m.key(&selected).is_err()); // Missing memory key is not silently removed.
    m.remove("Ollama").unwrap();
    m.set_provider(config).unwrap();
    assert!(m.endpoint(&selected).is_err());
}

#[test]
fn chat_stream_usage_defaults_on_and_opt_out_survives_rotation_and_restart() {
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    let config =
        json!({"name":"Local","api":"chat-completions","base_url":"http://127.0.0.1:11434/v1"});
    m.set_provider(config.clone()).unwrap();
    let selected = m.resolve(&Choice::new("Local", "fixture")).unwrap();
    assert!(m.stream_usage(&selected).unwrap());
    assert_eq!(m.list().unwrap()["connections"][0]["stream_usage"], true);

    let mut disabled = config.clone();
    disabled["stream_usage"] = json!(false);
    m.set_provider(disabled).unwrap();
    m.set_provider(config.clone()).unwrap();
    assert!(!m.stream_usage(&selected).unwrap());
    let mut rotated = config.clone();
    rotated["credentials"] = json!({"api_key":"fixture-key-only","storage":"memory"});
    m.set_provider(rotated).unwrap();
    assert!(!m.stream_usage(&selected).unwrap());
    assert_eq!(&**m.key(&selected).unwrap(), "fixture-key-only");
    drop(m);

    let m = Manager::open(root.path()).unwrap();
    assert!(!m.stream_usage(&selected).unwrap());
    assert_eq!(m.list().unwrap()["connections"][0]["stream_usage"], false);
    let mut enabled = config.clone();
    enabled["stream_usage"] = json!(true);
    m.set_provider(enabled).unwrap();
    assert!(m.stream_usage(&selected).unwrap());
    let mut invalid = config.clone();
    invalid["stream_usage"] = json!("false");
    assert!(m.set_provider(invalid).is_err());
    assert!(m.stream_usage(&selected).unwrap());
    m.remove("Local").unwrap();
    m.set_provider(config).unwrap();
    assert!(m.stream_usage(&selected).is_err());
}

#[test]
fn anthropic_thinking_is_explicit_validated_and_persisted() {
    use openworker_runtime::anthropic::Thinking;
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    let config =
        json!({"name":"Claude","api":"anthropic","base_url":"https://api.anthropic.com/v1"});
    m.set_provider(config.clone()).unwrap();
    let selected = m.resolve(&Choice::new("Claude", "fixture")).unwrap();
    assert!(m.thinking(&selected).unwrap().is_none());
    let mut enabled = config.clone();
    enabled["thinking"] = json!({"type":"enabled","budgetTokens":2048});
    m.set_provider(enabled).unwrap();
    m.set_provider(config.clone()).unwrap();
    assert_eq!(
        m.thinking(&selected).unwrap(),
        Some(Thinking::Enabled {
            budget_tokens: 2048
        })
    );
    let mut invalid = config.clone();
    invalid["thinking"] = json!({"type":"enabled","budgetTokens":2});
    assert!(m.set_provider(invalid).is_err());
    drop(m);
    let m = Manager::open(root.path()).unwrap();
    assert_eq!(
        m.thinking(&selected).unwrap(),
        Some(Thinking::Enabled {
            budget_tokens: 2048
        })
    );
    assert!(m
        .set_provider(json!({"name":"Wrong","api":"responses","thinking":{"type":"adaptive"}}))
        .is_err());
    let mut disabled = config;
    disabled["thinking"] = json!({"type":"disabled"});
    m.set_provider(disabled).unwrap();
    assert_eq!(m.thinking(&selected).unwrap(), Some(Thinking::Disabled));
    m.remove("Claude").unwrap();
    assert!(m.thinking(&selected).is_err());
}

#[test]
fn chat_stream_usage_migrates_existing_endpoint_rows() {
    let root = tempfile::tempdir().unwrap();
    let db = rusqlite::Connection::open(root.path().join("model-connections.sqlite")).unwrap();
    db.execute_batch(
        "CREATE TABLE connections(id TEXT PRIMARY KEY,label TEXT NOT NULL,identity TEXT NOT NULL,persistence TEXT NOT NULL,secret BLOB,provider TEXT NOT NULL);
         CREATE TABLE endpoints(id TEXT PRIMARY KEY,api TEXT NOT NULL,base_url TEXT NOT NULL);
         INSERT INTO connections VALUES('Local','Local','legacy-identity','none',NULL,'openai');
         INSERT INTO endpoints VALUES('Local','\"chat-completions\"','http://127.0.0.1:11434/v1');",
    ).unwrap();
    drop(db);
    let m = Manager::open(root.path()).unwrap();
    let selected = m.resolve(&Choice::new("Local", "fixture")).unwrap();
    assert!(m.stream_usage(&selected).unwrap());
    assert_eq!(selected.identity, "legacy-identity");
    drop(m);
    assert!(Manager::open(root.path())
        .unwrap()
        .stream_usage(&selected)
        .unwrap());
}

#[test]
fn anthropic_prompt_caching_is_durable_and_preserves_provider_identity() {
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    let config = json!({"name":"Claude","api":"anthropic","credentials":{"api_key":"fixture-key-one","storage":"memory"}});
    m.set_provider(config.clone()).unwrap();
    let selected = m.resolve(&Choice::new("Claude", "fixture")).unwrap();
    assert!(m.prompt_caching(&selected).unwrap());
    let mut disabled = config.clone();
    disabled["prompt_caching"] = json!(false);
    m.set_provider(disabled).unwrap();
    let mut rotated = config;
    rotated["credentials"]["api_key"] = json!("fixture-key-two");
    m.set_provider(rotated).unwrap();
    assert!(!m.prompt_caching(&selected).unwrap());
    assert_eq!(&**m.key(&selected).unwrap(), "fixture-key-two");
    drop(m);
    let m = Manager::open(root.path()).unwrap();
    m.set_provider(json!({"name":"Claude","api":"anthropic"}))
        .unwrap();
    assert!(!m.prompt_caching(&selected).unwrap());
    assert_eq!(m.list().unwrap()["connections"][0]["prompt_caching"], false);
    m.set_provider(json!({"name":"Claude","api":"anthropic","prompt_caching":true}))
        .unwrap();
    assert!(m.prompt_caching(&selected).unwrap());
    for api in ["responses", "chat-completions"] {
        assert!(m
            .set_provider(json!({"name":"Wrong","api":api,"prompt_caching":false}))
            .is_err());
    }
    m.remove("Claude").unwrap();
    assert!(m.prompt_caching(&selected).is_err());
}

#[test]
fn legacy_anthropic_connections_can_opt_out_without_replacing_credentials() {
    let root = tempfile::tempdir().unwrap();
    let db = rusqlite::Connection::open(root.path().join("model-connections.sqlite")).unwrap();
    db.execute_batch(
        "CREATE TABLE connections(id TEXT PRIMARY KEY,label TEXT NOT NULL,identity TEXT NOT NULL,persistence TEXT NOT NULL,secret BLOB,provider TEXT NOT NULL);
         CREATE TABLE endpoints(id TEXT PRIMARY KEY,api TEXT NOT NULL,base_url TEXT NOT NULL);
         INSERT INTO connections VALUES('Claude','Claude','legacy-identity','none',NULL,'anthropic');",
    ).unwrap();
    drop(db);
    let m = Manager::open(root.path()).unwrap();
    let selected = m.resolve(&Choice::new("Claude", "fixture")).unwrap();
    assert!(m.prompt_caching(&selected).unwrap());
    m.set_provider(json!({"name":"Claude","api":"anthropic","prompt_caching":false}))
        .unwrap();
    assert!(!m.prompt_caching(&selected).unwrap());
    assert!(m.key(&selected).unwrap().is_empty());
    assert_eq!(selected.identity, "legacy-identity");
}

#[test]
fn stream_usage_rejects_other_apis_and_supports_access_token_providers() {
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    for api in ["responses", "anthropic"] {
        assert!(m
            .set_provider(json!({"name":"Wrong","api":api,"stream_usage":false}))
            .is_err());
        let mut settings = key("Wrong", "fixture-key-only", "memory");
        settings["api"] = json!(api);
        settings["provider"] = json!(if api == "anthropic" {
            "anthropic"
        } else {
            "openai"
        });
        settings["stream_usage"] = json!(false);
        assert!(m.set(settings).is_err());
    }
    let config = json!({"name":"Proxy","api":"chat-completions","base_url":"https://proxy.example/v1","access_token_auth":true,"stream_usage":false});
    m.set_provider(config.clone()).unwrap();
    m.update_access_token(
        "Proxy",
        openworker_runtime::provider_auth::AccessToken::new(
            "fixture-access-token",
            openworker_runtime::provider_auth::now() + 3600,
        )
        .unwrap(),
    )
    .unwrap();
    let selected = m.resolve(&Choice::new("Proxy", "fixture")).unwrap();
    assert!(!m.stream_usage(&selected).unwrap());
    let mut unchanged = config;
    unchanged.as_object_mut().unwrap().remove("stream_usage");
    m.set_provider(unchanged).unwrap();
    assert!(!m.stream_usage(&selected).unwrap());
}

#[cfg(target_os = "macos")]
#[test]
#[ignore = "Explicit qualification: writes a disposable macOS Keychain item"]
fn macos_keychain_roundtrip_and_removal() {
    let root = tempfile::tempdir().unwrap();
    let m = Manager::open(root.path()).unwrap();
    m.set(key("test", "keychain-synthetic-test-key", "secure"))
        .unwrap();
    let selected = m.resolve(&Choice::new("test", "model")).unwrap();
    drop(m);
    let m = Manager::open(root.path()).unwrap();
    let result = m.key(&selected).unwrap();
    m.remove("test").unwrap();
    assert_eq!(&**result, "keychain-synthetic-test-key");
    let bytes = std::fs::read(root.path().join("model-connections.sqlite")).unwrap();
    assert!(!bytes
        .windows(b"keychain-synthetic-test-key".len())
        .any(|w| w == b"keychain-synthetic-test-key"));
    assert!(m.key(&selected).is_err());
}

#[test]
fn concurrent_controller_connection_cache_initialization() {
    // Two service controllers can prepare the same immutable child definition.
    // Their local connection-cache schema must be initialized atomically.
    for _ in 0..12 {
        let root = tempfile::tempdir().unwrap();
        let barrier = std::sync::Arc::new(std::sync::Barrier::new(4));
        std::thread::scope(|scope| {
            let tasks = (0..4)
                .map(|_| {
                    let barrier = barrier.clone();
                    let path = root.path();
                    scope.spawn(move || {
                        barrier.wait();
                        openworker_runtime::connections::Manager::open(path)
                            .map(|m| m.list().unwrap())
                    })
                })
                .collect::<Vec<_>>();
            for task in tasks {
                task.join().unwrap().unwrap();
            }
        });
    }
}