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.
394 lines
13 KiB
Rust
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");
|
|
}
|