delivery_contract.rs (23900B)
1 use radroots_event::{SignedEvent, wire::v1::Nip01EventWire}; 2 use radroots_transport::{ 3 DeliveryReceipt, DeliveryRequest, Error, SinkFailure, Target, TargetSet, 4 outcome::{DeliveryOutcome, DeliveryOutcomeKind, Retryability}, 5 policy::{ 6 SatisfactionClass, SatisfactionPolicy, SatisfactionState, TargetPolicy, 7 evaluate_satisfaction, 8 }, 9 sink::{DeliveryPayload, DeliveryTargetReceipt}, 10 }; 11 12 fn payload() -> DeliveryPayload { 13 let raw = r#"{"id":"56bfc78223bb2221bad82b539efdec1ade0f56d0eb0e1f592fd387df4b2ceee0","pubkey":"585591529da0bab31b3b1b1f986611cf5f435dca84f978c89ee8a40cca7103df","created_at":1700000001,"kind":0,"tags":[],"content":"{}","sig":"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"}"#; 14 let wire = Nip01EventWire::parse_json(raw).expect("wire event"); 15 DeliveryPayload::new( 16 SignedEvent::from_wire_verified_id(wire, raw).expect("signed delivery event"), 17 ) 18 } 19 20 fn targets() -> TargetSet { 21 TargetSet::new(vec![ 22 Target::nostr_relay("wss://one.example").expect("first"), 23 Target::nostr_relay("wss://two.example").expect("second"), 24 Target::nostr_relay("wss://three.example").expect("third"), 25 ]) 26 .expect("targets") 27 } 28 29 fn request(policy: SatisfactionPolicy) -> DeliveryRequest { 30 DeliveryRequest::new( 31 "delivery-request", 32 payload(), 33 targets(), 34 policy, 35 1_700_000_100_000, 36 ) 37 .expect("delivery request") 38 } 39 40 fn mixed_receipt(request: &DeliveryRequest) -> DeliveryReceipt { 41 let targets = request.target_set().targets(); 42 DeliveryReceipt::for_request( 43 request, 44 vec![ 45 DeliveryTargetReceipt::attempted( 46 targets[2].clone(), 47 DeliveryOutcome::unavailable() 48 .with_detail("offline", "relay unavailable") 49 .expect("normalized detail"), 50 ), 51 DeliveryTargetReceipt::attempted(targets[0].clone(), DeliveryOutcome::delivered()), 52 DeliveryTargetReceipt::attempted(targets[1].clone(), DeliveryOutcome::accepted()), 53 ], 54 ) 55 .expect("mixed receipt") 56 } 57 58 fn different_payload_with_same_request_scope(original: &DeliveryRequest) -> DeliveryRequest { 59 let mut wire = Nip01EventWire::parse_json(original.payload().event().raw_json()).unwrap(); 60 wire.content = "different exact event".into(); 61 wire.id = wire.computed_event_id().unwrap().to_string(); 62 let raw = serde_json::to_string(&wire).unwrap(); 63 let event = SignedEvent::from_wire_verified_id(wire, raw).unwrap(); 64 DeliveryRequest::new( 65 original.request_id().as_str(), 66 DeliveryPayload::new(event), 67 original.target_set().clone(), 68 original.satisfaction().clone(), 69 original.deadline_unix_ms(), 70 ) 71 .unwrap() 72 } 73 74 #[test] 75 fn receipt_scope_includes_the_exact_payload_even_when_request_id_and_targets_match() { 76 let original = request(SatisfactionPolicy::new( 77 SatisfactionClass::Accepted, 78 TargetPolicy::all(), 79 )); 80 let different = different_payload_with_same_request_scope(&original); 81 let receipt = mixed_receipt(&original); 82 receipt.validate_for_request(&original).unwrap(); 83 assert!(receipt.validate_for_request(&different).is_err()); 84 } 85 86 #[test] 87 fn partial_failure_scope_includes_the_exact_payload() { 88 let original = request(SatisfactionPolicy::new( 89 SatisfactionClass::Accepted, 90 TargetPolicy::all(), 91 )); 92 let different = different_payload_with_same_request_scope(&original); 93 let failure = SinkFailure::for_request( 94 &original, 95 "partial", 96 Retryability::Retryable, 97 None, 98 None, 99 vec![DeliveryTargetReceipt::attempted( 100 original.target_set().targets()[0].clone(), 101 DeliveryOutcome::accepted(), 102 )], 103 ) 104 .unwrap(); 105 failure.validate_for_request(&original).unwrap(); 106 assert!(failure.validate_for_request(&different).is_err()); 107 } 108 109 #[test] 110 fn receipt_scope_preserves_exact_representation_and_serialized_binding() { 111 let original = request(SatisfactionPolicy::new( 112 SatisfactionClass::Accepted, 113 TargetPolicy::all(), 114 )); 115 let raw = format!(" \n{}\n", original.payload().event().raw_json()); 116 let wire = Nip01EventWire::parse_json(&raw).unwrap(); 117 let event = SignedEvent::from_wire_verified_id(wire, raw).unwrap(); 118 let changed = DeliveryRequest::new( 119 original.request_id().as_str(), 120 DeliveryPayload::new(event), 121 original.target_set().clone(), 122 original.satisfaction().clone(), 123 original.deadline_unix_ms(), 124 ) 125 .unwrap(); 126 assert_eq!( 127 original.payload().event().envelope().id(), 128 changed.payload().event().envelope().id() 129 ); 130 let receipt = mixed_receipt(&original); 131 assert_eq!( 132 receipt.validate_for_request(&changed), 133 Err(Error::DeliveryReceiptPayloadMismatch) 134 ); 135 let failure = SinkFailure::transport_closed(&original); 136 assert_eq!( 137 failure.validate_for_request(&changed), 138 Err(Error::DeliveryReceiptPayloadMismatch) 139 ); 140 #[cfg(feature = "serde")] 141 { 142 let mut value = serde_json::to_value(&receipt).unwrap(); 143 value 144 .as_object_mut() 145 .unwrap() 146 .remove("exact_payload_sha256"); 147 assert!(serde_json::from_value::<DeliveryReceipt>(value).is_err()); 148 let mut digest_only = serde_json::to_value(&original).unwrap(); 149 digest_only.as_object_mut().unwrap().remove("payload"); 150 digest_only["exact_payload_sha256"] = 151 serde_json::to_value(&receipt).unwrap()["exact_payload_sha256"].clone(); 152 assert!(serde_json::from_value::<DeliveryRequest>(digest_only).is_err()); 153 let mut value = serde_json::to_value(&failure).unwrap(); 154 let original_byte = value["exact_payload_sha256"][0].as_u64().unwrap(); 155 value["exact_payload_sha256"][0] = serde_json::json!(original_byte ^ 1); 156 let altered: SinkFailure = serde_json::from_value(value).unwrap(); 157 assert_eq!( 158 altered.validate_for_request(&original), 159 Err(Error::DeliveryReceiptPayloadMismatch) 160 ); 161 } 162 } 163 164 #[test] 165 fn target_selection_is_exact_and_default_adapter_never_widens_it() { 166 use radroots_transport::{BoxFuture, EventSink, SinkStatus}; 167 use std::sync::atomic::{AtomicUsize, Ordering}; 168 struct Sink(AtomicUsize); 169 impl EventSink for Sink { 170 fn status(&self) -> BoxFuture<'_, Result<SinkStatus, Error>> { 171 Box::pin(async { panic!("no status probe") }) 172 } 173 fn deliver( 174 &self, 175 request: DeliveryRequest, 176 ) -> BoxFuture<'_, Result<DeliveryReceipt, SinkFailure>> { 177 Box::pin(async move { 178 self.0.fetch_add(1, Ordering::SeqCst); 179 Ok(mixed_receipt(&request)) 180 }) 181 } 182 } 183 let sink = Sink(AtomicUsize::new(0)); 184 let request = request(SatisfactionPolicy::new( 185 SatisfactionClass::Accepted, 186 TargetPolicy::all(), 187 )); 188 let original = request.clone(); 189 let labelled = Target::new_with_metadata( 190 radroots_transport::TransportId::NOSTR, 191 "wss://one.example", 192 None, 193 Some(radroots_transport::target::TargetLabel::parse("changed label").unwrap()), 194 ) 195 .unwrap(); 196 assert_eq!( 197 labelled.fingerprint(), 198 request.target_set().targets()[0].fingerprint() 199 ); 200 assert_eq!( 201 request.validate_target_selection(&TargetSet::new(vec![labelled]).unwrap()), 202 Err(Error::InvalidDeliveryTargetSelection) 203 ); 204 let subset = TargetSet::new(vec![request.target_set().targets()[0].clone()]).unwrap(); 205 request.validate_target_selection(&subset).unwrap(); 206 let unsupported = 207 futures::executor::block_on(sink.deliver_selected(request.clone(), subset)).unwrap_err(); 208 unsupported.validate_for_request(&request).unwrap(); 209 assert_eq!(unsupported.code(), "target_selection_unsupported"); 210 let foreign = 211 TargetSet::new(vec![Target::nostr_relay("wss://foreign.example").unwrap()]).unwrap(); 212 assert_eq!( 213 request.validate_target_selection(&foreign), 214 Err(Error::InvalidDeliveryTargetSelection) 215 ); 216 assert_eq!( 217 Error::InvalidDeliveryTargetSelection.to_string(), 218 "transport delivery target selection is not an exact subset" 219 ); 220 let invalid = 221 futures::executor::block_on(sink.deliver_selected(request.clone(), foreign)).unwrap_err(); 222 invalid.validate_for_request(&request).unwrap(); 223 assert_eq!(invalid.code(), "invalid_transport_contract"); 224 assert_eq!(sink.0.load(Ordering::SeqCst), 0); 225 let mut reversed = request.target_set().targets().to_vec(); 226 reversed.reverse(); 227 let receipt = futures::executor::block_on( 228 sink.deliver_selected(request.clone(), TargetSet::new(reversed).unwrap()), 229 ) 230 .unwrap(); 231 receipt.validate_for_request(&request).unwrap(); 232 assert_eq!(sink.0.load(Ordering::SeqCst), 1); 233 assert_eq!(request, original); 234 } 235 236 #[test] 237 fn any_all_quorum_and_required_targets_are_exact() { 238 let any = request(SatisfactionPolicy::new( 239 SatisfactionClass::Accepted, 240 TargetPolicy::any(), 241 )); 242 assert!(mixed_receipt(&any).is_satisfied(&any).expect("any")); 243 244 let all = request(SatisfactionPolicy::new( 245 SatisfactionClass::Accepted, 246 TargetPolicy::all(), 247 )); 248 assert!(!mixed_receipt(&all).is_satisfied(&all).expect("all")); 249 250 let quorum = request(SatisfactionPolicy::new( 251 SatisfactionClass::Accepted, 252 TargetPolicy::quorum(2).expect("quorum"), 253 )); 254 assert!( 255 mixed_receipt(&quorum) 256 .is_satisfied(&quorum) 257 .expect("quorum") 258 ); 259 260 let delivered = request(SatisfactionPolicy::new( 261 SatisfactionClass::Delivered, 262 TargetPolicy::quorum(2).expect("quorum"), 263 )); 264 assert!( 265 !mixed_receipt(&delivered) 266 .is_satisfied(&delivered) 267 .expect("delivered quorum") 268 ); 269 270 let selected = targets(); 271 let required = TargetPolicy::required(vec![ 272 selected.targets()[0].fingerprint().clone(), 273 selected.targets()[1].fingerprint().clone(), 274 ]) 275 .expect("required targets"); 276 let required_request = request(SatisfactionPolicy::new( 277 SatisfactionClass::Accepted, 278 required, 279 )); 280 assert!( 281 mixed_receipt(&required_request) 282 .is_satisfied(&required_request) 283 .expect("required") 284 ); 285 286 let unsatisfied = TargetPolicy::required(vec![ 287 selected.targets()[0].fingerprint().clone(), 288 selected.targets()[2].fingerprint().clone(), 289 ]) 290 .expect("required targets"); 291 let unsatisfied_request = request(SatisfactionPolicy::new( 292 SatisfactionClass::Accepted, 293 unsatisfied, 294 )); 295 assert!( 296 !mixed_receipt(&unsatisfied_request) 297 .is_satisfied(&unsatisfied_request) 298 .expect("required unsatisfied") 299 ); 300 } 301 302 #[test] 303 fn policies_and_requests_reject_empty_duplicate_and_impossible_inputs() { 304 assert_eq!( 305 TargetPolicy::quorum(0).expect_err("zero quorum"), 306 Error::InvalidSatisfactionPolicy 307 ); 308 assert_eq!( 309 TargetPolicy::required(Vec::new()).expect_err("empty required"), 310 Error::EmptyRequiredTargetSet 311 ); 312 let set = targets(); 313 let duplicate = set.targets()[0].fingerprint().clone(); 314 assert_eq!( 315 TargetPolicy::required(vec![duplicate.clone(), duplicate]).expect_err("duplicate required"), 316 Error::DuplicateRequiredTargetFingerprint 317 ); 318 assert_eq!( 319 DeliveryRequest::new( 320 "request", 321 payload(), 322 set.clone(), 323 SatisfactionPolicy::new( 324 SatisfactionClass::Accepted, 325 TargetPolicy::quorum(4).expect("nonzero quorum"), 326 ), 327 1, 328 ) 329 .expect_err("impossible quorum"), 330 Error::InvalidSatisfactionPolicy 331 ); 332 assert_eq!( 333 DeliveryRequest::new( 334 "", 335 payload(), 336 set.clone(), 337 SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::any()), 338 1, 339 ) 340 .expect_err("empty id"), 341 Error::EmptyDeliveryRequestId 342 ); 343 assert_eq!( 344 DeliveryRequest::new( 345 "request", 346 payload(), 347 set, 348 SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::any()), 349 0, 350 ) 351 .expect_err("zero deadline"), 352 Error::InvalidDeliveryDeadline 353 ); 354 assert_eq!( 355 TargetSet::new(Vec::new()).expect_err("empty target set"), 356 Error::EmptyTargetSet 357 ); 358 } 359 360 #[test] 361 fn receipts_reject_duplicate_missing_unexpected_and_false_attempts() { 362 let request = request(SatisfactionPolicy::new( 363 SatisfactionClass::Accepted, 364 TargetPolicy::all(), 365 )); 366 let first = request.target_set().targets()[0].clone(); 367 let second = request.target_set().targets()[1].clone(); 368 let third = request.target_set().targets()[2].clone(); 369 let accepted = DeliveryTargetReceipt::attempted(first.clone(), DeliveryOutcome::accepted()); 370 assert_eq!( 371 DeliveryTargetReceipt::skipped(first.clone(), DeliveryOutcome::accepted()) 372 .expect_err("unattempted success"), 373 Error::DeliveryTargetReceiptAttemptMismatch 374 ); 375 assert_eq!( 376 DeliveryReceipt::for_request(&request, vec![accepted.clone(), accepted]) 377 .expect_err("duplicate receipt"), 378 Error::DuplicateDeliveryTargetReceipt 379 ); 380 assert_eq!( 381 DeliveryReceipt::for_request( 382 &request, 383 vec![ 384 DeliveryTargetReceipt::attempted(first, DeliveryOutcome::accepted()), 385 DeliveryTargetReceipt::attempted(second, DeliveryOutcome::accepted()), 386 ], 387 ) 388 .expect_err("missing receipt"), 389 Error::MissingDeliveryTargetReceipt 390 ); 391 let foreign = Target::nostr_relay("wss://foreign.example").expect("foreign"); 392 assert_eq!( 393 DeliveryReceipt::for_request( 394 &request, 395 vec![ 396 DeliveryTargetReceipt::attempted(foreign, DeliveryOutcome::accepted()), 397 DeliveryTargetReceipt::attempted(third, DeliveryOutcome::accepted()), 398 ], 399 ) 400 .expect_err("unexpected receipt"), 401 Error::UnexpectedDeliveryTargetReceipt 402 ); 403 } 404 405 #[test] 406 fn retryability_and_terminality_are_explicit_normalized_data() { 407 let unavailable = DeliveryOutcome::unavailable(); 408 assert_eq!(unavailable.kind(), DeliveryOutcomeKind::Unavailable); 409 assert_eq!(unavailable.retryability(), Retryability::Retryable); 410 assert!(unavailable.is_retryable()); 411 assert!(!unavailable.is_terminal()); 412 413 let rejected = DeliveryOutcome::rejected(); 414 assert!(rejected.is_terminal()); 415 assert!(!rejected.is_retryable()); 416 assert_eq!( 417 DeliveryOutcome::failed(Retryability::NotApplicable).expect_err("unclassified failure"), 418 Error::InvalidDeliveryOutcome 419 ); 420 assert!( 421 DeliveryOutcome::failed(Retryability::Retryable) 422 .expect("retryable failure") 423 .is_retryable() 424 ); 425 assert!( 426 DeliveryOutcome::failed(Retryability::Terminal) 427 .expect("terminal failure") 428 .is_terminal() 429 ); 430 assert_eq!( 431 DeliveryOutcome::unavailable() 432 .with_detail("INVALID", "relay unavailable") 433 .expect_err("invalid code"), 434 Error::InvalidDeliveryOutcome 435 ); 436 } 437 438 #[test] 439 fn canonical_evaluator_covers_pending_exhausted_and_historical_evidence() { 440 let set = targets(); 441 let policy = SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()); 442 assert_eq!( 443 evaluate_satisfaction(&policy, &set, core::iter::empty()).expect("empty evidence"), 444 SatisfactionState::Pending 445 ); 446 447 let first = set.targets()[0].fingerprint(); 448 let second = set.targets()[1].fingerprint(); 449 let third = set.targets()[2].fingerprint(); 450 let accepted = DeliveryOutcome::accepted(); 451 let terminal = DeliveryOutcome::rejected(); 452 let retryable = DeliveryOutcome::unavailable(); 453 assert_eq!( 454 evaluate_satisfaction( 455 &policy, 456 &set, 457 [(first, &accepted), (second, &terminal), (third, &retryable),], 458 ) 459 .expect("mixed evidence"), 460 SatisfactionState::Exhausted 461 ); 462 assert_eq!( 463 evaluate_satisfaction( 464 &policy, 465 &set, 466 [ 467 (first, &accepted), 468 (second, &accepted), 469 (third, &accepted), 470 (first, &terminal), 471 ], 472 ) 473 .expect("historical success"), 474 SatisfactionState::Satisfied 475 ); 476 477 let foreign = Target::nostr_relay("wss://foreign.example").expect("foreign"); 478 assert_eq!( 479 evaluate_satisfaction(&policy, &set, [(foreign.fingerprint(), &accepted)]) 480 .expect_err("foreign evidence"), 481 Error::UnexpectedDeliveryTargetReceipt 482 ); 483 } 484 485 #[test] 486 fn policy_introspection_validation_and_wire_variants_are_complete() { 487 let set = targets(); 488 let any = TargetPolicy::any(); 489 assert!(any.is_any()); 490 assert!(!any.is_all()); 491 assert_eq!(any.quorum_threshold(), None); 492 assert_eq!(any.required_targets(), None); 493 494 let all = TargetPolicy::all(); 495 assert!(!all.is_any()); 496 assert!(all.is_all()); 497 assert_eq!(all.quorum_threshold(), None); 498 assert_eq!(all.required_targets(), None); 499 500 let quorum = TargetPolicy::quorum(2).expect("quorum"); 501 assert!(!quorum.is_any()); 502 assert!(!quorum.is_all()); 503 assert_eq!(quorum.quorum_threshold(), Some(2)); 504 assert_eq!(quorum.required_targets(), None); 505 506 let fingerprint = set.targets()[0].fingerprint().clone(); 507 let required = TargetPolicy::required(vec![fingerprint.clone()]).expect("required"); 508 assert!(!required.is_any()); 509 assert!(!required.is_all()); 510 assert_eq!(required.quorum_threshold(), None); 511 assert_eq!( 512 required.required_targets(), 513 Some(core::slice::from_ref(&fingerprint)) 514 ); 515 516 let policy = SatisfactionPolicy::new(SatisfactionClass::Delivered, required); 517 assert_eq!(policy.class(), SatisfactionClass::Delivered); 518 assert_eq!( 519 policy.targets().required_targets(), 520 Some(core::slice::from_ref(&fingerprint)) 521 ); 522 policy 523 .validate_for(&set) 524 .expect("required target is requested"); 525 526 let foreign = Target::nostr_relay("wss://foreign.example").expect("foreign"); 527 let impossible = SatisfactionPolicy::new( 528 SatisfactionClass::Accepted, 529 TargetPolicy::required(vec![foreign.fingerprint().clone()]).expect("required"), 530 ); 531 assert_eq!( 532 impossible.validate_for(&set).unwrap_err(), 533 Error::RequiredTargetNotRequested 534 ); 535 536 #[cfg(feature = "serde")] 537 for (wire, assertion) in [ 538 (serde_json::json!("any"), 0_u8), 539 (serde_json::json!("all"), 1), 540 (serde_json::json!({"quorum": 2}), 2), 541 (serde_json::json!({"required": [fingerprint.as_str()]}), 3), 542 ] { 543 let decoded: TargetPolicy = serde_json::from_value(wire).expect("target policy"); 544 match assertion { 545 0 => assert!(decoded.is_any()), 546 1 => assert!(decoded.is_all()), 547 2 => assert_eq!(decoded.quorum_threshold(), Some(2)), 548 3 => assert_eq!( 549 decoded.required_targets(), 550 Some(core::slice::from_ref(&fingerprint)) 551 ), 552 _ => unreachable!(), 553 } 554 } 555 556 #[cfg(feature = "serde")] 557 for invalid in [ 558 serde_json::json!({"quorum": 0}), 559 serde_json::json!({"required": []}), 560 serde_json::json!({"required": [fingerprint.as_str(), fingerprint.as_str()]}), 561 ] { 562 assert!(serde_json::from_value::<TargetPolicy>(invalid).is_err()); 563 } 564 } 565 566 #[test] 567 fn sink_failures_retain_validated_retry_timing_and_partial_evidence() { 568 let request = request(SatisfactionPolicy::new( 569 SatisfactionClass::Accepted, 570 TargetPolicy::all(), 571 )); 572 let partial = DeliveryTargetReceipt::attempted( 573 request.target_set().targets()[0].clone(), 574 DeliveryOutcome::accepted(), 575 ); 576 let failure = SinkFailure::for_request( 577 &request, 578 "relay_batch_unavailable", 579 Retryability::Retryable, 580 Some(1_700_000_200_000), 581 Some("relay batch unavailable".to_owned()), 582 vec![partial.clone()], 583 ) 584 .expect("sink failure"); 585 assert_eq!(failure.code(), "relay_batch_unavailable"); 586 assert_eq!(failure.retryability(), Retryability::Retryable); 587 assert_eq!(failure.retry_after_unix_ms(), Some(1_700_000_200_000)); 588 assert_eq!(failure.message(), Some("relay batch unavailable")); 589 assert_eq!(failure.partial_evidence(), core::slice::from_ref(&partial)); 590 assert_eq!( 591 SinkFailure::for_request( 592 &request, 593 "terminal_failure", 594 Retryability::Terminal, 595 Some(1), 596 None, 597 Vec::new(), 598 ) 599 .expect_err("terminal retry timing"), 600 Error::InvalidDeliveryOutcome 601 ); 602 assert_eq!( 603 SinkFailure::for_request( 604 &request, 605 "invalid_retry_time", 606 Retryability::Retryable, 607 Some(0), 608 None, 609 Vec::new(), 610 ) 611 .expect_err("zero retry timing"), 612 Error::InvalidDeliveryOutcome 613 ); 614 assert_eq!( 615 SinkFailure::for_request( 616 &request, 617 "duplicate_evidence", 618 Retryability::Retryable, 619 None, 620 None, 621 vec![partial.clone(), partial], 622 ) 623 .expect_err("duplicate evidence"), 624 Error::DuplicateDeliveryTargetReceipt 625 ); 626 } 627 628 #[test] 629 #[cfg(feature = "serde")] 630 fn serde_revalidates_policy_outcome_and_receipt_invariants() { 631 let request = request(SatisfactionPolicy::new( 632 SatisfactionClass::Accepted, 633 TargetPolicy::all(), 634 )); 635 let receipt = mixed_receipt(&request); 636 let encoded_request = serde_json::to_string(&request).expect("request json"); 637 assert_eq!( 638 serde_json::from_str::<DeliveryRequest>(&encoded_request).expect("request round trip"), 639 request 640 ); 641 let encoded_receipt = serde_json::to_string(&receipt).expect("receipt json"); 642 assert_eq!( 643 serde_json::from_str::<DeliveryReceipt>(&encoded_receipt).expect("receipt round trip"), 644 receipt 645 ); 646 647 let mut forged_outcome = 648 serde_json::to_value(DeliveryOutcome::accepted()).expect("outcome value"); 649 forged_outcome["retryability"] = serde_json::json!("retryable"); 650 assert!(serde_json::from_value::<DeliveryOutcome>(forged_outcome).is_err()); 651 652 let mut forged_attempt = serde_json::to_value(&receipt).expect("receipt value"); 653 forged_attempt["target_receipts"][0]["attempted"] = false.into(); 654 assert!(serde_json::from_value::<DeliveryReceipt>(forged_attempt).is_err()); 655 656 let mut missing = serde_json::to_value(&receipt).expect("receipt value"); 657 missing["target_receipts"] 658 .as_array_mut() 659 .expect("receipts array") 660 .pop(); 661 assert!(serde_json::from_value::<DeliveryReceipt>(missing).is_err()); 662 663 let failure = SinkFailure::for_request( 664 &request, 665 "relay_unavailable", 666 Retryability::Retryable, 667 Some(1_700_000_200_000), 668 None, 669 vec![receipt.target_receipts()[0].clone()], 670 ) 671 .expect("sink failure"); 672 let encoded_failure = serde_json::to_string(&failure).expect("failure json"); 673 assert_eq!( 674 serde_json::from_str::<SinkFailure>(&encoded_failure).expect("failure round trip"), 675 failure 676 ); 677 }