rezervovator/src/config.rs

#[cfg(feature = "ssr")]
use std::fs::read_to_string;
#[cfg(feature = "ssr")]
use std::net::SocketAddr;
#[cfg(feature = "ssr")]
use std::str::FromStr;
#[cfg(feature = "ssr")]
use serde::Deserialize;

#[cfg(feature = "ssr")]
#[derive(Deserialize)]
pub struct Network {
    bind_ip: String,
    port: u16
}

#[cfg(feature = "ssr")]
#[derive(Deserialize)]
pub struct Session {
    key: String
}

#[cfg(feature = "ssr")]
impl Session {
    pub fn key(&self) -> &[u8] {
        self.key.as_bytes()
    }
}

#[cfg(feature = "ssr")]
impl Network {
    pub fn bind_address(&self) -> SocketAddr {
        SocketAddr::from_str(format!("{}:{}", &self.bind_ip, self.port).as_str()).expect("Can't parse bind IP address")
    }
}

#[cfg(feature = "ssr")]
#[derive(Deserialize)]
pub struct Database {
    user: String,
    password: String,
    db_name: String,
    host: String,
    port: Option<u16>
}

#[cfg(feature = "ssr")]
impl Database {
    pub fn con_string(&self) -> String {
        format!("postgres://{}:{}@{}:{}/{}", self.user, self.password, self.host, self.port.unwrap_or(5432), self.db_name)
    }
}

#[cfg(feature = "ssr")]
#[derive(Deserialize, Clone)]
pub enum MailTransport {
    Smtp,
    File
}

#[cfg(feature = "ssr")]
#[derive(Deserialize, Clone)]
pub struct Mailing {
    transport: MailTransport,
    from: String,
    path: Option<String>,
    server: Option<String>,
    hello_name: Option<String>,
    port: Option<u16>,
    user: Option<String>,
    password: Option<String>,
    tls: Option<bool>,
    accept_all_certs: Option<bool>
}

#[cfg(feature = "ssr")]
impl Mailing {
    pub fn transport(&self) -> &MailTransport {
        &self.transport
    }
    pub fn from(&self) -> &str {
        &self.from
    }
    pub fn path(&self) -> &Option<String> {
        &self.path
    }
    pub fn server(&self) -> &Option<String> {
        &self.server
    }
    pub fn hello_name(&self) -> &Option<String> {
        &self.hello_name
    }
    pub fn port(&self) -> Option<u16> {
        self.port
    }
    pub fn user(&self) -> &Option<String> {
        &self.user
    }
    pub fn password(&self) -> &Option<String> {
        &self.password
    }
    pub fn tls(&self) -> Option<bool> {
        self.tls
    }
    pub fn accept_all_certs(&self) -> Option<bool> {
        self.accept_all_certs
    }
}

#[cfg(feature = "ssr")]
#[derive(Deserialize)]
pub struct Logging {
    severity: String
}

#[cfg(feature = "ssr")]
impl Logging {
    pub fn severity(&self) -> &str {
        &self.severity
    }
}

#[cfg(feature = "ssr")]
#[derive(Deserialize)]
pub struct Configuration {
    session: Session,
    network: Network,
    database: Database,
    mailing: Mailing,
    logging: Logging
}

#[cfg(feature = "ssr")]
impl Configuration {
    pub fn session(&self) -> &Session {
        &self.session
    }
    pub fn network(&self) -> &Network {
        &self.network
    }
    pub fn database(&self) -> &Database {
        &self.database
    }
    pub fn mailing(&self) -> &Mailing {
        &self.mailing
    }
    pub fn logging(&self) -> &Logging {
        &self.logging
    }
}

#[cfg(feature = "ssr")]
pub fn load_config(path: &str) -> Configuration {
    toml::from_str(read_to_string(path).expect("Can not open config file").as_str()).expect("Can not parse config file")
}



#[cfg(all(test, feature = "ssr"))]
mod tests {
    use super::*;

    fn sample() -> Configuration {
        load_config(concat!(env!("CARGO_MANIFEST_DIR"), "/config_sample.toml"))
    }

    #[test]
    fn sample_config_is_valid() {
        let config = sample();

        assert_eq!(config.network().bind_address(), SocketAddr::from_str("127.0.0.1:3000").unwrap());
        assert_eq!(config.database().con_string(), "postgres://user:password@localhost:5432/rezervator");
        assert_eq!(config.logging().severity(), "debug");
        assert!(matches!(config.mailing().transport(), MailTransport::File));
        assert_eq!(config.mailing().from(), "[email protected]");
        assert_eq!(config.mailing().path(), &Some("Maildir".to_string()));
        assert_eq!(config.mailing().server(), &None);
    }

    #[test]
    fn sample_session_key_is_long_enough() {
        // actix_web::cookie::Key::from panics on keys shorter than 64 bytes
        assert!(sample().session().key().len() >= 64);
    }

    #[test]
    fn database_port_defaults_to_5432() {
        let database: Database = toml::from_str(
            "user = 'u'\npassword = 'p'\ndb_name = 'db'\nhost = 'db.example.com'").unwrap();

        assert_eq!(database.con_string(), "postgres://u:[email protected]:5432/db");
    }

    #[test]
    fn database_custom_port() {
        let database: Database = toml::from_str(
            "user = 'u'\npassword = 'p'\ndb_name = 'db'\nhost = 'db.example.com'\nport = 6543").unwrap();

        assert_eq!(database.con_string(), "postgres://u:[email protected]:6543/db");
    }

    #[test]
    fn smtp_mailing_config() {
        let mailing: Mailing = toml::from_str(
            "transport = 'Smtp'\nfrom = '[email protected]'\nserver = 'smtp.b.cz'\nport = 587\ntls = true").unwrap();

        assert!(matches!(mailing.transport(), MailTransport::Smtp));
        assert_eq!(mailing.server(), &Some("smtp.b.cz".to_string()));
        assert_eq!(mailing.port(), Some(587));
        assert_eq!(mailing.tls(), Some(true));
        assert_eq!(mailing.accept_all_certs(), None);
    }
}