lib

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

error.rs (7643B)


      1 use std::{collections::BTreeSet, error::Error as _, mem::size_of};
      2 
      3 use radroots_domain::OperationId;
      4 use radroots_execution::{
      5     Admission, Code, Detail, Error, Field, InvalidErrorContext, OperationContext, Reason,
      6     RetryClass,
      7 };
      8 
      9 const FIRST: OperationId = OperationId::from_bytes([7; 32]);
     10 const SECOND: OperationId = OperationId::from_bytes([8; 32]);
     11 
     12 #[test]
     13 fn proposed_identity_never_claims_durable_admission() {
     14     for id in [None, Some(FIRST), Some(SECOND)] {
     15         let error = Error::new(
     16             Code::InvalidInput,
     17             OperationContext::proposed(id),
     18             RetryClass::Never,
     19             Some(Detail::new(Field::Currency, Reason::Unsupported)),
     20         )
     21         .unwrap();
     22         assert_eq!(error.context().operation_id(), id);
     23         assert_eq!(error.context().admission(), Admission::NotAdmitted);
     24         assert_eq!(error.code(), Code::InvalidInput);
     25         assert_eq!(error.retry(), RetryClass::Never);
     26         let detail = error.detail().unwrap();
     27         assert_eq!(detail.field(), Field::Currency);
     28         assert_eq!(detail.reason(), Reason::Unsupported);
     29         assert_eq!(error.to_string(), "invalid_input: Command input is invalid");
     30         assert!(error.source().is_none());
     31     }
     32 }
     33 
     34 #[test]
     35 fn uncertain_initial_commit_preserves_id_without_claiming_admission() {
     36     for id in [FIRST, SECOND] {
     37         for retry in [
     38             RetryClass::SafeSameOperation,
     39             RetryClass::ManualReconciliation,
     40         ] {
     41             let error = Error::new(
     42                 Code::CommitUnknown,
     43                 OperationContext::admission_unknown(id),
     44                 retry,
     45                 None,
     46             )
     47             .unwrap();
     48             assert_eq!(error.context().operation_id(), Some(id));
     49             assert_eq!(error.context().admission(), Admission::Unknown);
     50             assert_eq!(error.retry(), retry);
     51             assert_eq!(error.detail(), None);
     52         }
     53     }
     54     assert_eq!(
     55         Error::new(
     56             Code::CommitUnknown,
     57             OperationContext::proposed(Some(FIRST)),
     58             RetryClass::ManualReconciliation,
     59             None
     60         ),
     61         Err(InvalidErrorContext::OperationIdentityRequired)
     62     );
     63 }
     64 
     65 #[test]
     66 fn signing_delivery_and_tampering_cannot_precede_confirmed_preparation() {
     67     for code in [
     68         Code::SigningPending,
     69         Code::SigningUnknown,
     70         Code::DeliveryPending,
     71         Code::SignerTampering,
     72     ] {
     73         for context in [
     74             OperationContext::proposed(None),
     75             OperationContext::proposed(Some(FIRST)),
     76             OperationContext::admission_unknown(FIRST),
     77         ] {
     78             assert_eq!(
     79                 Error::new(code, context, RetryClass::ManualReconciliation, None),
     80                 Err(InvalidErrorContext::ConfirmedAdmissionRequired)
     81             );
     82         }
     83         for retry in [
     84             RetryClass::SafeSameOperation,
     85             RetryClass::ManualReconciliation,
     86         ] {
     87             let error = Error::new(code, OperationContext::retained(FIRST), retry, None).unwrap();
     88             assert_eq!(error.context().admission(), Admission::Confirmed);
     89             assert_eq!(error.context().operation_id(), Some(FIRST));
     90         }
     91     }
     92 }
     93 
     94 #[test]
     95 fn uncertain_work_cannot_be_reprepared_using_fresh_state_or_forgotten() {
     96     for code in [
     97         Code::CommitUnknown,
     98         Code::SigningPending,
     99         Code::SigningUnknown,
    100         Code::DeliveryPending,
    101         Code::SignerTampering,
    102     ] {
    103         for retry in [RetryClass::Never, RetryClass::AfterStateRefresh] {
    104             assert_eq!(
    105                 Error::new(code, OperationContext::retained(FIRST), retry, None),
    106                 Err(InvalidErrorContext::ReconciliationRequired)
    107             );
    108         }
    109     }
    110     for retry in [RetryClass::Never, RetryClass::AfterStateRefresh] {
    111         assert_eq!(
    112             Error::new(
    113                 Code::CommitUnknown,
    114                 OperationContext::admission_unknown(FIRST),
    115                 retry,
    116                 None
    117             ),
    118             Err(InvalidErrorContext::ReconciliationRequired)
    119         );
    120     }
    121 }
    122 
    123 #[test]
    124 fn same_operation_retry_requires_an_original_retained_or_uncertain_identity() {
    125     for context in [
    126         OperationContext::proposed(None),
    127         OperationContext::proposed(Some(FIRST)),
    128     ] {
    129         assert_eq!(
    130             Error::new(
    131                 Code::StorageFailure,
    132                 context,
    133                 RetryClass::SafeSameOperation,
    134                 None
    135             ),
    136             Err(InvalidErrorContext::RetainedRetryRequired)
    137         );
    138     }
    139     for context in [
    140         OperationContext::retained(FIRST),
    141         OperationContext::admission_unknown(SECOND),
    142     ] {
    143         let error = Error::new(
    144             Code::RecoveryRequired,
    145             context,
    146             RetryClass::SafeSameOperation,
    147             None,
    148         )
    149         .unwrap();
    150         assert_eq!(error.context(), context);
    151     }
    152     let conflict = Error::new(
    153         Code::IdempotencyConflict,
    154         OperationContext::retained(FIRST),
    155         RetryClass::SafeSameOperation,
    156         None,
    157     );
    158     assert_eq!(conflict, Err(InvalidErrorContext::ConflictingRetry));
    159     let refresh = Error::new(
    160         Code::StaleState,
    161         OperationContext::proposed(Some(SECOND)),
    162         RetryClass::AfterStateRefresh,
    163         None,
    164     )
    165     .unwrap();
    166     assert_eq!(refresh.context().admission(), Admission::NotAdmitted);
    167     assert_eq!(refresh.context().operation_id(), Some(SECOND));
    168 }
    169 
    170 #[test]
    171 fn fixed_diagnostics_and_messages_are_canonical_bounded_and_input_free() {
    172     let mut codes = BTreeSet::new();
    173     for &code in Code::ALL {
    174         assert!(codes.insert(code.as_str()));
    175         assert!(!code.as_str().is_empty() && code.as_str().len() <= 80);
    176         assert!(
    177             code.as_str()
    178                 .bytes()
    179                 .all(|byte| byte.is_ascii_lowercase() || byte == b'_')
    180         );
    181         assert!(!code.message().is_empty() && code.message().len() <= 512);
    182         let error = Error::new(
    183             code,
    184             OperationContext::retained(FIRST),
    185             RetryClass::ManualReconciliation,
    186             None,
    187         )
    188         .unwrap();
    189         assert_eq!(error.code(), code);
    190         assert!(error.source().is_none());
    191         assert!(format!("{error}").len() < 600);
    192         assert!(format!("{error:?}").len() < 1024);
    193     }
    194     for &field in Field::ALL {
    195         for &reason in Reason::ALL {
    196             let detail = Detail::new(field, reason);
    197             assert_eq!(detail.field().to_string(), field.as_str());
    198             assert_eq!(detail.reason().to_string(), reason.as_str());
    199             assert!(field.as_str().len() < 32 && reason.as_str().len() < 32);
    200             assert!(format!("{detail:?}").len() < 128);
    201         }
    202     }
    203     assert!(size_of::<Error>() <= 64);
    204 }
    205 
    206 #[test]
    207 fn retry_classes_and_construction_failures_have_fixed_protocol_strings() {
    208     for (retry, expected) in [
    209         (RetryClass::Never, "never"),
    210         (RetryClass::SafeSameOperation, "safe_same_operation"),
    211         (RetryClass::AfterStateRefresh, "after_state_refresh"),
    212         (RetryClass::ManualReconciliation, "manual_reconciliation"),
    213     ] {
    214         assert_eq!(retry.as_str(), expected);
    215     }
    216     for error in [
    217         InvalidErrorContext::ConfirmedAdmissionRequired,
    218         InvalidErrorContext::OperationIdentityRequired,
    219         InvalidErrorContext::RetainedRetryRequired,
    220         InvalidErrorContext::ReconciliationRequired,
    221         InvalidErrorContext::ConflictingRetry,
    222     ] {
    223         assert!(!error.to_string().is_empty() && error.to_string().len() < 80);
    224         assert!(error.source().is_none());
    225     }
    226 }