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 assert_send_sync::<ForgeError>();
111 }
112}