nordisk/nornir

tests/code_room_seam.rs

//! **The code-room seam** — the three front-door files reach the code graph
//! ONLY through the two dispatch points (`.nornir/mimir-v2-land.md` §6.6):
//!
//! * `nornir::mimir_lens::answer(lens, reach, params)` — the lenses (lane B);
//! * `nornir::code_room::reader::*` — every other reader (lane C).
//!
//! So lanes B and C fill their dispatch body and never edit `server_grpc.rs`,
//! `mcp_stdio.rs` or `bin/nornir.rs`. This guard keeps it that way: a front
//! door that answers a lens itself, names a surface the reader does not know,
//! or opens a lake / builds a room on its own goes RED here.

use std::collections::BTreeSet;

const FRONT_DOORS: [&str; 3] = ["src/server_grpc.rs", "src/mcp_stdio.rs", "src/bin/nornir.rs"];

fn source(rel: &str) -> String {
    let p = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join(rel);
    std::fs::read_to_string(&p).unwrap_or_else(|e| panic!("read {}: {e}", p.display()))
}

/// The first string literal after each occurrence of `call` in `src`.
fn first_literal_args(src: &str, call: &str) -> Vec<String> {
    let mut out = Vec::new();
    let mut rest = src;
    while let Some(at) = rest.find(call) {
        let after = &rest[at + call.len()..];
        // the literal must be the next token after `(` and whitespace / an
        // argument list of identifiers (`wctx,` / `Some(loaded),` / `&self`)
        if let Some(q) = after.find('"') {
            let head = &after[..q];
            let is_arg_prefix = head.chars().all(|c| c.is_alphanumeric() || " \n\t,_()&.".contains(c));
            if is_arg_prefix && let Some(end) = after[q + 1..].find('"') {
                out.push(after[q + 1..q + 1 + end].to_string());
            }
        }
        rest = after;
    }
    out
}

#[test]
fn no_front_door_answers_a_lens_itself() {
    for f in FRONT_DOORS {
        let src = source(f);
        assert!(
            !src.contains("mimir_lens::not_wired("),
            "{f} builds a lens answer itself — every lens goes through `mimir_lens::answer`"
        );
    }
}

#[test]
fn every_lens_a_front_door_names_is_dispatched() {
    let known: BTreeSet<&str> = nornir::mimir_lens::LENSES.iter().copied().collect();
    // + the lens that folds source text: dispatched, but it has no gRPC verb
    let dispatched: BTreeSet<&str> = known.iter().copied().chain(nornir::mimir_lens::SOURCE_LENSES.iter().copied()).collect();
    let mut seen = BTreeSet::new();
    for (f, calls) in [
        ("src/server_grpc.rs", &["lens_answer("][..]),
        ("src/mcp_stdio.rs", &["self.lens_embedded("][..]),
        ("src/bin/nornir.rs", &["code_room_lens("][..]),
    ] {
        let src = source(f);
        for call in calls {
            for lens in first_literal_args(&src, call) {
                assert!(dispatched.contains(lens.as_str()), "{f}: `{call}\"{lens}\"…)` — not in mimir_lens::LENSES");
                seen.insert(lens);
            }
        }
    }
    // the gRPC door serves all 18; a lens that lost its handler is a hole
    let grpc: BTreeSet<String> = first_literal_args(&source("src/server_grpc.rs"), "lens_answer(").into_iter().collect();
    for lens in &known {
        assert!(grpc.contains(*lens), "Mimir gRPC has no handler dispatching `{lens}`");
    }
    assert!(seen.len() >= known.len());
}

#[test]
fn every_surface_a_front_door_names_is_a_reader_surface() {
    let known: BTreeSet<&str> = nornir::code_room::reader::SURFACES.iter().copied().collect();
    let mut seen = BTreeSet::new();
    for (f, calls) in [
        ("src/server_grpc.rs", &["reader_answer(", "reader::answer("][..]),
        ("src/mcp_stdio.rs", &["self.reader_embedded("][..]),
        ("src/bin/nornir.rs", &["code_room_print(", "code_room_read("][..]),
    ] {
        let src = source(f);
        for call in calls {
            for s in first_literal_args(&src, call) {
                assert!(known.contains(s.as_str()), "{f}: `{call}\"{s}\"…)` — not in code_room::reader::SURFACES");
                seen.insert(s);
            }
        }
    }
    assert!(seen.len() >= 20, "the scan found only {} surfaces — it has gone blind: {seen:?}", seen.len());
}

/// Nothing outside `src/code_room/` opens the lake or builds a room: the
/// handle is the one owner (one lake per process — skade is single-process).
#[test]
fn no_front_door_opens_a_lake_or_builds_a_room() {
    for f in FRONT_DOORS {
        let src = source(f);
        for forbidden in ["EventLog::open(", "Room::open(", "Room::at(", "mimir_room::", "Consumer::boot("] {
            assert!(!src.contains(forbidden), "{f} names `{forbidden}` — that belongs behind `nornir::code_room`");
        }
    }
}

/// Every refusal the dispatch points give today is typed: a state from the
/// closed set and a sentence — never an empty answer.
#[test]
fn the_dispatch_points_refuse_by_state_never_by_an_empty_answer() {
    use nornir::code_room::{Reach, State, reader};
    let reach = Reach::none();
    for surface in reader::SURFACES {
        if let Err(r) = reader::answer(surface, &reach, &serde_json::Value::Null) {
            assert!(State::parse(r.state.as_str()).is_some());
            assert!(!r.note.trim().is_empty(), "{surface}: a refusal without a reason");
            assert_ne!(r.state, State::InvalidArgument, "{surface} is listed but not dispatched");
        }
    }
    for lens in nornir::mimir_lens::LENSES {
        let v = nornir::mimir_lens::answer(lens, &reach, &serde_json::json!({ "repo": "r" }));
        assert_eq!(v["kind"], *lens);
        let state = v["lens_meta"]["state"].as_str().unwrap_or_else(|| panic!("{lens}: no lens_meta.state"));
        if State::parse(state).is_some() {
            assert!(
                v["evidence_note"].as_str().is_some_and(|n| !n.trim().is_empty()),
                "{lens}: state `{state}` without an evidence_note"
            );
        }
    }
}