//! V1-2.3 proofs of the verification job (contract W4, V1-2 contract ยง6.5) on an in-memory //! `VerifyBackend`: the core's verdict computed in process from the very frame the parent //! builds (or the real child without seccomp under `test-hooks`), every child outcome mapped //! to its closed worker code, a missing drawing judged by the core, never by the worker. #![allow(clippy::unwrap_used, clippy::expect_used)] use std::cell::RefCell; use std::collections::VecDeque; use faunosteo_core::domain::sheet::verdict::{codes as verdict_codes, sha256_hex}; use faunosteo_worker::backend::{ BackendError, BackendResult, CompleteAnswer, DrawingRow, FailAnswer, VerifyBackend, VerifyInput, VerifyJob, }; use faunosteo_worker::config::Config; use faunosteo_worker::limits::VERIFY_MAX_DRAWING_BYTES; use faunosteo_worker::run::{Mode, parse_args, verify_loop}; use faunosteo_worker::spawn::{ChildOutcome, ChildRun}; use faunosteo_worker::verifier::Verifier; use faunosteo_worker::verify_job::{DRAWING_BUCKET, VerifyEnd, codes, process_verification}; use faunosteo_worker::watchdog::Watchdog; use faunosteo_worker::{exit_codes, verify}; use serde_json::{Value, json}; const REVIEW: &str = "aaaaaaaa-0000-4000-8000-000000000003"; const VERSION: &str = "aaaaaaaa-0000-4000-8000-000000000002"; const SHEET: &str = "aaaaaaaa-0000-4000-8000-000000000001"; const TOKEN: &str = "30000000-0000-0000-0000-00000000000c"; const ASSET: &str = "11111111-2222-4333-8444-555555555555"; const DRAWING: &str = concat!( "\n", r#""# ); fn name(text: &str) -> Value { json!({ "fr": text, "en": text }) } /// The core's small valid sheet (`crates/core/tests/sheet_verdict.rs::document`). 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 job() -> VerifyJob { VerifyJob { review_id: REVIEW.to_owned(), version_id: VERSION.to_owned(), sheet_id: SHEET.to_owned(), revision: 3, lease_token: TOKEN.to_owned(), attempts: 1, } } fn row() -> DrawingRow { let sha256 = sha256_hex(DRAWING.as_bytes()); DrawingRow { asset_id: ASSET.to_owned(), object_key: format!("{sha256}.svg"), sha256, byte_size: DRAWING.len() as u64, bucket: DRAWING_BUCKET.to_owned(), uploaded: true, } } fn input(document: String, drawings: Vec) -> VerifyInput { VerifyInput { review_id: REVIEW.to_owned(), version_id: VERSION.to_owned(), sheet_id: SHEET.to_owned(), revision: 3, document, base_document: None, drawings, } } struct Fake { calls: RefCell>, input: RefCell>>>, downloads: RefCell>>>, complete: RefCell>>, fail: RefCell>>, verdict: RefCell>, jobs: RefCell>, } impl Fake { fn with_input(input: VerifyInput) -> Self { Self { calls: RefCell::default(), input: RefCell::new(Some(Ok(Some(input)))), downloads: RefCell::default(), complete: RefCell::default(), fail: RefCell::default(), verdict: RefCell::default(), jobs: RefCell::default(), } } fn clean() -> Self { Self::with_input(input(document().to_string(), vec![row()])) } fn calls(&self) -> Vec { self.calls.borrow().clone() } fn names(&self) -> Vec { self.calls() .iter() .map(|c| c.split(' ').next().unwrap().to_owned()) .collect() } fn verdict(&self) -> Value { self.verdict.borrow().clone().expect("a completion") } } impl VerifyBackend for Fake { fn claim_verifications(&self, max_jobs: u32) -> BackendResult> { self.calls.borrow_mut().push(format!("claim {max_jobs}")); Ok(self.jobs.borrow_mut().drain(..).collect()) } fn verification_input( &self, review_id: &str, lease_token: &str, ) -> BackendResult> { self.calls .borrow_mut() .push(format!("input {review_id} {lease_token}")); self.input.borrow_mut().take().unwrap_or(Ok(None)) } fn download_drawing( &self, bucket: &str, key: &str, max_bytes: usize, ) -> BackendResult> { self.calls .borrow_mut() .push(format!("download {bucket}/{key} {max_bytes}")); self.downloads .borrow_mut() .pop_front() .unwrap_or_else(|| Ok(DRAWING.as_bytes().to_vec())) } fn complete_verification( &self, review_id: &str, lease_token: &str, verdict: &[u8], ) -> BackendResult { self.calls .borrow_mut() .push(format!("complete {review_id} {lease_token}")); let value: Value = serde_json::from_slice(verdict).unwrap(); let outcome = value["outcome"].clone(); *self.verdict.borrow_mut() = Some(value); self.complete .borrow_mut() .take() .unwrap_or(Ok(if outcome == "passed" { CompleteAnswer::Passed } else { CompleteAnswer::Failed })) } fn fail_verification( &self, review_id: &str, lease_token: &str, code: &str, ) -> BackendResult { self.calls .borrow_mut() .push(format!("fail {review_id} {lease_token} {code}")); self.fail .borrow_mut() .take() .unwrap_or(Ok(FailAnswer::Retry)) } } /// The child's work in process: the same frame, `verify::process`, the core's verdict. struct InProcess; impl Verifier for InProcess { fn verify(&self, frame: &[u8]) -> ChildRun { let outcome = match verify::process(frame) { Ok(verdict) => ChildOutcome::Produced(verdict), Err(failure) => ChildOutcome::Broken { code: failure.exit_code(), name: exit_codes::name(failure.exit_code()), }, }; ChildRun { outcome, stderr: String::new(), } } } /// A child that ends as told, at most once. struct Fixed(RefCell>); impl Fixed { fn with(outcome: ChildOutcome) -> Self { Self(RefCell::new(Some(outcome))) } fn never() -> Self { Self(RefCell::new(None)) } } impl Verifier for Fixed { fn verify(&self, _frame: &[u8]) -> ChildRun { ChildRun { outcome: self.0.borrow_mut().take().expect("no child run expected"), stderr: "child says\n\u{1b}[0m".to_owned(), } } } fn process(fake: &Fake, verifier: &dyn Verifier) -> VerifyEnd { process_verification(fake, verifier, &Watchdog::new(), &job()) } fn fail_call(code: &str) -> String { format!("fail {REVIEW} {TOKEN} {code}") } #[test] fn a_clean_sheet_follows_input_download_child_complete() { let fake = Fake::clean(); assert_eq!(process(&fake, &InProcess), VerifyEnd::Passed); let key = row().object_key; assert_eq!( fake.calls(), vec![ format!("input {REVIEW} {TOKEN}"), format!("download {DRAWING_BUCKET}/{key} {VERIFY_MAX_DRAWING_BYTES}"), format!("complete {REVIEW} {TOKEN}"), ] ); let verdict = fake.verdict(); assert_eq!(verdict["outcome"], "passed"); assert_eq!( ( &verdict["review_id"], &verdict["version_id"], &verdict["sheet_id"], &verdict["revision"] ), (&json!(REVIEW), &json!(VERSION), &json!(SHEET), &json!(3)) ); } #[test] fn an_unreadable_document_completes_failed() { let fake = Fake::with_input(input("not json".to_owned(), vec![row()])); assert_eq!(process(&fake, &InProcess), VerifyEnd::Failed); assert_eq!(fake.names(), ["input", "download", "complete"]); assert_eq!(fake.verdict()["failure_code"], verdict_codes::DOCUMENT); } #[test] fn a_stale_input_ends_without_any_other_call() { let fake = Fake::clean(); *fake.input.borrow_mut() = Some(Ok(None)); assert_eq!(process(&fake, &Fixed::never()), VerifyEnd::Stale); assert_eq!(fake.names(), ["input"]); } #[test] fn a_stale_completion_ends_and_a_malformed_one_is_reported() { let fake = Fake::clean(); *fake.complete.borrow_mut() = Some(Ok(CompleteAnswer::Stale)); assert_eq!(process(&fake, &InProcess), VerifyEnd::Stale); assert_eq!(fake.names(), ["input", "download", "complete"]); let fake = Fake::clean(); *fake.complete.borrow_mut() = Some(Ok(CompleteAnswer::Malformed)); assert_eq!( process(&fake, &InProcess), VerifyEnd::Reported(codes::VERDICT_REFUSED) ); assert_eq!( fake.calls().last().unwrap(), &fail_call(codes::VERDICT_REFUSED) ); } #[test] fn a_missing_or_oversized_drawing_is_judged_by_the_core() { for error in [BackendError::Status(404), BackendError::Overflow] { let fake = Fake::clean(); fake.downloads.borrow_mut().push_back(Err(error)); assert_eq!(process(&fake, &InProcess), VerifyEnd::Failed); assert_eq!(fake.names(), ["input", "download", "complete"]); let verdict = fake.verdict(); assert_eq!(verdict["failure_code"], verdict_codes::DRAWING_MISSING); assert_eq!(verdict["drawings"][0]["result"], "missing"); } } #[test] fn rows_outside_the_policy_are_never_fetched() { let mut not_uploaded = row(); not_uploaded.uploaded = false; let mut other_bucket = row(); other_bucket.bucket = "avatars".to_owned(); let mut other_key = row(); other_key.object_key = format!("{}.svg", "0".repeat(64)); let mut hostile_key = row(); hostile_key.object_key = "../avatars/x.svg".to_owned(); let mut too_big = row(); too_big.byte_size = VERIFY_MAX_DRAWING_BYTES as u64 + 1; for skipped in [not_uploaded, other_bucket, other_key, hostile_key, too_big] { let fake = Fake::with_input(input(document().to_string(), vec![skipped])); assert_eq!(process(&fake, &InProcess), VerifyEnd::Failed); assert_eq!(fake.names(), ["input", "complete"]); } } // Tracked misclassification (owner brief 2026-11-01), not fixed: an object larger than the // policy is passed without bytes, so the core judges it missing (`drawing_missing`, listed // after `caps`: the row's declared size already exceeds the cap) where `size_mismatch` would // name it. #[test] fn tracked_an_object_over_the_policy_is_reported_drawing_missing() { let mut too_big = row(); too_big.byte_size = VERIFY_MAX_DRAWING_BYTES as u64 + 1; let fake = Fake::with_input(input(document().to_string(), vec![too_big])); assert_eq!(process(&fake, &InProcess), VerifyEnd::Failed); assert_eq!(fake.names(), ["input", "complete"]); let verdict = fake.verdict(); assert_eq!( verdict["failures"], json!([verdict_codes::CAPS, verdict_codes::DRAWING_MISSING]) ); assert_eq!(verdict["drawings"][0]["result"], "missing"); } // Tracked misclassification (owner brief 2026-11-01), not fixed: a document naming enough // drawings that the frame header passes 64 KiB is refused by the parent's own framing and // reported `resource_limit` (a definitive worker failure) where `caps` would name it. #[test] fn tracked_a_header_over_64_kib_is_reported_resource_limit() { let rows = vec![row(); 600]; let fake = Fake::with_input(input(document().to_string(), rows)); assert_eq!( process(&fake, &Fixed::never()), VerifyEnd::Reported(codes::RESOURCE_LIMIT) ); assert_eq!( fake.calls().last().unwrap(), &fail_call(codes::RESOURCE_LIMIT) ); assert_eq!(fake.names().iter().filter(|n| *n == "fail").count(), 1); } #[test] fn downloads_stop_at_the_drawing_count() { let rows = vec![row(); 6]; let fake = Fake::with_input(input(document().to_string(), rows)); process(&fake, &InProcess); let downloads = fake.names().iter().filter(|n| *n == "download").count(); assert_eq!(downloads, 4); } #[test] fn a_transport_failure_is_reported_unavailable_without_a_child() { let fake = Fake::clean(); fake.downloads .borrow_mut() .push_back(Err(BackendError::Network("refused".to_owned()))); assert_eq!( process(&fake, &Fixed::never()), VerifyEnd::Reported(codes::UNAVAILABLE) ); assert_eq!(fake.names(), ["input", "download", "fail"]); assert_eq!(fake.calls()[2], fail_call(codes::UNAVAILABLE)); let fake = Fake::clean(); *fake.input.borrow_mut() = Some(Err(BackendError::Status(503))); assert_eq!( process(&fake, &Fixed::never()), VerifyEnd::Reported(codes::UNAVAILABLE) ); assert_eq!(fake.names(), ["input", "fail"]); } #[test] fn an_unrecordable_failure_leaves_the_lease() { let fake = Fake::clean(); *fake.input.borrow_mut() = Some(Err(BackendError::Status(503))); *fake.fail.borrow_mut() = Some(Err(BackendError::Status(503))); assert_eq!(process(&fake, &Fixed::never()), VerifyEnd::LeftForLease); let fake = Fake::clean(); *fake.fail.borrow_mut() = Some(Ok(FailAnswer::Stale)); assert_eq!( process(&fake, &Fixed::with(ChildOutcome::Timeout)), VerifyEnd::Stale ); } #[test] fn every_child_limit_maps_to_its_closed_code() { for (outcome, code) in [ (ChildOutcome::Timeout, codes::TIMEOUT), (ChildOutcome::OutputOverflow, codes::RESOURCE_LIMIT), ( ChildOutcome::Signalled { signal: 24 }, codes::RESOURCE_LIMIT, ), (ChildOutcome::Signalled { signal: 9 }, codes::UNAVAILABLE), (ChildOutcome::Signalled { signal: 15 }, codes::UNAVAILABLE), (ChildOutcome::Signalled { signal: 6 }, codes::RESOURCE_LIMIT), ( ChildOutcome::Signalled { signal: 31 }, codes::RESOURCE_LIMIT, ), ( ChildOutcome::Rejected { code: exit_codes::INPUT_TOO_LARGE, name: "input_too_large", }, codes::RESOURCE_LIMIT, ), ] { let fake = Fake::clean(); assert_eq!( process(&fake, &Fixed::with(outcome)), VerifyEnd::Reported(code) ); assert_eq!(fake.names(), ["input", "download", "fail"]); assert_eq!(fake.calls()[2], fail_call(code)); } } #[test] fn a_broken_or_failed_child_is_reported_then_stops_the_worker() { for outcome in [ ChildOutcome::Broken { code: exit_codes::SANDBOX_FAILED, name: "sandbox_failed", }, ChildOutcome::Failed("output refused: not a JSON object".to_owned()), ] { let fake = Fake::clean(); assert_eq!(process(&fake, &Fixed::with(outcome)), VerifyEnd::Stop); assert_eq!(fake.calls().last().unwrap(), &fail_call(codes::UNAVAILABLE)); } } #[test] fn a_round_with_a_hostile_identity_is_left_untouched() { let fake = Fake::clean(); let mut bad = job(); bad.lease_token = "x".to_owned(); assert_eq!( process_verification(&fake, &Fixed::never(), &Watchdog::new(), &bad), VerifyEnd::LeftForLease ); assert!(fake.calls().is_empty()); } fn once_config() -> Config { Config::from_vars(|name| match name { "SUPABASE_URL" => Some("http://kong:8000".to_owned()), "SUPABASE_SERVICE_ROLE_KEY" => Some("k".to_owned()), "WORKER_ONCE" => Some("1".to_owned()), _ => None, }) .unwrap() } #[test] fn once_mode_claims_one_round_without_a_sweep_or_stops_on_a_broken_child() { let fake = Fake::clean(); *fake.jobs.borrow_mut() = vec![job()]; assert_eq!( verify_loop(&once_config(), &fake, &InProcess, &Watchdog::new()), exit_codes::OK ); assert_eq!(fake.names(), ["claim", "input", "download", "complete"]); let fake = Fake::clean(); *fake.jobs.borrow_mut() = vec![job()]; let broken = Fixed::with(ChildOutcome::Broken { code: exit_codes::ENV_NOT_EMPTY, name: "env_not_empty", }); assert_eq!( verify_loop(&once_config(), &fake, &broken, &Watchdog::new()), exit_codes::CHILD_BROKEN ); } #[test] fn run_arguments_select_the_mode() { let args = |list: &[&str]| -> Vec { list.iter().map(|a| (*a).to_owned()).collect() }; assert_eq!(parse_args(&args(&[])), Ok((Mode::Avatars, false))); assert_eq!(parse_args(&args(&["--check"])), Ok((Mode::Avatars, true))); assert_eq!( parse_args(&args(&["--jobs", "sheet-verify"])), Ok((Mode::SheetVerify, false)) ); assert_eq!( parse_args(&args(&["--jobs", "sheet-verify", "--check"])), Ok((Mode::SheetVerify, true)) ); assert_eq!( parse_args(&args(&["--check", "--jobs", "sheet-verify"])), Ok((Mode::SheetVerify, true)) ); assert!(parse_args(&args(&["--jobs", "avatars"])).is_err()); assert!(parse_args(&args(&["--jobs"])).is_err()); assert!(parse_args(&args(&["--check", "--check"])).is_err()); assert!(parse_args(&args(&["--once"])).is_err()); } /// The real child (this crate's binary), rlimits on, seccomp off: the parent's frame, the /// child's reading and the spawner's classification end to end on any host (the filter /// itself is proven in the Alpine stage, tests/sandbox.rs). #[cfg(feature = "test-hooks")] #[test] fn the_real_child_without_seccomp_verifies_the_parents_frame() { use faunosteo_worker::spawn::Spawner; struct RealChild(Spawner); impl Verifier for RealChild { fn verify(&self, frame: &[u8]) -> ChildRun { self.0.run(frame) } } let mut spawner = Spawner::for_verify(env!("CARGO_BIN_EXE_faunosteo-worker")); spawner.extra_args = vec!["--no-seccomp".to_owned()]; let fake = Fake::clean(); assert_eq!(process(&fake, &RealChild(spawner)), VerifyEnd::Passed); assert_eq!(fake.verdict()["outcome"], "passed"); }