Refuse local references to ids a drawing does not define, scope canvas ids per view, upload every drawing in one stored form checked by the verdict and the preview, keep strict numeric rgb() colours, and commit real Inkscape 1.4.3 exports with their generator.
469 lines
16 KiB
Rust
469 lines
16 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");
|
|
}
|
|
|
|
#[test]
|
|
fn a_replaced_asset_releases_its_parse_and_a_pi_drawing_shows_rejected() {
|
|
let mut draft = PreviewSheet::load(
|
|
input(PreviewStatus::Draft, document_text(), None),
|
|
vec![horse_drawing()],
|
|
)
|
|
.unwrap();
|
|
for i in 0..40 {
|
|
let svg = format!(r#"<svg xmlns="http://www.w3.org/2000/svg"><path d="M0 0h{i}"/></svg>"#)
|
|
.into_bytes();
|
|
let sha = faunosteo_core::domain::sheet::verdict::sha256_hex(&svg);
|
|
draft
|
|
.add_drawing(PreviewDrawing {
|
|
asset_id: "same-asset".into(),
|
|
sha256: sha,
|
|
bytes: svg,
|
|
})
|
|
.unwrap();
|
|
}
|
|
assert_eq!(
|
|
draft.held_parses(),
|
|
2,
|
|
"the horse and the last bytes of the re-added asset"
|
|
);
|
|
let pi = br#"<?xml-stylesheet href="https://e/x.xsl"?><svg xmlns="http://www.w3.org/2000/svg"><path d="M0 0h1"/></svg>"#.to_vec();
|
|
let sha = faunosteo_core::domain::sheet::verdict::sha256_hex(&pi);
|
|
let mut doc = parse_json(&document_text()).unwrap();
|
|
doc["views"][0]["svg_asset_id"] = json!("33333333-0000-4000-8000-000000000001");
|
|
let preview = PreviewSheet::load(
|
|
input(PreviewStatus::Draft, doc.to_string(), None),
|
|
vec![PreviewDrawing {
|
|
asset_id: "33333333-0000-4000-8000-000000000001".into(),
|
|
sha256: sha,
|
|
bytes: pi,
|
|
}],
|
|
)
|
|
.unwrap();
|
|
let state = state(&preview);
|
|
assert_eq!(state.drawings[0].state, PreviewDrawingStatus::Rejected);
|
|
assert_eq!(
|
|
state.drawings[0].detail.as_deref(),
|
|
Some("processing_instruction")
|
|
);
|
|
}
|
|
|
|
/// Owner decision 2026-10-29: a stored drawing outside the stored form shows rejected
|
|
/// (`not_canonical`), as the verdict refuses it; the equine drawing is in that form.
|
|
#[test]
|
|
fn a_drawing_outside_the_stored_form_shows_rejected() {
|
|
let asset = "33333333-0000-4000-8000-000000000002";
|
|
let mut doc = parse_json(&document_text()).unwrap();
|
|
doc["views"][0]["svg_asset_id"] = json!(asset);
|
|
let horse_text = String::from_utf8(horse()).unwrap();
|
|
let loose = horse_text.split_once('\n').unwrap().1.as_bytes().to_vec();
|
|
let preview = PreviewSheet::load(
|
|
input(PreviewStatus::Draft, doc.to_string(), None),
|
|
vec![PreviewDrawing {
|
|
asset_id: asset.into(),
|
|
sha256: faunosteo_core::domain::sheet::verdict::sha256_hex(&loose),
|
|
bytes: loose,
|
|
}],
|
|
)
|
|
.unwrap();
|
|
let state = state(&preview);
|
|
assert_eq!(state.drawings[0].state, PreviewDrawingStatus::Rejected);
|
|
assert_eq!(state.drawings[0].detail.as_deref(), Some("not_canonical"));
|
|
let input = json!({ "viewId": "main" }).to_string();
|
|
let refused = canvas(call_with_preview(&preview, "view.canvas", &input));
|
|
assert_eq!(refused["detail"], json!("not_canonical"));
|
|
assert_eq!(
|
|
self::state(&published()).drawings[0].state,
|
|
PreviewDrawingStatus::Ok
|
|
);
|
|
}
|