lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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 }