lib

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

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(&copy));
    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 }