lib

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

inventory_delivery.rs (13550B)


      1 //! Synthetic report shape only; actual stock linkage is a native-store duty.
      2 use super::*;
      3 use radroots_storage::{
      4     command::{DeliveryIntent, DeliveryObservationKind},
      5     inventory::{
      6         StockDeliveryObservationPage, StockDeliveryRequest, StockDeliverySummary,
      7         StockDeliveryTargetProgress, StockRewrapAdmission, StockRewrapPage, StockRewrapRequest,
      8         StockRewrapState,
      9     },
     10 };
     11 use radroots_transport::{
     12     Target, TargetSet,
     13     policy::{SatisfactionClass, SatisfactionPolicy, TargetPolicy},
     14 };
     15 
     16 fn fixture() -> (StockEnvelopeRequest, StockEnvelopeReceipt, DeliveryIntent) {
     17     let original = attempt(1, 7, 8, true);
     18     let request = StockEnvelopeRequest::new(
     19         binding(WorkspaceScope::SellerStockOwner),
     20         checkpoint(0),
     21         original.operation_id(),
     22         original.command_digest(),
     23         key(),
     24         None,
     25     )
     26     .unwrap();
     27     let source = StockEnvelopeReceipt::from_committed_store(
     28         &request,
     29         original,
     30         evidence(original, key()),
     31         TransactionId::from_bytes([12; 32]),
     32         EnvelopeEventId::from_bytes([14; 32]),
     33         [15; 32],
     34         checkpoint(1),
     35     )
     36     .unwrap();
     37     let targets = TargetSet::new(vec![
     38         Target::nostr_relay("wss://one.example").unwrap(),
     39         Target::nostr_relay("wss://two.example").unwrap(),
     40     ])
     41     .unwrap();
     42     let intent = DeliveryIntent::new(
     43         &"a".repeat(64),
     44         source.event_id(),
     45         &targets,
     46         &SatisfactionPolicy::new(SatisfactionClass::Accepted, TargetPolicy::all()),
     47         core::num::NonZeroU64::new(300000).unwrap(),
     48     )
     49     .unwrap();
     50     (request, source, intent)
     51 }
     52 fn admission(
     53     request: &StockEnvelopeRequest,
     54     original: StockEnvelopeReceipt,
     55     index: u8,
     56 ) -> StockRewrapAdmission {
     57     StockRewrapAdmission::from_store_report(
     58         &StockRewrapRequest::new(
     59             StockEnvelopeRequest::new(
     60                 request.binding().clone(),
     61                 request.minimum_checkpoint(),
     62                 request.operation_id(),
     63                 request.command_digest(),
     64                 request.recipient(),
     65                 None,
     66             )
     67             .unwrap(),
     68             OperationId::from_bytes([index + 1; 32]),
     69         ),
     70         original,
     71         TransactionId::from_bytes([index + 128; 32]),
     72         radroots_domain::UnixSeconds::new(150).unwrap(),
     73         radroots_domain::UnixSeconds::new(180).unwrap(),
     74         checkpoint(u64::from(index) + 2),
     75     )
     76     .unwrap()
     77 }
     78 fn rewrapped(
     79     request: &StockEnvelopeRequest,
     80     original: StockEnvelopeReceipt,
     81     index: u8,
     82 ) -> StockEnvelopeReceipt {
     83     let event = EnvelopeEventId::from_bytes([index + 64; 32]);
     84     let selected = StockEnvelopeRequest::new(
     85         request.binding().clone(),
     86         request.minimum_checkpoint(),
     87         request.operation_id(),
     88         request.command_digest(),
     89         request.recipient(),
     90         None,
     91     )
     92     .unwrap()
     93     .with_envelope(event);
     94     StockEnvelopeReceipt::from_committed_store(
     95         &selected,
     96         radroots_storage::command::CommitAttempt::new(
     97             original.attempt().workspace_id(),
     98             original.attempt().operation_id(),
     99             original.attempt().command_digest(),
    100             Some(TransactionId::from_bytes([index + 32; 32])),
    101         ),
    102         original.evidence(),
    103         original.installation_transaction_id(),
    104         event,
    105         [index + 96; 32],
    106         checkpoint(u64::from(index) + 3),
    107     )
    108     .unwrap()
    109     .with_rewrap_admission(&admission(request, original, index))
    110     .unwrap()
    111 }
    112 
    113 #[test]
    114 fn selected_envelope_retains_a_separate_first_policy_source_without_weakening_original_reports() {
    115     let (request, original, intent) = fixture();
    116     let new = rewrapped(&request, original, 1);
    117     let selected = StockEnvelopeRequest::new(
    118         request.binding().clone(),
    119         request.minimum_checkpoint(),
    120         request.operation_id(),
    121         request.command_digest(),
    122         request.recipient(),
    123         None,
    124     )
    125     .unwrap()
    126     .with_envelope(new.event_id());
    127     assert!(
    128         StockDeliverySummary::from_store_report(
    129             &selected,
    130             Some(new),
    131             Some(intent.clone()),
    132             1,
    133             progress(&intent, &[false, false]),
    134             checkpoint(4)
    135         )
    136         .is_err()
    137     );
    138     let summary = StockDeliverySummary::from_store_report_with_policy_source(
    139         &selected,
    140         Some(new),
    141         Some(original),
    142         Some(intent.clone()),
    143         1,
    144         1,
    145         progress(&intent, &[false, false]),
    146         checkpoint(4),
    147     )
    148     .unwrap();
    149     assert_eq!(summary.source(), Some(new));
    150     assert_eq!(summary.publication_policy_source(), Some(original));
    151     assert_eq!(summary.original_intent(), Some(&intent));
    152     assert!(!summary.acceptance_satisfied().unwrap());
    153     let wrong_policy = rewrapped(&request, original, 2);
    154     assert!(
    155         StockDeliverySummary::from_store_report_with_policy_source(
    156             &selected,
    157             Some(new),
    158             Some(wrong_policy),
    159             Some(intent.clone()),
    160             1,
    161             1,
    162             progress(&intent, &[false, false]),
    163             checkpoint(5)
    164         )
    165         .is_err()
    166     );
    167     assert!(
    168         StockDeliveryRequest::new(
    169             request.binding().clone(),
    170             request.minimum_checkpoint(),
    171             request.operation_id(),
    172             request.command_digest(),
    173             request.recipient(),
    174             intent
    175         )
    176         .unwrap()
    177         .with_envelope(new.event_id())
    178         .is_err()
    179     );
    180 }
    181 
    182 #[test]
    183 fn additional_envelope_pages_reject_duplicate_identities_oversized_pages_and_false_cursors() {
    184     let (request, original, _) = fixture();
    185     let entries = (0..16)
    186         .map(|index| {
    187             StockRewrapState::from_store_report(
    188                 admission(&request, original, index),
    189                 Some(rewrapped(&request, original, index)),
    190             )
    191             .unwrap()
    192         })
    193         .collect::<Vec<_>>();
    194     let cursor = entries[15].admission().checkpoint().revision();
    195     let page = StockRewrapPage::from_store_report(&request, entries.clone(), true, checkpoint(18))
    196         .unwrap();
    197     assert_eq!(page.entries(), entries.as_slice());
    198     assert_eq!(page.next_after(), Some(cursor));
    199     assert_eq!(page.checkpoint(), checkpoint(18));
    200     assert!(
    201         StockRewrapPage::from_store_report(
    202             &request,
    203             vec![entries[0], entries[0]],
    204             false,
    205             checkpoint(18)
    206         )
    207         .is_err()
    208     );
    209     assert!(
    210         StockRewrapPage::from_store_report(
    211             &request,
    212             (0..17)
    213                 .map(|index| StockRewrapState::from_store_report(
    214                     admission(&request, original, index),
    215                     Some(rewrapped(&request, original, index))
    216                 )
    217                 .unwrap())
    218                 .collect(),
    219             false,
    220             checkpoint(19)
    221         )
    222         .is_err()
    223     );
    224     assert!(
    225         StockRewrapPage::from_store_report(&request, entries.clone(), false, checkpoint(1))
    226             .is_err()
    227     );
    228     assert!(
    229         StockRewrapPage::from_store_report(&request, vec![entries[0]], true, checkpoint(18))
    230             .is_err()
    231     );
    232 }
    233 fn progress(intent: &DeliveryIntent, accepted: &[bool; 2]) -> Vec<StockDeliveryTargetProgress> {
    234     intent
    235         .targets()
    236         .targets()
    237         .iter()
    238         .zip(accepted)
    239         .map(|(target, accepted)| {
    240             StockDeliveryTargetProgress::from_store_report(
    241                 target.fingerprint().clone(),
    242                 1,
    243                 *accepted,
    244                 Some(if *accepted {
    245                     DeliveryObservationKind::Accepted
    246                 } else {
    247                     DeliveryObservationKind::Disconnected
    248                 }),
    249                 None,
    250             )
    251             .unwrap()
    252         })
    253         .collect()
    254 }
    255 
    256 #[test]
    257 fn summary_keeps_the_complete_original_transport_criterion_and_never_promotes_capture_only() {
    258     let (request, source, intent) = fixture();
    259     let captured = StockDeliverySummary::from_store_report(
    260         &request,
    261         Some(source),
    262         None,
    263         0,
    264         vec![],
    265         checkpoint(3),
    266     )
    267     .unwrap();
    268     assert!(!captured.acceptance_satisfied().unwrap());
    269     assert!(captured.original_intent().is_none());
    270     for (accepted, expected) in [([true, false], false), ([true, true], true)] {
    271         let value = StockDeliverySummary::from_store_report(
    272             &request,
    273             Some(source),
    274             Some(intent.clone()),
    275             1,
    276             progress(&intent, &accepted),
    277             checkpoint(3),
    278         )
    279         .unwrap();
    280         assert_eq!(value.acceptance_satisfied().unwrap(), expected);
    281         assert_eq!(value.original_intent(), Some(&intent));
    282         assert_eq!(value.attempt_count(), 1);
    283         assert_eq!(value.targets().len(), 2);
    284         assert_eq!(format!("{value:?}"), "StockDeliverySummary(<redacted>)");
    285     }
    286 }
    287 
    288 #[test]
    289 fn endpoint_caps_and_summary_scope_reject_inconsistent_reports() {
    290     let (request, source, intent) = fixture();
    291     let fp = intent.targets().targets()[0].fingerprint();
    292     assert!(
    293         StockDeliveryTargetProgress::from_store_report(fp.clone(), 13, false, None, None).is_err()
    294     );
    295     assert!(
    296         StockDeliveryTargetProgress::from_store_report(fp.clone(), 0, true, None, None).is_err()
    297     );
    298     assert!(
    299         StockDeliveryTargetProgress::from_store_report(
    300             fp.clone(),
    301             1,
    302             false,
    303             None,
    304             core::num::NonZeroU64::new(1)
    305         )
    306         .is_err()
    307     );
    308     for count in [0, 3, 193] {
    309         assert!(
    310             StockDeliverySummary::from_store_report(
    311                 &request,
    312                 Some(source),
    313                 Some(intent.clone()),
    314                 count,
    315                 progress(&intent, &[false, false]),
    316                 checkpoint(3)
    317             )
    318             .is_err()
    319         );
    320     }
    321     let mut wrong_order = progress(&intent, &[false, false]);
    322     wrong_order.reverse();
    323     assert!(
    324         StockDeliverySummary::from_store_report(
    325             &request,
    326             Some(source),
    327             Some(intent.clone()),
    328             1,
    329             wrong_order,
    330             checkpoint(3)
    331         )
    332         .is_err()
    333     );
    334     assert!(
    335         StockDeliverySummary::from_store_report(
    336             &request,
    337             None,
    338             Some(intent.clone()),
    339             1,
    340             progress(&intent, &[false, false]),
    341             checkpoint(3)
    342         )
    343         .is_err()
    344     );
    345 }
    346 
    347 #[test]
    348 fn stock_intent_refuses_public_artifacts_and_empty_outcome_pages_do_not_advance() {
    349     let (request, source, intent) = fixture();
    350     let public = DeliveryIntent::public(
    351         &"b".repeat(64),
    352         source.event_id(),
    353         intent.targets(),
    354         intent.policy(),
    355         intent.deadline_unix_ms(),
    356     )
    357     .unwrap();
    358     assert!(
    359         StockDeliveryRequest::new(
    360             request.binding().clone(),
    361             checkpoint(0),
    362             request.operation_id(),
    363             request.command_digest(),
    364             request.recipient(),
    365             public
    366         )
    367         .is_err()
    368     );
    369     assert!(
    370         StockDeliveryObservationPage::from_store_report(&request, vec![], true, checkpoint(3))
    371             .is_err()
    372     );
    373     let page =
    374         StockDeliveryObservationPage::from_store_report(&request, vec![], false, checkpoint(3))
    375             .unwrap();
    376     assert!(page.entries().is_empty());
    377     assert!(page.next_after().is_none());
    378     assert_eq!(
    379         format!("{page:?}"),
    380         "StockDeliveryObservationPage(<redacted>)"
    381     );
    382 }
    383 
    384 #[test]
    385 fn scoped_delivery_counts_refuse_observations_without_a_selected_invocation() {
    386     let (request, original, intent) = fixture();
    387     let new = rewrapped(&request, original, 1);
    388     let selected = StockEnvelopeRequest::new(
    389         request.binding().clone(),
    390         request.minimum_checkpoint(),
    391         request.operation_id(),
    392         request.command_digest(),
    393         request.recipient(),
    394         None,
    395     )
    396     .unwrap()
    397     .with_envelope(new.event_id());
    398     let none = StockDeliverySummary::from_store_report_with_policy_source(
    399         &selected,
    400         Some(new),
    401         Some(original),
    402         Some(intent.clone()),
    403         1,
    404         0,
    405         progress(&intent, &[false, false])
    406             .into_iter()
    407             .map(|target| {
    408                 StockDeliveryTargetProgress::from_store_report(
    409                     target.target().clone(),
    410                     target.potential_attempts(),
    411                     false,
    412                     None,
    413                     None,
    414                 )
    415                 .unwrap()
    416             })
    417             .collect(),
    418         checkpoint(5),
    419     )
    420     .unwrap();
    421     assert_eq!(none.attempt_count(), 1);
    422     assert_eq!(none.selected_attempt_count(), 0);
    423     assert!(!none.acceptance_satisfied().unwrap());
    424     assert!(
    425         StockDeliverySummary::from_store_report_with_policy_source(
    426             &selected,
    427             Some(new),
    428             Some(original),
    429             Some(intent.clone()),
    430             1,
    431             2,
    432             progress(&intent, &[false, false]),
    433             checkpoint(5)
    434         )
    435         .is_err()
    436     );
    437     assert!(
    438         StockDeliverySummary::from_store_report_with_policy_source(
    439             &selected,
    440             Some(new),
    441             Some(original),
    442             Some(intent.clone()),
    443             1,
    444             0,
    445             progress(&intent, &[true, false]),
    446             checkpoint(5)
    447         )
    448         .is_err()
    449     );
    450 }