lib

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

error.rs (3286B)

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