openapi-forge 0.1.5

OpenAPI 3.0 parser and query library
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use thiserror::Error;

/// Errors that can occur when loading, parsing, or querying an `OpenAPI` spec.
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum ForgeError {
    /// An I/O error occurred while reading the spec file from disk.
    #[error("failed to read spec file: {0}")]
    Io(#[from] std::io::Error),

    /// The spec content could not be parsed as valid YAML.
    #[error("failed to parse YAML: {0}")]
    Yaml(#[from] serde_yaml_ng::Error),

    /// The spec content could not be parsed as valid JSON.
    #[error("failed to parse JSON: {0}")]
    Json(#[from] serde_json::Error),

    /// A `$ref` pointer could not be resolved within the spec.
    #[error("unresolved $ref: {0}")]
    UnresolvedRef(String),

    /// A referenced schema name does not exist in `components/schemas`.
    #[error("schema not found: {0}")]
    SchemaNotFound(String),

    /// The spec declares a version other than 3.0.x.
    #[error("unsupported spec version: {0} (expected 3.0.x)")]
    UnsupportedVersion(String),

    /// A string could not be parsed into the expected type.
    #[error("invalid input: {0}")]
    InvalidInput(String),
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn display_io_error() {
        let inner = std::io::Error::new(std::io::ErrorKind::NotFound, "gone");
        let err = ForgeError::Io(inner);
        let msg = err.to_string();
        assert!(
            msg.contains("failed to read spec file"),
            "IO error display should include context prefix, got: {msg}"
        );
        assert!(msg.contains("gone"), "IO error display should preserve inner message");
    }

    #[test]
    fn display_yaml_error() {
        let yaml_err = serde_yaml_ng::from_str::<serde_json::Value>("{{bad")
            .expect_err("should fail");
        let err = ForgeError::Yaml(yaml_err);
        let msg = err.to_string();
        assert!(
            msg.contains("failed to parse YAML"),
            "YAML error display should include context prefix, got: {msg}"
        );
    }

    #[test]
    fn display_json_error() {
        let json_err = serde_json::from_str::<serde_json::Value>("not json")
            .expect_err("should fail");
        let err = ForgeError::Json(json_err);
        let msg = err.to_string();
        assert!(
            msg.contains("failed to parse JSON"),
            "JSON error display should include context prefix, got: {msg}"
        );
    }

    #[test]
    fn display_unresolved_ref() {
        let err = ForgeError::UnresolvedRef("#/components/schemas/Missing".into());
        assert_eq!(
            err.to_string(),
            "unresolved $ref: #/components/schemas/Missing"
        );
    }

    #[test]
    fn display_schema_not_found() {
        let err = ForgeError::SchemaNotFound("NoSuchSchema".into());
        assert_eq!(err.to_string(), "schema not found: NoSuchSchema");
    }

    #[test]
    fn display_unsupported_version() {
        let err = ForgeError::UnsupportedVersion("2.0".into());
        assert_eq!(
            err.to_string(),
            "unsupported spec version: 2.0 (expected 3.0.x)"
        );
    }

    #[test]
    fn from_io_error() {
        let io_err = std::io::Error::new(std::io::ErrorKind::PermissionDenied, "denied");
        let forge_err: ForgeError = io_err.into();
        assert!(matches!(forge_err, ForgeError::Io(_)));
    }

    #[test]
    fn from_yaml_error() {
        let yaml_err = serde_yaml_ng::from_str::<serde_json::Value>("{{bad")
            .expect_err("should fail");
        let forge_err: ForgeError = yaml_err.into();
        assert!(matches!(forge_err, ForgeError::Yaml(_)));
    }

    #[test]
    fn from_json_error() {
        let json_err = serde_json::from_str::<serde_json::Value>("not json")
            .expect_err("should fail");
        let forge_err: ForgeError = json_err.into();
        assert!(matches!(forge_err, ForgeError::Json(_)));
    }

    #[test]
    fn display_invalid_input() {
        let err = ForgeError::InvalidInput("bad value".into());
        assert_eq!(err.to_string(), "invalid input: bad value");
    }

    #[test]
    fn error_is_debug() {
        let err = ForgeError::SchemaNotFound("X".into());
        let debug = format!("{err:?}");
        assert!(debug.contains("SchemaNotFound"));
    }
}