refactor(server): refactor env to advanced trait

Author: manhunto

server/src/bin/server.rs

@@ -5,7 +5,7 @@ use log::info;
 
 use server::amqp::{establish_connection_with_rabbit, Publisher};
 use server::dispatch_consumer::consume;
-use server::env::env_with_default;
+use server::env::{Env, EnvVar};
 use server::logs::init_log;
 use server::routes::routes;
 use server::storage::Storage;
@@ -16,7 +16,7 @@ async fn main() -> std::io::Result<()> {
     init_log();
 
     let ip = "127.0.0.1";
-    let port: u16 = env_with_default("SERVER_PORT", 8090);
+    let port: u16 = Env::env_or("SERVER_PORT", 8090);
 
     let storage = Data::new(Storage::new());
     let channel = establish_connection_with_rabbit().await;

server/src/env.rs

@@ -1,71 +1,89 @@
 use std::env;
 use std::env::VarError;
-use std::fmt::Debug;
-use std::str::FromStr;
-
-pub fn env<T>(key: &str) -> T
-where
-    T: Debug + FromStr,
-    <T as FromStr>::Err: Debug,
-{
-    get_env(key)
-        .unwrap_or_else(|_| panic!("env {} is not configured", key))
-        .parse()
-        .unwrap()
+
+pub trait EnvVar<T> {
+    fn env(key: &str) -> T;
+
+    fn env_or(key: &str, default: T) -> T;
+}
+
+pub struct Env {}
+
+impl Env {
+    fn get_env(key: &str) -> Result<String, VarError> {
+        env::var(key)
+    }
 }
 
-pub fn env_with_default<T>(key: &str, default: T) -> T
-where
-    T: Debug + FromStr,
-    <T as FromStr>::Err: Debug,
-{
-    if let Ok(var) = get_env(key) {
-        return var.parse().unwrap();
+impl EnvVar<String> for Env {
+    fn env(key: &str) -> String {
+        Self::get_env(key).unwrap_or_else(|_| panic!("env {} is not configured", key))
     }
 
-    default
+    fn env_or(key: &str, default: String) -> String {
+        Self::get_env(key).unwrap_or(default)
+    }
 }
 
-fn get_env(key: &str) -> Result<String, VarError> {
-    env::var(key)
+impl EnvVar<usize> for Env {
+    fn env(key: &str) -> usize {
+        <Self as EnvVar<String>>::env(key).parse().unwrap()
+    }
+
+    fn env_or(key: &str, default: usize) -> usize {
+        match Self::get_env(key) {
+            Ok(var) => var.parse().unwrap(),
+            Err(_) => default,
+        }
+    }
+}
+
+impl EnvVar<u16> for Env {
+    fn env(key: &str) -> u16 {
+        <Self as EnvVar<usize>>::env(key) as u16
+    }
+
+    fn env_or(key: &str, default: u16) -> u16 {
+        <Self as EnvVar<usize>>::env_or(key, default as usize) as u16
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use temp_env::{with_var, with_var_unset};
 
-    use crate::env::{env, env_with_default};
+    use crate::env::{Env, EnvVar};
 
     #[test]
     fn env_with_default_env_is_set() {
         with_var("TEST_STRING", Some("FOO"), || {
-            assert_eq!("FOO", env_with_default("TEST_STRING", "BAR".to_string()));
+            assert_eq!("FOO", Env::env_or("TEST_STRING", "BAR".to_string()));
         });
 
         with_var("TEST_INT", Some("123"), || {
-            let var: i32 = env_with_default("TEST_INT", 456);
+            let var: usize = Env::env_or("TEST_INT", 456);
             assert_eq!(123, var);
         });
     }
 
     #[test]
     fn env_with_default_env_is_not_set_then_pick_default() {
-        assert_eq!("BAR", env_with_default("TEST_STRING", "BAR".to_string()));
+        assert_eq!("BAR", Env::env_or("TEST_STRING", "BAR".to_string()));
 
-        let var: i32 = env_with_default("TEST_INT", 456);
+        let var: usize = Env::env_or("TEST_INT", 456);
         assert_eq!(456, var);
     }
 
     #[test]
     fn env_when_env_is_set() {
         with_var("TEST_STRING", Some("FOO"), || {
-            let var: String = env("TEST_STRING");
+            let var: String = Env::env("TEST_STRING");
 
             assert_eq!(String::from("FOO"), var);
         });
 
         with_var("TEST_INT", Some("132"), || {
-            let var: i32 = env("TEST_INT");
+            let var: usize = Env::env("TEST_INT");
 
             assert_eq!(132, var);
         });
@@ -75,15 +93,15 @@ mod tests {
     #[should_panic(expected = "env TEST_STRING is not configured")]
     fn env_without_string_env() {
         with_var_unset("TEST_STRING", || {
-            let _: String = env("TEST_STRING");
+            let _: String = Env::env("TEST_STRING");
         })
     }
 
     #[test]
     #[should_panic(expected = "env TEST_INT is not configured")]
     fn env_without_int_env() {
         with_var_unset("TEST_INT", || {
-            let _: u32 = env("TEST_INT");
+            let _: usize = Env::env("TEST_INT");
         })
     }
 }