Skip to main content

terraform_forge/
error.rs

1use thiserror::Error;
2
3#[derive(Debug, Error)]
4#[non_exhaustive]
5pub enum ForgeError {
6    #[error("IO error: {0}")]
7    Io(#[from] std::io::Error),
8
9    #[error("TOML parse error: {0}")]
10    Toml(#[from] toml::de::Error),
11
12    #[error("JSON error: {0}")]
13    Json(#[from] serde_json::Error),
14
15    #[error("OpenAPI error: {0}")]
16    OpenApi(#[from] openapi_forge::ForgeError),
17
18    #[error("missing CRUD endpoint: {resource} needs {endpoint}")]
19    MissingEndpoint { resource: String, endpoint: String },
20
21    #[error("schema not found in spec: {0}")]
22    SchemaNotFound(String),
23
24    #[error("resource spec validation error: {0}")]
25    ValidationError(String),
26
27    #[error("template error: {0}")]
28    TemplateError(String),
29}
30
31#[cfg(test)]
32mod tests {
33    use super::*;
34
35    #[test]
36    fn display_missing_endpoint() {
37        let err = ForgeError::MissingEndpoint {
38            resource: "akeyless_secret".to_string(),
39            endpoint: "/create".to_string(),
40        };
41        let msg = err.to_string();
42        assert!(msg.contains("akeyless_secret"));
43        assert!(msg.contains("/create"));
44        assert!(msg.contains("missing CRUD endpoint"));
45    }
46
47    #[test]
48    fn display_schema_not_found() {
49        let err = ForgeError::SchemaNotFound("FooSchema".to_string());
50        assert!(err.to_string().contains("FooSchema"));
51        assert!(err.to_string().contains("schema not found"));
52    }
53
54    #[test]
55    fn display_validation_error() {
56        let err = ForgeError::ValidationError("bad config".to_string());
57        assert!(err.to_string().contains("bad config"));
58    }
59
60    #[test]
61    fn display_template_error() {
62        let err = ForgeError::TemplateError("render failed".to_string());
63        assert!(err.to_string().contains("render failed"));
64    }
65
66    #[test]
67    fn from_io_error() {
68        let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "file missing");
69        let err: ForgeError = io_err.into();
70        assert!(err.to_string().contains("file missing"));
71    }
72
73    #[test]
74    fn from_json_error() {
75        let json_result: Result<serde_json::Value, _> = serde_json::from_str("{bad");
76        let json_err = json_result.unwrap_err();
77        let err: ForgeError = json_err.into();
78        assert!(err.to_string().contains("JSON error"));
79    }
80
81    #[test]
82    fn from_toml_error() {
83        let toml_result: Result<toml::Value, _> = toml::from_str("[bad");
84        let toml_err = toml_result.unwrap_err();
85        let err: ForgeError = toml_err.into();
86        assert!(err.to_string().contains("TOML parse error"));
87    }
88
89    #[test]
90    fn debug_impl() {
91        let err = ForgeError::SchemaNotFound("X".to_string());
92        let debug_str = format!("{err:?}");
93        assert!(debug_str.contains("SchemaNotFound"));
94    }
95
96    #[test]
97    fn from_openapi_error() {
98        let api_result: Result<openapi_forge::Spec, _> =
99            openapi_forge::Spec::parse("not valid yaml {{{}}}");
100        if let Err(openapi_err) = api_result {
101            let err: ForgeError = openapi_err.into();
102            assert!(err.to_string().contains("OpenAPI error"));
103        }
104    }
105
106    #[test]
107    fn error_variants_are_send_sync() {
108        fn assert_send_sync<T: Send + Sync>() {}
109        // ForgeError should be usable across threads
110        assert_send_sync::<ForgeError>();
111    }
112}