The core's authoring surface of contract §16.3: the server's document measure, review groups with digests and removal groups, the change list, the pure server verdict in the shape M5 reads, PreviewSheet with draft and published modes, and the editor's commands with the §6.6 markings.
351 lines
12 KiB
Rust
351 lines
12 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"));
|
|
}
|