Files
faunosteo/crates/core/tests/archive_rules.rs
T
bchanot 21906c4358 feat(domain): R2.2 report migration, rebase, sheet snapshot and layered archive reading in Rust; draft restore and archive import operations
migrateReportV2ToV3 / readReportDocument (version read on the raw value,
JS truthiness kept, a malformed mapped path still fails the read),
rebaseReportOnSheet (??= labels, archived names first-match),
buildSheetSnapshot / assertSnapshot (raw depth, shape, caps in UTF-16 and
UTF-8, integrity), readArchiveDocument (layered: report first, wrapper,
snapshot gate, sheet invariant, unsupported_envelope origin quirk).
Checked against 84 cases frozen from the TypeScript and 765 Zod verdicts
(one declared difference: L1, a lone surrogate reads as U+FFFD), the
ported report and archive suites and the 612 legacy leaves. Facade:
draft.restore (content kinds invalid / unsupported_version, rebase_failed
never a content kind), archive.import (incompatible_version with found,
no_attachment), archive.snapshot.
2026-10-14 00:28:02 +02:00

885 lines
30 KiB
Rust

//! `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::<Branding>(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::<Branding>(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": "<svg/>" }),
),
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/<x>",
"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::<PdfLabelSet>(set.clone())).unwrap()["fr"]["pdf.subject"],
set["fr"]["pdf.subject"]
);
let accepts = |v: Value| serde_json::from_value::<PdfLabelSet>(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 = "<svg xmlns=\"http://www.w3.org/2000/svg\"></svg>";
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("packages/domain/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<String> {
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<_>>(),
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<_>>(),
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<Value> = (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<Value> = (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<Value> = (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<Value> = 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<faunosteo_core::domain::archive::ArchiveReadOutcome, ReadFailure> {
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(
"packages/domain/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("packages/domain/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("packages/domain/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}"
);
}
}