The Rust pipeline is the official seed writer (pnpm import:equine); sheet-ref.json and report-migration-map.json carry 12d78872...74e2 and the v1 block, the only two seed files changed. 27c7383c...2660 stays a registered alias, honoured only through LoadedSheet::recognises_historical_stamp (verified v1, recomputed document). M1: the snapshot of an old report keeps its stamp; export, archive reader strict. Historical oracles run in their pre-switch context; equivalence is crate-private.
287 lines
10 KiB
Rust
287 lines
10 KiB
Rust
//! R5.6 preparation (owner 2026-10-24 « arbitrage D-R5.6 »): the convention
|
|
//! `sha256-rfc8785-validated-v1` and the trusted alias registry, PREPARED, NOT ACTIVE. The RFC
|
|
//! 8785 vectors, the V8 number oracle, the independent Node differential, the draft's frozen
|
|
//! value, the registry's contract and a census of the historical archives (JSON fixtures and
|
|
//! every fixture PDF's attachment) under the comparison the five consumers will use.
|
|
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
|
|
|
|
mod archive_support;
|
|
mod common;
|
|
|
|
use faunosteo_core::domain::js::parse_json;
|
|
use faunosteo_core::domain::sheet::fingerprint::{
|
|
AliasRefusal, FINGERPRINT_CONVENTION, FingerprintError, TRUSTED_ALIASES, canonical_json,
|
|
check_declared, sheet_fingerprint,
|
|
};
|
|
use faunosteo_core::pdf::read::probe::{ProbeLimits, read_attached_document};
|
|
use serde_json::Value;
|
|
use sha2::{Digest, Sha256};
|
|
|
|
const SHEET: &str = "503dc301-a8b1-50d4-9e44-0919b2fc2916";
|
|
const ALIAS: &str = "27c7383c445c73dc2001ebf4794a3ea63d416910bbbaa0d7848dd720de7c2660";
|
|
const CANONICAL: &str = "12d788727c1e532641bd5b3a7ecf39dbdd25e70350f8a76be5ca917b262874e2";
|
|
|
|
fn oracle(name: &str) -> Value {
|
|
serde_json::from_str(&common::repo_file(&format!(
|
|
"crates/core/tests/oracles/r5/{name}"
|
|
)))
|
|
.unwrap()
|
|
}
|
|
|
|
fn sha256(text: &str) -> String {
|
|
Sha256::digest(text.as_bytes())
|
|
.iter()
|
|
.map(|b| format!("{b:02x}"))
|
|
.collect()
|
|
}
|
|
|
|
#[test]
|
|
fn the_rfc_8785_vectors_are_reproduced() {
|
|
let vectors = oracle("fingerprints.json")["rfc8785_vectors"].clone();
|
|
for vector in vectors.as_array().unwrap() {
|
|
let input = parse_json(vector["input"].as_str().unwrap()).unwrap();
|
|
assert_eq!(
|
|
canonical_json(&input).unwrap(),
|
|
vector["canonical"].as_str().unwrap()
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn numbers_print_as_v8_on_the_whole_oracle() {
|
|
let rows = oracle("numbers.json")["rows"].clone();
|
|
let rows = rows.as_array().unwrap();
|
|
assert_eq!(rows.len(), 44_322);
|
|
for row in rows {
|
|
let bits = u64::from_str_radix(row[0].as_str().unwrap(), 16).unwrap();
|
|
let value = Value::from(f64::from_bits(bits));
|
|
assert_eq!(
|
|
canonical_json(&value).unwrap(),
|
|
row[1].as_str().unwrap(),
|
|
"{bits:016x}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn the_independent_node_reference_agrees_case_by_case() {
|
|
let frozen = oracle("fingerprint-differential.json");
|
|
for case in frozen["cases"].as_array().unwrap() {
|
|
let input = parse_json(case["input"].as_str().unwrap()).unwrap();
|
|
let canonical = canonical_json(&input).unwrap();
|
|
assert_eq!(canonical, case["canonical"].as_str().unwrap());
|
|
assert_eq!(sha256(&canonical), case["sha256"].as_str().unwrap());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn unicode_is_kept_and_ordered_by_utf16_units() {
|
|
// U+FB33 sorts after U+1F600 by code point, before it by UTF-16 units (0xFB33 > 0xD83D).
|
|
let value = parse_json(r#"{"דּ":1,"😀":2,"é":3,"é":4}"#).unwrap();
|
|
assert_eq!(
|
|
canonical_json(&value).unwrap(),
|
|
"{\"e\u{301}\":4,\"\u{e9}\":3,\"\u{1F600}\":2,\"\u{FB33}\":1}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn the_draft_gives_the_frozen_validated_value() {
|
|
let text = common::repo_file("supabase/seed/anatomical-sheets/equine/draft/document.json");
|
|
assert_eq!(sha256(&text), ALIAS);
|
|
assert_eq!(sheet_fingerprint(&text).unwrap(), CANONICAL);
|
|
let artifacts = oracle("fingerprints.json")["artifacts"].clone();
|
|
let draft = artifacts
|
|
.as_array()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|a| a["file"].as_str().unwrap().ends_with("draft/document.json"))
|
|
.unwrap()
|
|
.clone();
|
|
assert_eq!(draft["b_rfc8785_validated"], CANONICAL);
|
|
assert_eq!(draft["today_file_bytes"], ALIAS);
|
|
}
|
|
|
|
#[test]
|
|
fn an_invalid_or_malformed_document_has_no_fingerprint() {
|
|
let text = common::repo_file("supabase/seed/anatomical-sheets/equine/draft/document.json");
|
|
let mut value: Value = serde_json::from_str(&text).unwrap();
|
|
let first = value["annotations"][0]["id"].clone();
|
|
value["annotations"][1]["id"] = first;
|
|
let duplicated = serde_json::to_string(&value).unwrap();
|
|
assert!(matches!(sheet_fingerprint(&duplicated), Err(FingerprintError::Invalid(n)) if n > 0));
|
|
assert!(matches!(
|
|
sheet_fingerprint("[1]"),
|
|
Err(FingerprintError::Shape(_))
|
|
));
|
|
assert!(matches!(
|
|
sheet_fingerprint("{"),
|
|
Err(FingerprintError::Parse(_))
|
|
));
|
|
}
|
|
|
|
#[test]
|
|
fn the_registry_holds_one_pair_bound_to_the_equine_sheet() {
|
|
// The comparison itself is crate-private (its unit test sits in `fingerprint.rs`); the
|
|
// consumers reach it only through `LoadedSheet::recognises_historical_stamp`.
|
|
assert_eq!(TRUSTED_ALIASES.len(), 1);
|
|
assert_eq!(FINGERPRINT_CONVENTION, "sha256-rfc8785-validated-v1");
|
|
let pair = &TRUSTED_ALIASES[0];
|
|
assert_eq!(
|
|
(pair.sheet_id, pair.alias, pair.canonical),
|
|
(SHEET, ALIAS, CANONICAL)
|
|
);
|
|
let sheet = archive_support::draft_sheet();
|
|
assert!(sheet.recognises_historical_stamp(SHEET, ALIAS));
|
|
assert!(!sheet.recognises_historical_stamp(SHEET, CANONICAL));
|
|
assert!(!sheet.recognises_historical_stamp(SHEET, &"a".repeat(64)));
|
|
assert!(!sheet.recognises_historical_stamp("00000000-0000-0000-0000-000000000000", ALIAS));
|
|
}
|
|
|
|
#[test]
|
|
fn declared_metadata_never_creates_an_equivalence() {
|
|
let aliases = vec![ALIAS.to_owned()];
|
|
assert_eq!(
|
|
check_declared(SHEET, CANONICAL, FINGERPRINT_CONVENTION, &aliases),
|
|
Ok(())
|
|
);
|
|
assert_eq!(
|
|
check_declared(SHEET, CANONICAL, FINGERPRINT_CONVENTION, &[]),
|
|
Ok(())
|
|
);
|
|
let forged = vec!["b".repeat(64)];
|
|
assert_eq!(
|
|
check_declared(SHEET, CANONICAL, FINGERPRINT_CONVENTION, &forged),
|
|
Err(AliasRefusal::Untrusted("b".repeat(64)))
|
|
);
|
|
let foreign = "00000000-0000-0000-0000-000000000000";
|
|
assert!(check_declared(foreign, CANONICAL, FINGERPRINT_CONVENTION, &aliases).is_err());
|
|
assert!(check_declared(SHEET, &"c".repeat(64), FINGERPRINT_CONVENTION, &aliases).is_err());
|
|
assert!(
|
|
check_declared(
|
|
SHEET,
|
|
ALIAS,
|
|
FINGERPRINT_CONVENTION,
|
|
&[CANONICAL.to_owned()]
|
|
)
|
|
.is_err()
|
|
);
|
|
assert_eq!(
|
|
check_declared(SHEET, CANONICAL, "sha256-prettier-file-bytes-v0", &aliases),
|
|
Err(AliasRefusal::UnknownConvention(
|
|
"sha256-prettier-file-bytes-v0".into()
|
|
))
|
|
);
|
|
}
|
|
|
|
/// Every `sheet` reference of a report found in `value` (bare report or envelope).
|
|
fn stamps(value: &Value, found: &mut Vec<(String, String)>) {
|
|
match value {
|
|
Value::Object(map) => {
|
|
if let (Some(id), Some(sha)) = (
|
|
map.get("sheetId").and_then(Value::as_str),
|
|
map.get("documentSha256").and_then(Value::as_str),
|
|
) {
|
|
found.push((id.to_owned(), sha.to_owned()));
|
|
}
|
|
map.values().for_each(|item| stamps(item, found));
|
|
}
|
|
Value::Array(items) => items.iter().for_each(|item| stamps(item, found)),
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
fn files(dir: &std::path::Path, out: &mut Vec<std::path::PathBuf>) {
|
|
for entry in std::fs::read_dir(dir).unwrap() {
|
|
let path = entry.unwrap().path();
|
|
if path.is_dir() {
|
|
files(&path, out);
|
|
} else {
|
|
out.push(path);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn historical_archives_open_as_the_same_document_only_through_the_registered_pair() {
|
|
let mut paths = Vec::new();
|
|
files(
|
|
std::path::Path::new(&common::repo_path("apps/app/tests/fixtures")),
|
|
&mut paths,
|
|
);
|
|
let mut found = Vec::new();
|
|
let mut pdfs = 0;
|
|
for path in &paths {
|
|
let bytes = std::fs::read(path).unwrap();
|
|
let text = match path.extension().and_then(|e| e.to_str()) {
|
|
Some("json") => String::from_utf8(bytes).ok(),
|
|
Some("pdf") => read_attached_document(&bytes, ProbeLimits::UNBOUNDED)
|
|
.ok()
|
|
.map(|located| {
|
|
pdfs += 1;
|
|
located.text.into_owned()
|
|
}),
|
|
_ => None,
|
|
};
|
|
if let Some(value) = text.and_then(|t: String| serde_json::from_str::<Value>(&t).ok()) {
|
|
stamps(&value, &mut found);
|
|
}
|
|
}
|
|
assert_eq!(pdfs, 147, "attachments read");
|
|
let loaded = archive_support::draft_sheet();
|
|
assert_eq!(loaded.reference.document_sha256, CANONICAL);
|
|
let mut same = 0;
|
|
for (sheet, sha) in &found {
|
|
// What the rebase decides: equal values, or the proven historical stamp of this sheet.
|
|
let recognised = *sha == loaded.reference.document_sha256
|
|
|| (*sheet == loaded.reference.sheet_id
|
|
&& loaded.recognises_historical_stamp(sheet, sha));
|
|
let expected = sheet == SHEET && sha == ALIAS;
|
|
assert_eq!(recognised, expected, "{sheet} {sha}");
|
|
same += usize::from(expected);
|
|
}
|
|
// Every authentic stamp of the equine draft is the alias; the synthetic ones stay different.
|
|
println!(
|
|
"census: {pdfs} PDF attachments, {} stamps, {same} alias",
|
|
found.len()
|
|
);
|
|
assert_eq!((found.len(), same), (124, 123), "stamps, aliases");
|
|
}
|
|
|
|
#[test]
|
|
fn v1_never_carries_the_historical_value_or_a_malformed_one() {
|
|
assert_eq!(
|
|
check_declared(SHEET, ALIAS, FINGERPRINT_CONVENTION, &[]),
|
|
Err(AliasRefusal::NotCanonical(ALIAS.into()))
|
|
);
|
|
for bad in ["", "12d7", &"g".repeat(64), &CANONICAL.to_uppercase()] {
|
|
assert!(
|
|
check_declared(SHEET, bad, FINGERPRINT_CONVENTION, &[]).is_err(),
|
|
"{bad}"
|
|
);
|
|
}
|
|
}
|
|
|
|
fn nested(depth: usize) -> Value {
|
|
let mut value = Value::from(1);
|
|
for _ in 0..depth {
|
|
value = Value::Array(vec![value]);
|
|
}
|
|
value
|
|
}
|
|
|
|
#[test]
|
|
fn nesting_is_bounded_with_a_controlled_error() {
|
|
use faunosteo_core::domain::sheet::fingerprint::{CanonicalError, MAX_CANONICAL_DEPTH};
|
|
assert_eq!(MAX_CANONICAL_DEPTH, 128);
|
|
assert!(canonical_json(&nested(MAX_CANONICAL_DEPTH)).is_ok());
|
|
assert_eq!(
|
|
canonical_json(&nested(MAX_CANONICAL_DEPTH + 1)),
|
|
Err(CanonicalError::TooDeep)
|
|
);
|
|
let mut object = Value::from(1);
|
|
for _ in 0..=MAX_CANONICAL_DEPTH {
|
|
object = serde_json::json!({ "k": object });
|
|
}
|
|
assert_eq!(canonical_json(&object), Err(CanonicalError::TooDeep));
|
|
}
|