lib

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

error.rs (3529B)

      1 use core::fmt;
      2 
      3 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
      4 pub enum RadrootsProtectedStoreError {
      5     EntropyUnavailable,
      6     UnsupportedEnvelopeVersion(u8),
      7     InvalidStoreKeyLength(usize),
      8     EnvelopeEncodeFailed,
      9     EnvelopeDecodeFailed,
     10     KeyWrapFailed,
     11     KeyUnwrapFailed,
     12     EncryptFailed,
     13     DecryptFailed,
     14 }
     15 
     16 impl fmt::Display for RadrootsProtectedStoreError {
     17     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     18         match self {
     19             Self::EntropyUnavailable => f.write_str("protected-store entropy is unavailable"),
     20             Self::UnsupportedEnvelopeVersion(version) => {
     21                 write!(
     22                     f,
     23                     "protected-store envelope version {version} is unsupported"
     24                 )
     25             }
     26             Self::InvalidStoreKeyLength(length) => {
     27                 write!(f, "protected-store key must be 32 bytes, got {length}")
     28             }
     29             Self::EnvelopeEncodeFailed => f.write_str("protected-store envelope encoding failed"),
     30             Self::EnvelopeDecodeFailed => f.write_str("protected-store envelope decoding failed"),
     31             Self::KeyWrapFailed => f.write_str("protected-store key wrapping failed"),
     32             Self::KeyUnwrapFailed => f.write_str("protected-store key unwrapping failed"),
     33             Self::EncryptFailed => f.write_str("protected-store encryption failed"),
     34             Self::DecryptFailed => f.write_str("protected-store decryption failed"),
     35         }
     36     }
     37 }
     38 
     39 #[cfg(feature = "std")]
     40 impl std::error::Error for RadrootsProtectedStoreError {}
     41 
     42 #[cfg(test)]
     43 mod tests {
     44     use super::*;
     45     use alloc::string::ToString;
     46 
     47     #[test]
     48     fn display_covers_all_error_variants() {
     49         let cases = [
     50             (
     51                 RadrootsProtectedStoreError::EntropyUnavailable,
     52                 "protected-store entropy is unavailable",
     53             ),
     54             (
     55                 RadrootsProtectedStoreError::UnsupportedEnvelopeVersion(7),
     56                 "protected-store envelope version 7 is unsupported",
     57             ),
     58             (
     59                 RadrootsProtectedStoreError::InvalidStoreKeyLength(31),
     60                 "protected-store key must be 32 bytes, got 31",
     61             ),
     62             (
     63                 RadrootsProtectedStoreError::EnvelopeEncodeFailed,
     64                 "protected-store envelope encoding failed",
     65             ),
     66             (
     67                 RadrootsProtectedStoreError::EnvelopeDecodeFailed,
     68                 "protected-store envelope decoding failed",
     69             ),
     70             (
     71                 RadrootsProtectedStoreError::KeyWrapFailed,
     72                 "protected-store key wrapping failed",
     73             ),
     74             (
     75                 RadrootsProtectedStoreError::KeyUnwrapFailed,
     76                 "protected-store key unwrapping failed",
     77             ),
     78             (
     79                 RadrootsProtectedStoreError::EncryptFailed,
     80                 "protected-store encryption failed",
     81             ),
     82             (
     83                 RadrootsProtectedStoreError::DecryptFailed,
     84                 "protected-store decryption failed",
     85             ),
     86         ];
     87 
     88         for (error, expected) in cases {
     89             assert_eq!(error.to_string(), expected);
     90         }
     91     }
     92 
     93     #[cfg(feature = "std")]
     94     #[test]
     95     fn error_trait_is_available_with_std() {
     96         let error = RadrootsProtectedStoreError::DecryptFailed;
     97         let dyn_error: &dyn std::error::Error = &error;
     98 
     99         assert_eq!(dyn_error.to_string(), "protected-store decryption failed");
    100     }
    101 }