native_stock_rewrap_tests.rs (22348B)
1 //! Ordinary explicit wrapping and exact recovery use the real protected owner. 2 use super::*; 3 fn peer_index(r: &Rig, status: &crate::orders::AcceptanceStatus) -> usize { 4 status 5 .recipients() 6 .iter() 7 .position(|entry| entry.recipient != r.enrollment.input().participant()) 8 .unwrap() 9 } 10 #[tokio::test] 11 async fn ordinary_rewrap_is_explicit_preserves_originals_and_resumes_exact_bytes_without_signing() { 12 let r = Rig::new().await; 13 let (command, initial) = r.accept().await; 14 let index = peer_index(&r, &initial); 15 let recipient = initial.recipients()[index].recipient; 16 let original = initial.delivery().unwrap()[index].source().unwrap(); 17 let id = OperationId::from_bytes([71; 32]); 18 let (_, _, minimum) = r.minima().await; 19 r.io.missing_ack.store(true, Ordering::SeqCst); 20 let first = r 21 .client 22 .orders(&r.scope) 23 .rewrap_acceptance( 24 minimum, 25 command.context().operation_id(), 26 command.digest(), 27 recipient, 28 id, 29 ) 30 .await 31 .unwrap(); 32 let state = first.state().unwrap(); 33 let outer = state.envelope().unwrap(); 34 assert_eq!(state.admission().original(), original); 35 assert_ne!(outer.event_id(), original.event_id()); 36 assert_eq!(outer.evidence(), original.evidence()); 37 assert_eq!( 38 outer.installation_transaction_id(), 39 original.installation_transaction_id() 40 ); 41 let summary = first.delivery().unwrap(); 42 assert_eq!(summary.attempt_count(), 2); 43 assert_eq!(summary.selected_attempt_count(), 1); 44 assert!(!summary.acceptance_satisfied().unwrap()); 45 assert_eq!(summary.publication_policy_source(), Some(original)); 46 assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); 47 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 48 let sent = r.io.sent.lock().unwrap().clone(); 49 assert_eq!(sent.len(), 3); 50 let raw = sent[2].clone(); 51 let repeated = r 52 .client 53 .orders(&r.scope) 54 .rewrap_acceptance( 55 minimum, 56 command.context().operation_id(), 57 command.digest(), 58 recipient, 59 id, 60 ) 61 .await 62 .unwrap(); 63 assert_eq!(repeated.state(), Some(state)); 64 assert_eq!(r.io.sent.lock().unwrap().len(), 3); 65 assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); 66 let observed = r 67 .client 68 .orders(&r.scope) 69 .acceptance_status(minimum, command.context().operation_id(), command.digest()) 70 .await 71 .unwrap(); 72 assert_eq!(observed.installation(), initial.installation()); 73 let old = &observed.delivery().unwrap()[index]; 74 assert_eq!(old.source(), Some(original)); 75 assert_eq!(old.attempt_count(), 2); 76 assert_eq!(old.selected_attempt_count(), 1); 77 assert!(old.acceptance_satisfied().unwrap()); 78 let read = r 79 .client 80 .orders(&r.scope) 81 .acceptance_rewrap_status( 82 minimum, 83 command.context().operation_id(), 84 command.digest(), 85 recipient, 86 id, 87 ) 88 .await 89 .unwrap(); 90 assert_eq!(read.state(), Some(state)); 91 assert_eq!(r.io.sent.lock().unwrap().len(), 3); 92 r.io.missing_ack.store(false, Ordering::SeqCst); 93 let resumed = r 94 .client 95 .orders(&r.scope) 96 .resume_acceptance_rewrap( 97 minimum, 98 command.context().operation_id(), 99 command.digest(), 100 recipient, 101 id, 102 ) 103 .await 104 .unwrap(); 105 assert_eq!(resumed.state(), Some(state)); 106 assert_eq!(resumed.delivery().unwrap().attempt_count(), 3); 107 assert_eq!(resumed.delivery().unwrap().selected_attempt_count(), 2); 108 assert!(resumed.delivery().unwrap().acceptance_satisfied().unwrap()); 109 assert_eq!(r.io.sent.lock().unwrap()[3], raw); 110 assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); 111 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 112 r.client.close().await.unwrap(); 113 } 114 115 async fn fault_connection(r: &Rig) -> sqlx::SqliteConnection { 116 use sqlx::Connection; 117 let path = r._temp.path().join("stock/stock_execution_v1.sqlite"); 118 sqlx::SqliteConnection::connect(&format!("sqlite://{}", path.display())) 119 .await 120 .unwrap() 121 } 122 async fn original_entries(c: &mut sqlx::SqliteConnection) -> (Vec<Vec<u8>>, Vec<Vec<u8>>) { 123 let outers = sqlx::query_scalar("SELECT entry_id FROM stock_envelopes ORDER BY entry_id") 124 .fetch_all(&mut *c) 125 .await 126 .unwrap(); 127 let seals = sqlx::query_scalar("SELECT entry_id FROM stock_signing_evidence ORDER BY entry_id") 128 .fetch_all(c) 129 .await 130 .unwrap(); 131 (outers, seals) 132 } 133 134 #[tokio::test] 135 async fn obtained_rewrap_survives_statement_and_commit_failure_and_clockless_failed_close() { 136 use sqlx::Connection; 137 for uncertain in [false, true] { 138 let r = Rig::new().await; 139 let (command, initial) = r.accept().await; 140 let recipient = initial.recipients()[peer_index(&r, &initial)].recipient; 141 let (_, _, minimum) = r.minima().await; 142 let mut fault = fault_connection(&r).await; 143 let originals = original_entries(&mut fault).await; 144 if uncertain { 145 sqlx::raw_sql("CREATE TABLE rewrap_deferred_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER controlled_rewrap_failure AFTER INSERT ON stock_rewraps BEGIN INSERT INTO rewrap_deferred_fault VALUES(2); END").execute(&mut fault).await.unwrap(); 146 } else { 147 sqlx::query("CREATE TRIGGER controlled_rewrap_failure BEFORE INSERT ON stock_rewraps BEGIN SELECT RAISE(ABORT, 'controlled_rewrap_failure'); END").execute(&mut fault).await.unwrap(); 148 } 149 let error = r 150 .client 151 .orders(&r.scope) 152 .rewrap_acceptance( 153 minimum, 154 command.context().operation_id(), 155 command.digest(), 156 recipient, 157 OperationId::from_bytes([72; 32]), 158 ) 159 .await 160 .unwrap_err(); 161 assert_eq!( 162 error.code(), 163 if uncertain { 164 crate::Code::RecoveryRequired 165 } else { 166 crate::Code::StorageFailure 167 } 168 ); 169 assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); 170 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 171 assert_eq!(r.io.sent.lock().unwrap().len(), 2); 172 r.clock.0.store(0, Ordering::SeqCst); 173 assert!(r.client.close().await.is_err()); 174 assert!(r.provider.upgrade().is_some()); 175 sqlx::raw_sql( 176 "DROP TRIGGER controlled_rewrap_failure; DROP TABLE IF EXISTS rewrap_deferred_fault", 177 ) 178 .execute(&mut fault) 179 .await 180 .unwrap(); 181 r.client.close().await.unwrap(); 182 assert!(r.provider.upgrade().is_none()); 183 assert_eq!(original_entries(&mut fault).await, originals); 184 let counts: (i64, i64) = sqlx::query_as("SELECT (SELECT count(*) FROM stock_rewrap_admissions),(SELECT count(*) FROM stock_rewraps)").fetch_one(&mut fault).await.unwrap(); 185 assert_eq!(counts, (1, 1)); 186 assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); 187 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 188 assert_eq!(r.io.sent.lock().unwrap().len(), 2); 189 fault.close().await.unwrap(); 190 } 191 } 192 193 #[tokio::test] 194 async fn failed_rewrap_admission_repairs_without_a_key_or_renewed_invocation() { 195 use sqlx::Connection; 196 for uncertain in [false, true] { 197 let r = Rig::new().await; 198 let (command, initial) = r.accept().await; 199 let recipient = initial.recipients()[peer_index(&r, &initial)].recipient; 200 let (_, _, minimum) = r.minima().await; 201 let id = OperationId::from_bytes([73; 32]); 202 let mut fault = fault_connection(&r).await; 203 let originals = original_entries(&mut fault).await; 204 if uncertain { 205 sqlx::raw_sql("CREATE TABLE admission_deferred_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER controlled_admission_failure AFTER INSERT ON stock_rewrap_admissions BEGIN INSERT INTO admission_deferred_fault VALUES(2); END").execute(&mut fault).await.unwrap(); 206 } else { 207 sqlx::query("CREATE TRIGGER controlled_admission_failure BEFORE INSERT ON stock_rewrap_admissions BEGIN SELECT RAISE(ABORT, 'controlled_admission_failure'); END").execute(&mut fault).await.unwrap(); 208 } 209 let error = r 210 .client 211 .orders(&r.scope) 212 .rewrap_acceptance( 213 minimum, 214 command.context().operation_id(), 215 command.digest(), 216 recipient, 217 id, 218 ) 219 .await 220 .unwrap_err(); 221 assert_eq!( 222 error.code(), 223 if uncertain { 224 crate::Code::RecoveryRequired 225 } else { 226 crate::Code::StorageFailure 227 } 228 ); 229 r.clock.0.store(0, Ordering::SeqCst); 230 sqlx::raw_sql("DROP TRIGGER controlled_admission_failure; DROP TABLE IF EXISTS admission_deferred_fault").execute(&mut fault).await.unwrap(); 231 // Restore the exact catalog before uncertain-connection reopen. Repair 232 // then resolves only the original writer fence, without a current clock, 233 // a fresh admission or an invocation right. 234 r.client.stock(&r.scope).drain_evidence().await.unwrap(); 235 r.clock.0.store(150, Ordering::SeqCst); 236 let view = r 237 .client 238 .orders(&r.scope) 239 .resume_acceptance_rewrap( 240 minimum, 241 command.context().operation_id(), 242 command.digest(), 243 recipient, 244 id, 245 ) 246 .await 247 .unwrap(); 248 assert!(view.state().is_none()); 249 assert!(view.delivery().is_none()); 250 assert_eq!(original_entries(&mut fault).await, originals); 251 assert_eq!(r.io.wraps.load(Ordering::SeqCst), 2); 252 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 253 assert_eq!(r.io.sent.lock().unwrap().len(), 2); 254 r.client.close().await.unwrap(); 255 fault.close().await.unwrap(); 256 } 257 } 258 259 #[tokio::test] 260 async fn obtained_rewrap_delivery_survives_lost_waiter_commit_failure_and_clock_loss() { 261 use sqlx::Connection; 262 for uncertain in [false, true] { 263 let r = Rig::new().await; 264 let (command, initial) = r.accept().await; 265 let recipient = initial.recipients()[peer_index(&r, &initial)].recipient; 266 let (_, _, minimum) = r.minima().await; 267 r.io.pause_delivery.store(true, Ordering::SeqCst); 268 let client = r.client.clone(); 269 let scope = r.scope.clone(); 270 let waiter = tokio::spawn(async move { 271 client 272 .orders(&scope) 273 .rewrap_acceptance( 274 minimum, 275 command.context().operation_id(), 276 command.digest(), 277 recipient, 278 OperationId::from_bytes([74; 32]), 279 ) 280 .await 281 }); 282 tokio::time::timeout(std::time::Duration::from_secs(120), r.io.entered.notified()) 283 .await 284 .unwrap(); 285 waiter.abort(); 286 assert!(waiter.await.unwrap_err().is_cancelled()); 287 let mut fault = fault_connection(&r).await; 288 let originals = original_entries(&mut fault).await; 289 let attempts: Vec<(Vec<u8>, Vec<u8>)> = sqlx::query_as( 290 "SELECT entry_id,request_key FROM stock_delivery_attempts ORDER BY entry_id", 291 ) 292 .fetch_all(&mut fault) 293 .await 294 .unwrap(); 295 let observations: i64 = 296 sqlx::query_scalar("SELECT count(*) FROM stock_delivery_observations") 297 .fetch_one(&mut fault) 298 .await 299 .unwrap(); 300 if uncertain { 301 sqlx::raw_sql("CREATE TABLE rewrap_observation_fault(value INTEGER REFERENCES stock_authority(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER controlled_rewrap_observation AFTER INSERT ON stock_delivery_observations BEGIN INSERT INTO rewrap_observation_fault VALUES(2); END").execute(&mut fault).await.unwrap(); 302 } else { 303 sqlx::query("CREATE TRIGGER controlled_rewrap_observation BEFORE INSERT ON stock_delivery_observations BEGIN SELECT RAISE(ABORT, 'controlled_rewrap_observation'); END").execute(&mut fault).await.unwrap(); 304 } 305 r.clock.0.store(0, Ordering::SeqCst); 306 r.io.release.notify_one(); 307 let error = r.client.close().await.unwrap_err(); 308 assert_eq!( 309 error.code(), 310 if uncertain { 311 crate::Code::RecoveryRequired 312 } else { 313 crate::Code::StorageFailure 314 } 315 ); 316 assert!(r.provider.upgrade().is_some()); 317 sqlx::raw_sql("DROP TRIGGER controlled_rewrap_observation; DROP TABLE IF EXISTS rewrap_observation_fault").execute(&mut fault).await.unwrap(); 318 r.client.close().await.unwrap(); 319 assert!(r.provider.upgrade().is_none()); 320 assert_eq!(original_entries(&mut fault).await, originals); 321 let actual: Vec<(Vec<u8>, Vec<u8>)> = sqlx::query_as( 322 "SELECT entry_id,request_key FROM stock_delivery_attempts ORDER BY entry_id", 323 ) 324 .fetch_all(&mut fault) 325 .await 326 .unwrap(); 327 assert_eq!(actual, attempts); 328 let actual: i64 = sqlx::query_scalar("SELECT count(*) FROM stock_delivery_observations") 329 .fetch_one(&mut fault) 330 .await 331 .unwrap(); 332 assert_eq!(actual, observations + 1); 333 assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); 334 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 335 assert_eq!(r.io.sent.lock().unwrap().len(), 3); 336 fault.close().await.unwrap(); 337 } 338 } 339 340 #[tokio::test] 341 async fn rewrap_loopback_scopes_partial_acknowledgement_and_retries_exact_bytes_without_signing() { 342 use futures::{SinkExt, StreamExt}; 343 use radroots_transport_nostr::{ 344 Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, 345 }; 346 use std::time::{Duration, SystemTime, UNIX_EPOCH}; 347 use tokio_tungstenite::{accept_async, tungstenite::Message}; 348 async fn relay(listener: tokio::net::TcpListener, partial: bool) -> Vec<String> { 349 let (tcp, _) = listener.accept().await.unwrap(); 350 let mut socket = accept_async(tcp).await.unwrap(); 351 let mut frames = Vec::new(); 352 for index in 0..if partial { 2 } else { 1 } { 353 let frame = tokio::time::timeout(Duration::from_secs(300), async { 354 loop { 355 if let Message::Text(raw) = socket.next().await.unwrap().unwrap() { 356 let event: serde_json::Value = serde_json::from_str(&raw).unwrap(); 357 if event[0] == "EVENT" { 358 break (raw.to_string(), event[1]["id"].clone()); 359 } 360 } 361 } 362 }) 363 .await 364 .unwrap(); 365 socket 366 .send(Message::Text( 367 serde_json::json!(["OK", "ff".repeat(32), true, ""]) 368 .to_string() 369 .into(), 370 )) 371 .await 372 .unwrap(); 373 socket 374 .send(Message::Text( 375 serde_json::json!(["OK", frame.1, !partial || index > 0, ""]) 376 .to_string() 377 .into(), 378 )) 379 .await 380 .unwrap(); 381 frames.push(frame.0); 382 } 383 // Keep the accepted relay connected through the second invocation, so 384 // skipping it is actual target selection rather than disconnect luck. 385 if !partial { 386 while let Some(message) = socket.next().await { 387 match message.unwrap() { 388 Message::Text(raw) => { 389 let value: serde_json::Value = serde_json::from_str(&raw).unwrap(); 390 assert_ne!(value[0], "EVENT", "accepted target must not be retried"); 391 } 392 Message::Close(_) => break, 393 _ => {} 394 } 395 } 396 } 397 frames 398 } 399 let first = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); 400 let second = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); 401 let uris = vec![ 402 format!("ws://{}", first.local_addr().unwrap()), 403 format!("ws://{}", second.local_addr().unwrap()), 404 ]; 405 let now = SystemTime::now() 406 .duration_since(UNIX_EPOCH) 407 .unwrap() 408 .as_secs(); 409 let r = Rig::configured(Some(uris.clone()), now + 1800).await; 410 r.io.missing_ack.store(true, Ordering::SeqCst); 411 let (command, initial) = r.accept().await; 412 let index = peer_index(&r, &initial); 413 let recipient = initial.recipients()[index].recipient; 414 let original = initial.delivery().unwrap()[index].source().unwrap(); 415 let originals = r.io.sent.lock().unwrap().clone(); 416 let accepted = tokio::spawn(relay(first, false)); 417 let partial = tokio::spawn(relay(second, true)); 418 let config = Config::from_profile( 419 RelayProfile::explicit( 420 RelayProfileKind::Simulator, 421 uris.iter().map(|uri| { 422 RelayEndpoint::new(uri, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap() 423 }), 424 ) 425 .unwrap(), 426 ) 427 .with_timeouts(1000, 1000, 500) 428 .unwrap(); 429 let transport = Arc::new(radroots_transport_nostr_native::create_transport(config)); 430 *r.io.transport.lock().unwrap() = Some(transport.clone()); 431 r.clock.enable_realtime(); 432 let (_, _, minimum) = r.minima().await; 433 let grant = StockGrantEnrollment::prepare( 434 &SellerAuthoritySelection::from_attachment(r.enrollment.input()), 435 "explicit wrapping recovery".into(), 436 UnixSeconds::new(now + 1500).unwrap(), 437 StockGrantScope::full_inventory(), 438 ) 439 .unwrap(); 440 r.native 441 .enroll_stock_grant( 442 r.scope.binding().clone(), 443 minimum, 444 r.enrollment.proof(), 445 &grant, 446 ) 447 .await 448 .unwrap(); 449 let (_, _, minimum) = r.minima().await; 450 let capture = StockConsentCapture::prepare( 451 SellerAuthoritySelection::from_attachment(r.enrollment.input()), 452 grant.input().grant_id(), 453 StockConsentMode::RecoverOnly, 454 StockResources::all_pools(), 455 UnixSeconds::new(now + 1200).unwrap(), 456 CapturedOrderAcceptance::parse(command.protected_wire()).unwrap(), 457 ) 458 .unwrap(); 459 r.native 460 .issue_stock_consent( 461 r.scope.binding().clone(), 462 minimum, 463 &capture, 464 r.enrollment.proof(), 465 ) 466 .await 467 .unwrap(); 468 let (_, _, minimum) = r.minima().await; 469 let recovery = r 470 .client 471 .attach(grant.input().clone(), proof(grant.proof())) 472 .await 473 .unwrap(); 474 let id = OperationId::from_bytes([75; 32]); 475 let first = r 476 .client 477 .orders(&recovery) 478 .rewrap_acceptance( 479 minimum, 480 command.context().operation_id(), 481 command.digest(), 482 recipient, 483 id, 484 ) 485 .await 486 .unwrap(); 487 let state = first.state().unwrap(); 488 let summary = first.delivery().unwrap(); 489 assert_eq!(state.admission().original(), original); 490 assert_eq!(summary.attempt_count(), 2); 491 assert_eq!(summary.selected_attempt_count(), 1); 492 assert!(!summary.acceptance_satisfied().unwrap()); 493 assert_eq!(summary.targets().iter().filter(|v| v.accepted()).count(), 1); 494 let repeated = r 495 .client 496 .orders(&recovery) 497 .rewrap_acceptance( 498 minimum, 499 command.context().operation_id(), 500 command.digest(), 501 recipient, 502 id, 503 ) 504 .await 505 .unwrap(); 506 assert_eq!(repeated.state(), Some(state)); 507 assert_eq!(r.io.sent.lock().unwrap().len(), 3); 508 let resumed = r 509 .client 510 .orders(&recovery) 511 .resume_acceptance_rewrap( 512 minimum, 513 command.context().operation_id(), 514 command.digest(), 515 recipient, 516 id, 517 ) 518 .await 519 .unwrap(); 520 assert_eq!(resumed.state(), Some(state)); 521 let summary = resumed.delivery().unwrap(); 522 assert_eq!(summary.attempt_count(), 3); 523 assert_eq!(summary.selected_attempt_count(), 2); 524 assert!(summary.acceptance_satisfied().unwrap()); 525 let mut counts: Vec<_> = summary 526 .targets() 527 .iter() 528 .map(|v| v.potential_attempts()) 529 .collect(); 530 counts.sort(); 531 assert_eq!(counts, [2, 3]); 532 let observed = r 533 .client 534 .orders(&recovery) 535 .acceptance_status(minimum, command.context().operation_id(), command.digest()) 536 .await 537 .unwrap(); 538 assert_eq!(observed.installation(), initial.installation()); 539 let old = &observed.delivery().unwrap()[index]; 540 assert_eq!(old.source(), Some(original)); 541 assert_eq!(old.selected_attempt_count(), 1); 542 assert!(!old.acceptance_satisfied().unwrap()); 543 let sent = r.io.sent.lock().unwrap().clone(); 544 assert_eq!(&sent[..2], originals.as_slice()); 545 assert_eq!(sent[2], sent[3]); 546 assert!(!originals.contains(&sent[2])); 547 assert_eq!(r.control.signs.load(Ordering::SeqCst), 2); 548 assert_eq!(r.io.wraps.load(Ordering::SeqCst), 3); 549 transport.shutdown().await; 550 let accepted = tokio::time::timeout(Duration::from_secs(10), accepted) 551 .await 552 .unwrap() 553 .unwrap(); 554 let partial = tokio::time::timeout(Duration::from_secs(10), partial) 555 .await 556 .unwrap() 557 .unwrap(); 558 assert_eq!(accepted.len(), 1); 559 assert_eq!(partial.len(), 2); 560 assert_eq!(accepted[0], partial[0]); 561 assert_eq!(partial[0], partial[1]); 562 assert_eq!(accepted[0], format!("[\"EVENT\",{}]", sent[2])); 563 r.client.close().await.unwrap(); 564 }