identifier.rs (7069B)
1 use radroots_domain::{ExecutorId, IdentifierError, OperationId, OrderId, ThreadId, WorkspaceId}; 2 use std::{ 3 collections::hash_map::DefaultHasher, 4 hash::{Hash, Hasher}, 5 }; 6 7 const SEQUENTIAL: &str = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"; 8 9 #[test] 10 fn captured_context_identities_preserve_full_width_and_canonical_encoding() { 11 macro_rules! check { 12 ($t:ty) => {{ 13 let bytes = core::array::from_fn(|i| i as u8); 14 let id = <$t>::from_bytes(bytes); 15 assert_eq!(id.as_bytes(), &bytes); 16 assert_eq!(id.into_bytes(), bytes); 17 assert_eq!(id.to_string(), SEQUENTIAL); 18 assert_eq!(SEQUENTIAL.parse::<$t>().unwrap(), id); 19 assert!("A".repeat(64).parse::<$t>().is_err()); 20 assert!("0".repeat(63).parse::<$t>().is_err()); 21 #[cfg(feature = "serde")] 22 { 23 let encoded = format!("\"{SEQUENTIAL}\""); 24 assert_eq!(serde_json::to_string(&id).unwrap(), encoded); 25 assert_eq!(serde_json::from_str::<$t>(&encoded).unwrap(), id); 26 assert!(serde_json::from_str::<$t>("1").is_err()); 27 assert!(serde_json::from_str::<$t>("\"x\"").is_err()); 28 } 29 }}; 30 } 31 check!(radroots_domain::SigningAttemptId); 32 check!(radroots_domain::AgreementLineId); 33 check!(radroots_domain::FulfillmentGroupId); 34 check!(radroots_domain::TermsDigest); 35 check!(radroots_domain::GrantId); 36 check!(radroots_domain::RecordId); 37 check!(radroots_domain::SourceId); 38 check!(radroots_domain::CommandDigest); 39 check!(radroots_domain::RouteDigest); 40 check!(radroots_domain::CheckpointDigest); 41 check!(radroots_domain::ApprovalIntentDigest); 42 check!(radroots_domain::TransactionId); 43 check!(radroots_domain::MessageId); 44 check!(radroots_domain::EnvelopeEventId); 45 check!(radroots_domain::RumorEventId); 46 } 47 48 #[test] 49 fn all_namespaces_match_independent_byte_and_hex_vectors() { 50 let bytes = core::array::from_fn(|i| i as u8); 51 macro_rules! check { 52 ($t:ty) => {{ 53 let id = <$t>::from_bytes(bytes); 54 assert_eq!(id.as_bytes(), &bytes); 55 assert_eq!(id.into_bytes(), bytes); 56 assert_eq!(id.to_string(), SEQUENTIAL); 57 assert_eq!(SEQUENTIAL.parse::<$t>().unwrap(), id); 58 let largest = <$t>::from_bytes([255; 32]); 59 assert_eq!(largest.to_string(), "f".repeat(64)); 60 assert_eq!(largest.to_string().parse::<$t>().unwrap(), largest); 61 }}; 62 } 63 check!(OrderId); 64 check!(ThreadId); 65 check!(WorkspaceId); 66 check!(ExecutorId); 67 check!(OperationId); 68 } 69 70 #[test] 71 fn all_namespaces_reject_wrong_lengths_before_decoding() { 72 for input in [ 73 String::new(), 74 "0".repeat(63), 75 "0".repeat(65), 76 "0x".to_owned() + SEQUENTIAL, 77 "0".repeat(65_536), 78 ] { 79 macro_rules! check { 80 ($t:ty) => { 81 assert_eq!(input.parse::<$t>(), Err(IdentifierError::InvalidLength)); 82 }; 83 } 84 check!(OrderId); 85 check!(ThreadId); 86 check!(WorkspaceId); 87 check!(ExecutorId); 88 check!(OperationId); 89 } 90 } 91 92 #[test] 93 fn encoding_is_ascii_lowercase_without_trimming_or_case_folding() { 94 for input in [ 95 "A".repeat(64), 96 "g".repeat(64), 97 "é".repeat(32), 98 " ".repeat(64), 99 "0".repeat(63) + "\n", 100 "0".repeat(63) + "\0", 101 "a".repeat(63) + "F", 102 ] { 103 macro_rules! check { 104 ($t:ty) => { 105 assert_eq!(input.parse::<$t>(), Err(IdentifierError::InvalidEncoding)); 106 }; 107 } 108 check!(OrderId); 109 check!(ThreadId); 110 check!(WorkspaceId); 111 check!(ExecutorId); 112 check!(OperationId); 113 } 114 } 115 116 #[test] 117 fn every_ascii_character_is_checked_in_each_nibble_position() { 118 for byte in 0..=127_u8 { 119 for offset in 0..64 { 120 let mut input = [b'0'; 64]; 121 input[offset] = byte; 122 let result = core::str::from_utf8(&input).unwrap().parse::<OperationId>(); 123 if byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte) { 124 assert_eq!(result.unwrap().to_string().as_bytes(), input); 125 } else { 126 assert_eq!(result, Err(IdentifierError::InvalidEncoding)); 127 } 128 } 129 } 130 } 131 132 #[test] 133 fn equality_order_and_hash_are_exact_bytes_within_each_namespace() { 134 fn hash<T: Hash>(value: &T) -> u64 { 135 let mut hasher = DefaultHasher::new(); 136 value.hash(&mut hasher); 137 hasher.finish() 138 } 139 macro_rules! check { 140 ($t:ty) => {{ 141 let id = SEQUENTIAL.parse::<$t>().unwrap(); 142 let copy = <$t>::from_bytes(id.into_bytes()); 143 assert_eq!(id, copy); 144 assert_eq!(hash(&id), hash(©)); 145 let mut bytes = id.into_bytes(); 146 bytes[31] += 1; 147 let later = <$t>::from_bytes(bytes); 148 assert_ne!(id, later); 149 assert!(id < later); 150 assert_eq!(id.partial_cmp(&later), Some(core::cmp::Ordering::Less)); 151 }}; 152 } 153 check!(OrderId); 154 check!(ThreadId); 155 check!(WorkspaceId); 156 check!(ExecutorId); 157 check!(OperationId); 158 } 159 160 #[test] 161 fn errors_are_typed_bounded_and_do_not_retain_input() { 162 let errors = [ 163 IdentifierError::InvalidLength, 164 IdentifierError::InvalidEncoding, 165 ]; 166 for error in errors { 167 let object: &dyn core::error::Error = &error; 168 assert!(object.source().is_none()); 169 assert!(error.to_string().len() <= 64); 170 assert!(!format!("{error:?}").contains("sensitive_fixture")); 171 } 172 assert_ne!(errors[0].to_string(), errors[1].to_string()); 173 } 174 175 #[cfg(feature = "serde")] 176 mod json { 177 use super::*; 178 179 #[test] 180 fn each_namespace_round_trips_as_one_lossless_canonical_string() { 181 let encoded = format!("\"{SEQUENTIAL}\""); 182 macro_rules! check { 183 ($t:ty) => {{ 184 let id = SEQUENTIAL.parse::<$t>().unwrap(); 185 assert_eq!(serde_json::to_string(&id).unwrap(), encoded); 186 assert_eq!(serde_json::from_str::<$t>(&encoded).unwrap(), id); 187 }}; 188 } 189 check!(OrderId); 190 check!(ThreadId); 191 check!(WorkspaceId); 192 check!(ExecutorId); 193 check!(OperationId); 194 } 195 196 #[test] 197 fn json_cannot_bypass_string_width_or_encoding_validation() { 198 for encoded in [ 199 "0".to_owned(), 200 "null".to_owned(), 201 "{}".to_owned(), 202 "[0]".to_owned(), 203 "\"0\"".to_owned(), 204 format!("\"{}\"", "F".repeat(64)), 205 ] { 206 macro_rules! check { 207 ($t:ty) => { 208 assert!(serde_json::from_str::<$t>(&encoded).is_err(), "{encoded}"); 209 }; 210 } 211 check!(OrderId); 212 check!(ThreadId); 213 check!(WorkspaceId); 214 check!(ExecutorId); 215 check!(OperationId); 216 } 217 } 218 }