crates/backend/src/main.rs

@@ -76,9 +76,19 @@ async fn main() -> std::io::Result<()> {
     .await
 }
 
+#[cfg(not(test))]
+fn get_env_var(name: &str) -> dotenvy::Result<String> {
+    dotenvy::var(name)
+}
+
+#[cfg(test)]
+fn get_env_var(name: &str) -> Result<String, std::env::VarError> {
+    std::env::var(name)
+}
+
 async fn connect_to_redis_database() -> RedisSessionStore {
-    let redis_host = dotenvy::var("REDIS_HOST").expect("REDIS_HOST must be set in .env");
+    let redis_host = get_env_var("REDIS_HOST").expect("REDIS_HOST must be set in .env");
-    let redis_port = dotenvy::var("REDIS_PORT")
+    let redis_port = get_env_var("REDIS_PORT")
         .map(|x| x.parse::<u16>().expect("REDIS_PORT is not a valid port"))
         .unwrap_or(6379);
     let redis_connection_string = format!("redis://{}:{}", redis_host, redis_port);
@@ -86,15 +96,15 @@ async fn connect_to_redis_database() -> RedisSessionStore {
         .await
         .unwrap();
 
-    return store;
+    store
 }
 
 fn build_database_url() -> String {
-    let db_user = dotenvy::var("DB_USER").unwrap_or("pgg".to_owned());
+    let db_user = get_env_var("DB_USER").unwrap_or_else(|_| "pgg".to_owned());
-    let db_name = dotenvy::var("DB_NAME").unwrap_or("pgg".to_owned());
+    let db_name = get_env_var("DB_NAME").unwrap_or_else(|_| "pgg".to_owned());
-    let db_password = dotenvy::var("DB_PASSWORD").unwrap_or("pgg".to_owned());
+    let db_password = get_env_var("DB_PASSWORD").unwrap_or_else(|_| "pgg".to_owned());
-    let db_host = dotenvy::var("DB_HOST").expect("DB_HOST must be set in .env");
+    let db_host = get_env_var("DB_HOST").expect("DB_HOST must be set in .env");
-    let db_port = dotenvy::var("DB_PORT")
+    let db_port = get_env_var("DB_PORT")
         .map(|x| x.parse::<u16>().expect("DB_PORT is not a valid port"))
         .unwrap_or(5432);
 
@@ -109,18 +119,15 @@ fn build_database_url() -> String {
 
 #[cfg(test)]
 mod tests {
+    use std::env;
     use super::*;
-    use temp_env::{with_vars, with_vars_unset};
+    use temp_env::{with_var, with_vars};
 
     #[test]
     fn build_database_url_with_defaults() {
-        temp_env::with_vars(
+        with_vars(
             [
-                ("DB_USER", None::<&str>),
-                ("DB_NAME", None::<&str>),
-                ("DB_PASSWORD", None::<&str>),
                 ("DB_HOST", Some("localhost")),
-                ("DB_PORT", None::<&str>),
             ],
             || {
                 let expected_url = "postgresql://pgg:pgg@localhost:5432/pgg";
@@ -157,27 +164,22 @@ mod tests {
     #[test]
     #[should_panic(expected = "DB_HOST must be set in .env")]
     fn build_database_url_missing_host_panics() {
-        // Clear the environment variable completely
+        with_var("DB_HOST", None::<&str>, || {
-        unsafe { std::env::remove_var("DB_HOST") };
+            build_database_url();
-        build_database_url();
+        });
     }
 
     #[test]
     fn connect_to_redis_database_with_defaults() {
-        // This test requires a running Redis instance
-        // We're mocking the successful connection here
         with_vars(
             [
                 ("REDIS_HOST", Some("localhost")),
-                ("REDIS_PORT", None::<&str>),
             ],
             || {
                 let expected_conn_string = "redis://localhost:6379";
 
-                // Just verify the connection string format is correct
+                let redis_host = get_env_var("REDIS_HOST").unwrap_or_default();
-                // Actual connection would need integration tests
+                let redis_port = get_env_var("REDIS_PORT")
-                let redis_host = dotenvy::var("REDIS_HOST").unwrap_or_default();
-                let redis_port = dotenvy::var("REDIS_PORT")
                     .map(|x| x.parse::<u16>().unwrap_or(6379))
                     .unwrap_or(6379);
                 let actual_conn_string = format!("redis://{}:{}", redis_host, redis_port);
@@ -200,9 +202,8 @@ mod tests {
             || {
                 let expected_conn_string = "redis://redis.internal:6380";
 
-                // Verify connection string format
+                let redis_host = get_env_var("REDIS_HOST").unwrap_or_default();
-                let redis_host = dotenvy::var("REDIS_HOST").unwrap_or_default();
+                let redis_port = get_env_var("REDIS_PORT")
-                let redis_port = dotenvy::var("REDIS_PORT")
                     .map(|x| x.parse::<u16>().unwrap_or(6379))
                     .unwrap_or(6379);
                 let actual_conn_string = format!("redis://{}:{}", redis_host, redis_port);
@@ -214,4 +215,16 @@ mod tests {
             },
         );
     }
+
+    #[test]
+    fn check_if_no_env_variables_are_loaded_from_environment_file() {
+        assert_eq!(env::var("DB_NAME"), Err(env::VarError::NotPresent));
+        assert_eq!(env::var("DB_USER"), Err(env::VarError::NotPresent));
+        assert_eq!(env::var("DB_PASSWORD"), Err(env::VarError::NotPresent));
+        assert_eq!(env::var("DB_HOST"), Err(env::VarError::NotPresent));
+        assert_eq!(env::var("DB_PORT"), Err(env::VarError::NotPresent));
+
+        assert_eq!(env::var("REDIS_PORT"), Err(env::VarError::NotPresent));
+        assert_eq!(env::var("REDIS_HOST"), Err(env::VarError::NotPresent));
+    }
 }