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 }