lib

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

error.rs (4411B)

      1 #[cfg(not(feature = "std"))]
      2 use alloc::string::{String, ToString};
      3 
      4 use core::fmt;
      5 
      6 use radroots_event_codec::verify::RadrootsNip01VerificationError;
      7 use radroots_event_codec::{decode::EventParseError, encode::EventEncodeError};
      8 use radroots_replica_schema::ReplicaSchemaError;
      9 use radroots_sql_core::error::SqlError;
     10 
     11 #[derive(Debug)]
     12 pub enum RadrootsReplicaEventsError {
     13     Sql(ReplicaSchemaError<SqlError>),
     14     Encode(EventEncodeError),
     15     Parse(EventParseError),
     16     Verification(RadrootsNip01VerificationError),
     17     InvalidSelector(String),
     18     InvalidData(String),
     19 }
     20 
     21 impl fmt::Display for RadrootsReplicaEventsError {
     22     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     23         match self {
     24             Self::Sql(err) => write!(f, "replica_sync.sql: {}", err.error),
     25             Self::Encode(err) => write!(f, "replica_sync.encode: {err}"),
     26             Self::Parse(err) => write!(f, "replica_sync.parse: {err}"),
     27             Self::Verification(err) => write!(f, "replica_sync.verification: {err}"),
     28             Self::InvalidSelector(msg) => write!(f, "replica_sync.selector: {msg}"),
     29             Self::InvalidData(msg) => write!(f, "replica_sync.data: {msg}"),
     30         }
     31     }
     32 }
     33 
     34 #[cfg(feature = "std")]
     35 impl std::error::Error for RadrootsReplicaEventsError {}
     36 
     37 impl From<ReplicaSchemaError<SqlError>> for RadrootsReplicaEventsError {
     38     fn from(err: ReplicaSchemaError<SqlError>) -> Self {
     39         Self::Sql(err)
     40     }
     41 }
     42 
     43 impl From<EventEncodeError> for RadrootsReplicaEventsError {
     44     fn from(err: EventEncodeError) -> Self {
     45         Self::Encode(err)
     46     }
     47 }
     48 
     49 impl From<EventParseError> for RadrootsReplicaEventsError {
     50     fn from(err: EventParseError) -> Self {
     51         Self::Parse(err)
     52     }
     53 }
     54 
     55 impl From<RadrootsNip01VerificationError> for RadrootsReplicaEventsError {
     56     fn from(err: RadrootsNip01VerificationError) -> Self {
     57         Self::Verification(err)
     58     }
     59 }
     60 
     61 #[cfg(test)]
     62 mod tests {
     63     use super::RadrootsReplicaEventsError;
     64     use radroots_event_codec::verify::RadrootsNip01VerificationError;
     65     use radroots_event_codec::{decode::EventParseError, encode::EventEncodeError};
     66     use radroots_replica_schema::ReplicaSchemaError;
     67     use radroots_sql_core::error::SqlError;
     68 
     69     #[test]
     70     fn display_formats_all_error_variants() {
     71         let sql_err = RadrootsReplicaEventsError::Sql(ReplicaSchemaError::from(SqlError::Internal));
     72         assert!(sql_err.to_string().contains("replica_sync.sql"));
     73 
     74         let encode_err = RadrootsReplicaEventsError::Encode(EventEncodeError::InvalidField("name"));
     75         assert!(encode_err.to_string().contains("replica_sync.encode"));
     76 
     77         let parse_err = RadrootsReplicaEventsError::Parse(EventParseError::InvalidTag("d"));
     78         assert!(parse_err.to_string().contains("replica_sync.parse"));
     79 
     80         let verification_err = RadrootsReplicaEventsError::Verification(
     81             RadrootsNip01VerificationError::SignatureInvalid,
     82         );
     83         assert!(
     84             verification_err
     85                 .to_string()
     86                 .contains("replica_sync.verification")
     87         );
     88 
     89         let selector_err =
     90             RadrootsReplicaEventsError::InvalidSelector("selector missing".to_string());
     91         assert!(selector_err.to_string().contains("replica_sync.selector"));
     92 
     93         let data_err = RadrootsReplicaEventsError::InvalidData("bad data".to_string());
     94         assert!(data_err.to_string().contains("replica_sync.data"));
     95     }
     96 
     97     #[test]
     98     fn from_impls_map_into_expected_variants() {
     99         let sql_from: RadrootsReplicaEventsError =
    100             ReplicaSchemaError::from(SqlError::Internal).into();
    101         assert!(sql_from.to_string().contains("replica_sync.sql"));
    102 
    103         let encode_from: RadrootsReplicaEventsError = EventEncodeError::Json.into();
    104         assert!(encode_from.to_string().contains("replica_sync.encode"));
    105 
    106         let parse_number_err = "invalid".parse::<u32>().expect_err("parse int should fail");
    107         let parse_from: RadrootsReplicaEventsError =
    108             EventParseError::InvalidNumber("k", parse_number_err).into();
    109         assert!(parse_from.to_string().contains("replica_sync.parse"));
    110 
    111         let verification_from: RadrootsReplicaEventsError =
    112             RadrootsNip01VerificationError::SignatureInvalid.into();
    113         assert!(
    114             verification_from
    115                 .to_string()
    116                 .contains("replica_sync.verification")
    117         );
    118     }
    119 }