openapi-trait 0.0.2

Generate typed Rust traits from OpenAPI specifications using a proc-macro attribute
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
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

//! Integration tests for the `openapi_trait_axum` macro using the Petstore spec.

#[openapi_trait::axum("assets/testdata/petstore.openapi.yaml")]
pub mod petstore {}

use petstore::PetstoreApi as _;

// ---- Minimal implementation for compilation check ----

#[derive(Clone)]
struct MockPetstore;

impl petstore::PetstoreApi for MockPetstore {
    type Error = ::std::convert::Infallible;
}

#[test]
fn router_compiles() {
    let _router = MockPetstore.router();
}

#[test]
fn get_pet_by_id_request_has_pet_id_field() {
    let req = petstore::GetPetByIdRequest { pet_id: 42 };
    assert_eq!(req.pet_id, 42);
}

#[test]
fn find_pets_by_status_uses_enum_query() {
    let req = petstore::FindPetsByStatusRequest {
        status: petstore::FindPetsByStatusStatusQuery::Available,
    };
    let _ = req;
}

// ---- Server integration tests ----

#[tokio::test]
async fn axum_server_routes_matched_path() {
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();

    let app = MockPetstore.router().with_state(());
    tokio::spawn(async move {
        axum::serve(listener, app).await.unwrap();
    });

    let client = reqwest::Client::new();

    // Matched route: default impl returns Default → 500 INTERNAL_SERVER_ERROR
    let status = client
        .get(format!("http://{addr}/pet/42"))
        .send()
        .await
        .unwrap()
        .status();
    assert_eq!(status, reqwest::StatusCode::INTERNAL_SERVER_ERROR);
}

#[tokio::test]
async fn axum_server_returns_404_for_unknown_route() {
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();

    let app = MockPetstore.router().with_state(());
    tokio::spawn(async move {
        axum::serve(listener, app).await.unwrap();
    });

    let status = reqwest::get(format!("http://{addr}/no-such-route"))
        .await
        .unwrap()
        .status();
    assert_eq!(status, reqwest::StatusCode::NOT_FOUND);
}

#[derive(Clone)]
struct RichMockPetstore;

impl petstore::PetstoreApi for RichMockPetstore {
    type Error = ::std::convert::Infallible;

    async fn get_pet_by_id(
        &self,
        req: petstore::GetPetByIdRequest,
        _state: axum::extract::State<()>,
        _headers: axum::http::HeaderMap,
    ) -> Result<petstore::GetPetByIdResponse, Self::Error> {
        if req.pet_id == 42 {
            Ok(petstore::GetPetByIdResponse::Status200(petstore::Pet {
                id: Some(42),
                name: "doggie".into(),
                photo_urls: vec!["https://example.com/photo.jpg".into()],
                category: None,
                tags: None,
                status: None,
            }))
        } else {
            Ok(petstore::GetPetByIdResponse::Status404)
        }
    }
}

#[tokio::test]
async fn axum_server_get_pet_by_id_returns_200_and_404() {
    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let addr = listener.local_addr().unwrap();

    let app = RichMockPetstore.router().with_state(());
    tokio::spawn(async move {
        axum::serve(listener, app).await.unwrap();
    });

    let client = reqwest::Client::new();

    // Known pet → 200 with JSON body
    let resp = client
        .get(format!("http://{addr}/pet/42"))
        .send()
        .await
        .unwrap();
    assert_eq!(resp.status(), reqwest::StatusCode::OK);
    let body: serde_json::Value = resp.json().await.unwrap();
    assert_eq!(body["id"], 42);
    assert_eq!(body["name"], "doggie");

    // Unknown pet → 404
    let status = client
        .get(format!("http://{addr}/pet/99"))
        .send()
        .await
        .unwrap()
        .status();
    assert_eq!(status, reqwest::StatusCode::NOT_FOUND);
}