typeway-server 0.1.0

Server runtime for the typeway type-level web framework
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

//! Integration test: verify the server serves /openapi.json and /docs.
//!
//! Run: cargo test -p typeway-server --features openapi --test openapi_integration

#![cfg(feature = "openapi")]

use std::sync::Arc;

use typeway_core::*;
use typeway_macros::*;
use typeway_openapi::*;
use typeway_server::*;

// --- Domain types with ToSchema impls ---

struct User;
impl ToSchema for User {
    fn schema() -> typeway_openapi::spec::Schema {
        typeway_openapi::spec::Schema::object()
    }
    fn type_name() -> &'static str {
        "User"
    }
}

// --- API definition ---

typeway_path!(type HelloPath = "hello");

type API = (GetEndpoint<HelloPath, User>,);

async fn hello() -> &'static str {
    "hello"
}

// --- Test helpers ---

async fn start_server_with_openapi() -> u16 {
    let server = Server::<API>::new((bind::<_, _, _>(hello),)).with_openapi("Test API", "1.0.0");

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
    let port = listener.local_addr().unwrap().port();

    tokio::spawn(async move {
        let router = Arc::new(server.into_router());
        loop {
            let (stream, _) = listener.accept().await.unwrap();
            let io = hyper_util::rt::TokioIo::new(stream);
            let router = router.clone();
            tokio::spawn(async move {
                let svc = hyper::service::service_fn(move |req| {
                    let router = router.clone();
                    async move { Ok::<_, std::convert::Infallible>(router.route(req).await) }
                });
                let _ = hyper::server::conn::http1::Builder::new()
                    .serve_connection(io, svc)
                    .await;
            });
        }
    });

    tokio::time::sleep(std::time::Duration::from_millis(50)).await;
    port
}

// --- Tests ---

#[tokio::test]
async fn openapi_json_is_served() {
    let port = start_server_with_openapi().await;
    let resp = reqwest::get(format!("http://127.0.0.1:{port}/openapi.json"))
        .await
        .unwrap();

    assert_eq!(resp.status(), 200);
    assert_eq!(
        resp.headers().get("content-type").unwrap(),
        "application/json"
    );

    let body: serde_json::Value = resp.json().await.unwrap();
    assert_eq!(body["openapi"], "3.1.0");
    assert_eq!(body["info"]["title"], "Test API");
    assert_eq!(body["info"]["version"], "1.0.0");
    assert!(body["paths"]["/hello"]["get"].is_object());
}

#[tokio::test]
async fn docs_page_is_served() {
    let port = start_server_with_openapi().await;
    let resp = reqwest::get(format!("http://127.0.0.1:{port}/docs"))
        .await
        .unwrap();

    assert_eq!(resp.status(), 200);
    assert_eq!(
        resp.headers().get("content-type").unwrap(),
        "text/html; charset=utf-8"
    );

    let body = resp.text().await.unwrap();
    assert!(body.contains("API Documentation"));
    assert!(body.contains("Test API"));
    assert!(body.contains("/hello"));
}

#[tokio::test]
async fn normal_routes_still_work() {
    let port = start_server_with_openapi().await;
    let resp = reqwest::get(format!("http://127.0.0.1:{port}/hello"))
        .await
        .unwrap();

    assert_eq!(resp.status(), 200);
    let body = resp.text().await.unwrap();
    assert_eq!(body, "hello");
}