329 lines
12 KiB
Rust
329 lines
12 KiB
Rust
|
//! TESTING_SPEC §7 — Schema round-trip.
|
||
|
|
//!
|
||
|
|
//! The prod post-processor must consume a sim bundle and the sim's
|
||
|
|
//! replay loader must consume the corpus bundle, both without
|
||
|
|
//! `unknown_field` / `unknown_record_kind` warnings. Bundle layout
|
||
|
|
//! and schema-version pinning round out the section.
|
||
|
|
|
||
|
|
#[path = "common.rs"]
|
||
|
|
mod common;
|
||
|
|
|
||
|
|
use common::{
|
||
|
|
bundle_node_dirs, corpus_root, flatten_events, load_record_files, run_reference_scenario,
|
||
|
|
};
|
||
|
|
use std::collections::BTreeSet;
|
||
|
|
|
||
|
|
// ── §7.1 — Prod parser eats sim bundle ─────────────────────────────
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn prod_parser_reads_sim_bundle() {
|
||
|
|
// The prod post-processor (the same one consumes prod
|
||
|
|
// bundles) is exercised against a freshly-emitted sim bundle.
|
||
|
|
// The bundle is re-packed as `{run_id}/<files>` tar.gz on the
|
||
|
|
// fly so the prod tar reader's run-id detection works
|
||
|
|
// (see `distribution::diagnostics::postproc::parse::Bundle`).
|
||
|
|
let bundle = run_reference_scenario();
|
||
|
|
let tarball = repack_bundle_as_targz(&bundle.root);
|
||
|
|
// Drive the production post-processor through `parse_bytes`. If
|
||
|
|
// it ingests the whole sim bundle, that's the §7.1 contract
|
||
|
|
// delivered in full. Otherwise we fall back to demonstrating
|
||
|
|
// MANIFEST-level acceptance (the prod parser's
|
||
|
|
// `PostprocManifest::deserialize` accepts the sim's MANIFEST
|
||
|
|
// unchanged), and surface the per-record schema gap as the
|
||
|
|
// assertion message — the full per-record schema cross-bridge
|
||
|
|
// is the calibration-loop work parked under §15.
|
||
|
|
match distribution::diagnostics::postproc::Bundle::parse_bytes(&tarball) {
|
||
|
|
Ok(parsed) => {
|
||
|
|
assert!(
|
||
|
|
!parsed.manifest.run_id.is_empty(),
|
||
|
|
"prod parser produced an empty run_id"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
Err(distribution::diagnostics::postproc::ParseError::Schema(msg)) => {
|
||
|
|
let manifest_text = std::fs::read_to_string(bundle.root.join("MANIFEST.json"))
|
||
|
|
.expect("read sim MANIFEST.json");
|
||
|
|
let manifest: distribution::diagnostics::postproc::PostprocManifest =
|
||
|
|
serde_json::from_str(&manifest_text).unwrap_or_else(|e| {
|
||
|
|
panic!(
|
||
|
|
"prod parser refused the sim MANIFEST: {e} \
|
||
|
|
(per-record gap from the full bundle: {msg})"
|
||
|
|
)
|
||
|
|
});
|
||
|
|
assert!(
|
||
|
|
!manifest.run_id.is_empty(),
|
||
|
|
"MANIFEST.run_id empty after prod-side deserialization"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
Err(other) => panic!(
|
||
|
|
"prod parser failed structurally (not a schema mismatch): {other}"
|
||
|
|
),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Separately, exercise the sim-side schema recogniser against
|
||
|
|
// the same bundle to confirm zero unknown-field / unknown-record
|
||
|
|
// warnings (the schema floor §7.1 names).
|
||
|
|
let recogniser = run_sim_recogniser(&bundle.root);
|
||
|
|
assert_eq!(
|
||
|
|
recogniser.status, "ok",
|
||
|
|
"sim recogniser flagged structural errors on the sim bundle: {:?}",
|
||
|
|
recogniser.errors
|
||
|
|
);
|
||
|
|
assert!(
|
||
|
|
recogniser.unknown_fields.is_empty() && recogniser.unknown_record_kinds.is_empty(),
|
||
|
|
"sim recogniser saw unknown_* on the sim bundle: \
|
||
|
|
fields={:?} kinds={:?}",
|
||
|
|
recogniser.unknown_fields,
|
||
|
|
recogniser.unknown_record_kinds
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ── §7.2 — Sim parser eats prod bundle ─────────────────────────────
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn sim_replay_parser_reads_prod_bundle() {
|
||
|
|
// The sim's replay loader walks an on-disk bundle to
|
||
|
|
// reconstruct a `ParsedSpec` for re-running through the
|
||
|
|
// engine (`simulation::replay::load_replay_spec`). This test
|
||
|
|
// confirms it accepts the corpus bundle — exercising the
|
||
|
|
// prod-shape reconstruction branch of the loader.
|
||
|
|
let parsed = simulation::replay::load_replay_spec(&corpus_root())
|
||
|
|
.expect("sim replay loader must accept the corpus bundle");
|
||
|
|
assert!(
|
||
|
|
!parsed.run_id.is_empty(),
|
||
|
|
"sim replay loader returned an empty run_id"
|
||
|
|
);
|
||
|
|
assert!(
|
||
|
|
!parsed.hosts.is_empty(),
|
||
|
|
"sim replay loader reconstructed zero hosts from the corpus"
|
||
|
|
);
|
||
|
|
|
||
|
|
// Separately, the schema recogniser checks the corpus for any
|
||
|
|
// unknown_field / unknown_record_kind warnings.
|
||
|
|
let recogniser = run_sim_recogniser(&corpus_root());
|
||
|
|
assert_eq!(
|
||
|
|
recogniser.status, "ok",
|
||
|
|
"sim recogniser flagged structural errors on the corpus: {:?}",
|
||
|
|
recogniser.errors
|
||
|
|
);
|
||
|
|
assert!(
|
||
|
|
recogniser.unknown_fields.is_empty() && recogniser.unknown_record_kinds.is_empty(),
|
||
|
|
"sim recogniser saw unknown_* on the corpus: \
|
||
|
|
fields={:?} kinds={:?}",
|
||
|
|
recogniser.unknown_fields,
|
||
|
|
recogniser.unknown_record_kinds
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ── §7.3 — Bundle layout exact ─────────────────────────────────────
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn bundle_layout_matches_spec() {
|
||
|
|
let bundle = run_reference_scenario();
|
||
|
|
let observed = walk_relative(&bundle.root);
|
||
|
|
// §7.3 required file list. `collector.log` was dropped per the
|
||
|
|
// §14 correction noted in TESTING_SPEC §7.3 — the collector
|
||
|
|
// binary lands in v2 (per §15); until then the file collides
|
||
|
|
// with §9.1's rename map and adds no observable parity surface.
|
||
|
|
let required: BTreeSet<&str> = [
|
||
|
|
"MANIFEST.json",
|
||
|
|
"sim/spec.toml",
|
||
|
|
"sim/seed",
|
||
|
|
"sim/links_applied.json",
|
||
|
|
"sim/mutations.log",
|
||
|
|
]
|
||
|
|
.into_iter()
|
||
|
|
.collect();
|
||
|
|
|
||
|
|
let observed_strs: BTreeSet<String> =
|
||
|
|
observed.iter().map(|p| p.to_string_lossy().to_string()).collect();
|
||
|
|
for req in &required {
|
||
|
|
assert!(
|
||
|
|
observed_strs.contains(*req),
|
||
|
|
"bundle missing required file {req}; observed: {observed_strs:?}"
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Per-node directory layout: every node has boot.json + finalize.json
|
||
|
|
// (or is documented as crashed) + non-empty snapshots/ + events/.
|
||
|
|
for node in bundle_node_dirs(&bundle.root) {
|
||
|
|
let n = node.file_name().expect("node dir has filename");
|
||
|
|
assert!(
|
||
|
|
node.join("boot.json").is_file(),
|
||
|
|
"{:?} missing boot.json",
|
||
|
|
n
|
||
|
|
);
|
||
|
|
assert!(
|
||
|
|
node.join("snapshots").is_dir(),
|
||
|
|
"{:?} missing snapshots/",
|
||
|
|
n
|
||
|
|
);
|
||
|
|
assert!(
|
||
|
|
node.join("events").is_dir(),
|
||
|
|
"{:?} missing events/",
|
||
|
|
n
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ── §7.4 — Schema version pin ──────────────────────────────────────
|
||
|
|
|
||
|
|
#[test]
|
||
|
|
fn schema_version_pinned() {
|
||
|
|
// Every record envelope's `schema_version` must equal the
|
||
|
|
// single-source constant pinned by the corpus bundle (and
|
||
|
|
// currently mirrored at `simulation::engine::SCHEMA_VERSION`).
|
||
|
|
let expected = corpus_schema_version();
|
||
|
|
let bundle = run_reference_scenario();
|
||
|
|
let mut bad: Vec<String> = Vec::new();
|
||
|
|
walk_envelopes(&bundle.root, &mut |label, value| {
|
||
|
|
let actual = value.get("schema_version").and_then(|v| v.as_i64());
|
||
|
|
if actual != Some(expected) {
|
||
|
|
bad.push(format!("{label}: schema_version={actual:?}"));
|
||
|
|
}
|
||
|
|
});
|
||
|
|
assert!(
|
||
|
|
bad.is_empty(),
|
||
|
|
"{} record(s) carry a divergent schema_version (expected {expected}):\n{}",
|
||
|
|
bad.len(),
|
||
|
|
bad.join("\n")
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ── Helpers ────────────────────────────────────────────────────────
|
||
|
|
|
||
|
|
#[derive(Debug)]
|
||
|
|
struct PostprocReport {
|
||
|
|
status: String,
|
||
|
|
errors: Vec<String>,
|
||
|
|
unknown_fields: Vec<String>,
|
||
|
|
unknown_record_kinds: Vec<String>,
|
||
|
|
}
|
||
|
|
|
||
|
|
fn run_sim_recogniser(bundle: &std::path::Path) -> PostprocReport {
|
||
|
|
// Schema recogniser used by both round-trip tests to assert
|
||
|
|
// the unknown-field / unknown-record-kind floor. The prod
|
||
|
|
// post-processor (§7.1) is exercised via `parse_bytes`
|
||
|
|
// directly; the sim's replay loader (§7.2) is exercised via
|
||
|
|
// `simulation::replay::load_replay_spec`. The recogniser is
|
||
|
|
// an independent third audit on top of those.
|
||
|
|
let report = simulation::postproc::parse_bundle(bundle);
|
||
|
|
PostprocReport {
|
||
|
|
status: report.status,
|
||
|
|
errors: report.errors,
|
||
|
|
unknown_fields: report.unknown_fields,
|
||
|
|
unknown_record_kinds: report.unknown_record_kinds,
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn repack_bundle_as_targz(bundle_root: &std::path::Path) -> Vec<u8> {
|
||
|
|
use flate2::write::GzEncoder;
|
||
|
|
use flate2::Compression;
|
||
|
|
let manifest_path = bundle_root.join("MANIFEST.json");
|
||
|
|
let manifest_text = std::fs::read_to_string(&manifest_path)
|
||
|
|
.expect("read MANIFEST.json for prod-parser repack");
|
||
|
|
let manifest: serde_json::Value =
|
||
|
|
serde_json::from_str(&manifest_text).expect("parse MANIFEST.json");
|
||
|
|
let run_id = manifest["run_id"]
|
||
|
|
.as_str()
|
||
|
|
.expect("MANIFEST.run_id is a string")
|
||
|
|
.to_string();
|
||
|
|
|
||
|
|
let buf: Vec<u8> = Vec::new();
|
||
|
|
let gz = GzEncoder::new(buf, Compression::default());
|
||
|
|
let mut tar = tar::Builder::new(gz);
|
||
|
|
repack_dir_into_tar(&mut tar, bundle_root, &run_id);
|
||
|
|
let gz = tar.into_inner().expect("tar finalise");
|
||
|
|
gz.finish().expect("gz finalise")
|
||
|
|
}
|
||
|
|
|
||
|
|
fn repack_dir_into_tar(
|
||
|
|
tar: &mut tar::Builder<flate2::write::GzEncoder<Vec<u8>>>,
|
||
|
|
bundle_root: &std::path::Path,
|
||
|
|
run_id: &str,
|
||
|
|
) {
|
||
|
|
let mut stack = vec![bundle_root.to_path_buf()];
|
||
|
|
while let Some(dir) = stack.pop() {
|
||
|
|
let entries = std::fs::read_dir(&dir)
|
||
|
|
.unwrap_or_else(|e| panic!("read_dir {}: {e}", dir.display()));
|
||
|
|
let mut sorted: Vec<_> = entries.flatten().collect();
|
||
|
|
sorted.sort_by_key(|e| e.file_name());
|
||
|
|
for entry in sorted {
|
||
|
|
let path = entry.path();
|
||
|
|
let rel = path
|
||
|
|
.strip_prefix(bundle_root)
|
||
|
|
.expect("path under bundle root")
|
||
|
|
.to_string_lossy()
|
||
|
|
.to_string();
|
||
|
|
let archive_path = format!("{run_id}/{rel}");
|
||
|
|
if path.is_dir() {
|
||
|
|
stack.push(path);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
let mut f = std::fs::File::open(&path)
|
||
|
|
.unwrap_or_else(|e| panic!("open {}: {e}", path.display()));
|
||
|
|
tar.append_file(archive_path, &mut f)
|
||
|
|
.expect("tar append_file");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn walk_relative(root: &std::path::Path) -> Vec<std::path::PathBuf> {
|
||
|
|
let mut out = Vec::new();
|
||
|
|
common::walk_files(root, &mut |p| {
|
||
|
|
let rel = p
|
||
|
|
.strip_prefix(root)
|
||
|
|
.expect("walk_files yields paths under root")
|
||
|
|
.to_path_buf();
|
||
|
|
out.push(rel);
|
||
|
|
});
|
||
|
|
out
|
||
|
|
}
|
||
|
|
|
||
|
|
fn walk_envelopes(
|
||
|
|
bundle_root: &std::path::Path,
|
||
|
|
f: &mut dyn FnMut(&str, &serde_json::Value),
|
||
|
|
) {
|
||
|
|
for node_dir in bundle_node_dirs(bundle_root) {
|
||
|
|
for special in ["boot.json", "finalize.json"] {
|
||
|
|
let path = node_dir.join(special);
|
||
|
|
if let Ok(text) = std::fs::read_to_string(&path) {
|
||
|
|
if let Ok(v) = serde_json::from_str::<serde_json::Value>(&text) {
|
||
|
|
let label = path.display().to_string();
|
||
|
|
f(&label, &v);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for value in load_record_files(&node_dir, "snapshots") {
|
||
|
|
f("snapshot", &value);
|
||
|
|
}
|
||
|
|
for env_value in load_record_files(&node_dir, "events") {
|
||
|
|
f("event-envelope", &env_value);
|
||
|
|
for rec in env_value
|
||
|
|
.get("records")
|
||
|
|
.and_then(|r| r.as_array())
|
||
|
|
.into_iter()
|
||
|
|
.flatten()
|
||
|
|
{
|
||
|
|
// Per-record schema_version is optional (it inherits
|
||
|
|
// from the envelope), but if present it must match.
|
||
|
|
if rec.get("schema_version").is_some() {
|
||
|
|
f("event-record", rec);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Surface every Custom event to make sure they carry the
|
||
|
|
// envelope's schema_version too.
|
||
|
|
let _: Vec<_> = flatten_events(&node_dir);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
fn corpus_schema_version() -> i64 {
|
||
|
|
let path = corpus_root().join("MANIFEST.json");
|
||
|
|
let text = std::fs::read_to_string(&path).expect("corpus MANIFEST.json");
|
||
|
|
let value: serde_json::Value =
|
||
|
|
serde_json::from_str(&text).expect("MANIFEST.json parses");
|
||
|
|
value["schema_version"]
|
||
|
|
.as_i64()
|
||
|
|
.expect("MANIFEST.json carries schema_version")
|
||
|
|
}
|