openapi-to-rust 0.4.0

Generate strongly-typed Rust structs, HTTP clients, and SSE streaming clients from OpenAPI 3.1 specifications
Documentation 
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

#[cfg(test)]
mod tests {
    use openapi_to_rust::test_helpers::*;
    use serde_json::json;

    #[test]
    fn test_enum_generation_for_properties() {
        let spec = minimal_spec(json!({
            "RoleEnum": {
                "type": "string",
                "enum": ["assistant"],
                "const": "assistant"
            },
            "SimpleMessage": {
                "type": "object",
                "properties": {
                    "role": {
                        "type": "string",
                        "enum": ["assistant"],
                        "const": "assistant",
                        "default": "assistant"
                    },
                    "status": {
                        "type": "string",
                        "enum": ["active", "inactive", "pending"]
                    }
                },
                "required": ["role", "status"]
            }
        }));

        let result = test_generation("enum_properties", spec).expect("Generation failed");

        // Assert that RoleEnum was generated as a single-variant enum
        assert!(
            result.contains("pub enum RoleEnum"),
            "RoleEnum should be generated as an enum"
        );
        assert!(
            result.contains("pub enum SimpleMessageRole"),
            "SimpleMessageRole enum should be generated for role property"
        );
        assert!(
            result.contains("pub enum SimpleMessageStatus"),
            "SimpleMessageStatus enum should be generated for status property"
        );

        // Assert that the role property uses the enum type, not String
        assert!(
            !result.contains("pub role: String"),
            "role property should NOT be String"
        );
        assert!(
            result.contains("pub role: SimpleMessageRole"),
            "role property should use SimpleMessageRole enum"
        );

        // Assert that status property uses the enum type, not String
        assert!(
            !result.contains("pub status: String"),
            "status property should NOT be String"
        );
        assert!(
            result.contains("pub status: SimpleMessageStatus"),
            "status property should use SimpleMessageStatus enum"
        );

        // Verify the enum variants are correct
        assert!(
            result.contains("#[serde(rename = \"assistant\")]"),
            "RoleEnum should have assistant variant"
        );
        assert!(
            result.contains("#[serde(rename = \"active\")]"),
            "StatusEnum should have active variant"
        );
        assert!(
            result.contains("#[serde(rename = \"inactive\")]"),
            "StatusEnum should have inactive variant"
        );
        assert!(
            result.contains("#[serde(rename = \"pending\")]"),
            "StatusEnum should have pending variant"
        );

        // Verify default trait implementation
        assert!(result.contains("Default"), "Enums should derive Default");
        assert!(
            result.contains("#[default]"),
            "Enums should have a default variant marked"
        );
    }
}