Files
faunosteo/crates/core/tests/sheet_preview.rs
T
bchanot 8294d5471c fix(anatomy): V1-2.2 review findings, PIs and HTML refused, bounds
Security audit (PASS, 2 MEDIUM, 2 LOW) and verifier (ECARTS 6) on
741c25c: processing instructions and HTML fetchers refused, active
content under a long title classified, linear review groups, full
fixpoint check, bounded preview drawings, missing cap fixtures and
property checks, record wordings.
2026-10-29 13:38:33 +01:00

394 lines
13 KiB
Rust

//! V1-2.2: `PreviewSheet` (contract §8.1, §10). The equine draft previews with the index,
//! the fingerprint and the canvases of the bundled sheet; hash, fingerprint, caps and
//! missing-drawing faults refuse a published version; a draft loads with them reported and
//! draws with its integrity errors; a document replacement redraws without reading the
//! drawings again; no report operation runs on a preview.
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
mod common;
use faunosteo_core::domain::js::parse_json;
use faunosteo_core::domain::sheet::preview::{
PreviewDrawing, PreviewDrawingStatus, PreviewFailure, PreviewInput, PreviewSheet, PreviewState,
PreviewStatus,
};
use faunosteo_core::domain::sheet::{BundledSheetData, LoadedSheet, SheetIndexData};
use faunosteo_core::facade::{call_with_preview, call_with_sheet};
use serde_json::{Value, json};
const SEED: &str = "supabase/seed/anatomical-sheets/equine/draft";
const HORSE_ID: &str = "7f767f74-3b36-51a7-8465-52dd7e2ead4a";
const HORSE_SHA: &str = "0ea5202fa3b95bac167b87c12ee969ab0272e085b60c2d34dbca6202c5f08541";
const FINGERPRINT: &str = "12d788727c1e532641bd5b3a7ecf39dbdd25e70350f8a76be5ca917b262874e2";
fn document_text() -> String {
common::repo_file(&format!("{SEED}/document.json"))
}
fn horse() -> Vec<u8> {
std::fs::read(common::repo_path(&format!("{SEED}/assets/horse.svg"))).unwrap()
}
fn horse_drawing() -> PreviewDrawing {
PreviewDrawing {
asset_id: HORSE_ID.to_owned(),
sha256: HORSE_SHA.to_owned(),
bytes: horse(),
}
}
fn input(status: PreviewStatus, document: String, fingerprint: Option<&str>) -> PreviewInput {
PreviewInput {
status,
document,
fingerprint: fingerprint.map(str::to_owned),
}
}
fn published() -> PreviewSheet {
let input = input(PreviewStatus::Published, document_text(), Some(FINGERPRINT));
PreviewSheet::load(input, vec![horse_drawing()]).unwrap()
}
fn load_err(input: PreviewInput, drawings: Vec<PreviewDrawing>) -> PreviewFailure {
match PreviewSheet::load(input, drawings) {
Ok(_) => panic!("loaded"),
Err(failure) => failure,
}
}
/// The report editor's sheet, from the same seed folder as the bundle plugin reads.
fn bundled() -> LoadedSheet {
let reference = parse_json(&common::repo_file(&format!("{SEED}/sheet-ref.json"))).unwrap();
let payload = json!({
"status": "draft",
"ref": reference,
"document": parse_json(&document_text()).unwrap(),
"migrationMap": parse_json(&common::repo_file(&format!("{SEED}/report-migration-map.json"))).unwrap(),
"assets": { HORSE_ID: String::from_utf8(horse()).unwrap() },
"assetHashes": { HORSE_ID: HORSE_SHA }
});
let data: BundledSheetData = serde_json::from_value(payload).unwrap();
LoadedSheet::from_bundle(data).unwrap()
}
fn state(sheet: &PreviewSheet) -> PreviewState {
sheet.state().unwrap()
}
fn canvas(outcome: String) -> Value {
serde_json::from_str(&outcome).unwrap()
}
#[test]
fn the_equine_draft_previews_as_the_bundled_sheet() {
let preview = published();
let state = state(&preview);
let bundle = bundled();
let data = SheetIndexData::of(&bundle);
assert_eq!(state.fingerprint.as_deref(), Some(FINGERPRINT));
assert_eq!(bundle.reference.document_sha256, FINGERPRINT);
let index = state.index.unwrap();
assert_eq!(index.main_view_id, data.main_view_id);
assert_eq!(index.view_by_id, data.view_by_id);
assert_eq!(index.annotation_by_id, data.annotation_by_id);
assert_eq!(index.finding_zone_by_id, data.finding_zone_by_id);
assert_eq!(index.names, data.names);
assert_eq!(index.spine_ids, data.spine_ids);
assert_eq!(index.node_keys, data.node_keys);
assert_eq!(state.document, data.document);
for view in ["main", "head"] {
let input = json!({ "viewId": view }).to_string();
let from_preview = canvas(call_with_preview(&preview, "view.canvas", &input));
assert_eq!(from_preview["ok"], json!(true), "{view}");
assert_eq!(
from_preview,
canvas(call_with_sheet(&bundle, "view.canvas", &input)),
"{view}"
);
}
assert_eq!(state.report.groups.len(), 30);
assert_eq!(state.report.document_bytes, 184_105);
assert_eq!(state.drawings.len(), 1);
assert_eq!(state.drawings[0].state, PreviewDrawingStatus::Ok);
assert_eq!(preview.drawing_reads(), 1);
}
#[test]
fn a_hash_mismatch_is_refused_in_every_mode() {
let mut bytes = horse();
bytes[200] ^= 1;
for status in [
PreviewStatus::Draft,
PreviewStatus::Published,
PreviewStatus::Deprecated,
] {
let drawing = PreviewDrawing {
bytes: bytes.clone(),
..horse_drawing()
};
let failure = load_err(
input(status, document_text(), Some(FINGERPRINT)),
vec![drawing],
);
assert_eq!(
failure,
PreviewFailure::DrawingHashMismatch(HORSE_ID.to_owned())
);
assert_eq!(failure.kind(), "drawing_hash_mismatch");
}
let not_hex = PreviewDrawing {
sha256: "X".repeat(64),
..horse_drawing()
};
let failure = load_err(
input(PreviewStatus::Draft, document_text(), None),
vec![not_hex],
);
assert_eq!(failure.kind(), "drawing_hash_mismatch");
}
#[test]
fn a_published_version_needs_its_fingerprint_its_drawings_and_its_caps() {
let wrong = "a".repeat(64);
for stored in [Some(wrong.as_str()), None] {
let failure = load_err(
input(PreviewStatus::Published, document_text(), stored),
vec![horse_drawing()],
);
assert_eq!(failure, PreviewFailure::FingerprintMismatch);
}
let deprecated = input(
PreviewStatus::Deprecated,
document_text(),
Some(FINGERPRINT),
);
assert_eq!(
load_err(deprecated, vec![]),
PreviewFailure::DrawingMissing(HORSE_ID.to_owned())
);
// Over a cap: 1 025 annotations, its own fingerprint stored.
let mut over = parse_json(&document_text()).unwrap();
let template = over["annotations"][0].clone();
let annotations = over["annotations"].as_array_mut().unwrap();
for i in annotations.len()..1025 {
let mut copy = template.clone();
copy["id"] = json!(format!("extra-{i}"));
annotations.push(copy);
}
let text = over.to_string();
let fingerprint = faunosteo_core::domain::sheet::fingerprint::sheet_fingerprint(&text).unwrap();
let failure = load_err(
input(PreviewStatus::Published, text.clone(), Some(&fingerprint)),
vec![horse_drawing()],
);
assert_eq!(failure.kind(), "caps");
assert_eq!(failure.detail(), "annotations");
// The same document as a draft loads, the excess reported.
let draft = PreviewSheet::load(
input(PreviewStatus::Draft, text, None),
vec![horse_drawing()],
)
.unwrap();
let names: Vec<&str> = state(&draft)
.report
.caps
.exceeded
.iter()
.map(|c| c.as_str())
.collect();
assert_eq!(names, ["annotations"]);
}
#[test]
fn an_unreadable_document_is_refused_in_every_mode() {
for status in [PreviewStatus::Draft, PreviewStatus::Published] {
for text in ["{", r#"{"schema_version":2}"#, "[]"] {
let failure = load_err(input(status, text.to_owned(), None), vec![]);
assert_eq!(failure.kind(), "invalid_document", "{text}");
}
}
}
#[test]
fn a_draft_loads_with_its_missing_drawings_and_draws_with_its_issues() {
let missing =
PreviewSheet::load(input(PreviewStatus::Draft, document_text(), None), vec![]).unwrap();
assert_eq!(
state(&missing).drawings[0].state,
PreviewDrawingStatus::Missing
);
let canvas_out = canvas(call_with_preview(
&missing,
"view.canvas",
r#"{"viewId":"main"}"#,
));
assert_eq!(
(canvas_out["ok"].clone(), canvas_out["kind"].clone()),
(json!(false), json!("no_asset"))
);
// Integrity errors: a duplicate annotation id and a dangling category.
let mut invalid = parse_json(&document_text()).unwrap();
let copy = invalid["annotations"][0].clone();
invalid["annotations"].as_array_mut().unwrap().push(copy);
invalid["annotations"][1]["category_id"] = json!("nowhere");
let draft = PreviewSheet::load(
input(PreviewStatus::Draft, invalid.to_string(), None),
vec![horse_drawing()],
)
.unwrap();
let state = state(&draft);
assert!(state.fingerprint.is_none());
let codes: Vec<&str> = state
.report
.issues
.iter()
.map(|i| i.code.as_str())
.collect();
assert!(
codes.contains(&"annotation.id.duplicate")
&& codes.contains(&"annotation.category.missing")
);
let drawn = canvas(call_with_preview(
&draft,
"view.canvas",
r#"{"viewId":"main"}"#,
));
assert_eq!(drawn["ok"], json!(true));
assert!(
drawn["value"]["svg"]
.as_str()
.unwrap()
.contains("data-anno-id")
);
}
#[test]
fn a_replaced_document_redraws_without_reading_the_drawings_again() {
let mut draft = PreviewSheet::load(
input(PreviewStatus::Draft, document_text(), None),
vec![horse_drawing()],
)
.unwrap();
let before = canvas(call_with_preview(
&draft,
"view.canvas",
r#"{"viewId":"main"}"#,
));
let mut edited = parse_json(&document_text()).unwrap();
edited["annotations"].as_array_mut().unwrap().truncate(3);
for _ in 0..5 {
assert_eq!(
faunosteo_core::facade::replace_preview_document(&mut draft, &edited.to_string()),
r#"{"ok":true,"value":null}"#
);
}
let after = canvas(call_with_preview(
&draft,
"view.canvas",
r#"{"viewId":"main"}"#,
));
assert_eq!(after["ok"], json!(true));
assert_ne!(after, before);
assert_eq!(
draft.drawing_reads(),
1,
"the drawing was read once, at load"
);
assert_eq!(draft.document().annotations.len(), 3);
// A refused replacement keeps the previous document.
let refused = faunosteo_core::facade::replace_preview_document(&mut draft, "{");
assert!(refused.contains(r#""kind":"invalid_document""#));
assert_eq!(draft.document().annotations.len(), 3);
// A drawing added while open is read once, however often it is added.
let svg =
br#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 4 4"><path d="M0 0"/></svg>"#
.to_vec();
let sha = faunosteo_core::domain::sheet::verdict::sha256_hex(&svg);
for id in [
"22222222-0000-4000-8000-000000000001",
"22222222-0000-4000-8000-000000000002",
] {
let added = PreviewDrawing {
asset_id: id.to_owned(),
sha256: sha.clone(),
bytes: svg.clone(),
};
draft.add_drawing(added).unwrap();
}
assert_eq!(draft.drawing_reads(), 2);
}
#[test]
fn a_published_version_is_never_edited() {
let mut sheet = published();
assert_eq!(
sheet.replace_document(&document_text()),
Err(PreviewFailure::ReadOnly)
);
assert_eq!(
sheet.add_drawing(horse_drawing()),
Err(PreviewFailure::ReadOnly)
);
}
#[test]
fn no_report_operation_runs_on_a_preview() {
let preview = published();
for op in [
"draft.restore",
"archive.import",
"archive.snapshot",
"zone.click",
"index_data",
] {
let outcome = canvas(call_with_preview(&preview, op, "{}"));
assert_eq!(outcome["kind"], json!("unknown_op"), "{op}");
}
let state = canvas(call_with_preview(&preview, "preview.state", "{}"));
assert_eq!(state["value"]["status"], json!("published"));
}
#[test]
fn a_preview_holds_a_bounded_number_of_bounded_drawings() {
use faunosteo_core::domain::sheet::preview::MAX_HELD_DRAWINGS;
let huge = vec![b' '; 2 * 1024 * 1024 + 1];
let sha = faunosteo_core::domain::sheet::verdict::sha256_hex(&huge);
let oversized = PreviewDrawing {
asset_id: "a".into(),
sha256: sha,
bytes: huge,
};
let failure = load_err(
input(PreviewStatus::Draft, document_text(), None),
vec![oversized],
);
assert_eq!(
(failure.kind(), failure.detail()),
("caps", "drawing_bytes".to_owned())
);
let mut draft = PreviewSheet::load(
input(PreviewStatus::Draft, document_text(), None),
vec![horse_drawing()],
)
.unwrap();
for i in 1..MAX_HELD_DRAWINGS {
let added = PreviewDrawing {
asset_id: format!("extra-{i}"),
..horse_drawing()
};
draft.add_drawing(added).unwrap();
}
let one_more = PreviewDrawing {
asset_id: "one-more".into(),
..horse_drawing()
};
assert_eq!(
draft.add_drawing(one_more),
Err(PreviewFailure::Caps(vec![
faunosteo_core::domain::sheet::caps::CapName::Drawings
]))
);
assert_eq!(draft.drawing_reads(), 1, "the same bytes are read once");
}