Add comprehensive config tests

- Test all ConfigError ADT types and messages
- Test Environment conversions and current detection
- Test all type-safe accessors and optional variants
- Test throw accessors for error cases
- Test process-scoped config behavior and immutability
- 23 tests covering all config functionality

Author: vim89

cask/test/src/cask/ConfigTests.scala

@@ -1,90 +1,188 @@
 package test.cask
 
+import cask.Config
+import cask.Config.ConfigError
+import cask.Config.Environment
 import utest._
 
 object ConfigTests extends TestSuite {
 
   val tests = Tests {
-    test("ADT error types") {
-      val missing = cask.Config.ConfigError.Missing("test.key")
-      assert(missing.message.contains("missing"))
+    test("ConfigError ADT") {
+      test("Missing") {
+        val missing = ConfigError.Missing("test.key")
+        assert(missing.message.contains("missing"))
+        assert(missing.message.contains("test.key"))
+      }
+
+      test("InvalidType") {
+        val invalidType = ConfigError.InvalidType("test.key", "String", "Int")
+        assert(invalidType.message.contains("expected"))
+        assert(invalidType.message.contains("String"))
+        assert(invalidType.message.contains("Int"))
+      }
+
+      test("LoadFailure") {
+        val loadFailure = ConfigError.LoadFailure("file not found")
+        assert(loadFailure.message.contains("Failed to load"))
+        assert(loadFailure.message.contains("file not found"))
+      }
 
-      val invalidType = cask.Config.ConfigError.InvalidType("test.key", "String", "Int")
-      assert(invalidType.message.contains("expected"))
+      test("ParseFailure") {
+        val parseFailure = ConfigError.ParseFailure("test.key", "invalid", "syntax error")
+        assert(parseFailure.message.contains("test.key"))
+        assert(parseFailure.message.contains("invalid"))
+        assert(parseFailure.message.contains("syntax error"))
+      }
     }
 
-    test("Environment from string") {
-      import cask.Config.Environment._
+    test("Environment") {
+      test("fromString conversions") {
+        assert(Environment.fromString("dev") == Environment.Development)
+        assert(Environment.fromString("development") == Environment.Development)
+        assert(Environment.fromString("test") == Environment.Test)
+        assert(Environment.fromString("prod") == Environment.Production)
+        assert(Environment.fromString("production") == Environment.Production)
+
+        val custom = Environment.fromString("staging")
+        assert(custom.isInstanceOf[Environment.Custom])
+        assert(custom.name == "staging")
+      }
+
+      test("current environment") {
+        val env = Environment.current
+        assert(env.isInstanceOf[Environment])
+        assert(env.name.nonEmpty)
+      }
 
-      assert(fromString("dev") == Development)
-      assert(fromString("development") == Development)
-      assert(fromString("test") == Test)
-      assert(fromString("prod") == Production)
-      assert(fromString("production") == Production)
-      assert(fromString("staging").isInstanceOf[Custom])
+      test("environment names") {
+        assert(Environment.Development.name == "dev")
+        assert(Environment.Test.name == "test")
+        assert(Environment.Production.name == "prod")
+        assert(Environment.Custom("staging").name == "staging")
+      }
     }
 
-    test("Config loader Either pattern") {
-      val result = cask.Config.getString("nonexistent.key")
-      assert(result.isLeft)
+    test("Config getString") {
+      test("missing key returns Left") {
+        val result = Config.getString("nonexistent.key")
+        assert(result.isLeft)
 
-      result match {
-        case Left(error) => assert(error.message.contains("missing"))
-        case Right(_) => assert(false)
+        result match {
+          case Left(error) =>
+            assert(error.isInstanceOf[ConfigError.Missing])
+            assert(error.message.contains("missing"))
+          case Right(_) => assert(false)
+        }
+      }
+
+      test("pattern matching on Either") {
+        Config.getString("nonexistent") match {
+          case Left(_: ConfigError.Missing) => // Expected
+          case _ => assert(false)
+        }
       }
     }
 
-    test("Optional config accessors") {
-      val opt = cask.Config.getStringOpt("nonexistent.key")
-      assert(opt.isEmpty)
+    test("Config optional accessors") {
+      test("getStringOpt returns None for missing") {
+        val opt = Config.getStringOpt("nonexistent.key")
+        assert(opt.isEmpty)
+      }
+
+      test("getIntOpt returns None for missing") {
+        val opt = Config.getIntOpt("nonexistent.key")
+        assert(opt.isEmpty)
+      }
+
+      test("getBooleanOpt returns None for missing") {
+        val opt = Config.getBooleanOpt("nonexistent.key")
+        assert(opt.isEmpty)
+      }
     }
 
-    test("Type-safe accessors with different types") {
-      // These will work if application.conf exists with proper values
-      // Test that methods exist and return correct types
-      locally {
-        val _: Either[cask.Config.ConfigError, String] = cask.Config.getString("any.key")
+    test("Config type-safe accessors") {
+      test("getString returns Either") {
+        val _: Either[ConfigError, String] = Config.getString("any.key")
       }
-      locally {
-        val _: Either[cask.Config.ConfigError, Int] = cask.Config.getInt("any.key")
+
+      test("getInt returns Either") {
+        val _: Either[ConfigError, Int] = Config.getInt("any.key")
       }
-      locally {
-        val _: Either[cask.Config.ConfigError, Boolean] = cask.Config.getBoolean("any.key")
+
+      test("getBoolean returns Either") {
+        val _: Either[ConfigError, Boolean] = Config.getBoolean("any.key")
       }
-      locally {
-        val _: Either[cask.Config.ConfigError, Long] = cask.Config.getLong("any.key")
+
+      test("getLong returns Either") {
+        val _: Either[ConfigError, Long] = Config.getLong("any.key")
       }
-      locally {
-        val _: Either[cask.Config.ConfigError, Double] = cask.Config.getDouble("any.key")
+
+      test("getDouble returns Either") {
+        val _: Either[ConfigError, Double] = Config.getDouble("any.key")
       }
     }
 
-    test("Environment detection from CASK_ENV") {
-      val env = cask.Config.Environment.current
-      // Should default to Development if CASK_ENV not set
-      assert(env.isInstanceOf[cask.Config.Environment])
+    test("Config throw accessors") {
+      test("getStringOrThrow throws on missing") {
+        try {
+          Config.getStringOrThrow("nonexistent.key")
+          assert(false)
+        } catch {
+          case e: RuntimeException => assert(e.getMessage.contains("missing"))
+        }
+      }
+
+      test("getIntOrThrow throws on missing") {
+        try {
+          Config.getIntOrThrow("nonexistent.key")
+          assert(false)
+        } catch {
+          case e: RuntimeException => assert(e.getMessage.contains("missing"))
+        }
+      }
+
+      test("getBooleanOrThrow throws on missing") {
+        try {
+          Config.getBooleanOrThrow("nonexistent.key")
+          assert(false)
+        } catch {
+          case e: RuntimeException => assert(e.getMessage.contains("missing"))
+        }
+      }
     }
 
-    test("Config error pattern matching") {
-      import cask.Config.ConfigError._
+    test("Config underlying Typesafe Config access") {
+      val underlying = Config.underlying
+      assert(underlying != null)
+      assert(underlying.isInstanceOf[com.typesafe.config.Config])
+    }
 
-      val errors: Seq[cask.Config.ConfigError] = Seq(
-        Missing("key1"),
-        InvalidType("key2", "String", "Int"),
-        LoadFailure("cause"),
-        ParseFailure("key3", "value", "cause")
+    test("ConfigError pattern matching") {
+      val errors: Seq[ConfigError] = Seq(
+        ConfigError.Missing("key1"),
+        ConfigError.InvalidType("key2", "String", "Int"),
+        ConfigError.LoadFailure("cause"),
+        ConfigError.ParseFailure("key3", "value", "cause")
       )
 
       errors.foreach { error =>
         error match {
-          case Missing(key) => assert(key.nonEmpty)
-          case InvalidType(key, expected, actual) =>
+          case ConfigError.Missing(key) => assert(key.nonEmpty)
+          case ConfigError.InvalidType(key, expected, actual) =>
             assert(key.nonEmpty && expected.nonEmpty && actual.nonEmpty)
-          case LoadFailure(cause) => assert(cause.nonEmpty)
-          case ParseFailure(key, value, cause) =>
+          case ConfigError.LoadFailure(cause) => assert(cause.nonEmpty)
+          case ConfigError.ParseFailure(key, value, cause) =>
             assert(key.nonEmpty && cause.nonEmpty)
         }
       }
     }
+
+    test("Config is process-scoped and immutable") {
+      // Multiple accesses return same underlying config
+      val config1 = Config.underlying
+      val config2 = Config.underlying
+      assert(config1 eq config2)
+    }
   }
 }