lib

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

stock_unissued_tests.rs (5561B)


      1 //! Coordinator-only hostile-report models; these confer no stock authority.
      2 use super::*;
      3 use crate::session::commerce::{
      4     AcceptanceUnissued, AcceptanceUnissuedOutcome, AcceptanceUnissuedReceipt,
      5 };
      6 use alloc::boxed::Box;
      7 use radroots_domain::TransactionId;
      8 use radroots_signing::provider::ProviderError;
      9 use std::sync::atomic::{AtomicUsize, Ordering};
     10 struct Observation {
     11     claim: AcceptanceClaim,
     12     receipt: AcceptanceUnissuedReceipt,
     13     mode: Shared<AtomicUsize>,
     14 }
     15 impl AcceptanceUnissued for Observation {
     16     fn claim(&self) -> AcceptanceClaim {
     17         let mut claim = self.claim;
     18         if self.mode.load(Ordering::SeqCst) == 9 {
     19             claim.id = SigningAttemptId::from_bytes([0xfa; 32]);
     20         }
     21         claim
     22     }
     23     fn reason(&self) -> ProviderError {
     24         ProviderError::Cancelled
     25     }
     26     fn capture(
     27         &self,
     28     ) -> crate::session::HostFuture<'_, Result<AcceptanceUnissuedOutcome, OperationError>> {
     29         Box::pin(async move {
     30             let mode = self.mode.load(Ordering::SeqCst);
     31             let mut receipt = self.receipt;
     32             let a = receipt.attempt;
     33             receipt.attempt = radroots_storage::command::CommitAttempt::new(
     34                 if mode == 1 {
     35                     WorkspaceId::from_bytes([0xfb; 32])
     36                 } else {
     37                     a.workspace_id()
     38                 },
     39                 if mode == 2 {
     40                     OperationId::from_bytes([0xfb; 32])
     41                 } else {
     42                     a.operation_id()
     43                 },
     44                 if mode == 3 {
     45                     CommandDigest::from_bytes([0xfb; 32])
     46                 } else {
     47                     a.command_digest()
     48                 },
     49                 if mode == 4 { None } else { a.transaction_id() },
     50             );
     51             if mode == 5 {
     52                 receipt.claim = SigningAttemptId::from_bytes([0xfb; 32]);
     53             }
     54             if mode == 6 {
     55                 receipt.recipient = PublicKey::from_hex(
     56                     "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9",
     57                 )
     58                 .unwrap();
     59             }
     60             if mode == 7 {
     61                 receipt.reason = ProviderError::DeadlineExceeded;
     62             }
     63             if mode == 8 {
     64                 receipt.checkpoint = InventoryCheckpointRef::from_host_metadata(
     65                     AuthorityRef::new(
     66                         ExecutorId::from_bytes([0xfb; 32]),
     67                         Generation::new(1).unwrap(),
     68                     ),
     69                     Sequence::new(0).unwrap(),
     70                     None,
     71                 )
     72                 .unwrap();
     73             }
     74             if mode == 10 {
     75                 return Ok(AcceptanceUnissuedOutcome::Unknown(receipt.attempt));
     76             }
     77             if mode == 11 {
     78                 return Err(OperationError::StorageFailure);
     79             }
     80             Ok(AcceptanceUnissuedOutcome::Committed(Box::new(receipt)))
     81         })
     82     }
     83     fn reconcile(
     84         &self,
     85     ) -> crate::session::HostFuture<'_, Result<AcceptanceUnissuedOutcome, OperationError>> {
     86         self.capture()
     87     }
     88 }
     89 #[test]
     90 fn every_mismatched_or_uncertain_host_report_keeps_original_observation_and_lease_until_confirmed()
     91 {
     92     for mode in 1..=11 {
     93         let (context, _artifact, weak) = fixture();
     94         let control = Shared::new(AtomicUsize::new(mode));
     95         let receipt = AcceptanceUnissuedReceipt {
     96             attempt: radroots_storage::command::CommitAttempt::new(
     97                 context.selection.binding.input().workspace_id(),
     98                 context.selection.operation,
     99                 context.selection.digest,
    100                 Some(TransactionId::from_bytes([0xaa; 32])),
    101             ),
    102             claim: context.claim.id,
    103             recipient: context.recipient,
    104             reason: ProviderError::Cancelled,
    105             checkpoint: context.selection.minimum,
    106         };
    107         assert_ne!(
    108             receipt.recipient.to_hex(),
    109             "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9"
    110         );
    111         let owner = Owner::default();
    112         let operation = context.selection.operation;
    113         let observation = Box::new(Observation {
    114             claim: context.claim,
    115             receipt,
    116             mode: control.clone(),
    117         });
    118         let entry = owner.retain_unissued(
    119             context.selection,
    120             context.claim,
    121             context.recipient,
    122             observation,
    123             context.lease,
    124         );
    125         let result = block_on(owner.capture_unissued(&entry));
    126         if mode == 10 {
    127             assert!(matches!(result, Ok(AcceptanceUnissuedOutcome::Unknown(_))));
    128         } else {
    129             let error = result
    130                 .err()
    131                 .expect("mismatched or failed capture must refuse");
    132             assert_eq!(
    133                 error.code(),
    134                 if mode == 11 {
    135                     crate::Code::StorageFailure
    136                 } else {
    137                     crate::Code::RecoveryRequired
    138                 }
    139             );
    140             assert_eq!(error.context().operation_id(), Some(operation));
    141             assert_eq!(error.context().admission(), crate::Admission::Confirmed);
    142         }
    143         drop(entry);
    144         assert!(weak.upgrade().is_some());
    145         assert!(owner.ensure_ready().is_err());
    146         assert_eq!(owner.unissued.lock().unwrap().len(), 1);
    147         control.store(0, Ordering::SeqCst);
    148         block_on(owner.drain()).unwrap();
    149         assert!(owner.ensure_ready().is_ok());
    150         assert!(weak.upgrade().is_none());
    151     }
    152 }