test: update to ${VAR}

Author: Winston-503

tests/test_api_key_from_env.py

@@ -1,16 +1,16 @@
 """
-Tests for api_key from_env configuration feature
+Tests for api_key ${VAR} environment variable substitution in configuration.
 """
 
 import os
 import tempfile
 import unittest
 
-from openevolve.config import Config, LLMModelConfig
+from openevolve.config import Config, LLMModelConfig, _resolve_env_var
 
 
-class TestApiKeyFromEnv(unittest.TestCase):
-    """Tests for api_key from_env parameter handling in configuration"""
+class TestEnvVarSubstitution(unittest.TestCase):
+    """Tests for ${VAR} environment variable substitution in api_key fields"""
 
     def setUp(self):
         """Set up test environment variables"""
@@ -23,9 +23,32 @@ def tearDown(self):
         if self.test_env_var in os.environ:
             del os.environ[self.test_env_var]
 
-    def test_api_key_from_env_in_model_config(self):
-        """Test that api_key can be loaded from environment variable via from_env"""
-        model_config = LLMModelConfig(name="test-model", api_key={"from_env": self.test_env_var})
+    def test_resolve_env_var_with_match(self):
+        """Test that _resolve_env_var resolves ${VAR} syntax"""
+        result = _resolve_env_var(f"${{{self.test_env_var}}}")
+        self.assertEqual(result, self.test_api_key)
+
+    def test_resolve_env_var_no_match(self):
+        """Test that strings without ${VAR} are returned unchanged"""
+        result = _resolve_env_var("regular-api-key")
+        self.assertEqual(result, "regular-api-key")
+
+    def test_resolve_env_var_none(self):
+        """Test that None is returned unchanged"""
+        result = _resolve_env_var(None)
+        self.assertIsNone(result)
+
+    def test_resolve_env_var_missing_var(self):
+        """Test that missing environment variable raises ValueError"""
+        with self.assertRaises(ValueError) as context:
+            _resolve_env_var("${NONEXISTENT_ENV_VAR_12345}")
+
+        self.assertIn("NONEXISTENT_ENV_VAR_12345", str(context.exception))
+        self.assertIn("is not set", str(context.exception))
+
+    def test_api_key_env_var_in_model_config(self):
+        """Test that api_key ${VAR} works in LLMModelConfig"""
+        model_config = LLMModelConfig(name="test-model", api_key=f"${{{self.test_env_var}}}")
 
         self.assertEqual(model_config.api_key, self.test_api_key)
 
@@ -42,28 +65,13 @@ def test_api_key_none(self):
 
         self.assertIsNone(model_config.api_key)
 
-    def test_api_key_from_env_missing_env_var(self):
-        """Test that missing environment variable raises ValueError"""
-        with self.assertRaises(ValueError) as context:
-            LLMModelConfig(name="test-model", api_key={"from_env": "NONEXISTENT_ENV_VAR_12345"})
-
-        self.assertIn("NONEXISTENT_ENV_VAR_12345", str(context.exception))
-        self.assertIn("is not set", str(context.exception))
-
-    def test_api_key_dict_without_from_env_key(self):
-        """Test that dict without from_env key raises ValueError"""
-        with self.assertRaises(ValueError) as context:
-            LLMModelConfig(name="test-model", api_key={"wrong_key": "value"})
-
-        self.assertIn("from_env", str(context.exception))
-
-    def test_api_key_from_env_in_llm_config(self):
-        """Test that api_key from_env works at LLM config level"""
+    def test_api_key_env_var_in_llm_config(self):
+        """Test that api_key ${VAR} works at LLM config level"""
         yaml_config = {
             "log_level": "INFO",
             "llm": {
                 "api_base": "https://api.openai.com/v1",
-                "api_key": {"from_env": self.test_env_var},
+                "api_key": f"${{{self.test_env_var}}}",
                 "models": [{"name": "test-model", "weight": 1.0}],
             },
         }
@@ -74,8 +82,8 @@ def test_api_key_from_env_in_llm_config(self):
         # Models should inherit the resolved api_key
         self.assertEqual(config.llm.models[0].api_key, self.test_api_key)
 
-    def test_api_key_from_env_per_model(self):
-        """Test that api_key from_env can be specified per model"""
+    def test_api_key_env_var_per_model(self):
+        """Test that api_key ${VAR} can be specified per model"""
         # Set up a second env var for testing
         second_env_var = "TEST_OPENEVOLVE_API_KEY_2"
         second_api_key = "second-secret-key-67890"
@@ -90,9 +98,13 @@ def test_api_key_from_env_per_model(self):
                         {
                             "name": "model-1",
                             "weight": 1.0,
-                            "api_key": {"from_env": self.test_env_var},
+                            "api_key": f"${{{self.test_env_var}}}",
+                        },
+                        {
+                            "name": "model-2",
+                            "weight": 0.5,
+                            "api_key": f"${{{second_env_var}}}",
                         },
-                        {"name": "model-2", "weight": 0.5, "api_key": {"from_env": second_env_var}},
                     ],
                 },
             }
@@ -105,8 +117,8 @@ def test_api_key_from_env_per_model(self):
             if second_env_var in os.environ:
                 del os.environ[second_env_var]
 
-    def test_api_key_from_env_in_evaluator_models(self):
-        """Test that api_key from_env works in evaluator_models"""
+    def test_api_key_env_var_in_evaluator_models(self):
+        """Test that api_key ${VAR} works in evaluator_models"""
         yaml_config = {
             "log_level": "INFO",
             "llm": {
@@ -116,7 +128,7 @@ def test_api_key_from_env_in_evaluator_models(self):
                     {
                         "name": "evaluator-model",
                         "weight": 1.0,
-                        "api_key": {"from_env": self.test_env_var},
+                        "api_key": f"${{{self.test_env_var}}}",
                     }
                 ],
             },
@@ -126,14 +138,13 @@ def test_api_key_from_env_in_evaluator_models(self):
 
         self.assertEqual(config.llm.evaluator_models[0].api_key, self.test_api_key)
 
-    def test_yaml_file_loading_with_from_env(self):
-        """Test loading api_key from_env from actual YAML file"""
+    def test_yaml_file_loading_with_env_var(self):
+        """Test loading api_key ${VAR} from actual YAML file"""
         yaml_content = f"""
 log_level: INFO
 llm:
   api_base: https://api.openai.com/v1
-  api_key:
-    from_env: {self.test_env_var}
+  api_key: ${{{self.test_env_var}}}
   models:
   - name: test-model
     weight: 1.0
@@ -150,7 +161,7 @@ def test_yaml_file_loading_with_from_env(self):
                 os.unlink(f.name)
 
     def test_mixed_api_key_sources(self):
-        """Test mixing direct api_key and from_env in same config"""
+        """Test mixing direct api_key and ${VAR} in same config"""
         yaml_config = {
             "log_level": "INFO",
             "llm": {
@@ -160,9 +171,13 @@ def test_mixed_api_key_sources(self):
                     {
                         "name": "model-with-env",
                         "weight": 1.0,
-                        "api_key": {"from_env": self.test_env_var},
+                        "api_key": f"${{{self.test_env_var}}}",
+                    },
+                    {
+                        "name": "model-with-direct",
+                        "weight": 0.5,
+                        "api_key": "model-direct-key",
                     },
-                    {"name": "model-with-direct", "weight": 0.5, "api_key": "model-direct-key"},
                 ],
             },
         }