receipt_public_delivery.rs (27598B)
1 //! Actual native public D over the existing journal and qualified Nostr sink. 2 use super::*; 3 use futures::{SinkExt, StreamExt}; 4 use nostr::JsonUtil; 5 use radroots_nostr::{ 6 key::parse_secret_key, 7 signing::{LocalSigner, OsNonceSource}, 8 }; 9 use radroots_protocol::{intent::SigningReplay, listing::PublicSigningPlan}; 10 use radroots_signing::{ 11 issuance::{OutcomeKind, SigningIntent}, 12 provider::{ParticipantProvider, ProviderCall}, 13 request::CancellationSignal, 14 }; 15 use radroots_storage::command::{ 16 ArtifactEvidence, ClaimAttemptOutcome, ClaimAttemptRequest, DeliveryAttempt, 17 DeliveryAttemptOutcome, DeliveryAttemptRequest, DeliveryIntent, DeliveryObservation, 18 DeliveryObservationKind, DeliveryObservationOutcome, EvidenceCaptureOutcome, 19 InstallationOutcome, InstallationRequest, PlanBindingOutcome, PublicPublicationWork, 20 PublicationArtifact, SigningTarget, 21 }; 22 use radroots_transport::{ 23 EventSink, TargetSet, 24 policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy}, 25 }; 26 use radroots_transport_nostr::{ 27 Config, RelayAccess, RelayEndpoint, RelayProfile, RelayProfileKind, RelayUrlPolicy, 28 }; 29 use std::{ 30 num::NonZeroU64, 31 time::{SystemTime, UNIX_EPOCH}, 32 }; 33 use tokio::net::TcpListener; 34 use tokio_tungstenite::{accept_async, tungstenite::Message}; 35 fn now_ms() -> u64 { 36 SystemTime::now() 37 .duration_since(UNIX_EPOCH) 38 .unwrap() 39 .as_millis() 40 .try_into() 41 .unwrap() 42 } 43 fn signer_now() -> Result<u64, radroots_signing::Error> { 44 Ok(now_ms()) 45 } 46 struct Ready { 47 fixture: Fixture, 48 store: Arc<NativeWorkspace>, 49 input: AttachmentInput, 50 proof: AttachmentProof, 51 binding: WorkspaceBinding, 52 work: PublicPublicationWork, 53 raw: String, 54 config: Config, 55 } 56 impl Ready { 57 async fn new(urls: &[String], id: u8) -> Self { 58 let fixture = Fixture::new(); 59 let time = now_ms() / 1000; 60 fixture.clock.now.store(time, Ordering::SeqCst); 61 let (store, input, proof) = NativeWorkspace::initialize_local_outbox( 62 &fixture.path, 63 LocalOutboxConfig::seller( 64 key(), 65 key(), 66 "public-delivery", 67 UnixSeconds::new(time + 600).unwrap(), 68 ) 69 .unwrap(), 70 fixture.crypto(), 71 fixture.clock.clone(), 72 ) 73 .await 74 .unwrap(); 75 let binding = store.authenticate(input.clone(), &proof).await.unwrap(); 76 let store = Arc::new(store); 77 let context = CommandContextData::new( 78 OperationId::from_bytes([id; 32]), 79 binding.actor(), 80 input.workspace_id(), 81 input.authority(), 82 input.route_digest(), 83 None, 84 None, 85 UnixSeconds::new(time + 120).unwrap(), 86 None, 87 ) 88 .unwrap(); 89 let wire = json!({"type":"listing.publish","context":context,"input":{"id":format!("{id:02x}").repeat(16),"title":"Native public delivery","summary":"Quote required","description_markdown":"Public terms","published_at":time.to_string(),"profile":{"profile":"radroots.listing","version":1,"state":"active","product":{"name":"Carrots","description":"x".repeat(4096),"producer":null,"origin_summary":null},"default_option":"02".repeat(32),"options":[{"id":"02".repeat(32),"label":"Bunch","unit":{"type":"package","label":"bunch","contents":{"type":"unspecified"}},"increment":"1","minimum":"1","price":{"type":"quote_required"},"supply":{"type":"available","amount":"10"},"lead_seconds":"0"}],"fulfillment":{"modes":["pickup"],"area":"Example","lead_seconds":"0"},"authority":null,"media":[]}}}); 90 let prepared = committed( 91 store 92 .admit_command_and_hold( 93 AdmissionRequest::from_protected_wire( 94 binding.clone(), 95 &serde_json::to_vec(&wire).unwrap(), 96 ) 97 .unwrap(), 98 copy(&proof), 99 ) 100 .await 101 .unwrap(), 102 ); 103 let plan = PublicSigningPlan::capture( 104 prepared.request().command().listing().unwrap(), 105 UnixSeconds::new(time).unwrap(), 106 urls, 107 SigningReplay::NonReplayable, 108 ) 109 .unwrap(); 110 let digest = *plan.digest(); 111 assert!( 112 plan.event() 113 .fields() 114 .tags 115 .iter() 116 .any(|tag| tag.iter().any(|field| field.len() > 4096)) 117 ); 118 let PlanBindingOutcome::Committed(_) = store 119 .bind_signing_intents(binding.clone(), plan.into(), copy(&proof)) 120 .await 121 .unwrap() 122 else { 123 panic!("actual T1 commit") 124 }; 125 let ClaimAttemptOutcome::Claimed(attempt) = store 126 .claim_attempt( 127 ClaimAttemptRequest::for_artifact( 128 binding.clone(), 129 prepared.identity().operation_id(), 130 prepared.identity().command_digest(), 131 digest, 132 SigningTarget::PublicEvent, 133 ), 134 copy(&proof), 135 ) 136 .await 137 .unwrap() 138 else { 139 panic!("actual first claim") 140 }; 141 let signer = LocalSigner::with_clock( 142 parse_secret_key("0000000000000000000000000000000000000000000000000000000000000001") 143 .unwrap(), 144 signer_now, 145 ) 146 .unwrap() 147 .with_nonce_source(Arc::new(OsNonceSource)); 148 let intent = SigningIntent::from_plan( 149 attempt.bound_plan().plan(), 150 SigningTarget::PublicEvent, 151 ProviderCall::new(key(), attempt.deadline_unix_ms(), CancellationSignal::new()), 152 ) 153 .unwrap(); 154 let (_, outcome) = signer.sign_exact(intent).await.into_parts(); 155 let OutcomeKind::Obtained(artifact) = outcome else { 156 panic!("actual public signature") 157 }; 158 let evidence = artifact.with_json(|raw| { 159 nostr::Event::from_json(raw).unwrap().verify().unwrap(); 160 ArtifactEvidence::verify(&attempt, raw, artifact.observed_at_unix_ms()).unwrap() 161 }); 162 let raw = evidence.raw_json().to_owned(); 163 assert!(matches!( 164 store 165 .capture_evidence(input.clone(), &proof, &evidence) 166 .await 167 .unwrap(), 168 EvidenceCaptureOutcome::Committed(_) 169 )); 170 assert!(matches!( 171 store 172 .install_transition_and_outbox( 173 InstallationRequest::new( 174 binding.clone(), 175 prepared.identity().operation_id(), 176 prepared.identity().command_digest(), 177 digest 178 ), 179 copy(&proof) 180 ) 181 .await 182 .unwrap(), 183 InstallationOutcome::ListingCommitted(_) 184 )); 185 let snapshot = store 186 .operation_snapshot( 187 binding.clone(), 188 prepared.identity().operation_id(), 189 None, 190 copy(&proof), 191 ) 192 .await 193 .unwrap() 194 .unwrap(); 195 let work = snapshot.public_publications()[0]; 196 let config = Config::from_profile( 197 RelayProfile::explicit( 198 RelayProfileKind::Simulator, 199 urls.iter().map(|url| { 200 RelayEndpoint::new(url, RelayUrlPolicy::Local, RelayAccess::ReadWrite).unwrap() 201 }), 202 ) 203 .unwrap(), 204 ) 205 .with_timeouts(1000, 1000, 500) 206 .unwrap(); 207 Self { 208 fixture, 209 store, 210 input, 211 proof, 212 binding, 213 work, 214 raw, 215 config, 216 } 217 } 218 fn targets(&self) -> TargetSet { 219 TargetSet::new( 220 self.config 221 .relays() 222 .iter() 223 .map(|v| v.to_target().unwrap()) 224 .collect(), 225 ) 226 .unwrap() 227 } 228 fn request(&self, id: u8) -> DeliveryAttemptRequest { 229 let now = self.fixture.clock.now().unwrap().get() * 1000; 230 DeliveryAttemptRequest::new( 231 self.binding.clone(), 232 self.work, 233 DeliveryIntent::public( 234 &format!("{id:02x}").repeat(32), 235 self.work.evidence().event_id(), 236 &self.targets(), 237 &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), 238 NonZeroU64::new(now + 60_000).unwrap(), 239 ) 240 .unwrap(), 241 ) 242 .unwrap() 243 } 244 async fn retain(&self, id: u8) -> DeliveryAttempt { 245 match self 246 .store 247 .prepare_delivery_attempt(self.request(id), copy(&self.proof), None) 248 .await 249 .unwrap() 250 { 251 DeliveryAttemptOutcome::Claimed(v) => *v, 252 _ => panic!("actual fresh public D claim"), 253 } 254 } 255 async fn snapshot( 256 &self, 257 store: &NativeWorkspace, 258 ) -> radroots_storage::command::OperationSnapshot { 259 store 260 .operation_snapshot( 261 self.binding.clone(), 262 self.work.evidence().operation_id(), 263 Some(self.work.evidence().command_digest()), 264 copy(&self.proof), 265 ) 266 .await 267 .unwrap() 268 .unwrap() 269 } 270 async fn query( 271 &self, 272 store: &NativeWorkspace, 273 id: &radroots_transport::sink::DeliveryRequestId, 274 ) -> Option<DeliveryAttempt> { 275 store 276 .delivery_attempt( 277 self.binding.clone(), 278 self.work.evidence().operation_id(), 279 self.work.evidence().command_digest(), 280 SigningTarget::PublicEvent, 281 id.clone(), 282 copy(&self.proof), 283 ) 284 .await 285 .unwrap() 286 } 287 } 288 #[tokio::test] 289 async fn public_d_retains_original_before_actual_loopback_and_reopens_independent_ack() { 290 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 291 let ready = Ready::new(&[format!("ws://{}", listener.local_addr().unwrap())], 180).await; 292 let attempt = ready.retain(1).await; 293 assert_eq!(attempt.raw_json(), ready.raw); 294 assert_eq!(attempt.work(), PublicationArtifact::Public(ready.work)); 295 assert_eq!(attempt.work().recipient(), None); 296 assert_eq!( 297 attempt.intent().event_id(), 298 ready.work.evidence().event_id() 299 ); 300 let snapshot = ready.snapshot(&ready.store).await; 301 let checkpoint = snapshot.checkpoint_digest(); 302 assert!(snapshot.installed_message().is_none()); 303 assert!(snapshot.publications().is_empty()); 304 assert_eq!(snapshot.public_publications(), &[ready.work]); 305 assert_eq!(snapshot.delivery_attempts().len(), 1); 306 assert!(!snapshot.publication_accepted(ready.work).unwrap()); 307 assert!(matches!( 308 ready 309 .store 310 .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None) 311 .await 312 .unwrap(), 313 DeliveryAttemptOutcome::Retained(_) 314 )); 315 let expected = format!("[\"EVENT\",{}]", ready.raw); 316 let server = tokio::spawn(async move { 317 let (tcp, _) = listener.accept().await.unwrap(); 318 let mut socket = accept_async(tcp).await.unwrap(); 319 let raw = tokio::time::timeout(Duration::from_secs(5), async { 320 loop { 321 if let Message::Text(raw) = socket.next().await.unwrap().unwrap() { 322 break raw; 323 } 324 } 325 }) 326 .await 327 .unwrap(); 328 assert_eq!(raw.as_str(), expected); 329 let frame: serde_json::Value = serde_json::from_str(&raw).unwrap(); 330 let event = nostr::Event::from_json(frame[1].to_string()).unwrap(); 331 event.verify().unwrap(); 332 assert_eq!(event.kind.as_u16(), 30402); 333 socket 334 .send(Message::Text( 335 json!(["OK", "ff".repeat(32), true, ""]).to_string().into(), 336 )) 337 .await 338 .unwrap(); 339 socket 340 .send(Message::Text( 341 json!(["OK", frame[1]["id"], true, ""]).to_string().into(), 342 )) 343 .await 344 .unwrap(); 345 }); 346 let transport = radroots_transport_nostr_native::create_transport(ready.config.clone()); 347 let request = attempt.transport_request().unwrap(); 348 let selected = attempt.intent().selected_target_set().unwrap(); 349 let receipt = transport 350 .deliver_selected(request.clone(), selected) 351 .await 352 .unwrap(); 353 receipt.validate_for_request(&request).unwrap(); 354 assert!(receipt.is_satisfied(&request).unwrap()); 355 server.await.unwrap(); 356 let observation = DeliveryObservation::from_receipt( 357 &attempt, 358 &receipt, 359 request.target_set().targets()[0].fingerprint(), 360 None, 361 ) 362 .unwrap(); 363 assert_eq!(observation.kind(), DeliveryObservationKind::Accepted); 364 let DeliveryObservationOutcome::Committed(first) = ready 365 .store 366 .record_delivery_observation(ready.binding.clone(), copy(&ready.proof), observation) 367 .await 368 .unwrap() 369 else { 370 panic!("actual durable ACK") 371 }; 372 let complete = ready.snapshot(&ready.store).await; 373 assert_ne!(complete.checkpoint_digest(), checkpoint); 374 assert!(complete.publication_accepted(ready.work).unwrap()); 375 assert_eq!( 376 complete.listing_installation(), 377 snapshot.listing_installation() 378 ); 379 transport.shutdown().await; 380 ready.store.close().await.unwrap(); 381 let reopened = ready.fixture.reopen(ready.input.clone()).await; 382 let retained = ready 383 .query(&reopened, attempt.intent().request_id()) 384 .await 385 .unwrap(); 386 assert_eq!(retained.raw_json(), ready.raw); 387 assert_eq!(retained.transaction_id(), attempt.transaction_id()); 388 let observations = reopened 389 .delivery_observations( 390 ready.binding.clone(), 391 ready.work.evidence().operation_id(), 392 ready.work.evidence().command_digest(), 393 SigningTarget::PublicEvent, 394 attempt.intent().request_id().clone(), 395 copy(&ready.proof), 396 ) 397 .await 398 .unwrap(); 399 assert_eq!(observations, vec![first]); 400 assert!( 401 ready 402 .snapshot(&reopened) 403 .await 404 .publication_accepted(ready.work) 405 .unwrap() 406 ); 407 reopened.close().await.unwrap(); 408 } 409 #[tokio::test] 410 async fn public_d_requires_original_targets_role_and_current_proof_before_any_claim() { 411 let ready = Ready::new(&["ws://127.0.0.1:9".into()], 181).await; 412 assert!( 413 DeliveryAttemptRequest::new( 414 ready.binding.clone(), 415 ready.work, 416 DeliveryIntent::new( 417 &"11".repeat(32), 418 ready.work.evidence().event_id(), 419 &ready.targets(), 420 &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), 421 NonZeroU64::new(now_ms() + 60_000).unwrap() 422 ) 423 .unwrap() 424 ) 425 .is_err() 426 ); 427 assert!(matches!( 428 ready 429 .store 430 .prepare_delivery_attempt( 431 ready.request(1), 432 AttachmentProof::from_protected_input(&[0; 32]).unwrap(), 433 None 434 ) 435 .await, 436 Err(OperationError::Workspace(WorkspaceError::Unauthorized)) 437 )); 438 let other = TargetSet::new(vec![ 439 radroots_transport::Target::nostr_relay("ws://127.0.0.1:10").unwrap(), 440 ]) 441 .unwrap(); 442 let request = DeliveryAttemptRequest::new( 443 ready.binding.clone(), 444 ready.work, 445 DeliveryIntent::public( 446 &"11".repeat(32), 447 ready.work.evidence().event_id(), 448 &other, 449 &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), 450 NonZeroU64::new(now_ms() + 60_000).unwrap(), 451 ) 452 .unwrap(), 453 ) 454 .unwrap(); 455 assert!(matches!( 456 ready 457 .store 458 .prepare_delivery_attempt(request, copy(&ready.proof), None) 459 .await, 460 Err(OperationError::UnverifiedApproval) 461 )); 462 assert!( 463 ready 464 .snapshot(&ready.store) 465 .await 466 .delivery_attempts() 467 .is_empty() 468 ); 469 ready.store.close().await.unwrap(); 470 } 471 #[tokio::test] 472 async fn public_retries_reuse_original_after_first_issue_expiry_and_spend_twelve_endpoint_slots() { 473 let ready = Ready::new(&["ws://127.0.0.1:9".into()], 182).await; 474 ready.fixture.clock.now.fetch_add(121, Ordering::SeqCst); 475 for id in 1..=12 { 476 let attempt = ready.retain(id).await; 477 assert_eq!(attempt.raw_json(), ready.raw); 478 assert_eq!(attempt.target_ordinals(), &[id]); 479 } 480 assert!(matches!( 481 ready 482 .store 483 .prepare_delivery_attempt(ready.request(13), copy(&ready.proof), None) 484 .await, 485 Err(OperationError::DeliveryAttemptLimit) 486 )); 487 assert!(matches!( 488 ready 489 .store 490 .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None) 491 .await 492 .unwrap(), 493 DeliveryAttemptOutcome::Retained(_) 494 )); 495 let state = ready.snapshot(&ready.store).await; 496 assert_eq!(state.delivery_attempts().len(), 12); 497 assert!(state.delivery_observations().is_empty()); 498 assert!(!state.publication_accepted(ready.work).unwrap()); 499 ready.store.close().await.unwrap(); 500 let reopened = ready.fixture.reopen(ready.input.clone()).await; 501 let state = ready.snapshot(&reopened).await; 502 assert_eq!(state.delivery_attempts().len(), 12); 503 reopened.close().await.unwrap(); 504 } 505 #[tokio::test] 506 async fn public_d_part_insert_failure_rolls_back_without_losing_installed_revision() { 507 let ready = Ready::new(&["ws://127.0.0.1:9".into()], 183).await; 508 let mut db = ready.fixture.database().await; 509 sqlx::raw_sql("CREATE TRIGGER fail_public_d BEFORE INSERT ON artifact_delivery_parts BEGIN SELECT RAISE(ABORT,'isolated fixture'); END").execute(&mut db).await.unwrap(); 510 assert!(matches!( 511 ready 512 .store 513 .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None) 514 .await, 515 Err(OperationError::StorageFailure) 516 )); 517 let state = ready.snapshot(&ready.store).await; 518 assert!(state.listing_installation().is_some()); 519 assert!(state.delivery_attempts().is_empty()); 520 sqlx::query("DROP TRIGGER fail_public_d") 521 .execute(&mut db) 522 .await 523 .unwrap(); 524 db.close().await.unwrap(); 525 let retained = ready.retain(1).await; 526 assert_eq!(retained.raw_json(), ready.raw); 527 ready.store.close().await.unwrap(); 528 } 529 #[tokio::test] 530 async fn lost_public_d_observer_never_turns_reopen_into_dispatch_permission() { 531 let ready = Ready::new(&["ws://127.0.0.1:9".into()], 184).await; 532 let (arrived, resume) = ready.fixture.clock.arm(1); 533 let mut pending = 534 ready 535 .store 536 .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None); 537 assert!(futures::poll!(pending.as_mut()).is_pending()); 538 reached(arrived).await; 539 drop(pending); 540 resume.send(()).unwrap(); 541 ready.store.close().await.unwrap(); 542 let reopened = ready.fixture.reopen(ready.input.clone()).await; 543 assert!(matches!( 544 reopened 545 .prepare_delivery_attempt(ready.request(1), copy(&ready.proof), None) 546 .await 547 .unwrap(), 548 DeliveryAttemptOutcome::Retained(_) 549 )); 550 assert_eq!(ready.snapshot(&reopened).await.delivery_attempts().len(), 1); 551 reopened.close().await.unwrap(); 552 } 553 554 #[tokio::test] 555 async fn actual_public_rejection_disconnect_and_missing_matching_ack_remain_independent() { 556 for (mode, expected) in [ 557 (0, DeliveryObservationKind::Rejected), 558 (1, DeliveryObservationKind::Disconnected), 559 (2, DeliveryObservationKind::TimedOut), 560 ] { 561 let listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); 562 let ready = Ready::new( 563 &[format!("ws://{}", listener.local_addr().unwrap())], 564 185 + mode, 565 ) 566 .await; 567 let deadline = NonZeroU64::new(now_ms() + 2_000).unwrap(); 568 let request = DeliveryAttemptRequest::new( 569 ready.binding.clone(), 570 ready.work, 571 DeliveryIntent::public( 572 &format!("{mode:02x}").repeat(32), 573 ready.work.evidence().event_id(), 574 &ready.targets(), 575 &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()), 576 deadline, 577 ) 578 .unwrap(), 579 ) 580 .unwrap(); 581 let DeliveryAttemptOutcome::Claimed(attempt) = ready 582 .store 583 .prepare_delivery_attempt(request, copy(&ready.proof), None) 584 .await 585 .unwrap() 586 else { 587 panic!("actual public D") 588 }; 589 let (release, held) = tokio::sync::oneshot::channel::<()>(); 590 let server = tokio::spawn(async move { 591 let (tcp, _) = listener.accept().await.unwrap(); 592 let mut socket = accept_async(tcp).await.unwrap(); 593 let raw = tokio::time::timeout(Duration::from_secs(5), async { 594 loop { 595 if let Message::Text(raw) = socket.next().await.unwrap().unwrap() { 596 break raw; 597 } 598 } 599 }) 600 .await 601 .unwrap(); 602 let event: serde_json::Value = serde_json::from_str(&raw).unwrap(); 603 match mode { 604 0 => socket 605 .send(Message::Text( 606 json!(["OK", event[1]["id"], false, "blocked: denied"]) 607 .to_string() 608 .into(), 609 )) 610 .await 611 .unwrap(), 612 1 => { 613 socket.close(None).await.unwrap(); 614 } 615 _ => socket 616 .send(Message::Text( 617 json!(["OK", "ff".repeat(32), true, ""]).to_string().into(), 618 )) 619 .await 620 .unwrap(), 621 } 622 let _ = held.await; 623 }); 624 let transport = radroots_transport_nostr_native::create_transport(ready.config.clone()); 625 let request = attempt.transport_request().unwrap(); 626 let target = request.target_set().targets()[0].fingerprint(); 627 let result = transport 628 .deliver_selected( 629 request.clone(), 630 attempt.intent().selected_target_set().unwrap(), 631 ) 632 .await; 633 let observation = match result { 634 Ok(receipt) => { 635 assert!(!receipt.is_satisfied(&request).unwrap()); 636 DeliveryObservation::from_receipt(&attempt, &receipt, target, None).unwrap() 637 } 638 Err(failure) => { 639 DeliveryObservation::from_failure(&attempt, &failure, target, None).unwrap() 640 } 641 }; 642 assert_eq!(observation.kind(), expected); 643 // Already obtained original target evidence remains capturable while a 644 // fresh clock/access check would refuse another operation. 645 ready.fixture.clock.now.store(0, Ordering::SeqCst); 646 assert!(matches!( 647 ready 648 .store 649 .record_delivery_observation(ready.binding.clone(), copy(&ready.proof), observation) 650 .await 651 .unwrap(), 652 DeliveryObservationOutcome::Committed(_) 653 )); 654 ready 655 .fixture 656 .clock 657 .now 658 .store(now_ms() / 1000, Ordering::SeqCst); 659 assert!( 660 !ready 661 .snapshot(&ready.store) 662 .await 663 .publication_accepted(ready.work) 664 .unwrap() 665 ); 666 let _ = release.send(()); 667 server.await.unwrap(); 668 transport.shutdown().await; 669 ready.store.close().await.unwrap(); 670 } 671 } 672 #[tokio::test] 673 async fn unknown_public_d_commit_requires_safe_reopen_and_never_reports_a_dispatch_right() { 674 let ready = Ready::new(&["ws://127.0.0.1:9".into()], 188).await; 675 let mut db = ready.fixture.database().await; 676 sqlx::raw_sql("CREATE TABLE deferred_d_fault(value INTEGER REFERENCES workspace_grant(singleton) DEFERRABLE INITIALLY DEFERRED); CREATE TRIGGER fail_public_d_commit AFTER INSERT ON artifact_delivery_attempts BEGIN INSERT INTO deferred_d_fault VALUES(2); END").execute(&mut db).await.unwrap(); 677 let request = ready.request(1); 678 let id = request.intent().request_id().clone(); 679 let DeliveryAttemptOutcome::Unknown { operation, attempt } = ready 680 .store 681 .prepare_delivery_attempt(request, copy(&ready.proof), None) 682 .await 683 .unwrap() 684 else { 685 panic!("actual failed COMMIT must be unknown") 686 }; 687 assert_eq!(attempt, id); 688 assert_eq!( 689 operation.operation_id(), 690 ready.work.evidence().operation_id() 691 ); 692 assert!(operation.transaction_id().is_some()); 693 assert!(matches!( 694 ready 695 .store 696 .prepare_delivery_attempt(ready.request(2), copy(&ready.proof), None) 697 .await, 698 Err(OperationError::RecoveryRequired) 699 )); 700 ready.store.close().await.unwrap(); 701 sqlx::raw_sql("DROP TRIGGER fail_public_d_commit; DROP TABLE deferred_d_fault") 702 .execute(&mut db) 703 .await 704 .unwrap(); 705 db.close().await.unwrap(); 706 let reopened = ready.fixture.reopen(ready.input.clone()).await; 707 assert!(ready.query(&reopened, &id).await.is_none()); 708 let state = ready.snapshot(&reopened).await; 709 assert!(state.delivery_attempts().is_empty()); 710 assert!(state.listing_installation().is_some()); 711 assert!(!state.publication_accepted(ready.work).unwrap()); 712 reopened.close().await.unwrap(); 713 } 714 #[tokio::test] 715 async fn current_public_scope_and_original_policy_cannot_be_replaced_by_a_new_attempt() { 716 let ready = Ready::new(&["ws://127.0.0.1:9".into()], 189).await; 717 let original = ready.retain(1).await; 718 let changed = DeliveryAttemptRequest::new( 719 ready.binding.clone(), 720 ready.work, 721 DeliveryIntent::public( 722 &"02".repeat(32), 723 ready.work.evidence().event_id(), 724 &ready.targets(), 725 &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::any()), 726 NonZeroU64::new(now_ms() + 60_000).unwrap(), 727 ) 728 .unwrap(), 729 ) 730 .unwrap(); 731 assert!(matches!( 732 ready 733 .store 734 .prepare_delivery_attempt(changed, copy(&ready.proof), None) 735 .await, 736 Err(OperationError::IdempotencyConflict) 737 )); 738 ready 739 .store 740 .revoke(ready.input.clone(), &ready.proof) 741 .await 742 .unwrap(); 743 assert!(matches!( 744 ready 745 .store 746 .prepare_delivery_attempt(ready.request(2), copy(&ready.proof), None) 747 .await, 748 Err(OperationError::Workspace(WorkspaceError::GrantRevoked)) 749 )); 750 assert_eq!(original.raw_json(), ready.raw); 751 ready.store.close().await.unwrap(); 752 }