//! `packages/domain/tests/archive.{envelope,snapshot,branding-labels}.test.ts` ported with //! their exact expectations, plus the two session entries (draft restore, archive import). #![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)] mod archive_support; mod common; use archive_support::*; use faunosteo_core::domain::archive::{ ArchiveOrigin, Branding, PDF_LABEL_KEYS, PdfLabelSet, ReportArchiveEnvelope, SnapshotCaps, SnapshotRejection, assert_snapshot, build_sheet_snapshot, parse_envelope, read_archive_document, }; use faunosteo_core::domain::report::{ReadFailure, Report, read_report_document}; use faunosteo_core::domain::session::{ ImportFailure, RestoreFailure, import_archive, restore_draft, }; use faunosteo_core::domain::sheet::LoadedSheet; use faunosteo_core::domain::sheet::validate::{SheetIssueSeverity, validate_sheet_document}; use faunosteo_core::json::to_js_pretty; use serde_json::{Value, json}; fn rejection(input: &Value) -> Result<(), SnapshotRejection> { assert_snapshot(input).map(|_| ()) } // --------------------------------------------------------------------------- // archive.branding-labels.test.ts fn branding_accepts(value: Value) -> bool { serde_json::from_value::(value).is_ok() } fn with(mut base: Value, key: &str, value: Value) -> Value { base[key] = value; base } #[test] fn branding_accepts_the_identity_and_both_image_kinds() { let parsed: Branding = from(sample_branding()); assert_eq!(to_value(&parsed), sample_branding()); let bare = json!({ "siteUrl": "http://localhost:5173", "headerLogo": null, "footerLogo": null, "poweredBy": null, "partner": null }); assert_eq!(to_value(&from::(bare.clone())), bare); } #[test] fn branding_rejects_its_faults() { let b = sample_branding; let mut powered = b()["poweredBy"].clone(); powered["fallbackText"] = json!("x".repeat(129)); let mut partner = b()["partner"].clone(); partner["extra"] = json!(true); let cases = [ with(b(), "extra", json!(1)), with(b(), "siteUrl", json!("javascript:alert(1)")), with(b(), "siteUrl", json!("ftp://x.test/a")), with( b(), "siteUrl", json!(format!("https://x.test/{}", "a".repeat(2048))), ), with( b(), "headerLogo", json!({ "kind": "png", "base64": "A".repeat(512 * 1024 + 4) }), ), with( b(), "headerLogo", json!({ "kind": "png", "base64": "" }), ), with( b(), "footerLogo", json!({ "kind": "svg", "svg": "x".repeat(256 * 1024 + 1) }), ), with(b(), "poweredBy", powered), with(b(), "partner", partner), ]; for (i, case) in cases.into_iter().enumerate() { assert!(!branding_accepts(case), "case {i}"); } } #[test] fn branding_urls() { let max = format!( "https://x.test/{}", "a".repeat(2048 - "https://x.test/".len()) ); for url in [ "https://faunosteo.com", "https://zenquality.fr", "https://www.instagram.com/paws.iin.harmony", "http://localhost:5173", "https://x.test/a-b_c~d?e=1&f=2#frag", max.as_str(), ] { assert!( branding_accepts(with(sample_branding(), "siteUrl", json!(url))), "{url}" ); } let injection = "https://a.example/) /Next << /S /JavaScript /JS (app.alert\\(1\\)) >> /Z ("; for url in [ "https://a.example/)", "https://a.example/(", injection, "https://a.example/a\\b", "https://a.example/a b", "https://a.example/a\tb", "https://a.example/a\u{1}b", "https://a.example/a\u{7f}b", "https://a.example/", "https://a.example/\"x", "https://a.example/'x", "https://a.example/é", "https://", "HTTPS://a.example/", ] { assert!( !branding_accepts(with(sample_branding(), "siteUrl", json!(url))), "{url}" ); let mut credit = sample_branding(); credit["partner"]["url"] = json!(url); assert!(!branding_accepts(credit), "credit {url}"); } } #[test] fn label_sets() { assert_eq!(PDF_LABEL_KEYS.len(), 25); let mut keys = PDF_LABEL_KEYS.to_vec(); keys.sort_unstable(); keys.dedup(); assert_eq!(keys.len(), 25); let set = sample_label_set(); assert_eq!( serde_json::to_value(from::(set.clone())).unwrap()["fr"]["pdf.subject"], set["fr"]["pdf.subject"] ); let accepts = |v: Value| serde_json::from_value::(v).is_ok(); let mut missing = sample_labels(); missing.as_object_mut().unwrap().remove("pdf.empty"); assert!(!accepts(json!({ "fr": missing, "en": sample_labels() }))); assert!(!accepts( json!({ "fr": with(sample_labels(), "pdf.extra", json!("x")), "en": sample_labels() }) )); assert!(!accepts( json!({ "fr": with(sample_labels(), "pdf.subject", json!("x".repeat(257))), "en": sample_labels() }) )); assert!(!accepts(json!({ "fr": sample_labels() }))); assert!(!accepts( json!({ "fr": sample_labels(), "en": sample_labels(), "de": sample_labels() }) )); } // --------------------------------------------------------------------------- // archive.snapshot.test.ts const SHA: &str = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; const HASH: &str = "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"; const SVG: &str = ""; fn slice_source() -> LoadedSheet { slice_sheet( snake_ref("sheet-1", None, SHA), horse_slice(), SVG, Some(HASH), ) } fn slice_report() -> Report { from(json!({ "version": 3, "id": "r1", "createdAt": "2026-10-10T10:00:00Z", "date": "2026-10-10", "practitioner": { "name": "Dr. Dupont" }, "animal": { "speciesId": "equine", "name": "Mistral" }, "owner": { "name": "Jean Martin" }, "sheet": { "sheetId": "sheet-1", "versionId": null, "documentSha256": SHA }, "observations": [{ "id": "obs-1", "zones": [{ "annotationId": "hip", "viewId": "view-main" }], "findings": [ { "findingZoneId": "hip", "path": ["hip-dysfunctions", "articular", "restriction-flexion"], "labelFrSnapshot": "Restriction en flexion", "labelEnSnapshot": "Flexion restriction" }, { "findingZoneId": "hip", "path": ["hip-dysfunctions", "articular", "ghost-leaf"], "labelFrSnapshot": "Disparu", "labelEnSnapshot": "Gone", "unresolved": true }, { "findingZoneId": "sphenoid", "path": ["ssb-dysfunctions", "physiological", "torsion-right"], "labelFrSnapshot": "Torsion droite", "labelEnSnapshot": "Right torsion" } ], "freeTextFindings": [], "comment": "" }], "conclusion": "", "recommendations": "", "localAnnotations": [] })) } fn slice_snapshot() -> Value { to_value(&build_sheet_snapshot(&slice_source(), &slice_report())) } fn draft_full_report(draft: &LoadedSheet) -> Report { let full = json_file("crates/core/tests/fixtures/report-v2.full.json"); read_report_document(&full, &draft.migration_map) .unwrap() .report } #[test] fn draft_snapshot_keeps_every_view_annotation_category_and_region() { let draft = draft_sheet(); let snapshot = build_sheet_snapshot(&draft, &draft_full_report(&draft)); let (doc, src) = (&snapshot.document, &draft.document); assert_eq!(to_value(&doc.views), to_value(&src.views)); assert_eq!(to_value(&doc.annotations), to_value(&src.annotations)); assert_eq!(to_value(&doc.categories), to_value(&src.categories)); assert_eq!( to_value(&doc.vertebral_config), to_value(&src.vertebral_config) ); assert!(doc.references.is_empty()); assert_eq!(doc.name, src.name); assert_eq!(doc.scope_disclaimer, src.scope_disclaimer); assert_eq!(doc.attribution, src.attribution); assert_eq!(doc.species_id, "equine"); assert_eq!(to_value(&doc.schema_version), json!(2)); } #[test] fn draft_snapshot_prunes_finding_trees_to_the_paths_used() { let draft = draft_sheet(); let report = draft_full_report(&draft); let snapshot = build_sheet_snapshot(&draft, &report); let ids = |zones: &[faunosteo_core::domain::sheet::FindingZone]| -> Vec { zones.iter().map(|z| z.id.clone()).collect() }; assert_eq!( ids(&snapshot.document.finding_zones), ids(&draft.document.finding_zones) ); let c7 = to_value( snapshot .document .finding_zones .iter() .find(|z| z.id == "c7-t1") .unwrap(), ); assert_eq!(c7["categories"].as_array().unwrap().len(), 1); assert_eq!(c7["categories"][0]["id"], "c7-t1-dysfunctions"); assert_eq!(c7["categories"][0]["kind"], "dysfunction"); assert_eq!(c7["categories"][0]["description"], json!({})); assert_eq!(c7["categories"][0]["reference_ids"], json!([])); assert_eq!(c7["categories"][0]["children"].as_array().unwrap().len(), 1); assert_eq!(c7["categories"][0]["children"][0]["id"], "segmental"); let leaf = &c7["categories"][0]["children"][0]["children"]; assert_eq!(leaf.as_array().unwrap().len(), 1); assert_eq!(leaf[0]["id"], "fixation"); assert_eq!(leaf[0]["description"], json!({})); assert_eq!(leaf[0]["children"], json!([])); let used: Vec<&str> = report .observations .iter() .flat_map(|o| &o.findings) .map(|f| f.finding_zone_id.as_str()) .collect(); for zone in &snapshot.document.finding_zones { assert_eq!( zone.categories.is_empty(), !used.contains(&zone.id.as_str()), "{}", zone.id ); } } #[test] fn draft_snapshot_carries_the_reachable_asset_hash_and_full_ref() { let draft = draft_sheet(); let snapshot = build_sheet_snapshot(&draft, &draft_full_report(&draft)); let (id, svg) = draft.assets.iter().next().unwrap(); assert_eq!(snapshot.assets.len(), 1); assert_eq!(&snapshot.assets[0].svg_asset_id, id); assert_eq!( snapshot.assets[0].sha256.as_ref(), draft.asset_hashes.get(id) ); assert_eq!(&snapshot.assets[0].svg, svg); let reference = to_value(&snapshot.reference); assert_eq!(reference["sheetId"], json!(draft.reference.sheet_id)); assert_eq!( reference["documentSha256"], json!(draft.reference.document_sha256) ); assert_eq!(reference["versionId"], Value::Null); assert_eq!( ( reference["schemaVersion"].clone(), reference["speciesId"].clone() ), (json!(2), json!("equine")) ); assert_eq!(to_value(&snapshot.status), json!("draft")); } #[test] fn draft_snapshot_is_valid_small_and_passes_its_gate() { let draft = draft_sheet(); let snapshot = build_sheet_snapshot(&draft, &draft_full_report(&draft)); let errors = validate_sheet_document(&snapshot.document) .into_iter() .filter(|i| i.severity == SheetIssueSeverity::Error) .count(); assert_eq!(errors, 0); let bytes = to_js_pretty(&snapshot).unwrap().len(); println!("snapshot (report-v2.full on the draft, pretty JSON): {bytes} bytes"); assert!(bytes < 250_000); assert_eq!(assert_snapshot(&to_value(&snapshot)).unwrap(), snapshot); } #[test] fn draft_snapshot_is_pure_and_deterministic() { let draft = draft_sheet(); let report = draft_full_report(&draft); let before = to_value(&draft.document); let snapshot = build_sheet_snapshot(&draft, &report); assert_eq!(to_value(&draft.document), before); assert_eq!(build_sheet_snapshot(&draft, &report), snapshot); } #[test] fn legacy_leaves_snapshot_keeps_what_exists_of_an_unresolved_path_and_nothing_else() { let draft = draft_sheet(); let migrated = read_report_document(&leaves_as_v2_report(&legacy_leaves()), &draft.migration_map).unwrap(); assert!(migrated.unresolved_findings > 0); let snap = build_sheet_snapshot(&draft, &migrated.report); assert_eq!(assert_snapshot(&to_value(&snap)).unwrap(), snap); let loaded = loaded( snake_ref( &snap.reference.sheet_id, None, &snap.reference.document_sha256, ), to_value(&snap.document), minimal_map(), json!({}), json!({}), ); for finding in migrated .report .observations .iter() .flat_map(|o| &o.findings) { let node = loaded .indexed() .node_at(&finding.finding_zone_id, &finding.path); assert_eq!( node.is_some(), finding.unresolved.is_none(), "{}", finding.path.join("/") ); } } #[test] fn slice_snapshot_copies_review_status_and_vet_flag_and_skips_a_missing_asset() { let snapshot = slice_snapshot(); let zones = snapshot["document"]["finding_zones"].as_array().unwrap(); let hip = zones.iter().find(|z| z["id"] == "hip").unwrap(); assert_eq!( hip["categories"] .as_array() .unwrap() .iter() .map(|c| c["id"].clone()) .collect::>(), vec![json!("hip-dysfunctions")] ); assert_eq!(hip["categories"][0]["review_status"], "inherited"); assert_eq!( hip["categories"][0]["children"][0]["children"] .as_array() .unwrap() .iter() .map(|n| n["id"].clone()) .collect::>(), vec![json!("restriction-flexion")] ); let sphenoid = zones.iter().find(|z| z["id"] == "sphenoid").unwrap(); let torsion = &sphenoid["categories"][0]["children"][0]["children"][0]; assert_eq!( ( torsion["id"].clone(), torsion["requires_vet_referral"].clone() ), (json!("torsion-right"), json!(false)) ); assert_eq!( snapshot["assets"], json!([{ "svgAssetId": HORSE_MAIN_ASSET_ID, "sha256": HASH, "svg": SVG }]) ); let no_hash = slice_sheet(snake_ref("sheet-1", None, SHA), horse_slice(), SVG, None); assert_eq!( build_sheet_snapshot(&no_hash, &slice_report()).assets[0].sha256, None ); let no_svg = loaded( snake_ref("sheet-1", None, SHA), horse_slice(), minimal_map(), json!({}), json!({}), ); assert!( build_sheet_snapshot(&no_svg, &slice_report()) .assets .is_empty() ); } #[test] fn assert_accepts_the_slice_snapshot_and_returns_the_parsed_copy() { let parsed = assert_snapshot(&slice_snapshot()).unwrap(); assert_eq!(to_value(&parsed), slice_snapshot()); } #[test] fn assert_rejects_a_tree_deeper_than_the_cap_before_parsing_anything() { let mut node = json!({ "id": "leaf" }); for depth in 0..SnapshotCaps::FINDING_DEPTH { node = json!({ "id": format!("n{depth}"), "children": [node] }); } let raw = json!({ "garbage": true, "document": { "finding_zones": [{ "categories": [node] }] } }); assert_eq!(rejection(&raw), Err(SnapshotRejection::Caps)); let shallow = json!({ "document": { "finding_zones": [{ "categories": [{ "id": "c" }] }] } }); assert_eq!(rejection(&shallow), Err(SnapshotRejection::Schema)); assert_eq!( rejection(&json!({ "document": { "finding_zones": "x" } })), Err(SnapshotRejection::Schema) ); } #[test] fn assert_rejects_shape_faults() { assert_eq!( rejection(&with(slice_snapshot(), "extra", json!(1))), Err(SnapshotRejection::Schema) ); let mut no_status = slice_snapshot(); no_status.as_object_mut().unwrap().remove("status"); assert_eq!(rejection(&no_status), Err(SnapshotRejection::Schema)); let five: Vec = (0..5).map(|i| json!({ "svgAssetId": format!("00000000-0000-4000-8000-00000000000{i}"), "sha256": null, "svg": SVG })).collect(); assert_eq!( rejection(&with(slice_snapshot(), "assets", json!(five))), Err(SnapshotRejection::Schema) ); for input in [Value::Null, json!("snapshot"), json!([slice_snapshot()])] { assert_eq!(rejection(&input), Err(SnapshotRejection::Schema)); } } #[test] fn assert_rejects_a_proto_key() { let text = serde_json::to_string(&slice_snapshot()).unwrap().replacen( "\"status\"", "\"__proto__\":{\"polluted\":1},\"status\"", 1, ); let raw = faunosteo_core::domain::js::parse_json(&text).unwrap(); assert_eq!(rejection(&raw), Err(SnapshotRejection::Schema)); } #[test] fn assert_rejects_counts_over_the_caps() { let mut views = slice_snapshot(); let detail = views["document"]["views"][1].clone(); for i in 0..SnapshotCaps::VIEWS { views["document"]["views"] .as_array_mut() .unwrap() .push(with(detail.clone(), "id", json!(format!("extra-{i}")))); } assert_eq!(rejection(&views), Err(SnapshotRejection::Caps)); let mut annotations = slice_snapshot(); let first = annotations["document"]["annotations"][0].clone(); for i in 0..SnapshotCaps::ANNOTATIONS { annotations["document"]["annotations"] .as_array_mut() .unwrap() .push(with(first.clone(), "id", json!(format!("extra-{i}")))); } assert_eq!(rejection(&annotations), Err(SnapshotRejection::Caps)); let mut nodes = slice_snapshot(); let leaves: Vec = (0..SnapshotCaps::FINDING_NODES).map(|i| json!({ "id": format!("leaf-{i}"), "name": { "fr": "x", "en": "x" }, "description": {}, "requires_vet_referral": false, "reference_ids": [], "review_status": "inherited", "children": [] })).collect(); nodes["document"]["finding_zones"][0]["categories"][0]["children"] = json!(leaves); assert_eq!(rejection(&nodes), Err(SnapshotRejection::Caps)); let mut label = slice_snapshot(); label["document"]["name"]["fr"] = json!("x".repeat(SnapshotCaps::LABEL_CHARS + 1)); assert_eq!(rejection(&label), Err(SnapshotRejection::Caps)); } #[test] fn assert_rejects_oversize_assets_in_bytes_single_and_total() { let mut big = slice_snapshot(); // 1.1M two-byte code points: under the schema's character cap, over 2 MiB. big["assets"][0]["svg"] = json!("é".repeat(1_100_000)); assert_eq!(rejection(&big), Err(SnapshotRejection::Caps)); let total: Vec = (0..4).map(|i| json!({ "svgAssetId": if i == 0 { HORSE_MAIN_ASSET_ID.to_owned() } else { format!("00000000-0000-4000-8000-00000000000{i}") }, "sha256": null, "svg": "a".repeat(1_600_000) })).collect(); assert_eq!( rejection(&with(slice_snapshot(), "assets", json!(total))), Err(SnapshotRejection::Caps) ); } #[test] fn assert_rejects_a_view_reaching_no_carried_asset() { assert_eq!( rejection(&with(slice_snapshot(), "assets", json!([]))), Err(SnapshotRejection::Integrity) ); let mut other = slice_snapshot(); other["assets"][0]["svgAssetId"] = json!("00000000-0000-4000-8000-000000000009"); assert_eq!(rejection(&other), Err(SnapshotRejection::Integrity)); } #[test] fn assert_rejects_a_sheet_rule_error() { let mut rule = slice_snapshot(); let zones: Vec = rule["document"]["finding_zones"] .as_array() .unwrap() .iter() .filter(|z| z["id"] != "atm") .cloned() .collect(); rule["document"]["finding_zones"] = json!(zones); assert_eq!(rejection(&rule), Err(SnapshotRejection::Integrity)); } // --------------------------------------------------------------------------- // archive.envelope.test.ts struct EnvelopeFixture { draft: LoadedSheet, report: Report, } impl EnvelopeFixture { fn new() -> Self { let draft = draft_sheet(); let report = draft_full_report(&draft); Self { draft, report } } /// A fresh envelope as `JSON.parse` of an attachment would give it. fn envelope(&self) -> Value { json!({ "format": "faunosteo-report-archive", "envelopeVersion": 1, "exportedAt": "2026-10-11T10:00:00.000Z", "locale": "fr", "report": report_value(&self.report), "sheetSnapshot": to_value(&build_sheet_snapshot(&self.draft, &self.report)), "branding": sample_branding(), "labels": sample_label_set(), }) } fn read( &self, data: &Value, ) -> Result { read_archive_document(data, &self.draft.migration_map) } } #[test] fn envelope_reads_a_bare_v3_as_is() { let f = EnvelopeFixture::new(); let outcome = f.read(&report_value(&f.report)).unwrap(); assert_eq!( to_value(&outcome), json!({ "report": report_value(&f.report), "origin": "bare_v3", "migrated": false, "unresolvedZones": 0, "unresolvedFindings": 0, "archive": null }) ); } #[test] fn envelope_migrates_a_bare_v2_with_the_counts_of_the_migration() { let f = EnvelopeFixture::new(); let outcome = f .read(&json_file("crates/core/tests/fixtures/report-v2.full.json")) .unwrap(); assert_eq!(outcome.origin, ArchiveOrigin::V2); assert!(outcome.migrated && outcome.archive.is_none() && outcome.snapshot_rejected.is_none()); assert_eq!(outcome.report, f.report); let leaves = leaves_as_v2_report(&legacy_leaves()); let expected = read_report_document(&leaves, &f.draft.migration_map).unwrap(); let migrated = f.read(&leaves).unwrap(); assert!(expected.unresolved_findings > 0); assert_eq!( (migrated.unresolved_findings, migrated.unresolved_zones), (expected.unresolved_findings, expected.unresolved_zones) ); assert_eq!(migrated.report, expected.report); } #[test] fn envelope_throws_for_an_unreadable_report_version_or_a_non_object() { let f = EnvelopeFixture::new(); let v1 = with(report_value(&f.report), "version", json!(1)); assert_eq!( f.read(&v1).err(), Some(ReadFailure::UnsupportedVersion(Some(1.0))) ); for data in [ Value::Null, json!("report"), json!(42), json!([report_value(&f.report)]), ] { assert_eq!( f.read(&data).err(), Some(ReadFailure::UnsupportedVersion(None)) ); } } #[test] fn envelope_v1_is_accepted_whole() { let f = EnvelopeFixture::new(); let env = f.envelope(); let outcome = f.read(&env).unwrap(); assert_eq!(outcome.origin, ArchiveOrigin::EnvelopeV1); assert!( !outcome.migrated && outcome.unresolved_zones == 0 && outcome.snapshot_rejected.is_none() ); assert_eq!(outcome.report, f.report); let archive: ReportArchiveEnvelope = outcome.archive.unwrap(); assert_eq!(to_value(&archive), env); assert_eq!(to_value(&parse_envelope(&env).unwrap()), env); } #[test] fn envelope_of_an_unknown_version_keeps_the_report() { let f = EnvelopeFixture::new(); let outcome = f .read(&with(f.envelope(), "envelopeVersion", json!(2))) .unwrap(); assert_eq!(outcome.report, f.report); assert_eq!(outcome.origin, ArchiveOrigin::BareV3); assert!(outcome.archive.is_none()); assert_eq!( outcome.snapshot_rejected, Some(SnapshotRejection::UnsupportedEnvelope) ); } #[test] fn envelope_names_the_wrapped_report_version_it_cannot_read() { let f = EnvelopeFixture::new(); let env = with( f.envelope(), "report", with(report_value(&f.report), "version", json!(4)), ); assert_eq!( f.read(&env).err(), Some(ReadFailure::UnsupportedVersion(Some(4.0))) ); } #[test] fn envelope_ignores_unknown_metadata_keys_proto_included() { let f = EnvelopeFixture::new(); let outcome = f .read(&with( f.envelope(), "futureField", json!({ "anything": true }), )) .unwrap(); assert!( to_value(outcome.archive.as_ref().unwrap()) .get("futureField") .is_none() ); let text = serde_json::to_string(&f.envelope()).unwrap().replacen( "\"format\"", "\"__proto__\":{\"polluted\":true},\"format\"", 1, ); let polluted = f .read(&faunosteo_core::domain::js::parse_json(&text).unwrap()) .unwrap(); assert!( to_value(polluted.archive.as_ref().unwrap()) .get("__proto__") .is_none() ); } #[test] fn envelope_is_dropped_on_a_wrapper_fault() { let f = EnvelopeFixture::new(); let branding = with( f.envelope(), "branding", with(sample_branding(), "siteUrl", json!("javascript:alert(1)")), ); let outcome = f.read(&branding).unwrap(); assert_eq!(outcome.report, f.report); assert_eq!(outcome.origin, ArchiveOrigin::EnvelopeV1); assert!(outcome.archive.is_none()); assert_eq!(outcome.snapshot_rejected, Some(SnapshotRejection::Schema)); for (key, value) in [ ("labels", json!({ "fr": sample_labels() })), ("locale", json!("de")), ("format", json!("other")), ] { let outcome = f.read(&with(f.envelope(), key, value)).unwrap(); assert_eq!( outcome.snapshot_rejected, Some(SnapshotRejection::Schema), "{key}" ); } } #[test] fn envelope_drops_a_snapshot_over_the_caps_or_failing_its_schema() { let f = EnvelopeFixture::new(); let mut caps = f.envelope(); caps["sheetSnapshot"]["document"]["name"]["fr"] = json!("x".repeat(513)); let outcome = f.read(&caps).unwrap(); assert_eq!( (outcome.report == f.report, outcome.archive.is_none()), (true, true) ); assert_eq!(outcome.snapshot_rejected, Some(SnapshotRejection::Caps)); let mut schema = f.envelope(); schema["sheetSnapshot"]["extra"] = json!(1); assert_eq!( f.read(&schema).unwrap().snapshot_rejected, Some(SnapshotRejection::Schema) ); let mut missing = f.envelope(); missing.as_object_mut().unwrap().remove("sheetSnapshot"); assert_eq!( f.read(&missing).unwrap().snapshot_rejected, Some(SnapshotRejection::Schema) ); let mut integrity = f.envelope(); integrity["sheetSnapshot"]["assets"] = json!([]); assert_eq!( f.read(&integrity).unwrap().snapshot_rejected, Some(SnapshotRejection::Integrity) ); } #[test] fn envelope_drops_a_snapshot_of_another_sheet() { let f = EnvelopeFixture::new(); let mut sha = f.envelope(); sha["sheetSnapshot"]["ref"]["documentSha256"] = json!("f".repeat(64)); let outcome = f.read(&sha).unwrap(); assert_eq!( (outcome.origin, outcome.archive.is_none()), (ArchiveOrigin::EnvelopeV1, true) ); assert_eq!( outcome.snapshot_rejected, Some(SnapshotRejection::SheetMismatch) ); let mut id = f.envelope(); id["sheetSnapshot"]["ref"]["sheetId"] = json!("another-sheet"); assert_eq!( f.read(&id).unwrap().snapshot_rejected, Some(SnapshotRejection::SheetMismatch) ); } #[test] fn envelope_migrates_a_wrapped_v2_report_and_still_checks_the_snapshot() { let f = EnvelopeFixture::new(); let env = with( f.envelope(), "report", json_file("crates/core/tests/fixtures/report-v2.full.json"), ); let outcome = f.read(&env).unwrap(); assert_eq!(outcome.origin, ArchiveOrigin::EnvelopeV1); assert!(outcome.migrated); assert_eq!(outcome.report, f.report); assert_eq!(outcome.archive.unwrap().report, f.report); } // --------------------------------------------------------------------------- // Session entries (no TypeScript twin: the store and HomeRoute compositions) #[test] fn restore_reads_a_draft_and_keeps_it_when_it_sits_on_the_loaded_sheet() { let f = EnvelopeFixture::new(); let text = serde_json::to_string(&report_value(&f.report)).unwrap(); let restored = restore_draft(&f.draft, &text, None).unwrap(); assert_eq!(restored.rebase.report, f.report); assert!(!restored.rebase.rebased && restored.archive.is_none() && !restored.archive_rejected); let v2 = common::repo_file("crates/core/tests/fixtures/report-v2.full.json"); assert_eq!( restore_draft(&f.draft, &v2, None).unwrap().rebase.report, f.report ); } #[test] fn restore_rebases_a_stale_draft_with_the_archived_snapshot_and_flags_an_unreadable_archive() { let f = EnvelopeFixture::new(); let mut stale = report_value(&f.report); stale["sheet"]["documentSha256"] = json!("e".repeat(64)); let mut archive = f.envelope(); archive["report"] = stale.clone(); archive["sheetSnapshot"]["ref"]["documentSha256"] = json!("e".repeat(64)); let draft = serde_json::to_string(&stale).unwrap(); let archive_text = serde_json::to_string(&archive).unwrap(); let restored = restore_draft(&f.draft, &draft, Some(&archive_text)).unwrap(); assert!(restored.rebase.rebased && restored.archive.is_some() && !restored.archive_rejected); assert_eq!(restored.rebase.report.sheet, f.draft.reference); let broken = restore_draft(&f.draft, &draft, Some("{ not json")).unwrap(); assert!(broken.archive.is_none() && broken.archive_rejected && broken.rebase.rebased); } #[test] fn restore_fails_with_a_content_kind_only() { let f = EnvelopeFixture::new(); assert!(matches!( restore_draft(&f.draft, "{ not json", None), Err(RestoreFailure::Invalid(_)) )); assert!( matches!(restore_draft(&f.draft, "{\"version\":9}", None), Err(RestoreFailure::UnsupportedVersion(Some(v))) if v == 9.0) ); assert!(matches!( restore_draft(&f.draft, "{\"version\":3}", None), Err(RestoreFailure::Invalid(_)) )); assert!(matches!( restore_draft(&f.draft, "[]", None), Err(RestoreFailure::UnsupportedVersion(None)) )); } #[test] fn import_reads_and_rebases_or_names_the_failure_as_the_engine_does() { let f = EnvelopeFixture::new(); let text = serde_json::to_string(&f.envelope()).unwrap(); let imported = import_archive(&f.draft, &text).unwrap(); assert_eq!(imported.read.origin, ArchiveOrigin::EnvelopeV1); assert!(!imported.rebase.rebased); assert_eq!(imported.rebase.report, f.report); let v7 = serde_json::to_string(&with(report_value(&f.report), "version", json!(7))).unwrap(); assert_eq!( import_archive(&f.draft, &v7).err(), Some(ImportFailure::IncompatibleVersion(7.0)) ); for data in ["{\"hello\":1}", "{\"version\":3}", "null", "{ not json"] { assert_eq!( import_archive(&f.draft, data).err(), Some(ImportFailure::NoAttachment), "{data}" ); } } // --------------------------------------------------------------------------- // L1: a lone UTF-16 surrogate escape refuses the text whole, never replaced /// `value` as JSON text with `MARK` swapped for the raw escape `escape` (serde_json cannot /// write a lone surrogate itself; `JSON.stringify` writes exactly this). fn text_with_escape(value: &Value, escape: &str) -> String { serde_json::to_string(value) .unwrap() .replace("MARK", escape) } #[test] fn a_draft_with_a_lone_surrogate_is_refused_as_content_never_rewritten() { let f = EnvelopeFixture::new(); let report = with(report_value(&f.report), "conclusion", json!("aMARKb")); for escape in ["\\ud800", "\\udfff", "\\ud83d\\ud83d"] { let draft = text_with_escape(&report, escape); assert!( matches!( restore_draft(&f.draft, &draft, None), Err(RestoreFailure::LoneSurrogate(_)) ), "{escape}" ); } let v2 = common::repo_file("crates/core/tests/fixtures/report-v2.full.json").replace( "\"comment\": \"Réagit à la palpation du garrot.\"", "\"comment\": \"Réagit \\udc00\"", ); assert!(v2.contains("\\udc00")); assert!(matches!( restore_draft(&f.draft, &v2, None), Err(RestoreFailure::LoneSurrogate(_)) )); } #[test] fn an_archive_with_a_lone_surrogate_is_set_aside_while_the_draft_restores() { let f = EnvelopeFixture::new(); let draft = serde_json::to_string(&report_value(&f.report)).unwrap(); let mut envelope = f.envelope(); envelope["branding"]["poweredBy"]["fallbackText"] = json!("MARK"); let readable = serde_json::to_string(&envelope) .unwrap() .replace("MARK", "zen"); assert!( !restore_draft(&f.draft, &draft, Some(&readable)) .unwrap() .archive_rejected ); let archive = text_with_escape(&envelope, "\\ud800"); let restored = restore_draft(&f.draft, &draft, Some(&archive)).unwrap(); assert!(restored.archive.is_none() && restored.archive_rejected); assert_eq!(restored.rebase.report, f.report); } #[test] fn an_attachment_with_a_lone_surrogate_is_refused_with_its_own_kind() { let f = EnvelopeFixture::new(); let mut envelope = f.envelope(); envelope["report"]["conclusion"] = json!("MARK"); let text = text_with_escape(&envelope, "\\ud800"); assert!(matches!( import_archive(&f.draft, &text), Err(ImportFailure::LoneSurrogate(_)) )); let bare = text_with_escape( &with(report_value(&f.report), "conclusion", json!("MARK")), "\\udbff", ); assert!(matches!( import_archive(&f.draft, &bare), Err(ImportFailure::LoneSurrogate(_)) )); } #[test] fn normal_text_with_pairs_and_escaped_backslashes_reads_unchanged() { let f = EnvelopeFixture::new(); let kept = "😀 \\ud800 é \u{FFFD}"; let report = with(report_value(&f.report), "conclusion", json!(kept)); let text = serde_json::to_string(&report).unwrap(); assert!(text.contains("\\\\ud800")); let restored = restore_draft(&f.draft, &text, None).unwrap(); assert_eq!(restored.rebase.report.conclusion, kept); let mut envelope = f.envelope(); envelope["report"] = report.clone(); let paired = serde_json::to_string(&envelope) .unwrap() .replace('😀', "\\ud83d\\ude00"); let imported = import_archive(&f.draft, &paired).unwrap(); assert_eq!(imported.rebase.report.conclusion, kept); }