36ceb357d5
dvr_relay (accepted): the lesson's relay keeps a ten-second DVR window of the composite and signs a version 2 record of it, a viewer joining at 20 s filled from the window. Refused: dvr_out_exceeds and dvr_stored_exceeds (record_invalid), record_unknown_version (version 3), dvr_record_too_large (past B2(M) by less than an entry). Each accepted record's facts state its version, and a version 2 record's six DVR figures; every existing record keeps its bytes. Co-Authored-By: Claude Opus 5.5 <[email protected]>
99 lines
5.3 KiB
Rust
99 lines
5.3 KiB
Rust
//! `wai.live.metering` (extensions/live-metering.md): the committed corpus
|
|
//! `live-conformance/metering/vectors.json` regenerates byte for byte from its fixed seeds and
|
|
//! the reference relay's recorded record, every vector in it gets the outcome it states, every
|
|
//! reason the extension adds refuses a vector, the large audience's relay record is the size of
|
|
//! the lesson's, a relay keeping a DVR window signs a version 2 record and every other record
|
|
//! is version 1, and the extension's §9 lists exactly the reasons the reference reports.
|
|
#![cfg(feature = "live_metering")]
|
|
|
|
use std::collections::BTreeSet;
|
|
use std::path::PathBuf;
|
|
use wai::live_metering::{corpus, Reason};
|
|
|
|
fn wai_dir() -> PathBuf {
|
|
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("..")
|
|
}
|
|
|
|
fn read(p: &str) -> String {
|
|
std::fs::read_to_string(wai_dir().join(p)).unwrap_or_else(|e| panic!("{p}: {e}"))
|
|
}
|
|
|
|
fn committed() -> String {
|
|
read("live-conformance/metering/vectors.json")
|
|
}
|
|
|
|
#[test]
|
|
fn the_committed_corpus_regenerates_from_its_seeds() {
|
|
assert!(committed() == corpus::generate(), "live-conformance/metering/vectors.json differs from `wai_live_metering_vectors gen`");
|
|
}
|
|
|
|
#[test]
|
|
fn every_vector_gets_its_stated_outcome() {
|
|
let fails = corpus::verify(&committed());
|
|
assert!(fails.is_empty(), "{}", fails.join("\n"));
|
|
}
|
|
|
|
/// Every reason this extension adds refuses a vector; the accepted vectors are the ones §10
|
|
/// names; the large audience's relay record is the lesson's size, within the same bound; the
|
|
/// mixed vector states one total per class; the ceilings vector names two grants past; the
|
|
/// DVR relay's record is version 2, 48 bytes longer than the lesson relay's under a bound 48
|
|
/// bytes higher, with every DVR figure above 0, and every other accepted record is version 1.
|
|
#[test]
|
|
fn the_corpus_covers_every_reason_and_case() {
|
|
let doc: serde_json::Value = serde_json::from_str(&committed()).unwrap();
|
|
let vectors = doc["vectors"].as_array().unwrap();
|
|
let seen: BTreeSet<&str> = vectors.iter().filter_map(|v| v["reason"].as_str()).collect();
|
|
for r in Reason::ALL {
|
|
assert!(seen.contains(r.code()), "nothing in the corpus is refused {r}");
|
|
}
|
|
let get = |n: &str| vectors.iter().find(|v| v["name"] == n).unwrap_or_else(|| panic!("no vector {n}"));
|
|
for n in ["lesson", "signed_by_authority", "mixed_classes", "ceilings_past", "large_audience", "relay_recorded", "dvr_relay"] {
|
|
assert_eq!(get(n)["outcome"], "accept", "{n}");
|
|
}
|
|
let relay_record = |n: &str| {
|
|
let v = get(n);
|
|
let relay = &doc["principals"]["relay"];
|
|
let i = v["hops"].as_array().unwrap().iter().position(|h| h["record"].as_str().unwrap()[74..138] == relay.as_str().unwrap()[..]).unwrap();
|
|
let rec = v["hops"][i]["record"].as_str().unwrap().len() / 2;
|
|
v["records"].as_array().unwrap().iter().find(|r| r["size"] == rec).unwrap().clone()
|
|
};
|
|
let (lesson, large) = (relay_record("lesson"), relay_record("large_audience"));
|
|
assert_eq!(lesson["size"], large["size"], "the record does not grow with the audience");
|
|
assert_eq!(lesson["bound"], large["bound"]);
|
|
assert!(large["size"].as_u64() <= large["bound"].as_u64());
|
|
assert!(get("large_audience")["units"]["sessions"].as_u64().unwrap() > 10_000);
|
|
assert_eq!(get("large_audience")["qoe_cell"]["suppressed"], false);
|
|
assert_eq!(get("lesson")["qoe_cell"]["suppressed"], true);
|
|
assert_eq!(get("lesson")["coverage"], "whole");
|
|
assert_eq!(get("mixed_classes")["totals"].as_array().unwrap().len(), 3);
|
|
assert_eq!(get("relay_recorded")["coverage"], "partial");
|
|
let past = get("ceilings_past")["past"].as_array().unwrap();
|
|
assert_eq!(past.iter().map(|p| p["flags"].as_u64().unwrap()).collect::<BTreeSet<_>>(), BTreeSet::from([1, 2]));
|
|
let dvr = relay_record("dvr_relay");
|
|
assert_eq!(dvr["version"], 2);
|
|
assert_eq!(dvr["size"].as_u64().unwrap(), lesson["size"].as_u64().unwrap() + 48);
|
|
assert_eq!(dvr["bound"].as_u64().unwrap(), lesson["bound"].as_u64().unwrap() + 48);
|
|
for k in ["dvr_objects_out", "dvr_bytes_out", "dvr_objects_stored", "dvr_bytes_stored", "dvr_byte_s", "dvr_dropped"] {
|
|
assert!(dvr[k].as_u64().unwrap() > 0, "{k}");
|
|
}
|
|
for v in vectors.iter().filter(|v| v["outcome"] == "accept" && v["name"] != "dvr_relay") {
|
|
for r in v["records"].as_array().unwrap() {
|
|
assert_eq!(r["version"], 1, "{}", v["name"]);
|
|
assert!(r.get("dvr_byte_s").is_none());
|
|
}
|
|
}
|
|
for (n, why) in [("dvr_out_exceeds", "record_invalid"), ("dvr_stored_exceeds", "record_invalid"), ("record_unknown_version", "unknown_version"), ("dvr_record_too_large", "record_too_large")] {
|
|
assert_eq!(get(n)["reason"], why, "{n}");
|
|
}
|
|
}
|
|
|
|
/// §9 of the extension lists exactly the codes `Reason::ALL` has, each once, in order.
|
|
#[test]
|
|
fn the_extension_lists_the_reasons() {
|
|
let text = read("extensions/live-metering.md");
|
|
let at = text.find("\n## 9. Reasons").expect("a §9");
|
|
let end = text[at + 1..].find("\n## ").map_or(text.len(), |e| at + 1 + e);
|
|
let listed: Vec<String> = text[at..end].lines().filter(|l| l.starts_with("| `")).filter_map(|l| l.split('`').nth(1).map(String::from)).collect();
|
|
let want: Vec<String> = Reason::ALL.iter().map(|r| r.code().to_string()).collect();
|
|
assert_eq!(listed, want, "§9's table and Reason::ALL differ");
|
|
}
|