roadster 0.8.1

A "Batteries Included" web framework for rust designed to get you moving fast.
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

use crate::api::core::health::db_diesel_health;
use crate::app::context::{AppContext, AppContextWeak};
use crate::error::RoadsterResult;
use crate::health::check::{CheckResponse, HealthCheck, missing_context_response};
use async_trait::async_trait;
use tracing::instrument;

pub struct DbDieselHealthCheck<C, F>
where
    C: 'static + diesel::connection::Connection + diesel::r2d2::R2D2Connection,
    F: Send + Sync + Fn(&AppContext) -> &r2d2::Pool<diesel::r2d2::ConnectionManager<C>>,
{
    context: AppContextWeak,
    name: String,
    get_pool: F,
}

impl<C, F> DbDieselHealthCheck<C, F>
where
    C: 'static + diesel::connection::Connection + diesel::r2d2::R2D2Connection,
    F: Send + Sync + Fn(&AppContext) -> &r2d2::Pool<diesel::r2d2::ConnectionManager<C>>,
{
    #[cfg_attr(
        not(any(
            feature = "db-diesel-postgres-pool",
            feature = "db-diesel-mysql-pool",
            feature = "db-diesel-sqlite-pool"
        )),
        allow(unused)
    )]
    pub(crate) fn new(context: &AppContext, name: impl ToString, get_pool: F) -> Self {
        Self {
            context: context.downgrade(),
            name: name.to_string(),
            get_pool,
        }
    }
}

#[async_trait]
impl<C, F> HealthCheck for DbDieselHealthCheck<C, F>
where
    C: 'static + diesel::connection::Connection + diesel::r2d2::R2D2Connection,
    F: Send + Sync + Fn(&AppContext) -> &r2d2::Pool<diesel::r2d2::ConnectionManager<C>>,
{
    fn name(&self) -> String {
        format!("db-diesel-{}", self.name)
    }

    fn enabled(&self) -> bool {
        self.context
            .upgrade()
            .map(|context| enabled(&context))
            .unwrap_or_default()
    }

    #[instrument(skip_all)]
    async fn check(&self) -> RoadsterResult<CheckResponse> {
        let context = self.context.upgrade();
        let response = match context {
            Some(context) => db_diesel_health((self.get_pool)(&context), None).await,
            None => missing_context_response(),
        };
        Ok(response)
    }
}

fn enabled(context: &AppContext) -> bool {
    context
        .config()
        .health_check
        .database
        .common
        .enabled(context)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::config::AppConfig;
    use rstest::rstest;

    #[rstest]
    #[case(false, Some(true), true)]
    #[case(false, Some(false), false)]
    #[cfg_attr(coverage_nightly, coverage(off))]
    fn enabled(
        #[case] default_enable: bool,
        #[case] enable: Option<bool>,
        #[case] expected_enabled: bool,
    ) {
        // Arrange
        let mut config = AppConfig::test(None).unwrap();
        config.health_check.default_enable = default_enable;
        config.health_check.database.common.enable = enable;

        let context = AppContext::test(Some(config), None, None).unwrap();

        // Act/Assert
        assert_eq!(super::enabled(&context), expected_enabled);
    }
}