Skip to main content

iab_specs_core/
errors.rs

1use std::result;
2use thiserror::Error;
3
4#[derive(Error, Debug)]
5pub enum Error {
6    #[error("{0}")]
7    UninitializedFieldError(&'static str),
8
9    #[cfg(feature = "serde_json")]
10    #[error("{0}")]
11    SerdeJsonError(#[from] serde_json::Error),
12
13    #[error("{0}")]
14    SerdePlainError(#[from] serde_plain::Error),
15
16    #[error("{0}")]
17    StdFmtError(#[from] std::fmt::Error),
18
19    #[error("Invalid transition from '{from}' to '{to}'")]
20    InvalidTransition { from: String, to: String },
21}
22
23impl From<derive_builder::UninitializedFieldError> for Error {
24    fn from(e: derive_builder::UninitializedFieldError) -> Self {
25        Self::UninitializedFieldError(e.field_name())
26    }
27}
28
29/// Alias for a `Result` with the error type `iab_specs_core::Error`.
30pub type Result<T> = result::Result<T, Error>;
31
32#[cfg(test)]
33mod tests {
34    use super::*;
35
36    #[test]
37    fn test_uninitialized_field_error() {
38        let err = Error::UninitializedFieldError("test_field");
39        assert_eq!(err.to_string(), "test_field");
40    }
41
42    #[cfg(feature = "serde_json")]
43    #[test]
44    fn test_serde_json_error() {
45        let json_err = serde_json::from_str::<serde_json::Value>("invalid json");
46        assert!(json_err.is_err());
47        let err: Error = json_err.unwrap_err().into();
48        assert!(err.to_string().contains("expected value"));
49    }
50
51    #[test]
52    fn test_serde_plain_error() {
53        use serde::de::Error as _;
54        let plain_err = serde_plain::Error::custom("custom error");
55        let err: Error = plain_err.into();
56        assert_eq!(err.to_string(), "custom error");
57    }
58
59    #[test]
60    fn test_from_builder_uninitialized_field_error() {
61        use derive_builder::UninitializedFieldError;
62        let builder_err = UninitializedFieldError::new("field_name");
63        let err: Error = builder_err.into();
64        assert_eq!(err.to_string(), "field_name");
65    }
66
67    #[test]
68    fn test_invalid_transition() {
69        let err = Error::InvalidTransition {
70            from: "pending".to_string(),
71            to: "completed".to_string(),
72        };
73        assert_eq!(
74            err.to_string(),
75            "Invalid transition from 'pending' to 'completed'"
76        );
77    }
78}