open-standards/wai/wai-rs/tests/impression_aggregate.rs

//! `wai.delivery.impressions` (extensions/impression-aggregates.md): the committed corpus
//! `live-conformance/impressions/` regenerates byte for byte from its fixed seeds, holds no other
//! file, every case in it gets the outcome it states, §10 lists exactly the reasons the reference
//! reports, each standing receipt's result is its contributions' tally and stitched presentation's
//! own count of the flight's claims (§8.11), and the size bounds of §5.4 and §6.4 decide a
//! file's outcome at their edge.
#![cfg(feature = "impression_aggregate")]

use std::collections::BTreeMap;
use std::path::PathBuf;
use wai::impression_aggregate::{
    accept, corpus, encode_hpke_list, TaskFile, UploadFile, CATALOGUE_MALFORMED, CODES, MAX_TASK_FILE, MAX_UPLOAD, TASK_FILE_MALFORMED, UPLOAD_MALFORMED,
};
use wai::telemetry_aggregate::dap::{HpkeCiphertext, HpkeConfig, Report, ReportMetadata};

fn wai_dir() -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("..")
}

fn committed() -> BTreeMap<String, String> {
    let dir = wai_dir().join("live-conformance/impressions");
    std::fs::read_dir(&dir)
        .expect("the committed corpus")
        .flatten()
        .map(|e| (e.file_name().to_string_lossy().into_owned(), e.path()))
        .filter(|(n, _)| n != "README.md")
        .map(|(n, p)| (n, std::fs::read_to_string(p).expect("a text file")))
        .collect()
}

#[test]
fn the_committed_corpus_regenerates_from_its_seeds() {
    let files = committed();
    let generated: BTreeMap<String, String> = corpus::generate().into_iter().collect();
    let extra: Vec<&String> = files.keys().filter(|k| !generated.contains_key(*k)).collect();
    let missing: Vec<&String> = generated.keys().filter(|k| !files.contains_key(*k)).collect();
    let differ: Vec<&String> = generated.iter().filter(|(k, v)| files.get(*k).is_some_and(|f| f != *v)).map(|(k, _)| k).collect();
    assert!(extra.is_empty() && missing.is_empty() && differ.is_empty(), "extra {extra:?}, missing {missing:?}, differ {differ:?}: run `wai_impression_aggregate_vectors gen`");
}

#[test]
fn every_case_gets_its_stated_outcome() {
    let fails = corpus::verify(&committed());
    assert!(fails.is_empty(), "{}", fails.join("\n"));
}

/// §8.11: each standing receipt's result is the plaintext tally of its contributions, and the
/// flight's table gives per creative what stitched presentation's verifier gives.
#[test]
fn aggregation_reproduces_the_plaintext_and_stitched_counts() {
    let fails = corpus::equivalence();
    assert!(fails.is_empty(), "{}", fails.join("\n"));
}

/// §10 of the extension lists exactly the codes `CODES` has, each once, in order.
#[test]
fn the_extension_lists_the_reasons() {
    let text = std::fs::read_to_string(wai_dir().join("extensions/impression-aggregates.md")).expect("the extension");
    let at = text.find("\n## 10. Reasons").expect("a §10");
    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> = CODES.iter().map(|c| c.to_string()).collect();
    assert_eq!(listed, want, "§10's table and CODES differ");
}

/// The size bounds of §5.4 and §6.4, which no vector carries. A file of exactly the bound that
/// reads in every other respect is read: a task file passes step 1 and is refused at step 2,
/// where its catalogue of zeros does not read, and an upload file reads. The same file one byte
/// longer is refused at step 1, so a reader without the bound, or with another, fails here.
/// §4.3's bound decides no outcome: no catalogue that meets §4.3 comes near it.
#[test]
fn the_size_bounds_decide_at_their_edge() {
    let list = |id: u8| encode_hpke_list(&[HpkeConfig { id, kem: 0x0020, kdf: 0x0001, aead: 0x0001, public_key: vec![9; 32] }]);
    let task_file = |catalogue: usize| {
        let f = TaskFile { task: vec![], catalogue: vec![0; catalogue], leader_hpke: list(1), helper_hpke: list(2), signer: [0; 32], signer_id: "x".into(), sig: [0; 64] };
        f.to_bytes()
    };
    let at = MAX_TASK_FILE - task_file(0).len();
    let (inside, past) = (task_file(at), task_file(at + 1));
    assert_eq!((inside.len(), past.len()), (MAX_TASK_FILE, MAX_TASK_FILE + 1));
    assert_eq!(accept(&inside, &[], &[], None).err(), Some(CATALOGUE_MALFORMED), "a task file at the bound reaches step 2");
    assert_eq!(accept(&past, &[], &[], None).err(), Some(TASK_FILE_MALFORMED), "one byte past it is refused at step 1");
    let ct = HpkeCiphertext { config_id: 1, enc: vec![1], payload: vec![1] };
    let upload = |share: usize| {
        let metadata = ReportMetadata { id: [0; 16], time: 0, public_extensions: vec![] };
        let r = Report { metadata, public_share: vec![0; share], leader_share: ct.clone(), helper_share: ct.clone() };
        UploadFile { task_id: [0; 32], reports: vec![r] }.encode()
    };
    let at = MAX_UPLOAD - upload(0).len();
    let (inside, past) = (upload(at), upload(at + 1));
    assert_eq!((inside.len(), past.len()), (MAX_UPLOAD, MAX_UPLOAD + 1));
    assert_eq!(UploadFile::parse(&inside).map(|f| f.reports.len()).ok(), Some(1), "an upload file at the bound reads");
    assert_eq!(UploadFile::parse(&past).err(), Some(UPLOAD_MALFORMED), "one byte past it is refused");
}