workspace_evidence.rs (18929B)
1 //! Controlled owner/lifecycle tests, not signature or SQLite qualification. 2 use super::*; 3 use std::sync::atomic::AtomicUsize; 4 5 #[derive(Default)] 6 pub(super) struct Control { 7 pub(super) reconciliations: AtomicUsize, 8 pub(super) queries: AtomicUsize, 9 mode: AtomicUsize, 10 calls: Mutex<Vec<(OperationId, CommandDigest, SigningAttemptId, String)>>, 11 } 12 pub(super) fn capture<'a>( 13 store: &'a Store, 14 request: &'a StockEvidenceRequest, 15 credential: &'a AttachmentProof, 16 ) -> radroots_storage::event::BoxFuture<'a, Result<StockEvidenceOutcome, OperationError>> { 17 Box::pin(async move { 18 assert_eq!(credential.with_secret(|value| *value), [7; 32]); 19 assert_eq!(request.binding().input(), &input(5)); 20 store.capture.calls.lock().unwrap().push(( 21 request.operation_id(), 22 request.command_digest(), 23 request.signing_attempt_id(), 24 request.with_json(str::to_owned), 25 )); 26 poll_fn(|cx| { 27 store.waker.register(cx.waker()); 28 if store.waiting.load(Ordering::SeqCst) { 29 Poll::Pending 30 } else { 31 Poll::Ready(()) 32 } 33 }) 34 .await; 35 let mode = store.capture.mode.load(Ordering::SeqCst); 36 let original = request.attempt(); 37 if mode == 2 { 38 return Err(OperationError::StorageFailure); 39 } 40 if mode == 0 { 41 return Ok(StockEvidenceOutcome::Unknown(original)); 42 } 43 let anchor = radroots_storage::command::CommitAttempt::new( 44 original.workspace_id(), 45 if mode == 3 || mode == 4 { 46 OperationId::from_bytes([123; 32]) 47 } else { 48 original.operation_id() 49 }, 50 original.command_digest(), 51 Some(TransactionId::from_bytes([124; 32])), 52 ); 53 if mode == 4 { 54 return Ok(StockEvidenceOutcome::Unknown(anchor)); 55 } 56 let receipt = StockEvidenceReceipt::from_committed_store( 57 anchor, 58 if mode == 6 { 59 SigningAttemptId::from_bytes([125; 32]) 60 } else { 61 request.signing_attempt_id() 62 }, 63 request.recipient(), 64 if mode == 5 { 65 [126; 32] 66 } else { 67 request.evidence_digest() 68 }, 69 request.observed_at_unix_ms(), 70 )?; 71 Ok(StockEvidenceOutcome::Committed(receipt)) 72 }) 73 } 74 fn selected_store() -> Shared<Store> { 75 let store = store(); 76 *store.model.binding.lock().unwrap() = WorkspaceBinding::from_authenticated_host( 77 input(5), 78 radroots_storage::workspace::WorkspaceScope::SellerStockOwner, 79 ActorRef::new(key(), ActorRole::Seller, None, Some(input(5).grant_id())), 80 "device", 81 Sequence::new(1).unwrap(), 82 UnixSeconds::new(200).unwrap(), 83 UnixSeconds::new(100).unwrap(), 84 ) 85 .unwrap(); 86 store 87 } 88 fn request(scope: &WorkspaceSession, op: u8) -> StockEvidenceRequest { 89 StockEvidenceRequest::from_obtained_wire( 90 scope.binding().clone(), 91 OperationId::from_bytes([op; 32]), 92 digest(), 93 SigningAttemptId::from_bytes([83; 32]), 94 key(), 95 [84; 32], 96 "synthetic retained material; this controlled port authenticates no signature", 97 None, 98 ) 99 .unwrap() 100 } 101 fn creation() -> radroots_protocol::command::CreatePoolInput { 102 use radroots_domain::{listing::MeasurementUnit, stock::PoolUnit}; 103 radroots_protocol::command::CreatePoolInput::new( 104 PoolId::from_bytes([85; 32]), 105 "synthetic inventory", 106 PoolUnit::new(MeasurementUnit::Each, 0).unwrap(), 107 Quantity::new("1".parse().unwrap(), MeasurementUnit::Each).unwrap(), 108 ) 109 .unwrap() 110 } 111 fn context(scope: &WorkspaceSession) -> radroots_execution::workspace::CommandContext { 112 scope 113 .command_context( 114 OperationId::from_bytes([86; 32]), 115 None, 116 None, 117 UnixSeconds::new(150).unwrap(), 118 ) 119 .unwrap() 120 } 121 #[derive(Clone)] 122 struct Lifecycle(Shared<Mutex<Vec<&'static str>>>, Option<Shared<Tasks>>); 123 impl Lifecycle { 124 fn record(&self, event: &'static str) -> HostFuture<'_, radroots_execution::Result<()>> { 125 Box::pin(async move { 126 self.0.lock().unwrap().push(event); 127 Ok(()) 128 }) 129 } 130 } 131 impl SessionHost for Lifecycle { 132 fn start(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 133 self.record("start") 134 } 135 fn quiesce(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 136 self.record("quiesce") 137 } 138 fn drain(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 139 Box::pin(async move { 140 self.0.lock().unwrap().push("drain"); 141 if let Some(tasks) = &self.1 { 142 let jobs = core::mem::take(&mut *tasks.queued.lock().unwrap()); 143 for job in jobs { 144 job.await; 145 } 146 } 147 Ok(()) 148 }) 149 } 150 fn disconnect(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 151 self.record("disconnect") 152 } 153 fn dispose_callbacks(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 154 self.record("callbacks") 155 } 156 fn close_storage(&self) -> HostFuture<'_, radroots_execution::Result<()>> { 157 self.record("storage") 158 } 159 } 160 161 #[test] 162 fn unknown_capture_retains_material_after_observer_loss_blocks_fresh_work_and_closes_only_after_exact_retry() 163 { 164 block_on(async { 165 let store = selected_store(); 166 let tasks = Shared::new(Tasks::default()); 167 let trace = Shared::new(Mutex::new(Vec::new())); 168 let client = ClientSession::new_with_task_host( 169 Lifecycle(trace.clone(), None), 170 core::num::NonZeroU16::new(8).unwrap(), 171 tasks.clone(), 172 ); 173 let scope = client 174 .attach_workspace(store.clone(), input(5), proof()) 175 .await 176 .unwrap(); 177 client.start().await.unwrap(); 178 let original = request(&scope, 90); 179 let original_wire = original.with_json(str::to_owned); 180 let mut observed = 181 Box::pin(client.capture_stock_evidence(store.clone(), &scope, &original)); 182 assert!(futures::poll!(observed.as_mut()).is_pending()); 183 // A mutation admitted earlier must recheck before its actual store call. 184 let mut queued_mutation = Box::pin(client.create_stock_pool( 185 store.clone(), 186 &scope, 187 context(&scope), 188 minimum(&scope), 189 creation(), 190 )); 191 assert!(futures::poll!(queued_mutation.as_mut()).is_pending()); 192 assert_eq!( 193 client 194 .capture_stock_evidence(store.clone(), &scope, &original) 195 .await 196 .unwrap_err() 197 .code(), 198 Code::CapabilityUnavailable 199 ); 200 drop(observed); 201 drop(original); 202 let jobs = core::mem::take(&mut *tasks.queued.lock().unwrap()); 203 for job in jobs { 204 job.await; 205 } 206 assert_eq!( 207 queued_mutation.await.unwrap_err().code(), 208 Code::RecoveryRequired 209 ); 210 assert_eq!( 211 client 212 .create_stock_pool( 213 store.clone(), 214 &scope, 215 context(&scope), 216 minimum(&scope), 217 creation() 218 ) 219 .await 220 .unwrap_err() 221 .code(), 222 Code::RecoveryRequired 223 ); 224 assert!(store.calls.lock().unwrap().is_empty()); 225 let mut read = Box::pin(client.stock_pool( 226 store.clone(), 227 &scope, 228 minimum(&scope), 229 PoolId::from_bytes([85; 32]), 230 )); 231 assert!(futures::poll!(read.as_mut()).is_pending()); 232 let job = tasks.queued.lock().unwrap().pop().unwrap(); 233 job.await; 234 assert!(read.await.unwrap().is_none()); 235 assert_eq!(store.capture.queries.load(Ordering::SeqCst), 1); 236 assert_eq!( 237 client.close().await.unwrap_err().code(), 238 Code::RecoveryRequired 239 ); 240 assert_eq!(*trace.lock().unwrap(), vec!["start", "quiesce", "drain"]); 241 store.capture.mode.store(1, Ordering::SeqCst); 242 client.close().await.unwrap(); 243 assert_eq!( 244 *trace.lock().unwrap(), 245 vec![ 246 "start", 247 "quiesce", 248 "drain", 249 "disconnect", 250 "callbacks", 251 "storage" 252 ] 253 ); 254 let calls = store.capture.calls.lock().unwrap(); 255 assert!(calls.len() >= 3); 256 assert!(store.capture.reconciliations.load(Ordering::SeqCst) >= 2); 257 assert!(calls.iter().all(|value| value == &calls[0])); 258 assert_eq!(calls[0].0, OperationId::from_bytes([90; 32])); 259 assert_eq!(calls[0].3, original_wire); 260 }); 261 } 262 263 #[test] 264 fn storage_errors_and_foreign_receipts_keep_original_capture_until_a_matching_confirmed_append() { 265 block_on(async { 266 let store = selected_store(); 267 let tasks = Shared::new(Tasks::default()); 268 let client = ClientSession::new_with_task_host( 269 Host, 270 core::num::NonZeroU16::new(8).unwrap(), 271 tasks.clone(), 272 ); 273 let scope = client 274 .attach_workspace(store.clone(), input(5), proof()) 275 .await 276 .unwrap(); 277 client.start().await.unwrap(); 278 let original = request(&scope, 91); 279 let mut observed = 280 Box::pin(client.capture_stock_evidence(store.clone(), &scope, &original)); 281 assert!(futures::poll!(observed.as_mut()).is_pending()); 282 let job = tasks.queued.lock().unwrap().pop().unwrap(); 283 job.await; 284 assert!(matches!( 285 observed.await.unwrap(), 286 StockEvidenceOutcome::Unknown(_) 287 )); 288 for mode in 2..=6 { 289 store.capture.mode.store(mode, Ordering::SeqCst); 290 let error = client.drain_stock_evidence().await.unwrap_err(); 291 assert_eq!( 292 error.code(), 293 if mode == 2 { 294 Code::StorageFailure 295 } else { 296 Code::RecoveryRequired 297 } 298 ); 299 assert_eq!(error.retry(), RetryClass::ManualReconciliation); 300 assert_eq!( 301 client 302 .create_stock_pool( 303 store.clone(), 304 &scope, 305 context(&scope), 306 minimum(&scope), 307 creation() 308 ) 309 .await 310 .unwrap_err() 311 .code(), 312 Code::RecoveryRequired 313 ); 314 } 315 store.capture.mode.store(1, Ordering::SeqCst); 316 client.drain_stock_evidence().await.unwrap(); 317 assert_eq!(store.capture.reconciliations.load(Ordering::SeqCst), 6); 318 { 319 let calls = store.capture.calls.lock().unwrap(); 320 assert!(calls.iter().all(|value| value == &calls[0])); 321 } 322 client.close().await.unwrap(); 323 original.with_json(|raw| assert!(raw.contains("synthetic retained material"))); 324 }); 325 } 326 327 #[test] 328 fn unpolled_foreign_closed_missing_and_refused_hosts_leave_original_input_and_execute_no_capture() { 329 block_on(async { 330 let store = selected_store(); 331 let tasks = Shared::new(Tasks::default()); 332 let client = ClientSession::new_with_task_host( 333 Host, 334 core::num::NonZeroU16::new(8).unwrap(), 335 tasks.clone(), 336 ); 337 let scope = client 338 .attach_workspace(store.clone(), input(5), proof()) 339 .await 340 .unwrap(); 341 client.start().await.unwrap(); 342 let original = request(&scope, 92); 343 drop(client.capture_stock_evidence(store.clone(), &scope, &original)); 344 assert!(tasks.queued.lock().unwrap().is_empty()); 345 let foreign = WorkspaceSession::attach(store.clone(), input(5), proof()) 346 .await 347 .unwrap(); 348 assert_eq!( 349 client 350 .capture_stock_evidence(store.clone(), &foreign, &original) 351 .await 352 .unwrap_err() 353 .code(), 354 Code::Unauthorized 355 ); 356 for selected in [ 357 input(9), 358 radroots_storage::workspace::seller_stock::SellerAuthoritySelection::from_attachment( 359 &input(5), 360 ) 361 .attachment(GrantId::from_bytes([99; 32])) 362 .unwrap(), 363 ] { 364 let actor = ActorRef::new(key(), ActorRole::Seller, None, Some(selected.grant_id())); 365 let binding = WorkspaceBinding::from_authenticated_host( 366 selected, 367 radroots_storage::workspace::WorkspaceScope::SellerStockOwner, 368 actor, 369 "device", 370 Sequence::new(1).unwrap(), 371 UnixSeconds::new(200).unwrap(), 372 UnixSeconds::new(100).unwrap(), 373 ) 374 .unwrap(); 375 let forged = StockEvidenceRequest::from_obtained_wire( 376 binding, 377 original.operation_id(), 378 original.command_digest(), 379 original.signing_attempt_id(), 380 original.recipient(), 381 *original.intent_digest(), 382 "synthetic foreign descriptor", 383 None, 384 ) 385 .unwrap(); 386 assert_eq!( 387 client 388 .capture_stock_evidence(store.clone(), &scope, &forged) 389 .await 390 .unwrap_err() 391 .code(), 392 Code::Unauthorized 393 ); 394 } 395 tasks.refuse.store(true, Ordering::SeqCst); 396 assert_eq!( 397 client 398 .capture_stock_evidence(store.clone(), &scope, &original) 399 .await 400 .unwrap_err() 401 .code(), 402 Code::CapabilityUnavailable 403 ); 404 tasks.refuse.store(false, Ordering::SeqCst); 405 scope.close(); 406 assert!( 407 client 408 .capture_stock_evidence(store.clone(), &scope, &original) 409 .await 410 .is_err() 411 ); 412 client.close().await.unwrap(); 413 let no_host = ClientSession::new(Host, core::num::NonZeroU16::new(8).unwrap()); 414 let scope = no_host 415 .attach_workspace(store.clone(), input(5), proof()) 416 .await 417 .unwrap(); 418 no_host.start().await.unwrap(); 419 assert!( 420 no_host 421 .capture_stock_evidence(store.clone(), &scope, &original) 422 .await 423 .is_err() 424 ); 425 no_host.close().await.unwrap(); 426 assert!(store.capture.calls.lock().unwrap().is_empty()); 427 original.with_json(|raw| assert!(raw.contains("synthetic retained material"))); 428 }); 429 } 430 431 #[test] 432 fn close_waits_for_the_active_capture_and_keeps_original_material_after_the_observer_is_dropped() { 433 block_on(async { 434 let store = selected_store(); 435 store.capture.mode.store(1, Ordering::SeqCst); 436 store.waiting.store(true, Ordering::SeqCst); 437 let tasks = Shared::new(Tasks::default()); 438 let trace = Shared::new(Mutex::new(Vec::new())); 439 let client = ClientSession::new_with_task_host( 440 Lifecycle(trace.clone(), None), 441 core::num::NonZeroU16::new(8).unwrap(), 442 tasks.clone(), 443 ); 444 let scope = client 445 .attach_workspace(store.clone(), input(5), proof()) 446 .await 447 .unwrap(); 448 client.start().await.unwrap(); 449 let original = request(&scope, 93); 450 let mut observed = 451 Box::pin(client.capture_stock_evidence(store.clone(), &scope, &original)); 452 assert!(futures::poll!(observed.as_mut()).is_pending()); 453 let mut job = tasks.queued.lock().unwrap().pop().unwrap(); 454 assert!(futures::poll!(job.as_mut()).is_pending()); 455 drop(observed); 456 drop(original); 457 let mut closing = Box::pin(client.close()); 458 assert!(futures::poll!(closing.as_mut()).is_pending()); 459 assert_eq!(*trace.lock().unwrap(), vec!["start", "quiesce", "drain"]); 460 store.waiting.store(false, Ordering::SeqCst); 461 store.waker.wake(); 462 job.await; 463 closing.await.unwrap(); 464 assert_eq!( 465 *trace.lock().unwrap(), 466 vec![ 467 "start", 468 "quiesce", 469 "drain", 470 "disconnect", 471 "callbacks", 472 "storage" 473 ] 474 ); 475 assert_eq!(store.capture.calls.lock().unwrap().len(), 1); 476 }); 477 } 478 479 #[test] 480 fn close_drives_the_host_owned_active_task_before_retrying_its_retained_capture() { 481 block_on(async { 482 let store = selected_store(); 483 store.capture.mode.store(1, Ordering::SeqCst); 484 store.waiting.store(true, Ordering::SeqCst); 485 let tasks = Shared::new(Tasks::default()); 486 let trace = Shared::new(Mutex::new(Vec::new())); 487 let client = ClientSession::new_with_task_host( 488 Lifecycle(trace.clone(), Some(tasks.clone())), 489 core::num::NonZeroU16::new(8).unwrap(), 490 tasks.clone(), 491 ); 492 let scope = client 493 .attach_workspace(store.clone(), input(5), proof()) 494 .await 495 .unwrap(); 496 client.start().await.unwrap(); 497 let original = request(&scope, 94); 498 let mut observed = 499 Box::pin(client.capture_stock_evidence(store.clone(), &scope, &original)); 500 assert!(futures::poll!(observed.as_mut()).is_pending()); 501 let mut job = tasks.queued.lock().unwrap().pop().unwrap(); 502 assert!(futures::poll!(job.as_mut()).is_pending()); 503 tasks.queued.lock().unwrap().push(job); 504 drop(observed); 505 drop(original); 506 let mut closing = Box::pin(client.close()); 507 assert!(futures::poll!(closing.as_mut()).is_pending()); 508 assert_eq!(*trace.lock().unwrap(), vec!["start", "quiesce", "drain"]); 509 store.waiting.store(false, Ordering::SeqCst); 510 store.waker.wake(); 511 assert!(matches!( 512 futures::poll!(closing.as_mut()), 513 Poll::Ready(Ok(())) 514 )); 515 assert_eq!( 516 *trace.lock().unwrap(), 517 vec![ 518 "start", 519 "quiesce", 520 "drain", 521 "disconnect", 522 "callbacks", 523 "storage" 524 ] 525 ); 526 assert_eq!(store.capture.calls.lock().unwrap().len(), 1); 527 }); 528 }