nordisk/edda

crates/nornir-escape/src/selftest.rs

//! # Functional-status emit bridge — `nornir-escape` → test matrix
//!
//! The single internal call site this crate uses to push a *functional* row into
//! the [`nornir_testmatrix`] matrix, so `nornir test --features testmatrix`
//! records whether `nornir-escape`'s real surface (the four canonical entity
//! mappings, the clean-passthrough borrow, and the RED corrupted-mapping
//! rejection) ACTUALLY behaves — without eyeballing anything.
//!
//! ## Release strips everything
//! The `testmatrix` cargo feature gates the whole bridge: with it OFF (the
//! release default) [`emit`] is an `#[inline]` no-op and `nornir-testmatrix` is
//! not even linked. Lit ONLY under `cargo … --features testmatrix`.

/// The aspect tag every self-emitted row carries (matches `functional_row`).
pub const ASPECT_FUNCTIONAL: &str = "functional";

/// Push ONE functional-status row for a single real check (feature ON).
///
/// * `component` — the unit under test (becomes the row's `suite`).
/// * `check` — the specific assertion's name (becomes the row's `test_name`).
/// * `ok` — the **real** verdict.
/// * `detail` — the **measured** value.
#[cfg(feature = "testmatrix")]
#[inline]
pub fn emit(component: &str, check: &str, ok: bool, detail: &str) {
    nornir_testmatrix::functional_status(component, check, ok, detail);
}

/// No-op stub when the `testmatrix` feature is OFF (release builds). Inlined and
/// empty so the call — and, with the wrap-the-call-site pattern, the detail
/// string-building — is stripped entirely.
#[cfg(not(feature = "testmatrix"))]
#[inline]
pub fn emit(_component: &str, _check: &str, _ok: bool, _detail: &str) {}

/// `assert!`-with-emit: assert on the real return value AND record the verdict as
/// a matrix row. The `assert!` is the test's actual gate; the emit is the matrix
/// observation.
#[macro_export]
macro_rules! assert_emit {
    ($component:expr, $check:expr, $ok:expr, $($detail:tt)+) => {{
        let __ok: bool = $ok;
        let __detail = ::std::format!($($detail)+);
        $crate::selftest::emit($component, $check, __ok, &__detail);
        ::std::assert!(__ok, "{}::{} — {}", $component, $check, __detail);
    }};
}

// ─── inject-and-assert wiring test (feature ON only) ─────────────────────────
#[cfg(all(test, feature = "testmatrix"))]
mod wiring {
    use crate::xml;

    /// Exercise `nornir-escape`'s real surface, emit an honest row per check,
    /// then drain the process-global functional buffer and assert the rows
    /// landed — proving the emit bridge is wired end to end.
    #[test]
    fn emits_honest_rows_for_escape_surfaces() {
        let amp = xml("&");
        assert_emit!("nornir-escape", "amp_entity", amp == "&", "xml(&)={amp}");

        let lt = xml("<");
        assert_emit!("nornir-escape", "lt_entity", lt == "&lt;", "xml(<)={lt}");

        let gt = xml(">");
        assert_emit!("nornir-escape", "gt_entity", gt == "&gt;", "xml(>)={gt}");

        let quot = xml("\"");
        assert_emit!("nornir-escape", "quot_entity", quot == "&quot;", "xml(quot)={quot}");

        let mixed = xml("a & b < c > d \" e");
        assert_emit!(
            "nornir-escape",
            "mixed_string",
            mixed == "a &amp; b &lt; c &gt; d &quot; e",
            "mixed={mixed}"
        );

        // Clean input must borrow (no allocation).
        let clean_borrows = matches!(xml("plain"), std::borrow::Cow::Borrowed(_));
        assert_emit!(
            "nornir-escape",
            "clean_borrows",
            clean_borrows,
            "clean_borrows={clean_borrows}"
        );

        // Apostrophe stays literal — matches every twin.
        let apo = xml("it's");
        assert_emit!("nornir-escape", "apostrophe_literal", apo == "it's", "apo={apo}");

        // RED surface: a corrupted expectation must NOT match the true output.
        let wrong = xml("&");
        crate::selftest::emit(
            "nornir-escape",
            "corrupted_mapping_is_rejected",
            wrong != "&AMP;",
            &format!("wrong={wrong}"),
        );

        let rows = nornir_testmatrix::drain_functional_rows();
        let has = |t: &str, pass: bool| {
            rows.iter().any(|r| {
                r.suite == "nornir-escape" && r.test_name == t && (r.status == "pass") == pass
            })
        };
        assert!(has("amp_entity", true), "rows={rows:?}");
        assert!(has("lt_entity", true), "rows={rows:?}");
        assert!(has("gt_entity", true), "rows={rows:?}");
        assert!(has("quot_entity", true), "rows={rows:?}");
        assert!(has("mixed_string", true), "rows={rows:?}");
        assert!(has("clean_borrows", true), "rows={rows:?}");
        assert!(has("apostrophe_literal", true), "rows={rows:?}");
        assert!(has("corrupted_mapping_is_rejected", true), "rows={rows:?}");
        assert!(rows.iter().all(|r| r.aspect == "functional"), "rows={rows:?}");
    }
}