//! 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) { 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::(&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)); }