sword 0.4.1

Structured web framework built on top of tokio ecosystem, providing powerful features for building robust web applications.
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

use std::{fmt::Display, str::FromStr};

/// The runtime environment of a Sword application.
///
/// Determines which default configuration file is loaded by
/// [`ApplicationBuilder`](crate::ApplicationBuilder) when `SWORD_ENV` is set.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub enum Environment {
    #[default]
    Development,

    Production,
    Testing,
}

impl Environment {
    /// Reads the current environment from the `SWORD_ENV` variable.
    ///
    /// Returns `Ok(None)` when the variable is not set and `Err` when it is
    /// set to an invalid value.
    pub fn current() -> Result<Option<Self>, String> {
        let Ok(env) = std::env::var("SWORD_ENV") else {
            return Ok(None);
        };

        Environment::from_str(&env).map(Some)
    }

    /// The default configuration file path for this environment.
    pub fn default_config_path(&self) -> &'static str {
        match self {
            Self::Production => "config/config.prod.toml",
            Self::Development => "config/config.dev.toml",
            Self::Testing => "config/config.test.toml",
        }
    }
}

impl FromStr for Environment {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_ascii_lowercase().as_str() {
            "dev" | "development" => Ok(Self::Development),
            "prod" | "production" => Ok(Self::Production),
            "test" | "testing" => Ok(Self::Testing),
            other => Err(format!("invalid environment value: {other}")),
        }
    }
}

impl Display for Environment {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Production => write!(f, "prod"),
            Self::Development => write!(f, "dev"),
            Self::Testing => write!(f, "test"),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parses_short_names() {
        assert_eq!(
            "dev".parse::<Environment>().unwrap(),
            Environment::Development
        );
        assert_eq!(
            "prod".parse::<Environment>().unwrap(),
            Environment::Production
        );
        assert_eq!("test".parse::<Environment>().unwrap(), Environment::Testing);
    }

    #[test]
    fn parses_long_names() {
        assert_eq!(
            "development".parse::<Environment>().unwrap(),
            Environment::Development
        );
        assert_eq!(
            "production".parse::<Environment>().unwrap(),
            Environment::Production
        );
        assert_eq!(
            "testing".parse::<Environment>().unwrap(),
            Environment::Testing
        );
    }

    #[test]
    fn parses_case_insensitively() {
        assert_eq!(
            "DEV".parse::<Environment>().unwrap(),
            Environment::Development
        );
        assert_eq!(
            "Prod".parse::<Environment>().unwrap(),
            Environment::Production
        );
        assert_eq!("TEST".parse::<Environment>().unwrap(), Environment::Testing);
    }

    #[test]
    fn rejects_invalid_values() {
        assert!("staging".parse::<Environment>().is_err());
        assert!("".parse::<Environment>().is_err());
        assert!("devlopment".parse::<Environment>().is_err());
    }

    #[test]
    fn default_config_paths_match_environment() {
        assert_eq!(
            Environment::Development.default_config_path(),
            "config/config.dev.toml"
        );
        assert_eq!(
            Environment::Production.default_config_path(),
            "config/config.prod.toml"
        );
        assert_eq!(
            Environment::Testing.default_config_path(),
            "config/config.test.toml"
        );
    }
}