springtime-web-axum 3.0.1

Web framework based on Springtime and axum.
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
136
137
138
139
140
141
142
143

//! Controller routing handling. By default, routing is based on gathering existing controllers and
//! their request handlers.

use crate::controller::Controller;
use axum::Router;
#[cfg(test)]
use mockall::automock;
use springtime_di::component_registry::conditional::unregistered_component;
use springtime_di::instance_provider::{ComponentInstancePtr, ErrorPtr};
use springtime_di::{component_alias, injectable, Component};
use tracing::debug;

/// Trait for configuring [Router] created by [RouterBootstrap]. Multiple such components can be
/// present and each one will be called with the current router instance.
#[injectable]
#[cfg_attr(test, automock)]
pub trait RouterConfigure {
    /// Configure and return existing [Router].
    fn configure(&self, router: Router) -> Result<Router, ErrorPtr>;
}

/// Trait for creating a [Router], usually based on injected
/// [Controller](crate::controller::Controller)s.
#[injectable]
pub trait RouterBootstrap {
    /// Creates a new [Router].
    fn bootstrap_router(&self, server_name: &str) -> Result<Router, ErrorPtr>;
}

#[derive(Component)]
#[component(priority = -128, condition = "unregistered_component::<dyn RouterBootstrap + Send + Sync>")]
struct ControllerRouterBootstrap {
    controllers: Vec<ComponentInstancePtr<dyn Controller + Send + Sync>>,
    configure_components: Vec<ComponentInstancePtr<dyn RouterConfigure + Send + Sync>>,
}

#[component_alias]
impl RouterBootstrap for ControllerRouterBootstrap {
    fn bootstrap_router(&self, server_name: &str) -> Result<Router, ErrorPtr> {
        self.controllers
            .iter()
            .filter(|controller| {
                controller
                    .server_names()
                    .map(|server_names| server_names.contains(server_name))
                    .unwrap_or(true)
            })
            .try_fold(Router::new(), |router, controller| {
                let path = controller.path().unwrap_or_else(|| "/".to_string());
                let inner_router = controller.create_router()?;

                debug!(path, "Registering new controller routes.");

                controller
                    .configure_router(inner_router, controller.clone())
                    .and_then(|inner_router| controller.post_configure_router(inner_router))
                    .map(|inner_router| {
                        if path.is_empty() || path == "/" {
                            // cannot nest root-level routers
                            router.merge(inner_router)
                        } else {
                            router.nest(&path, inner_router)
                        }
                    })
            })
            .and_then(|router| {
                self.configure_components
                    .iter()
                    .try_fold(router, |router, configure| configure.configure(router))
            })
    }
}

#[cfg(test)]
mod tests {
    use crate::controller::MockController;
    use crate::router::{ControllerRouterBootstrap, MockRouterConfigure, RouterBootstrap};
    use axum::Router;
    use rustc_hash::FxHashSet;
    use springtime_di::instance_provider::ComponentInstancePtr;

    #[test]
    fn should_configure_router_with_filtering() {
        let mut controller = MockController::new();
        controller
            .expect_configure_router()
            .times(1)
            .return_const(Ok(Router::new()));
        controller.expect_server_names().times(1).return_const(
            ["1".to_string(), "2".to_string()]
                .into_iter()
                .collect::<FxHashSet<_>>(),
        );
        controller.expect_path().return_const(None);
        controller
            .expect_create_router()
            .return_const(Ok(Router::new()));
        controller
            .expect_post_configure_router()
            .returning(|router| Ok(router));

        let bootstrap = ControllerRouterBootstrap {
            controllers: vec![ComponentInstancePtr::new(controller)],
            configure_components: vec![],
        };
        assert!(bootstrap.bootstrap_router("1").is_ok());
    }

    #[test]
    fn should_not_configure_router_with_filtering() {
        let mut controller = MockController::new();
        controller
            .expect_configure_router()
            .times(0)
            .return_const(Ok(Router::new()));
        controller.expect_server_names().times(1).return_const(
            ["1".to_string(), "2".to_string()]
                .into_iter()
                .collect::<FxHashSet<_>>(),
        );

        let bootstrap = ControllerRouterBootstrap {
            controllers: vec![ComponentInstancePtr::new(controller)],
            configure_components: vec![],
        };
        assert!(bootstrap.bootstrap_router("3").is_ok());
    }

    #[test]
    fn should_pass_existing_router_for_configuration() {
        let mut configure = MockRouterConfigure::new();
        configure
            .expect_configure()
            .times(1)
            .returning(|router| Ok(router));

        let bootstrap = ControllerRouterBootstrap {
            controllers: vec![],
            configure_components: vec![ComponentInstancePtr::new(configure)],
        };
        assert!(bootstrap.bootstrap_router("1").is_ok());
    }
}