modo-rs 0.8.0

Rust web framework for small monolithic apps
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

use axum::Router;
use http::Method;

use crate::service::{AppState, Registry};

use super::request::TestRequestBuilder;

/// An assembled test application ready to receive in-process HTTP requests.
///
/// Obtain one via [`TestApp::builder()`] or [`TestApp::from_router()`].
/// Each HTTP-method helper returns a [`TestRequestBuilder`] that you configure
/// and then drive to completion with `.send().await`.
pub struct TestApp {
    router: Router,
}

/// Builder for [`TestApp`].
///
/// Register services, routes, layers, and merged sub-routers before calling
/// [`build()`](TestAppBuilder::build) to produce a [`TestApp`].
#[must_use]
pub struct TestAppBuilder {
    registry: Registry,
    router: Router<AppState>,
}

impl TestApp {
    /// Create a new [`TestAppBuilder`] with an empty registry and router.
    pub fn builder() -> TestAppBuilder {
        TestAppBuilder {
            registry: Registry::new(),
            router: Router::new(),
        }
    }

    /// Wrap an existing [`Router`] (already finalized with state) in a [`TestApp`].
    ///
    /// Use this when you have a fully-assembled `Router` and do not need the
    /// builder's service-registry integration.
    pub fn from_router(router: Router) -> Self {
        Self { router }
    }

    /// Start a `GET` request to `uri`.
    pub fn get(&self, uri: &str) -> TestRequestBuilder {
        self.request(Method::GET, uri)
    }

    /// Start a `POST` request to `uri`.
    pub fn post(&self, uri: &str) -> TestRequestBuilder {
        self.request(Method::POST, uri)
    }

    /// Start a `PUT` request to `uri`.
    pub fn put(&self, uri: &str) -> TestRequestBuilder {
        self.request(Method::PUT, uri)
    }

    /// Start a `PATCH` request to `uri`.
    pub fn patch(&self, uri: &str) -> TestRequestBuilder {
        self.request(Method::PATCH, uri)
    }

    /// Start a `DELETE` request to `uri`.
    pub fn delete(&self, uri: &str) -> TestRequestBuilder {
        self.request(Method::DELETE, uri)
    }

    /// Start an `OPTIONS` request to `uri`.
    pub fn options(&self, uri: &str) -> TestRequestBuilder {
        self.request(Method::OPTIONS, uri)
    }

    /// Start a request with an arbitrary HTTP `method` to `uri`.
    pub fn request(&self, method: Method, uri: &str) -> TestRequestBuilder {
        TestRequestBuilder::new(self.router.clone(), method, uri)
    }
}

impl TestAppBuilder {
    /// Register a service value of type `T` in the service registry.
    ///
    /// The value is stored by its concrete type and can be extracted in
    /// handlers via `modo::service::Service<T>`.
    pub fn service<T: Send + Sync + 'static>(mut self, val: T) -> Self {
        self.registry.add(val);
        self
    }

    /// Add a route to the test router.
    pub fn route(
        mut self,
        path: &str,
        method_router: axum::routing::MethodRouter<AppState>,
    ) -> Self {
        self.router = self.router.route(path, method_router);
        self
    }

    /// Apply a Tower middleware layer to the test router.
    pub fn layer<L>(mut self, layer: L) -> Self
    where
        L: tower::Layer<axum::routing::Route> + Clone + Send + Sync + 'static,
        L::Service: tower::Service<http::Request<axum::body::Body>> + Clone + Send + Sync + 'static,
        <L::Service as tower::Service<http::Request<axum::body::Body>>>::Response:
            axum::response::IntoResponse + 'static,
        <L::Service as tower::Service<http::Request<axum::body::Body>>>::Error:
            Into<std::convert::Infallible> + 'static,
        <L::Service as tower::Service<http::Request<axum::body::Body>>>::Future: Send + 'static,
    {
        self.router = self.router.layer(layer);
        self
    }

    /// Merge another `Router<AppState>` into the test router.
    pub fn merge(mut self, router: Router<AppState>) -> Self {
        self.router = self.router.merge(router);
        self
    }

    /// Finalize the builder: bind the service registry as router state and
    /// return a [`TestApp`] ready for sending requests.
    pub fn build(self) -> TestApp {
        let state = self.registry.into_state();
        TestApp {
            router: self.router.with_state(state),
        }
    }
}