colibri/crates/colibri-contracts/tests/golden.rs

//! Golden tests: the contract structs must accept the real committed manifests
//! (produced by different agents/hosts) and round-trip without data loss.

use colibri_contracts::*;

const OSA_INV: &str = include_str!("../../../manifests/2026-05-26-osa-runtime-inventory.json");
const DOMEDOG_INV: &str =
    include_str!("../../../manifests/2026-05-26-domedog-runtime-inventory.json");
const OSA_RUN: &str = include_str!("../../../manifests/2026-05-26-osa-pi-bump-run-manifest.json");
const DOMEDOG_RUN: &str =
    include_str!("../../../manifests/2026-05-26-domedog-linux-lane-run-manifest.json");
const DOMEDOG_CACHE: &str =
    include_str!("../../../manifests/2026-05-26-domedog-deepseek-cache-result.json");
const OSA_CACHE: &str =
    include_str!("../../../manifests/2026-05-26-osa-deepseek-cache-result.json");
const OSA_GATE4_RUN: &str =
    include_str!("../../../manifests/2026-05-26-osa-freebsd-gate4-run-manifest.json");

fn roundtrip_eq<T>(value: &T)
where
    T: serde::Serialize + serde::de::DeserializeOwned + PartialEq + std::fmt::Debug,
{
    let json = serde_json::to_string(value).expect("serialize");
    let again: T = serde_json::from_str(&json).expect("re-deserialize");
    assert_eq!(value, &again, "round-trip mismatch");
}

#[test]
fn parses_osa_inventory() {
    let inv: RuntimeInventory = serde_json::from_str(OSA_INV).expect("parse osa inventory");
    assert_eq!(inv.schema, RUNTIME_INVENTORY_SCHEMA);
    assert_eq!(inv.host, "osa.smilepowered.org");
    assert_eq!(inv.pi.as_deref(), Some("0.75.5"));
    assert_eq!(inv.package_manager.as_deref(), Some("pkg"));
    roundtrip_eq(&inv);
}

#[test]
fn parses_domedog_inventory() {
    let inv: RuntimeInventory = serde_json::from_str(DOMEDOG_INV).expect("parse domedog inventory");
    assert_eq!(inv.schema, RUNTIME_INVENTORY_SCHEMA);
    assert_eq!(inv.host, "domedog");
    assert_eq!(inv.pi.as_deref(), Some("0.75.5"));
    assert_eq!(inv.node.as_deref(), Some("v24.16.0"));
    roundtrip_eq(&inv);
}

#[test]
fn parses_osa_run_manifest() {
    let run: RunManifest = serde_json::from_str(OSA_RUN).expect("parse osa run manifest");
    assert_eq!(run.schema, RUN_MANIFEST_SCHEMA);
    assert_eq!(run.role, "freebsd-build");
    assert_eq!(run.agent.as_deref(), Some("codex-osa"));
    assert!(run.summary.contains_key("pi_after"));
    roundtrip_eq(&run);
}

#[test]
fn parses_domedog_run_manifest() {
    let run: RunManifest = serde_json::from_str(DOMEDOG_RUN).expect("parse domedog run manifest");
    assert_eq!(run.schema, RUN_MANIFEST_SCHEMA);
    assert_eq!(run.role, "linux-build-smoke");
    assert_eq!(
        run.artifacts.get("runtime_inventory").map(String::as_str),
        Some("manifests/2026-05-26-domedog-runtime-inventory.json")
    );
    roundtrip_eq(&run);
}

#[test]
fn parses_domedog_live_cache_result() {
    let res: ProviderSmokeResult =
        serde_json::from_str(DOMEDOG_CACHE).expect("parse live cache result");
    assert_eq!(res.schema, PROVIDER_SMOKE_SCHEMA);
    assert_eq!(res.status, "ok");
    assert!(res.cache_hit_observed, "expected a cache hit");
    assert!(res.cache_hit_tokens > 0);
    roundtrip_eq(&res);
}

#[test]
fn parses_osa_live_cache_result() {
    let res: ProviderSmokeResult = serde_json::from_str(OSA_CACHE).expect("parse osa cache result");
    assert_eq!(res.schema, PROVIDER_SMOKE_SCHEMA);
    assert_eq!(res.host, "osa");
    assert_eq!(res.agent, "codex-osa");
    assert_eq!(res.status, "ok");
    assert!(res.cache_hit_observed, "expected a cache hit");
    assert!(res.cache_hit_tokens > 0);
    roundtrip_eq(&res);
}

#[test]
fn parses_osa_gate4_run_manifest() {
    let run: RunManifest = serde_json::from_str(OSA_GATE4_RUN).expect("parse osa gate4 run");
    assert_eq!(run.schema, RUN_MANIFEST_SCHEMA);
    assert_eq!(run.role, "freebsd-build-cache-smoke");
    assert_eq!(run.agent.as_deref(), Some("codex-osa"));
    assert_eq!(
        run.artifacts
            .get("deepseek_cache_result")
            .map(String::as_str),
        Some("manifests/2026-05-26-osa-deepseek-cache-result.json")
    );
    roundtrip_eq(&run);
}

#[test]
fn provider_smoke_skipped_shape() {
    // No live result committed yet; assert the struct accepts a skipped result.
    let raw = r#"{
        "schema": "clawdie.provider-smoke.result.v1",
        "test_id": "colibri-probe-20260526T080805Z",
        "host": "domedog",
        "agent": "claude-domedog",
        "provider": "deepseek",
        "model": "deepseek-chat",
        "started_at": "2026-05-26T08:08:05Z",
        "ended_at": "2026-05-26T08:08:05Z",
        "status": "skipped",
        "cache_hit_tokens": 0,
        "cache_hit_observed": false,
        "notes": ["DEEPSEEK_API_KEY unset/empty — build verified, live cache probe skipped"]
    }"#;
    let res: ProviderSmokeResult = serde_json::from_str(raw).expect("parse provider smoke");
    assert_eq!(res.schema, PROVIDER_SMOKE_SCHEMA);
    assert_eq!(res.status, "skipped");
    assert!(res.warm_usage.is_none());
    roundtrip_eq(&res);
}