feat(domain): V1-2.2 document measure, review groups, verdict, preview, edits

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.
This commit is contained in:
bchanot committed 2026-10-29 13:14:21 +01:00
1 parent ac71c5b662
commit 64a43840ce
21 files changed
+5204 -17

No files matched your search

@@ -0,0 +1,99 @@
{
"generator": "crates/core/tests/oracles/v1-2-2/size.mjs",
"postgres": "PostgreSQL 17.5 on aarch64-unknown-linux-gnu, compiled by emcc (Emscripten gcc/clang-like replacement + linker emulating GNU ld) 3.1.74 (1092ec30a3fb1d46b1782ff1b4db5094d3d06ae5), 32-bit",
"vectors": [
{
"name": "zero",
"text": "0",
"bytes": 1
},
{
"name": "negative_zero",
"text": "0",
"bytes": 1
},
{
"name": "integers",
"text": "[1,-12,100,9007199254740992,123456789012345680000]",
"bytes": 54
},
{
"name": "fractions",
"text": "[0.5,0.1,0.001,123.456,0.3333333333333333,-0.3333333333333333,0.000001]",
"bytes": 77
},
{
"name": "exponents",
"text": "[1e-7,1.5e-7,-1.5e-7,2.5e-10,1e+21,1.5e+21,1e+300,5e-324]",
"bytes": 730
},
{
"name": "extremes",
"text": "[1.7976931348623157e+308,5e-324,-1.7976931348623157e+308]",
"bytes": 951
},
{
"name": "literals",
"text": "[true,false,null]",
"bytes": 19
},
{
"name": "strings",
"text": "[\"\",\"a\",\"é\",\"€\",\"𝄞\",\"\\\"\",\"\\\\\",\"/\",\"<script>\",\"Hanche « gauche »\"]",
"bytes": 82
},
{
"name": "escapes",
"text": "[\"\\b\\f\\n\\r\\t\",\"\\u0001\\u001f\",\"\",\"

\",\"a\\\"b\\\\c\\nd\"]",
"bytes": 59
},
{
"name": "empty_containers",
"text": "[[],{},[[]],[{}],{\"a\":{}}]",
"bytes": 31
},
{
"name": "keys",
"text": "{\"é\":\"x\",\"𝄞\":1,\"a b\":[],\"\\\"\":\"\\\\\",\"\\n\":0}",
"bytes": 54
},
{
"name": "nested_arrays",
"text": "[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]",
"bytes": 122
},
{
"name": "dense",
"text": "[{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"a\":1},{\"Line truncated
"bytes": 10000
},
{
"name": "pgtap_017_exponents",
"text": "{\"pad\":[1e-7,1e+21]}",
"bytes": 44
},
{
"name": "mixed",
"text": "{\"schema_version\":2,\"name\":{\"fr\":\"Cheval\",\"en\":\"Horse\"},\"views\":[{\"id\":\"main\",\"view_box\":{\"min_x\":-0.5,\"min_y\":1e-7,\"width\":1e+21,\"height\":2}}]}",
"bytes": 184
},
{
"name": "repeated_key",
"text": "{\"a\":1,\"b\":2,\"a\":22}",
"bytes": 17
},
{
"name": "whitespace",
"text": "{ \"a\" : [ 1 , 2 ] ,\n \"b\" : { } }",
"bytes": 22
}
],
"pgtap_017_base": {
"text": "{\"pad\": \"\", \"name\": {\"en\": \"R horse\", \"fr\": \"Cheval R\"}, \"views\": [{\"id\": \"main\", \"kind\": \"main\", \"name\": {\"en\": \"V\", \"fr\": \"V\"}, \"view_box\": null, \"svg_asset_id\": \"00000000-0000-4000-8000-000000000001\"}], \"categories\": [{\"id\": \"c\", \"name\": {\"en\": \"C\", \"fr\": \"C\"}, \"color\": null}], \"references\": [], \"species_id\": \"equine\", \"annotations\": [{\"id\": \"a1\", \"kind\": \"point\", \"name\": {\"en\": \"P\", \"fr\": \"P\"}, \"view_id\": \"main\", \"geometry\": null, \"laterality\": \"unpaired\", \"category_id\": \"c\", \"review_status\": \"reviewed\", \"finding_zone_id\": \"z1\", \"vertebral_region_code\": null}], \"attribution\": {\"notes\": null, \"authors\": [\"F\"], \"license\": null}, \"description\": {\"en\": \"d\", \"fr\": \"d\"}, \"finding_zones\": [{\"id\": \"z1\", \"name\": {\"en\": \"Z\", \"fr\": \"Z\"}, \"categories\": [{\"id\": \"cat\", \"kind\": \"dysfunction\", \"name\": {\"en\": \"D\", \"fr\": \"D\"}, \"children\": [{\"id\": \"n1\", \"name\": {\"en\": \"N\", \"fr\": \"N\"}, \"review_status\": \"reviewed\"}], \"review_status\": \"reviewed\"}]}], \"schema_version\": 2, \"scope_disclaimer\": {\"en\": \"x\", \"fr\": \"x\"}, \"vertebral_config\": {\"regions\": []}}",
"bytes": 1048
},
"seed": {
"file": "supabase/seed/anatomical-sheets/equine/draft/document.json",
"bytes": 184105
}
}
+92
View File
@@ -0,0 +1,92 @@
// V1-2.2 size oracle: PostgreSQL measures each text the way the save RPCs and the table CHECK
// do, `octet_length(text::jsonb::text)` (contract §12.2), and `size.json` freezes the answers
// the core's `document_text_bytes` must reproduce (`crates/core/tests/sheet_size.rs`).
//
// PostgreSQL is PGlite (PostgreSQL 17 compiled to WebAssembly, the Dockerless pgTAP runner of
// packages/supabase). Texts are written by JSON.stringify, as a page sends them, except the
// repeated-key case and the seed file, which are read as they stand.
//
// Run from the repository root: node crates/core/tests/oracles/v1-2-2/size.mjs
import { readFileSync, writeFileSync } from 'node:fs'
import { createRequire } from 'node:module'
const root = new URL('../../../../../', import.meta.url)
const require = createRequire(new URL('packages/supabase/package.json', root))
const { PGlite } = await import(require.resolve('@electric-sql/pglite'))
const SEED = 'supabase/seed/anatomical-sheets/equine/draft/document.json'
const nested = (depth) => {
let value = []
for (let i = 0; i < depth; i += 1) value = [value]
return value
}
const values = {
zero: 0,
negative_zero: -0,
integers: [1, -12, 100, 9007199254740993, 123456789012345680000],
fractions: [0.5, 0.1, 0.001, 123.456, 1 / 3, -1 / 3, 1e-6],
exponents: [1e-7, 1.5e-7, -1.5e-7, 2.5e-10, 1e21, 1.5e21, 1e300, 5e-324],
extremes: [Number.MAX_VALUE, Number.MIN_VALUE, -Number.MAX_VALUE],
literals: [true, false, null],
strings: ['', 'a', 'é', '€', '𝄞', '"', '\\', '/', '<script>', 'Hanche « gauche »'],
escapes: ['\b\f\n\r\t', '\u0001\u001f', '\u007f', '

', 'a"b\\c\nd'],
empty_containers: [[], {}, [[]], [{}], { a: {} }],
keys: { é: 'x', '𝄞': 1, 'a b': [], '"': '\\', '\n': 0 },
nested_arrays: nested(60),
dense: Array.from({ length: 1000 }, () => ({ a: 1 })),
pgtap_017_exponents: { pad: [1e-7, 1e21] },
mixed: { schema_version: 2, name: { fr: 'Cheval', en: 'Horse' }, views: [{ id: 'main', view_box: { min_x: -0.5, min_y: 1e-7, width: 1e21, height: 2 } }] },
}
const texts = Object.entries(values).map(([name, value]) => ({ name, text: JSON.stringify(value) }))
texts.push({ name: 'repeated_key', text: '{"a":1,"b":2,"a":22}' })
texts.push({ name: 'whitespace', text: '{ "a" : [ 1 , 2 ] ,\n "b" : { } }' })
const db = new PGlite()
const measure = async (text) =>
(await db.query('select octet_length($1::jsonb::text) as n', [text])).rows[0].n
const vectors = []
for (const { name, text } of texts) vectors.push({ name, text, bytes: await measure(text) })
// The pgTAP 017 base document (`pg_temp.doc(asset, 'reviewed')`) with an empty pad: the
// `sized` fixtures pad it to cap − 1, cap and cap + 1 bytes.
await db.exec(`create function doc(p_asset uuid, st text) returns jsonb language sql as $$
select jsonb_build_object('schema_version', 2, 'species_id', 'equine',
'name', jsonb_build_object('fr', 'Cheval R', 'en', 'R horse'),
'description', jsonb_build_object('fr', 'd', 'en', 'd'),
'scope_disclaimer', jsonb_build_object('fr', 'x', 'en', 'x'),
'attribution', jsonb_build_object('authors', jsonb_build_array('F'), 'license', null, 'notes', null),
'vertebral_config', jsonb_build_object('regions', '[]'::jsonb), 'references', '[]'::jsonb,
'categories', jsonb_build_array(jsonb_build_object('id', 'c', 'name', jsonb_build_object('fr', 'C', 'en', 'C'), 'color', null)),
'views', jsonb_build_array(jsonb_build_object('id', 'main', 'kind', 'main', 'name', jsonb_build_object('fr', 'V', 'en', 'V'),
'svg_asset_id', p_asset, 'view_box', null)),
'annotations', jsonb_build_array(jsonb_build_object('id', 'a1', 'kind', 'point', 'view_id', 'main', 'category_id', 'c',
'laterality', 'unpaired', 'geometry', null, 'review_status', st, 'name', jsonb_build_object('fr', 'P', 'en', 'P'),
'finding_zone_id', 'z1', 'vertebral_region_code', null)),
'finding_zones', (select jsonb_agg(jsonb_build_object('id', 'z' || i, 'name', jsonb_build_object('fr', 'Z', 'en', 'Z'),
'categories', jsonb_build_array(jsonb_build_object('id', 'cat', 'kind', 'dysfunction', 'name', jsonb_build_object('fr', 'D', 'en', 'D'),
'review_status', st, 'children', jsonb_build_array(jsonb_build_object('id', 'n1', 'name', jsonb_build_object('fr', 'N', 'en', 'N'),
'review_status', st)))))) from generate_series(1, 1) i));
$$`)
const base = (
await db.query(
`select (doc('00000000-0000-4000-8000-000000000001', 'reviewed') || '{"pad": ""}'::jsonb)::text as t`,
)
).rows[0].t
const pgtap017 = { text: base, bytes: await measure(base) }
const seed = readFileSync(new URL(SEED, root), 'utf8')
const version = (await db.query('select version() as v')).rows[0].v
const oracle = {
generator: 'crates/core/tests/oracles/v1-2-2/size.mjs',
postgres: version,
vectors,
pgtap_017_base: pgtap017,
seed: { file: SEED, bytes: await measure(seed) },
}
writeFileSync(new URL('size.json', import.meta.url), `${JSON.stringify(oracle, null, 2)}\n`)
console.log(`${vectors.length} vectors, base ${pgtap017.bytes} B, seed ${oracle.seed.bytes} B, ${version}`)
+797
View File
@@ -0,0 +1,797 @@
//! V1-2.2: the editor's commands (contract §6.6, §8.1). The status rules, case by case; the
//! refusals; `dependents`; the facade; and a property test over random command sequences:
//! every output reads back strictly, existing keys survive unless removed, an edited or new
//! element is `to_confirm`, nothing ever becomes `inherited`.
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
mod common;
use std::collections::HashMap;
use faunosteo_core::domain::js::parse_json;
use faunosteo_core::domain::sheet::AnatomicalSheetDocument;
use faunosteo_core::domain::sheet::edit::{
EditCommand, EditError, Relation, apply_edit, dependents,
};
use faunosteo_core::domain::sheet::keys::{ElementKey, marked_elements};
use faunosteo_core::domain::sheet::schema::ReviewStatus;
use faunosteo_core::facade::call;
use serde_json::{Value, json};
const SEED: &str = "supabase/seed/anatomical-sheets/equine/draft/document.json";
fn name(text: &str) -> Value {
json!({ "fr": text, "en": text })
}
/// Two views (a detail crop of the main one), a point in each, a trigger, a zone with a
/// category and a two-level node, one reference, one region; everything `reviewed`.
fn small() -> AnatomicalSheetDocument {
serde_json::from_value(json!({
"schema_version": 2, "species_id": "canine", "name": name("Chien"),
"description": {}, "scope_disclaimer": {},
"attribution": { "authors": [], "license": null, "notes": null },
"vertebral_config": { "regions": [{ "code": "C", "name": name("Cervicales"), "count": 7 }] },
"references": [{ "id": "r1", "type": "book", "citation": "Atlas" }],
"categories": [{ "id": "c", "name": name("C"), "color": null }],
"views": [
{ "id": "main", "kind": "main", "name": name("Vue"), "svg_asset_id": "11111111-2222-4333-8444-555555555555", "view_box": null },
{ "id": "head", "kind": "detail", "name": name("Tête"), "svg_asset_id": null,
"view_box": { "min_x": 0, "min_y": 0, "width": 4, "height": 4 }, "parent_view_id": "main" }
],
"annotations": [
{ "id": "a1", "kind": "point", "view_id": "main", "category_id": "c", "laterality": "left",
"geometry": { "type": "circle", "cx": 1, "cy": 1, "r": 1 }, "review_status": "reviewed",
"name": name("P1"), "finding_zone_id": "z1", "vertebral_region_code": "C" },
{ "id": "a2", "kind": "point", "view_id": "head", "category_id": "c", "laterality": "unpaired",
"geometry": { "type": "circle", "cx": 2, "cy": 2, "r": 1 }, "review_status": "reviewed",
"name": name("P2"), "finding_zone_id": "z1", "vertebral_region_code": null },
{ "id": "t1", "kind": "detail_trigger", "view_id": "main", "category_id": "c", "laterality": "unpaired",
"geometry": { "type": "polygon", "points": [[0, 0], [1, 0], [1, 1]] }, "review_status": "reviewed",
"name": null, "opens_view_id": "head" }
],
"finding_zones": [{ "id": "z1", "name": name("Z"), "categories": [{ "id": "cat", "kind": "dysfunction",
"name": name("D"), "reference_ids": ["r1"], "review_status": "reviewed",
"children": [{ "id": "n1", "name": name("N1"), "review_status": "reviewed",
"children": [{ "id": "n2", "name": name("N2"), "review_status": "reviewed" }] }] }] }]
}))
.unwrap()
}
fn command(value: Value) -> EditCommand {
serde_json::from_value(value).unwrap()
}
fn edit(doc: &AnatomicalSheetDocument, value: Value) -> AnatomicalSheetDocument {
apply_edit(doc, command(value)).unwrap()
}
fn refused(doc: &AnatomicalSheetDocument, value: Value) -> EditError {
apply_edit(doc, command(value)).unwrap_err()
}
fn statuses(doc: &AnatomicalSheetDocument) -> HashMap<ElementKey, ReviewStatus> {
marked_elements(doc)
.into_iter()
.map(|m| (m.key, m.status))
.collect()
}
fn status(doc: &AnatomicalSheetDocument, key: Value) -> ReviewStatus {
let key: ElementKey = serde_json::from_value(key).unwrap();
statuses(doc)[&key]
}
fn finding(path: &[&str]) -> Value {
json!({ "kind": "finding", "zone_id": "z1", "path": path })
}
fn annotation(id: &str) -> Value {
json!({ "kind": "annotation", "id": id })
}
#[test]
fn inserted_elements_start_to_confirm_with_their_subtree() {
let doc = small();
let point = json!({ "id": "a3", "kind": "point", "view_id": "main", "category_id": "c", "laterality": "right",
"geometry": null, "review_status": "reviewed", "name": name("P3"), "finding_zone_id": null, "vertebral_region_code": null });
let next = edit(
&doc,
json!({ "op": "insert", "element": { "kind": "annotation", "value": point }, "position": 0 }),
);
assert_eq!(next.annotations[0].id(), "a3");
assert_eq!(
status(&next, annotation("a3")),
ReviewStatus::ToConfirm,
"a page's marking is ignored"
);
let subtree = json!({ "id": "n3", "name": name("N3"), "review_status": "reviewed",
"children": [{ "id": "n4", "name": name("N4"), "review_status": "inherited" }] });
let next = edit(
&doc,
json!({ "op": "insert", "parent": finding(&["cat"]), "element": { "kind": "finding_node", "value": subtree } }),
);
assert_eq!(
status(&next, finding(&["cat", "n3"])),
ReviewStatus::ToConfirm
);
assert_eq!(
status(&next, finding(&["cat", "n3", "n4"])),
ReviewStatus::ToConfirm
);
let zone = json!({ "id": "z2", "name": name("Z2"), "categories": [{ "id": "k", "kind": "custom", "name": name("K"),
"review_status": "reviewed", "children": [] }] });
let next = edit(
&doc,
json!({ "op": "insert", "element": { "kind": "zone", "value": zone } }),
);
let key = json!({ "kind": "finding", "zone_id": "z2", "path": ["k"] });
assert_eq!(status(&next, key), ReviewStatus::ToConfirm);
}
#[test]
fn a_content_change_reconfirms_an_identical_update_does_not() {
let doc = small();
let mut same = serde_json::to_value(&doc.annotations[0]).unwrap();
let unchanged = edit(
&doc,
json!({ "op": "update", "key": annotation("a1"), "element": { "kind": "annotation", "value": same.clone() } }),
);
assert_eq!(unchanged, doc);
same["review_status"] = json!("to_confirm");
let ignored = edit(
&doc,
json!({ "op": "update", "key": annotation("a1"), "element": { "kind": "annotation", "value": same.clone() } }),
);
assert_eq!(
status(&ignored, annotation("a1")),
ReviewStatus::Reviewed,
"update never sets a marking"
);
for (field, value) in [
("name", name("Autre")),
("laterality", json!("right")),
("color", json!("#112233")),
("finding_zone_id", Value::Null),
("view_id", json!("head")),
(
"geometry",
json!({ "type": "circle", "cx": 1.5, "cy": 1, "r": 1 }),
),
] {
let mut changed = serde_json::to_value(&doc.annotations[0]).unwrap();
changed[field] = value;
let next = edit(
&doc,
json!({ "op": "update", "key": annotation("a1"), "element": { "kind": "annotation", "value": changed } }),
);
assert_eq!(
status(&next, annotation("a1")),
ReviewStatus::ToConfirm,
"{field}"
);
assert_eq!(status(&next, annotation("a2")), ReviewStatus::Reviewed);
}
let node = json!({ "id": "n1", "name": name("N1 bis"), "requires_vet_referral": false, "review_status": "reviewed" });
let next = edit(
&doc,
json!({ "op": "update", "key": finding(&["cat", "n1"]), "element": { "kind": "finding_node", "value": node } }),
);
assert_eq!(
status(&next, finding(&["cat", "n1"])),
ReviewStatus::ToConfirm
);
assert_eq!(
status(&next, finding(&["cat", "n1", "n2"])),
ReviewStatus::Reviewed,
"children untouched"
);
assert_eq!(
next.finding_zones[0].categories[0].children[0]
.children
.len(),
1,
"children kept"
);
let cited =
json!({ "id": "n1", "name": name("N1"), "reference_ids": [], "review_status": "reviewed" });
let next = edit(
&doc,
json!({ "op": "update", "key": finding(&["cat", "n1"]), "element": { "kind": "finding_node", "value": cited } }),
);
assert_eq!(
status(&next, finding(&["cat", "n1"])),
ReviewStatus::Reviewed,
"same content"
);
let flagged = json!({ "id": "n1", "name": name("N1"), "requires_vet_referral": true });
let next = edit(
&doc,
json!({ "op": "update", "key": finding(&["cat", "n1"]), "element": { "kind": "finding_node", "value": flagged } }),
);
assert_eq!(
status(&next, finding(&["cat", "n1"])),
ReviewStatus::ToConfirm
);
let category = json!({ "id": "cat", "kind": "anamnesis", "name": name("D"), "reference_ids": ["r1"], "children": [] });
let next = edit(
&doc,
json!({ "op": "update", "key": finding(&["cat"]), "element": { "kind": "finding_category", "value": category } }),
);
assert_eq!(status(&next, finding(&["cat"])), ReviewStatus::ToConfirm);
assert_eq!(next.finding_zones[0].categories[0].children.len(), 1);
}
#[test]
fn shared_elements_and_reorders_keep_the_markings() {
let doc = small();
let before = statuses(&doc);
let texts = json!({ "name": name("Chien domestique"), "description": { "fr": "d" }, "scope_disclaimer": { "fr": "x", "en": "x" },
"attribution": { "authors": ["B"], "license": null, "notes": null } });
let reference = json!({ "id": "r1", "type": "journal", "citation": "Revue" });
let region = json!({ "code": "C", "name": name("Cou"), "count": 7, "count_range": { "min": 6, "max": 8 } });
let category = json!({ "id": "c", "name": name("Catégorie"), "color": "#aa0000" });
for command in [
json!({ "op": "update", "key": { "kind": "sheet" }, "element": { "kind": "sheet", "value": texts } }),
json!({ "op": "update", "key": { "kind": "reference", "id": "r1" }, "element": { "kind": "reference", "value": reference } }),
json!({ "op": "update", "key": { "kind": "region", "code": "C" }, "element": { "kind": "region", "value": region } }),
json!({ "op": "update", "key": { "kind": "category", "id": "c" }, "element": { "kind": "category", "value": category } }),
json!({ "op": "move", "key": annotation("t1"), "position": 0 }),
json!({ "op": "move", "key": { "kind": "view", "id": "head" }, "position": 0 }),
] {
assert_eq!(statuses(&edit(&doc, command.clone())), before, "{command}");
}
let moved = edit(
&doc,
json!({ "op": "move", "key": annotation("t1"), "position": 0 }),
);
assert_eq!(moved.annotations[0].id(), "t1");
}
#[test]
fn a_redrawn_view_reconfirms_its_annotations_and_its_crops() {
let doc = small();
let mut main = serde_json::to_value(&doc.views[0]).unwrap();
main["svg_asset_id"] = json!("11111111-2222-4333-8444-000000000009");
let next = edit(
&doc,
json!({ "op": "update", "key": { "kind": "view", "id": "main" }, "element": { "kind": "view", "value": main } }),
);
assert_eq!(status(&next, annotation("a1")), ReviewStatus::ToConfirm);
assert_eq!(status(&next, annotation("t1")), ReviewStatus::ToConfirm);
assert_eq!(
status(&next, annotation("a2")),
ReviewStatus::ToConfirm,
"head crops main: its drawing changed too"
);
let mut head = serde_json::to_value(&doc.views[1]).unwrap();
head["view_box"]["width"] = json!(5);
let next = edit(
&doc,
json!({ "op": "update", "key": { "kind": "view", "id": "head" }, "element": { "kind": "view", "value": head } }),
);
assert_eq!(status(&next, annotation("a2")), ReviewStatus::ToConfirm);
assert_eq!(status(&next, annotation("a1")), ReviewStatus::Reviewed);
let mut renamed = serde_json::to_value(&doc.views[1]).unwrap();
renamed["name"] = name("Crâne");
let next = edit(
&doc,
json!({ "op": "update", "key": { "kind": "view", "id": "head" }, "element": { "kind": "view", "value": renamed } }),
);
assert_eq!(
status(&next, annotation("a2")),
ReviewStatus::Reviewed,
"a rename draws nothing new"
);
}
#[test]
fn markings_are_set_one_element_category_or_zone_at_a_time() {
let doc = small();
let next = edit(
&doc,
json!({ "op": "set_status", "key": finding(&["cat", "n1"]), "status": "to_confirm" }),
);
assert_eq!(
status(&next, finding(&["cat", "n1"])),
ReviewStatus::ToConfirm
);
assert_eq!(
status(&next, finding(&["cat", "n1", "n2"])),
ReviewStatus::Reviewed
);
let next = edit(
&next,
json!({ "op": "set_status", "key": finding(&["cat", "n1"]), "status": "reviewed" }),
);
assert_eq!(statuses(&next), statuses(&doc));
let inherited: Result<EditCommand, _> = serde_json::from_value(
json!({ "op": "set_status", "key": annotation("a1"), "status": "inherited" }),
);
assert!(inherited.is_err(), "no command assigns inherited");
let all_to_confirm = edit(
&doc,
json!({ "op": "set_status", "key": finding(&["cat"]), "status": "to_confirm" }),
);
let all_to_confirm = edit(
&all_to_confirm,
json!({ "op": "set_status", "key": finding(&["cat", "n1", "n2"]), "status": "to_confirm" }),
);
let marked = edit(
&all_to_confirm,
json!({ "op": "mark_reviewed", "key": finding(&["cat"]) }),
);
assert_eq!(status(&marked, finding(&["cat"])), ReviewStatus::Reviewed);
assert_eq!(
status(&marked, finding(&["cat", "n1", "n2"])),
ReviewStatus::Reviewed
);
let zone = edit(
&all_to_confirm,
json!({ "op": "mark_reviewed", "key": { "kind": "zone", "id": "z1" } }),
);
assert_eq!(statuses(&zone), statuses(&doc));
for key in [
finding(&["cat", "n1"]),
annotation("a1"),
json!({ "kind": "view", "id": "main" }),
json!({ "kind": "sheet" }),
] {
assert_eq!(
refused(&doc, json!({ "op": "mark_reviewed", "key": key })),
EditError::InvalidTarget
);
}
assert_eq!(
refused(
&doc,
json!({ "op": "set_status", "key": { "kind": "view", "id": "main" }, "status": "reviewed" })
),
EditError::InvalidTarget
);
}
#[test]
fn a_removal_takes_the_descendants_and_leaves_references_to_the_panel() {
let doc = small();
let next = edit(
&doc,
json!({ "op": "remove", "key": finding(&["cat", "n1"]) }),
);
assert!(next.finding_zones[0].categories[0].children.is_empty());
let next = edit(
&doc,
json!({ "op": "remove", "key": { "kind": "view", "id": "head" } }),
);
assert_eq!(next.views.len(), 1);
assert_eq!(next.annotations.len(), 3, "a2 and t1 stay, dangling");
let issues = faunosteo_core::domain::sheet::validate_sheet_document(&next);
assert!(issues.iter().any(|i| i.code == "annotation.view.missing"));
let next = edit(
&doc,
json!({ "op": "remove", "key": { "kind": "zone", "id": "z1" } }),
);
assert!(next.finding_zones.is_empty());
}
#[test]
fn ambiguous_unknown_or_out_of_range_targets_are_refused() {
let doc = small();
let copy = serde_json::to_value(&doc.annotations[0]).unwrap();
let cases = [
(
json!({ "op": "insert", "element": { "kind": "annotation", "value": copy.clone() } }),
EditError::DuplicateKey,
),
(
json!({ "op": "insert", "element": { "kind": "annotation", "value": copy.clone() }, "position": 9 }),
EditError::DuplicateKey,
),
(
json!({ "op": "remove", "key": annotation("zz") }),
EditError::UnknownKey,
),
(
json!({ "op": "remove", "key": finding(&["cat", "zz"]) }),
EditError::UnknownKey,
),
(
json!({ "op": "remove", "key": finding(&[]) }),
EditError::UnknownKey,
),
(
json!({ "op": "remove", "key": { "kind": "sheet" } }),
EditError::InvalidTarget,
),
(
json!({ "op": "move", "key": annotation("a1"), "position": 3 }),
EditError::InvalidPosition,
),
(
json!({ "op": "update", "key": annotation("a2"), "element": { "kind": "annotation", "value": copy.clone() } }),
EditError::IdChanged,
),
(
json!({ "op": "update", "key": annotation("a1"), "element": { "kind": "zone", "value": { "id": "a1", "name": name("x"), "categories": [] } } }),
EditError::InvalidTarget,
),
(
json!({ "op": "insert", "parent": { "kind": "zone", "id": "z1" }, "element": { "kind": "finding_node", "value": { "id": "x", "name": name("x") } } }),
EditError::InvalidTarget,
),
(
json!({ "op": "insert", "parent": finding(&["cat"]), "element": { "kind": "finding_node", "value": { "id": "n1", "name": name("x") } } }),
EditError::DuplicateKey,
),
(
json!({ "op": "insert", "parent": { "kind": "zone", "id": "z9" }, "element": { "kind": "finding_category", "value": { "id": "k", "kind": "custom", "name": name("x"), "children": [] } } }),
EditError::UnknownKey,
),
(
json!({ "op": "insert", "element": { "kind": "sheet", "value": { "name": name("x"), "description": {}, "scope_disclaimer": {}, "attribution": { "authors": [], "license": null, "notes": null } } } }),
EditError::InvalidTarget,
),
];
for (command, error) in cases {
assert_eq!(refused(&doc, command.clone()), error, "{command}");
}
let twins = json!({ "id": "n9", "name": name("x"), "children": [{ "id": "k", "name": name("k") }, { "id": "k", "name": name("k") }] });
assert_eq!(
refused(
&doc,
json!({ "op": "insert", "parent": finding(&["cat"]), "element": { "kind": "finding_node", "value": twins } })
),
EditError::DuplicateKey
);
}
#[test]
fn findings_stop_at_eight_levels() {
let doc = small();
// n2 sits at level 3 (category 1, n1 2, n2 3): five more levels fit, six do not.
let nested = |levels: usize| {
let mut node = json!({ "id": format!("d{levels}"), "name": name("d") });
for level in (1..levels).rev() {
node = json!({ "id": format!("d{level}"), "name": name("d"), "children": [node] });
}
node
};
let under_n2 = finding(&["cat", "n1", "n2"]);
edit(
&doc,
json!({ "op": "insert", "parent": under_n2.clone(), "element": { "kind": "finding_node", "value": nested(5) } }),
);
assert_eq!(
refused(
&doc,
json!({ "op": "insert", "parent": under_n2, "element": { "kind": "finding_node", "value": nested(6) } })
),
EditError::TooDeep
);
}
#[test]
fn dependents_list_what_a_removal_leaves_dangling_or_takes() {
let doc = small();
let of = |key: Value| -> Vec<(ElementKey, Relation)> {
let key: ElementKey = serde_json::from_value(key).unwrap();
dependents(&doc, &key)
.into_iter()
.map(|d| (d.element, d.relation))
.collect()
};
let a = |id: &str| ElementKey::Annotation { id: id.to_owned() };
let f = |path: &[&str]| ElementKey::Finding {
zone_id: "z1".to_owned(),
path: path.iter().map(|s| (*s).to_owned()).collect(),
};
assert_eq!(
of(json!({ "kind": "view", "id": "head" })),
[(a("a2"), Relation::DrawnIn), (a("t1"), Relation::Opens)]
);
assert_eq!(
of(json!({ "kind": "view", "id": "main" }))[0],
(
ElementKey::View {
id: "head".to_owned()
},
Relation::ChildView
)
);
assert_eq!(of(json!({ "kind": "category", "id": "c" })).len(), 3);
assert_eq!(
of(json!({ "kind": "region", "code": "C" })),
[(a("a1"), Relation::UsesRegion)]
);
assert_eq!(
of(json!({ "kind": "reference", "id": "r1" })),
[(f(&["cat"]), Relation::Cites)]
);
assert_eq!(
of(json!({ "kind": "zone", "id": "z1" })),
[
(a("a1"), Relation::LinksZone),
(a("a2"), Relation::LinksZone),
(f(&["cat"]), Relation::Descendant),
(f(&["cat", "n1"]), Relation::Descendant),
(f(&["cat", "n1", "n2"]), Relation::Descendant)
]
);
assert_eq!(
of(finding(&["cat", "n1"])),
[(f(&["cat", "n1", "n2"]), Relation::Descendant)]
);
assert!(of(annotation("a1")).is_empty());
}
#[test]
fn the_facade_runs_the_commands_with_closed_kinds() {
let doc = serde_json::to_value(small()).unwrap();
let input = json!({ "document": doc, "command": { "op": "remove", "key": annotation("a1") } });
let outcome: Value = serde_json::from_str(&call("sheet.edit", &input.to_string())).unwrap();
assert_eq!(outcome["ok"], json!(true));
assert_eq!(
outcome["value"]["document"]["annotations"]
.as_array()
.unwrap()
.len(),
2
);
let bad = json!({ "document": doc, "command": { "op": "remove", "key": annotation("zz") } });
let outcome: Value = serde_json::from_str(&call("sheet.edit", &bad.to_string())).unwrap();
assert_eq!(outcome["kind"], json!("unknown_key"));
let shape = json!({ "document": doc, "command": { "op": "remove" } });
assert!(call("sheet.edit", &shape.to_string()).contains(r#""kind":"invalid_shape""#));
let deps = json!({ "document": doc, "key": { "kind": "view", "id": "head" } });
let outcome: Value =
serde_json::from_str(&call("sheet.dependents", &deps.to_string())).unwrap();
assert_eq!(
outcome["value"]["dependents"][0],
json!({ "element": annotation("a2"), "relation": "drawn_in" })
);
let huge = format!("{{\"document\":\"{}\"}}", "x".repeat(11 * 1024 * 1024));
assert!(call("sheet.edit", &huge).contains(r#""kind":"too_large""#));
}
// ---------------------------------------------------------------------------
// Property test
struct Rng(u64);
impl Rng {
fn next(&mut self) -> u64 {
self.0 ^= self.0 << 13;
self.0 ^= self.0 >> 7;
self.0 ^= self.0 << 17;
self.0
}
fn below(&mut self, n: usize) -> usize {
if n == 0 {
0
} else {
(self.next() % n as u64) as usize
}
}
fn pick<'a, T>(&mut self, items: &'a [T]) -> Option<&'a T> {
(!items.is_empty()).then(|| &items[self.below(items.len())])
}
}
/// A random command against the document as it stands; ids from `counter`.
fn random_command(doc: &AnatomicalSheetDocument, rng: &mut Rng, counter: &mut usize) -> Value {
*counter += 1;
let id = format!("g{counter}");
let marked: Vec<ElementKey> = marked_elements(doc).into_iter().map(|m| m.key).collect();
let views: Vec<&str> = doc.views.iter().map(|v| v.id()).collect();
let view = rng.pick(&views).copied().unwrap_or("main");
let findings: Vec<&ElementKey> = marked
.iter()
.filter(|k| matches!(k, ElementKey::Finding { path, .. } if path.len() < 8))
.collect();
match rng.below(9) {
0 => {
json!({ "op": "insert", "position": rng.below(2), "element": { "kind": "annotation", "value": {
"id": id, "kind": "point", "view_id": view, "category_id": "c", "laterality": "left",
"geometry": { "type": "circle", "cx": rng.below(9), "cy": 1, "r": 1 }, "review_status": "reviewed",
"name": name(&id), "finding_zone_id": "z1", "vertebral_region_code": null } } })
}
1 => match rng.pick(&findings) {
Some(ElementKey::Finding { zone_id, path }) => json!({ "op": "insert",
"parent": { "kind": "finding", "zone_id": zone_id, "path": path },
"element": { "kind": "finding_node", "value": { "id": id, "name": name(&id), "review_status": "reviewed" } } }),
_ => {
json!({ "op": "insert", "element": { "kind": "zone", "value": { "id": id, "name": name(&id), "categories": [] } } })
}
},
2 => {
json!({ "op": "insert", "element": { "kind": "view", "value": { "id": id, "kind": "detail", "name": name(&id),
"svg_asset_id": null, "view_box": { "min_x": 0, "min_y": 0, "width": 1 + rng.below(4), "height": 2 }, "parent_view_id": view } } })
}
3 | 4 => {
let key = rng.pick(&marked).cloned();
match key {
Some(key) => update_command(doc, &key, rng),
None => json!({ "op": "remove", "key": { "kind": "sheet" } }),
}
}
5 => {
json!({ "op": "remove", "key": rng.pick(&marked).cloned().unwrap_or(ElementKey::Sheet) })
}
6 => {
json!({ "op": "move", "key": rng.pick(&marked).cloned().unwrap_or(ElementKey::Sheet), "position": rng.below(3) })
}
7 => {
json!({ "op": "set_status", "key": rng.pick(&marked).cloned().unwrap_or(ElementKey::Sheet),
"status": if rng.below(2) == 0 { "reviewed" } else { "to_confirm" } })
}
_ => {
let zone = rng
.pick(&doc.finding_zones)
.map(|z| z.id.clone())
.unwrap_or_default();
json!({ "op": "mark_reviewed", "key": { "kind": "zone", "id": zone } })
}
}
}
/// An update of `key`: its current value, renamed half the time.
fn update_command(doc: &AnatomicalSheetDocument, key: &ElementKey, rng: &mut Rng) -> Value {
let rename = rng.below(2) == 0;
let (kind, mut value) = match key {
ElementKey::Annotation { id } => (
"annotation",
serde_json::to_value(doc.annotations.iter().find(|a| a.id() == id).unwrap()).unwrap(),
),
ElementKey::Finding { zone_id, path } => {
let zone = doc.finding_zones.iter().find(|z| &z.id == zone_id).unwrap();
let category = zone.categories.iter().find(|c| c.id == path[0]).unwrap();
if path.len() == 1 {
("finding_category", serde_json::to_value(category).unwrap())
} else {
let mut nodes = &category.children;
let mut node = None;
for segment in &path[1..] {
let found = nodes.iter().find(|n| &n.id == segment).unwrap();
nodes = &found.children;
node = Some(found);
}
("finding_node", serde_json::to_value(node.unwrap()).unwrap())
}
}
_ => unreachable!(),
};
let changes = rename && value["name"] != name("renamed");
if rename {
value["name"] = name("renamed");
}
json!({ "op": "update", "key": key, "element": { "kind": kind, "value": value }, "changes": changes })
}
#[test]
fn random_command_sequences_keep_every_invariant() {
let equine: AnatomicalSheetDocument =
serde_json::from_value(parse_json(&common::repo_file(SEED)).unwrap()).unwrap();
for (seed, start) in [
(0x9e37_79b9_7f4a_7c15_u64, small()),
(0x2545_f491_4f6c_dd1d, equine),
] {
let mut rng = Rng(seed);
let mut counter = 0;
let mut doc = start;
let (mut applied, mut refusals) = (0, 0);
for _ in 0..400 {
let mut raw = random_command(&doc, &mut rng, &mut counter);
let changes = raw.as_object_mut().unwrap().remove("changes");
let Ok(command) = serde_json::from_value::<EditCommand>(raw.clone()) else {
continue;
};
let before = statuses(&doc);
let inherited_before = before
.values()
.filter(|s| **s == ReviewStatus::Inherited)
.count();
match apply_edit(&doc, command) {
Err(_) => refusals += 1,
Ok(next) => {
applied += 1;
let text = serde_json::to_string(&next).unwrap();
let reread: AnatomicalSheetDocument =
serde_json::from_value(parse_json(&text).unwrap()).unwrap();
assert_eq!(reread, next, "strictly parseable: {raw}");
let after = statuses(&next);
let inherited_after = after
.values()
.filter(|s| **s == ReviewStatus::Inherited)
.count();
assert!(
inherited_after <= inherited_before,
"nothing becomes inherited: {raw}"
);
check_command(&raw, changes.as_ref(), &before, &after);
doc = next;
}
}
}
assert!(
applied > 200 && refusals > 0,
"{applied} applied, {refusals} refused"
);
}
}
/// The marking rule of the command just applied, on the keys it names.
fn check_command(
raw: &Value,
changes: Option<&Value>,
before: &HashMap<ElementKey, ReviewStatus>,
after: &HashMap<ElementKey, ReviewStatus>,
) {
let op = raw["op"].as_str().unwrap();
let key = || serde_json::from_value::<ElementKey>(raw["key"].clone()).unwrap();
match op {
"insert" => {
let new: Vec<_> = after.keys().filter(|k| !before.contains_key(*k)).collect();
assert!(
new.iter().all(|k| after[*k] == ReviewStatus::ToConfirm),
"{raw}"
);
}
"update" => {
let key = key();
let expected = if changes == Some(&json!(true)) {
ReviewStatus::ToConfirm
} else {
before[&key]
};
assert_eq!(after[&key], expected, "{raw}");
assert!(
before
.iter()
.all(|(k, s)| *k == key || after.get(k) == Some(s)),
"{raw}"
);
}
"move" => assert_eq!(before, after, "{raw}"),
"set_status" => {
let expected = if raw["status"] == json!("reviewed") {
ReviewStatus::Reviewed
} else {
ReviewStatus::ToConfirm
};
assert_eq!(after[&key()], expected);
assert!(
before
.iter()
.all(|(k, s)| *k == key() || after.get(k) == Some(s)),
"{raw}"
);
}
"remove" => {
let gone: Vec<_> = before.keys().filter(|k| !after.contains_key(*k)).collect();
assert!(
gone.iter().all(|k| k == &&key() || is_below(k, &key())),
"{raw}"
);
}
_ => {}
}
}
fn is_below(key: &ElementKey, ancestor: &ElementKey) -> bool {
match (key, ancestor) {
(ElementKey::Finding { zone_id, .. }, ElementKey::Zone { id }) => zone_id == id,
(
ElementKey::Finding {
zone_id: a,
path: p,
},
ElementKey::Finding {
zone_id: b,
path: q,
},
) => a == b && p.len() > q.len() && p.starts_with(q),
_ => false,
}
}
+350
View File
@@ -0,0 +1,350 @@
//! 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"));
}
+351
View File
@@ -0,0 +1,351 @@
//! V1-2.2: completeness, review groups, digests, removal groups and the change list
//! (contract §6.3, §6.6), on the equine draft (the counts of contract §1 and §14.1) and on
//! derived versions built by the edit commands.
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
mod common;
use faunosteo_core::domain::js::parse_json;
use faunosteo_core::domain::sheet::AnatomicalSheetDocument;
use faunosteo_core::domain::sheet::edit::{EditCommand, apply_edit};
use faunosteo_core::domain::sheet::keys::ElementKey;
use faunosteo_core::domain::sheet::review::{
ChangeKind, ElementChange, ReviewGroup, change_list, completeness, review_groups,
};
use faunosteo_core::domain::sheet::schema::ReviewStatus;
use serde_json::{Value, json};
const SEED: &str = "supabase/seed/anatomical-sheets/equine/draft/document.json";
fn equine() -> AnatomicalSheetDocument {
serde_json::from_value(parse_json(&common::repo_file(SEED)).unwrap()).unwrap()
}
fn edit(document: &AnatomicalSheetDocument, command: Value) -> AnatomicalSheetDocument {
let command: EditCommand = serde_json::from_value(command).unwrap();
apply_edit(document, command).unwrap()
}
fn groups(
document: &AnatomicalSheetDocument,
base: Option<&AnatomicalSheetDocument>,
) -> Vec<ReviewGroup> {
review_groups(document, base).unwrap()
}
fn group<'a>(groups: &'a [ReviewGroup], key: &str) -> &'a ReviewGroup {
groups
.iter()
.find(|g| g.key == key)
.unwrap_or_else(|| panic!("{key}"))
}
#[test]
fn the_equine_draft_has_the_counts_of_the_contract() {
let document = equine();
let counts = completeness(&document);
assert_eq!(counts.statuses.to_confirm, 188);
assert_eq!(counts.statuses.reviewed, 31);
assert_eq!(counts.statuses.inherited, 620);
let total = counts.statuses.to_confirm + counts.statuses.reviewed + counts.statuses.inherited;
assert_eq!(total, 839, "28 annotations, 81 categories, 730 nodes");
assert!(counts.vet_referrals > 0 && counts.uncited > 0);
let all = groups(&document, None);
assert_eq!(all.len(), 30, "general, 2 views, 27 zones");
assert_eq!(all[0].key, "general");
assert_eq!(all.iter().filter(|g| g.key.starts_with("view:")).count(), 2);
assert_eq!(
all.iter().filter(|g| g.key.starts_with("zone:")).count(),
27
);
assert!(all.iter().all(|g| g.digest.len() == 64 && !g.removed));
let marked: u64 = all
.iter()
.map(|g| g.statuses.to_confirm + g.statuses.reviewed + g.statuses.inherited)
.sum();
assert_eq!(
marked, 839,
"every marked element sits in exactly one group"
);
assert!(group(&all, "general").coverable);
assert_eq!(
all.iter().filter(|g| g.coverable).count(),
1,
"only general: nothing reviewed whole"
);
}
#[test]
fn digests_are_stable_and_local_to_their_group() {
let document = equine();
let before = groups(&document, None);
assert_eq!(before, groups(&document.clone(), None));
let zone = document.finding_zones[3].id.clone();
let renamed = edit(
&document,
json!({ "op": "update", "key": { "kind": "zone", "id": zone },
"element": { "kind": "zone", "value": { "id": zone, "name": { "fr": "Autre", "en": "Other" }, "categories": [] } } }),
);
let after = groups(&renamed, None);
for (old, new) in before.iter().zip(&after) {
assert_eq!(old.key, new.key);
assert_eq!(
old.digest == new.digest,
old.key != format!("zone:{zone}"),
"{}",
old.key
);
}
}
#[test]
fn an_omitted_status_digests_as_written_out_inherited() {
let text = common::repo_file(SEED);
let mut value = parse_json(&text).unwrap();
let pointer = first_omitted_status(&value).expect("the seed omits inherited somewhere");
let omitted: AnatomicalSheetDocument = serde_json::from_value(value.clone()).unwrap();
value.pointer_mut(&pointer).unwrap()["review_status"] = json!("inherited");
let explicit: AnatomicalSheetDocument = serde_json::from_value(value).unwrap();
assert_eq!(groups(&omitted, None), groups(&explicit, None));
}
/// The JSON pointer of the first finding node written without a `review_status`.
fn first_omitted_status(document: &Value) -> Option<String> {
let zones = document["finding_zones"].as_array()?;
for (z, zone) in zones.iter().enumerate() {
for (c, category) in zone["categories"].as_array()?.iter().enumerate() {
for (n, node) in category["children"].as_array()?.iter().enumerate() {
if node.get("review_status").is_none() {
return Some(format!("/finding_zones/{z}/categories/{c}/children/{n}"));
}
}
}
}
None
}
#[test]
fn a_group_is_coverable_once_every_element_is_reviewed() {
let document = equine();
let zone = document.finding_zones[0].id.clone();
let marked = edit(
&document,
json!({ "op": "mark_reviewed", "key": { "kind": "zone", "id": zone } }),
);
let all = groups(&marked, None);
let target = group(&all, &format!("zone:{zone}"));
assert!(target.coverable);
assert_eq!(target.statuses.to_confirm + target.statuses.inherited, 0);
assert_ne!(
target.digest,
group(&groups(&document, None), &format!("zone:{zone}")).digest
);
}
#[test]
fn a_derived_version_that_deletes_a_zone_has_its_removal_group() {
let base = equine();
let zone = base.finding_zones[5].id.clone();
let derived = edit(
&base,
json!({ "op": "remove", "key": { "kind": "zone", "id": zone } }),
);
let all = groups(&derived, Some(&base));
assert_eq!(
all.len(),
30,
"29 groups of the version and one removal group"
);
let removal = all.last().unwrap();
assert_eq!(removal.key, format!("zone:{zone}"));
assert!(removal.removed && removal.coverable);
assert_ne!(
removal.digest,
group(&groups(&base, None), &removal.key).digest
);
// A second derivation removing the same zone gives the same removal digest (carry).
let again = groups(&derived.clone(), Some(&base));
assert_eq!(again.last().unwrap().digest, removal.digest);
// Unchanged groups keep the base's digest; without a base nothing is a removal.
let base_groups = groups(&base, None);
for g in all.iter().filter(|g| !g.removed) {
assert_eq!(g.digest, group(&base_groups, &g.key).digest, "{}", g.key);
}
assert!(groups(&derived, None).iter().all(|g| !g.removed));
// The change list names the zone and everything that went with it.
let changes = change_list(&derived, &base);
let removed: Vec<&ElementChange> = changes
.iter()
.filter(|c| c.change == ChangeKind::Removed)
.collect();
assert!(removed.iter().all(|c| c.group == removal.key));
assert!(
removed
.iter()
.any(|c| c.element == ElementKey::Zone { id: zone.clone() })
);
let zone_size = 1 + count_findings(&base, &zone);
assert_eq!(removed.len(), zone_size);
assert_eq!(changes.len(), zone_size, "nothing else changed");
}
fn count_findings(document: &AnatomicalSheetDocument, zone_id: &str) -> usize {
fn nodes(list: &[faunosteo_core::domain::sheet::FindingNode]) -> usize {
list.iter().map(|n| 1 + nodes(&n.children)).sum()
}
let zone = document
.finding_zones
.iter()
.find(|z| z.id == zone_id)
.unwrap();
zone.categories.iter().map(|c| 1 + nodes(&c.children)).sum()
}
#[test]
fn the_change_list_tells_added_changed_status_changed_and_moved() {
let base = equine();
let zone = base.finding_zones[0].clone();
let category = zone.categories[0].clone();
let node = category.children[0].clone();
let path = vec![category.id.clone(), node.id.clone()];
let finding = |path: &[String]| json!({ "kind": "finding", "zone_id": zone.id, "path": path });
// Status only.
let marked = edit(
&base,
json!({ "op": "set_status", "key": finding(&path), "status": "reviewed" }),
);
// A renamed node: content changed.
let mut renamed = node.clone();
renamed.name.fr = format!("{} (corrigé)", renamed.name.fr);
let changed = edit(
&marked,
json!({ "op": "update", "key": finding(&[category.id.clone(), category.children[1].id.clone()]),
"element": { "kind": "finding_node", "value": { "id": category.children[1].id, "name": renamed.name, "children": [] } } }),
);
// A new node under the category.
let added = edit(
&changed,
json!({ "op": "insert", "parent": finding(std::slice::from_ref(&category.id)),
"element": { "kind": "finding_node", "value": { "id": "n-new", "name": { "fr": "Nouveau", "en": "New" } } } }),
);
let changes = change_list(&added, &base);
let kind_of = |path: &[String]| {
changes
.iter()
.find(|c| {
c.element
== ElementKey::Finding {
zone_id: zone.id.clone(),
path: path.to_vec(),
}
})
.map(|c| (c.change, c.status_before, c.status_after))
};
assert_eq!(
kind_of(&path),
Some((
ChangeKind::StatusChanged,
Some(node.review_status),
Some(ReviewStatus::Reviewed)
))
);
let second = vec![category.id.clone(), category.children[1].id.clone()];
assert_eq!(kind_of(&second).map(|k| k.0), Some(ChangeKind::Changed));
assert_eq!(
kind_of(&second).map(|k| k.2),
Some(Some(ReviewStatus::ToConfirm))
);
let new = vec![category.id.clone(), "n-new".to_owned()];
assert_eq!(
kind_of(&new),
Some((ChangeKind::Added, None, Some(ReviewStatus::ToConfirm)))
);
assert_eq!(changes.len(), 3);
assert!(
changes
.iter()
.all(|c| c.group == format!("zone:{}", zone.id))
);
// A node re-created under another parent (no move in level 1): removed plus added.
let leaf = &category.children[2];
let other = &zone.categories[1];
let removed = edit(
&base,
json!({ "op": "remove", "key": finding(&[category.id.clone(), leaf.id.clone()]) }),
);
let mut copy = serde_json::to_value(leaf).unwrap();
copy["children"] = json!([]);
let recreated = edit(
&removed,
json!({ "op": "insert", "parent": finding(std::slice::from_ref(&other.id)), "element": { "kind": "finding_node", "value": copy } }),
);
let moved = change_list(&recreated, &base);
assert!(moved.iter().any(|c| c.change == ChangeKind::Removed));
assert!(moved.iter().any(|c| c.change == ChangeKind::Added));
}
#[test]
fn a_reorder_changes_the_group_digest_only() {
let base = equine();
let zone = &base.finding_zones[0];
let path = [zone.categories[0].id.clone()];
let moved = edit(
&base,
json!({ "op": "move", "key": { "kind": "finding", "zone_id": zone.id, "path": path }, "position": 1 }),
);
assert!(change_list(&moved, &base).is_empty(), "no element changed");
let key = format!("zone:{}", zone.id);
assert_ne!(
group(&groups(&moved, None), &key).digest,
group(&groups(&base, None), &key).digest
);
}
#[test]
fn a_removal_digest_is_bound_to_its_group_key() {
let base = equine();
let first = base.finding_zones[0].id.clone();
let second = base.finding_zones[1].id.clone();
let without_first = edit(
&base,
json!({ "op": "remove", "key": { "kind": "zone", "id": first } }),
);
let derived = edit(
&without_first,
json!({ "op": "remove", "key": { "kind": "zone", "id": second } }),
);
let removals: Vec<ReviewGroup> = groups(&derived, Some(&base))
.into_iter()
.filter(|g| g.removed)
.collect();
assert_eq!(removals.len(), 2);
assert_ne!(removals[0].digest, removals[1].digest);
}
#[test]
fn an_inherited_element_alone_keeps_its_group_uncoverable() {
let document = equine();
let zone = document.finding_zones[0].clone();
let marked = edit(
&document,
json!({ "op": "mark_reviewed", "key": { "kind": "zone", "id": zone.id } }),
);
let mut value = serde_json::to_value(&marked).unwrap();
value["finding_zones"][0]["categories"][0]["children"][0]
.as_object_mut()
.unwrap()
.remove("review_status");
let one_inherited: AnatomicalSheetDocument = serde_json::from_value(value).unwrap();
let key = format!("zone:{}", zone.id);
let all = groups(&one_inherited, None);
let target = group(&all, &key);
assert_eq!(
(target.statuses.to_confirm, target.statuses.inherited),
(0, 1)
);
assert!(
!target.coverable,
"an omitted status is inherited, never acknowledgeable"
);
assert!(group(&groups(&marked, None), &key).coverable);
}
+120
View File
@@ -0,0 +1,120 @@
//! V1-2.2: the document size as the server measures it (contract §12.2). Every vector of
//! `oracles/v1-2-2/size.json` was measured by PostgreSQL (`octet_length(text::jsonb::text)`,
//! PGlite 17.5); the equine seed's value equals the one the contract recorded on the real
//! image (184 105 bytes). The pgTAP 017 fixtures are rebuilt on the same base document:
//! cap − 1, cap and cap + 1 bytes in 1-, 3- and 4-byte characters, a dense document, numbers
//! JavaScript prints with an exponent.
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
mod common;
use faunosteo_core::domain::js::parse_json;
use faunosteo_core::domain::sheet::size::{MAX_DOCUMENT_BYTES, document_text_bytes};
use serde_json::{Value, json};
fn oracle() -> Value {
common::oracle_file("v1-2-2/size.json").1
}
fn measure(text: &str) -> u64 {
document_text_bytes(&parse_json(text).unwrap())
}
#[test]
fn every_postgresql_vector_is_reproduced() {
let oracle = oracle();
let vectors = oracle["vectors"].as_array().unwrap();
assert!(vectors.len() >= 17);
for vector in vectors {
let text = vector["text"].as_str().unwrap();
assert_eq!(
measure(text),
vector["bytes"].as_u64().unwrap(),
"{}",
vector["name"]
);
}
}
#[test]
fn the_equine_seed_measures_as_on_the_server() {
let oracle = oracle();
let seed = &oracle["seed"];
let text = common::repo_file(seed["file"].as_str().unwrap());
assert_eq!(measure(&text), 184_105);
assert_eq!(seed["bytes"].as_u64(), Some(184_105));
}
/// `pg_temp.sized(base, bytes, unit)`: the base with a `pad` string of units, then `x`s, so
/// that the whole document measures `bytes`.
fn sized(base: &Value, bytes: u64, unit: &str) -> Value {
let mut empty = base.clone();
empty["pad"] = json!("");
let free = bytes - document_text_bytes(&empty);
let width = unit.len() as u64;
let pad = unit.repeat((free / width) as usize) + &"x".repeat((free % width) as usize);
let mut document = base.clone();
document["pad"] = Value::String(pad);
document
}
fn pgtap_base() -> (Value, u64) {
let oracle = oracle();
let base = &oracle["pgtap_017_base"];
let mut value = parse_json(base["text"].as_str().unwrap()).unwrap();
value.as_object_mut().unwrap().remove("pad");
(value, base["bytes"].as_u64().unwrap())
}
#[test]
fn the_pgtap_017_cap_vectors_measure_as_the_server_does() {
let (base, with_empty_pad) = pgtap_base();
let mut empty = base.clone();
empty["pad"] = json!("");
assert_eq!(document_text_bytes(&empty), with_empty_pad);
for unit in ["x", "€", "𝄞"] {
for bytes in [
MAX_DOCUMENT_BYTES - 1,
MAX_DOCUMENT_BYTES,
MAX_DOCUMENT_BYTES + 1,
] {
let document = sized(&base, bytes, unit);
assert_eq!(document_text_bytes(&document), bytes, "{unit} {bytes}");
}
}
let wide = sized(&base, MAX_DOCUMENT_BYTES, "€");
let characters = wide["pad"].as_str().unwrap().chars().count();
assert!(characters < 800_000, "2 MiB in far fewer characters");
}
#[test]
fn a_dense_document_is_measured_as_text_not_as_binary_jsonb() {
let (mut document, _) = pgtap_base();
document["pad"] = Value::Array(vec![json!({ "a": 1 }); 100_000]);
let bytes = document_text_bytes(&document);
// `{"a": 1}` is 8 bytes and `, ` separates them: the array is 2 + 800 000 + 199 998
// bytes; the member adds `"pad"`, `: ` and the `, ` before it.
let mut without = document.clone();
without.as_object_mut().unwrap().remove("pad");
assert_eq!(bytes - document_text_bytes(&without), 1_000_000 + 5 + 2 + 2);
assert!(bytes <= MAX_DOCUMENT_BYTES);
}
#[test]
fn exponent_numbers_count_in_their_plain_form() {
let (mut document, _) = pgtap_base();
document["pad"] = Value::Array(vec![json!(1e21); 100_000]);
let compact = faunosteo_core::json::to_js_compact(&document).unwrap();
// The page's compact text is under the cap (`1e+21` is five bytes); PostgreSQL prints
// 22 digits per number and refuses it.
assert!((compact.len() as u64) < MAX_DOCUMENT_BYTES);
assert!(document_text_bytes(&document) > MAX_DOCUMENT_BYTES);
}
#[test]
fn the_measure_is_linear_in_the_numbers() {
let document = Value::Array(vec![json!(0); 600_000]);
let started = std::time::Instant::now();
assert_eq!(document_text_bytes(&document), 2 + 600_000 + 2 * 599_999);
assert!(started.elapsed().as_secs() < 2);
}
+542
View File
@@ -0,0 +1,542 @@
//! V1-2.2: the server verdict (contract §6.4, §6.5, §6.7). A clean sheet and the equine draft
//! pass; each submission rule fails alone with its closed code; the caps hold at cap − 1 and
//! cap and fail at cap + 1 (labels in astral characters included); the shape is the one the
//! M5 SQL reads; the same input gives the same verdict; a synthetic document at the caps is
//! verified in time.
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
mod common;
use faunosteo_core::domain::sheet::fingerprint::sheet_fingerprint;
use faunosteo_core::domain::sheet::verdict::{
DrawingResult, Verdict, VerdictBinding, VerdictDrawing, VerdictInput, VerdictOutcome, codes,
compute_verdict, sha256_hex,
};
use serde_json::{Value, json};
const ASSET: &str = "11111111-2222-4333-8444-555555555555";
const DRAWING: &str =
r#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"><path d="M0 0L5 5"/></svg>"#;
const SEED: &str = "supabase/seed/anatomical-sheets/equine/draft";
const HORSE_ID: &str = "7f767f74-3b36-51a7-8465-52dd7e2ead4a";
fn binding() -> VerdictBinding {
VerdictBinding {
sheet_id: "aaaaaaaa-0000-4000-8000-000000000001".to_owned(),
version_id: "aaaaaaaa-0000-4000-8000-000000000002".to_owned(),
revision: 3,
review_id: "aaaaaaaa-0000-4000-8000-000000000003".to_owned(),
}
}
fn name(text: &str) -> Value {
json!({ "fr": text, "en": text })
}
/// A small valid document drawn on `ASSET`: one view, one point, one zone with a category
/// and a node, everything `to_confirm` (submittable, not yet approvable).
fn document() -> Value {
json!({
"schema_version": 2, "species_id": "canine", "name": name("Chien"),
"description": {}, "scope_disclaimer": { "fr": "Outil", "en": "Tool" },
"attribution": { "authors": ["A"], "license": null, "notes": null },
"vertebral_config": { "regions": [] }, "references": [],
"categories": [{ "id": "c", "name": name("C"), "color": null }],
"views": [{ "id": "main", "kind": "main", "name": name("Vue"), "svg_asset_id": ASSET, "view_box": null }],
"annotations": [{ "id": "a1", "kind": "point", "view_id": "main", "category_id": "c",
"laterality": "unpaired", "geometry": { "type": "circle", "cx": 1, "cy": 1, "r": 1 },
"review_status": "to_confirm", "name": name("P"), "finding_zone_id": "z1", "vertebral_region_code": null }],
"finding_zones": [{ "id": "z1", "name": name("Z"), "categories": [{ "id": "cat", "kind": "dysfunction",
"name": name("D"), "review_status": "to_confirm",
"children": [{ "id": "n1", "name": name("N"), "review_status": "to_confirm" }] }] }]
})
}
fn row(bytes: &[u8]) -> VerdictDrawing<'_> {
VerdictDrawing {
asset_id: ASSET,
sha256: Box::leak(sha256_hex(bytes).into_boxed_str()),
byte_size: bytes.len() as u64,
bytes: Some(bytes),
}
}
fn verdict_of(document: &Value, drawings: Vec<VerdictDrawing<'_>>) -> Verdict {
let text = document.to_string();
compute_verdict(&VerdictInput {
binding: binding(),
document: &text,
base_document: None,
drawings,
})
}
fn verdict(document: &Value) -> Verdict {
verdict_of(document, vec![row(DRAWING.as_bytes())])
}
#[test]
fn a_clean_sheet_passes_bound_to_its_round() {
let doc = document();
let verdict = verdict(&doc);
assert_eq!(
verdict.outcome,
VerdictOutcome::Passed,
"{:?}",
verdict.failures
);
assert_eq!(
(verdict.failure_code.as_deref(), verdict.failures.len()),
(None, 0)
);
assert_eq!(
verdict.fingerprint,
Some(sheet_fingerprint(&doc.to_string()).unwrap())
);
let b = binding();
assert_eq!(
(
&verdict.sheet_id,
&verdict.version_id,
verdict.revision,
&verdict.review_id
),
(&b.sheet_id, &b.version_id, b.revision, &b.review_id)
);
assert_eq!(verdict.format, 1);
assert!(verdict.verified_with.starts_with("faunosteo-core "));
assert_eq!(verdict.drawings.len(), 1);
assert_eq!(verdict.drawings[0].result, DrawingResult::Ok);
let keys: Vec<&str> = verdict.groups.iter().map(|g| g.key.as_str()).collect();
assert_eq!(keys, ["general", "view:main", "zone:z1"]);
assert!(
verdict.groups.iter().skip(1).all(|g| !g.coverable),
"to_confirm left"
);
assert!(verdict.changes.is_none());
let completeness = verdict.completeness.unwrap();
assert_eq!(completeness.statuses.to_confirm, 3);
assert_eq!(completeness.uncited, 2);
}
#[test]
fn the_shape_is_what_the_sql_reads() {
let value = serde_json::to_value(verdict(&document())).unwrap();
assert!(value["fingerprint"].as_str().unwrap().len() == 64);
for group in value["groups"].as_array().unwrap() {
assert!(group["key"].is_string() && group["digest"].is_string());
assert!(group["coverable"].is_boolean());
}
let drawing = &value["drawings"][0];
assert_eq!(drawing["asset_id"], json!(ASSET));
assert_eq!(drawing["sha256"], json!(sha256_hex(DRAWING.as_bytes())));
assert_eq!(value["outcome"], json!("passed"));
assert_eq!(
value["verified_with"].as_str().map(|s| s.len() <= 100),
Some(true)
);
}
#[test]
fn the_equine_draft_passes_with_its_fingerprint_and_thirty_groups() {
let text = common::repo_file(&format!("{SEED}/document.json"));
let horse = std::fs::read(common::repo_path(&format!("{SEED}/assets/horse.svg"))).unwrap();
let verdict = compute_verdict(&VerdictInput {
binding: binding(),
document: &text,
base_document: None,
drawings: vec![VerdictDrawing {
asset_id: HORSE_ID,
sha256: "0ea5202fa3b95bac167b87c12ee969ab0272e085b60c2d34dbca6202c5f08541",
byte_size: 132_997,
bytes: Some(&horse),
}],
});
assert_eq!(
verdict.outcome,
VerdictOutcome::Passed,
"{:?}",
verdict.failures
);
assert_eq!(
verdict.fingerprint.as_deref(),
Some("12d788727c1e532641bd5b3a7ecf39dbdd25e70350f8a76be5ca917b262874e2")
);
assert_eq!(verdict.groups.len(), 30);
assert_eq!(verdict.document_bytes, 184_105);
assert!(
verdict
.issues
.iter()
.all(|i| i.severity != faunosteo_core::domain::sheet::SheetIssueSeverity::Error)
);
}
fn failures(verdict: &Verdict) -> Vec<&str> {
verdict.failures.iter().map(String::as_str).collect()
}
#[test]
fn an_unreadable_document_or_base_fails_as_integrity() {
for text in ["{", "[]", r#"{"schema_version":2}"#] {
let verdict = compute_verdict(&VerdictInput {
binding: binding(),
document: text,
base_document: None,
drawings: vec![],
});
assert_eq!(failures(&verdict), [codes::DOCUMENT], "{text}");
assert!(verdict.fingerprint.is_none() && verdict.groups.is_empty());
}
let mut unknown = document();
unknown["extra"] = json!(1);
assert_eq!(
failures(&verdict(&unknown)),
[codes::DOCUMENT],
"strict shape"
);
let text = document().to_string();
let verdict = compute_verdict(&VerdictInput {
binding: binding(),
document: &text,
base_document: Some("{\"broken\""),
drawings: vec![row(DRAWING.as_bytes())],
});
assert_eq!(failures(&verdict), [codes::BASE]);
}
#[test]
fn each_submission_rule_fails_alone() {
let mut duplicate = document();
let copy = duplicate["annotations"][0].clone();
duplicate["annotations"].as_array_mut().unwrap().push(copy);
let v = verdict(&duplicate);
assert_eq!(failures(&v), [codes::RULES]);
assert!(
v.fingerprint.is_none(),
"no fingerprint with an integrity error"
);
assert!(v.issues.iter().any(|i| i.code == "annotation.id.duplicate"));
let mut undrawn = document();
undrawn["annotations"][0]["geometry"] = Value::Null;
let v = verdict(&undrawn);
assert_eq!(failures(&v), [codes::NO_GEOMETRY]);
assert!(
v.fingerprint.is_some(),
"a missing geometry is no integrity error"
);
assert!(v.issues.iter().any(|i| i.code == "annotation.geometry.missing" && i.path == "annotations[0].geometry"));
}
#[test]
fn each_drawing_fault_fails_with_its_code() {
let doc = document();
let bytes = DRAWING.as_bytes();
let base = row(bytes);
let cases: Vec<(Vec<VerdictDrawing<'_>>, &str, DrawingResult)> = vec![
(vec![], codes::DRAWING_MISSING, DrawingResult::Missing),
(
vec![VerdictDrawing {
bytes: None,
..base
}],
codes::DRAWING_MISSING,
DrawingResult::Missing,
),
(
vec![VerdictDrawing {
byte_size: 1,
..base
}],
codes::SIZE_MISMATCH,
DrawingResult::SizeMismatch,
),
(
vec![VerdictDrawing {
sha256: "ab",
..base
}],
codes::OBJECT_CONFLICT,
DrawingResult::HashMismatch,
),
];
for (drawings, code, result) in cases {
let v = verdict_of(&doc, drawings);
assert_eq!(failures(&v), [code]);
assert_eq!(v.drawings[0].result, result);
assert!(v.fingerprint.is_some());
}
let invalid: &[u8] = b"<svg xmlns=\"http://www.w3.org/2000/svg\">\xff</svg>";
let doctype = b"<!DOCTYPE svg><svg xmlns=\"http://www.w3.org/2000/svg\"/>";
let styled = br#"<svg xmlns="http://www.w3.org/2000/svg"><style>.a{fill:red}</style><path class="a" d="M0 0"/></svg>"#;
for (bytes, code, detail) in [
(invalid, codes::SVG_REJECTED, "malformed"),
(&doctype[..], codes::SVG_REJECTED, "doctype"),
(&styled[..], codes::SVG_REMOVAL, "style"),
] {
let v = verdict_of(&doc, vec![row(bytes)]);
assert_eq!(failures(&v), [code]);
assert_eq!(v.drawings[0].detail.as_deref(), Some(detail));
}
}
/// `count` annotations drawn in the main view, all in zone `z1`.
fn with_annotations(count: usize) -> Value {
let mut doc = document();
let template = doc["annotations"][0].clone();
doc["annotations"] = (0..count)
.map(|i| {
let mut a = template.clone();
a["id"] = json!(format!("a{i}"));
a
})
.collect();
doc
}
fn caps_failed(doc: &Value) -> bool {
let v = verdict(doc);
assert!(
v.failures.iter().all(|c| c == codes::CAPS),
"{:?}",
v.failures
);
v.failures.iter().any(|c| c == codes::CAPS)
}
#[test]
fn the_caps_hold_at_the_cap_and_fail_one_over() {
assert!(!caps_failed(&with_annotations(1023)) && !caps_failed(&with_annotations(1024)));
assert!(caps_failed(&with_annotations(1025)));
// Labels in UTF-16 units: 𝄞 counts two.
for (label, over) in [
("𝄞".repeat(255) + "a", false),
("𝄞".repeat(256), false),
("𝄞".repeat(256) + "a", true),
] {
let mut doc = document();
doc["finding_zones"][0]["name"] = json!({ "fr": label, "en": "Z" });
assert_eq!(caps_failed(&doc), over);
}
for (depth, over) in [(7, false), (8, false), (9, true)] {
let mut doc = document();
doc["finding_zones"][0]["categories"][0]["children"] = chain(depth - 1);
assert_eq!(caps_failed(&doc), over, "depth {depth}");
}
for (nodes, over) in [(8191, false), (8192, false), (8193, true)] {
let mut doc = document();
let flat: Vec<Value> = (0..nodes - 1)
.map(|i| json!({ "id": format!("n{i}"), "name": name("N"), "review_status": "to_confirm" }))
.collect();
doc["finding_zones"][0]["categories"][0]["children"] = Value::Array(flat);
assert_eq!(caps_failed(&doc), over, "{nodes} nodes");
}
}
/// `levels` nested nodes below the category.
fn chain(levels: usize) -> Value {
let mut children = json!([]);
for i in (0..levels).rev() {
children = json!([{ "id": format!("d{i}"), "name": name("N"), "review_status": "to_confirm", "children": children }]);
}
children
}
#[test]
fn the_document_cap_is_the_server_measure() {
let measure = |doc: &Value| verdict(doc).document_bytes;
let mut doc = document();
doc["description"] = json!({ "fr": "" });
let empty = measure(&doc);
for (bytes, over) in [
(2_097_151_u64, false),
(2_097_152, false),
(2_097_153, true),
] {
let mut sized = doc.clone();
sized["description"]["fr"] = json!(
"é".repeat(((bytes - empty) / 2) as usize)
+ &"x".repeat(((bytes - empty) % 2) as usize)
);
assert_eq!(measure(&sized), bytes);
assert_eq!(caps_failed(&sized), over, "{bytes}");
}
}
#[test]
fn drawings_count_toward_the_caps() {
let mut doc = document();
let ids = [
ASSET,
"11111111-2222-4333-8444-000000000002",
"11111111-2222-4333-8444-000000000003",
"11111111-2222-4333-8444-000000000004",
"11111111-2222-4333-8444-000000000005",
];
let views: Vec<Value> = ids
.iter()
.enumerate()
.map(|(i, id)| match i {
0 => json!({ "id": "main", "kind": "main", "name": name("V"), "svg_asset_id": id, "view_box": null }),
_ => json!({ "id": format!("d{i}"), "kind": "detail", "name": name("D"), "svg_asset_id": id,
"view_box": null, "parent_view_id": "main" }),
})
.collect();
let triggers: Vec<Value> = (1..ids.len())
.map(|i| json!({ "id": format!("t{i}"), "kind": "detail_trigger", "view_id": "main", "category_id": "c",
"laterality": "unpaired", "geometry": { "type": "circle", "cx": 2, "cy": 2, "r": 1 },
"review_status": "to_confirm", "name": null, "opens_view_id": format!("d{i}") }))
.collect();
doc["views"] = Value::Array(views);
doc["annotations"].as_array_mut().unwrap().extend(triggers);
let bytes = DRAWING.as_bytes();
let rows = |n: usize| -> Vec<VerdictDrawing<'_>> {
ids.iter()
.take(n)
.map(|id| VerdictDrawing {
asset_id: id,
..row(bytes)
})
.collect()
};
let mut four = doc.clone();
four["views"].as_array_mut().unwrap().pop();
four["annotations"].as_array_mut().unwrap().pop();
assert_eq!(failures(&verdict_of(&four, rows(4))), Vec::<&str>::new());
let v = verdict_of(&doc, rows(5));
assert_eq!(failures(&v), [codes::CAPS]);
assert!(
v.caps
.unwrap()
.exceeded
.iter()
.any(|c| c.as_str() == "drawings")
);
}
#[test]
fn the_first_failure_names_the_round_in_code_order() {
let mut doc = with_annotations(1025);
doc["annotations"][0]["geometry"] = Value::Null;
let copy = doc["annotations"][1].clone();
doc["annotations"].as_array_mut().unwrap().push(copy);
let v = verdict_of(&doc, vec![]);
assert_eq!(
failures(&v),
[
codes::RULES,
codes::NO_GEOMETRY,
codes::CAPS,
codes::DRAWING_MISSING
]
);
assert_eq!(v.failure_code.as_deref(), Some(codes::RULES));
assert_eq!(v.outcome, VerdictOutcome::Failed);
}
#[test]
fn the_same_input_gives_the_same_verdict() {
let doc = document();
let first = serde_json::to_string(&verdict(&doc)).unwrap();
assert_eq!(first, serde_json::to_string(&verdict(&doc)).unwrap());
}
#[test]
fn a_base_gives_removal_groups_and_the_change_list() {
let mut base = document();
base["finding_zones"]
.as_array_mut()
.unwrap()
.push(json!({ "id": "z2", "name": name("Z2"), "categories": [] }));
let text = document().to_string();
let base_text = base.to_string();
let v = compute_verdict(&VerdictInput {
binding: binding(),
document: &text,
base_document: Some(&base_text),
drawings: vec![row(DRAWING.as_bytes())],
});
assert_eq!(v.outcome, VerdictOutcome::Passed);
let last = v.groups.last().unwrap();
assert_eq!(
(last.key.as_str(), last.removed, last.coverable),
("zone:z2", true, true)
);
let changes = v.changes.unwrap();
assert_eq!(changes.len(), 1);
assert_eq!(changes[0].group, "zone:z2");
}
/// A document at every cap: 64 views, 1 024 annotations, 8 192 finding nodes, depth 8.
fn at_caps() -> Value {
let mut doc = document();
let mut views = vec![
json!({ "id": "main", "kind": "main", "name": name("V"), "svg_asset_id": ASSET, "view_box": null }),
];
let mut annotations = Vec::new();
for i in 1..64 {
views.push(json!({ "id": format!("d{i}"), "kind": "detail", "name": name("D"), "svg_asset_id": null,
"view_box": { "min_x": 0, "min_y": 0, "width": 5, "height": 5 }, "parent_view_id": "main" }));
annotations.push(json!({ "id": format!("t{i}"), "kind": "detail_trigger", "view_id": "main", "category_id": "c",
"laterality": "unpaired", "geometry": { "type": "polygon", "points": [[0, 0], [1, 0], [1, 1]] },
"review_status": "reviewed", "name": null, "opens_view_id": format!("d{i}") }));
}
let zones: Vec<Value> = (0..64)
.map(|z| {
let mut children = vec![chain_reviewed(7)];
children.extend((0..120).map(|n| json!({ "id": format!("l{n}"), "name": name("Nœud de lésion"), "review_status": "reviewed" })));
json!({ "id": format!("z{z}"), "name": name("Zone"), "categories": [{ "id": "cat", "kind": "dysfunction",
"name": name("Catégorie"), "review_status": "reviewed", "children": children }] })
})
.collect();
for i in 0..(1024 - 63) {
annotations.push(json!({ "id": format!("p{i}"), "kind": "point", "view_id": format!("d{}", 1 + i % 63),
"category_id": "c", "laterality": "left", "geometry": { "type": "circle", "cx": 1.25, "cy": 2.5, "r": 0.5 },
"review_status": "reviewed", "name": name("Point"), "finding_zone_id": format!("z{}", i % 64),
"vertebral_region_code": null }));
}
doc["views"] = Value::Array(views);
doc["annotations"] = Value::Array(annotations);
doc["finding_zones"] = Value::Array(zones);
doc
}
fn chain_reviewed(levels: usize) -> Value {
let mut node =
json!({ "id": format!("c{levels}"), "name": name("N"), "review_status": "reviewed" });
for level in (1..levels).rev() {
node = json!({ "id": format!("c{level}"), "name": name("N"), "review_status": "reviewed", "children": [node] });
}
node
}
#[test]
fn a_document_at_every_cap_is_verified_in_time() {
let doc = at_caps();
let started = std::time::Instant::now();
let v = verdict(&doc);
let elapsed = started.elapsed();
assert_eq!(v.outcome, VerdictOutcome::Passed, "{:?}", v.failures);
let caps = v.caps.unwrap();
assert_eq!(
(
caps.views,
caps.annotations,
caps.finding_nodes,
caps.finding_depth
),
(64, 1024, 8192, 8)
);
assert_eq!(v.groups.len(), 1 + 64 + 64);
assert!(v.groups.iter().all(|g| g.coverable));
println!(
"verdict at the caps: {} ms, document {} bytes",
elapsed.as_millis(),
v.document_bytes
);
assert!(
elapsed.as_secs() < 20,
"the core's share of the 120 s budget"
);
}