ara-cli 0.1.10.5__py3-none-any.whl → 0.1.14.0__py3-none-any.whl

tests/test_ara_config.py

@@ -41,10 +41,11 @@ def valid_config_dict():
                 "provider": "openai",
                 "model": "openai/gpt-4o",
                 "temperature": 0.5,
-                "max_tokens": 4096
+                "max_tokens": 4096,
             }
         },
-        "default_llm": "gpt-4o-custom"
+        "default_llm": "gpt-4o-custom",
+        "conversion_llm": "gpt-4o-custom",
     }
 
 
@@ -58,10 +59,10 @@ def corrupted_config_dict():
             "bad-model": {
                 "provider": "test",
                 "model": "test/model",
-                "temperature": "not_a_float"
+                "temperature": "not_a_float",
             }
         },
-        "default_llm": 999
+        "default_llm": 999,
     }
 
 
@@ -72,8 +73,10 @@ def reset_config_manager():
     yield
     ConfigManager.reset()
 
+
 # --- Test Pydantic Models ---
 
+
 class TestLLMConfigItem:
     def test_valid_temperature(self):
         """Tests that a valid temperature is accepted."""
@@ -81,13 +84,22 @@ class TestLLMConfigItem:
         assert config.temperature == 0.7
 
     def test_invalid_temperature_too_high_raises_error(self):
-        """Tests that temperature > 1.0 raises a ValidationError."""
-        with pytest.raises(ValidationError, match="Input should be less than or equal to 1"):
-            LLMConfigItem(provider="test", model="test/model", temperature=1.5)
+        """Tests that temperature > 2.0 raises a ValidationError."""
+        with pytest.raises(
+            ValidationError, match="Input should be less than or equal to 2"
+        ):
+            LLMConfigItem(provider="test", model="test/model", temperature=2.1)
+
+    def test_valid_high_temperature(self):
+        """Tests that a temperature between 1.0 and 2.0 is accepted."""
+        config = LLMConfigItem(provider="test", model="test/model", temperature=1.5)
+        assert config.temperature == 1.5
 
     def test_invalid_temperature_too_low_raises_error(self):
         """Tests that temperature < 0.0 raises a ValidationError."""
-        with pytest.raises(ValidationError, match="Input should be greater than or equal to 0"):
+        with pytest.raises(
+            ValidationError, match="Input should be greater than or equal to 0"
+        ):
             LLMConfigItem(provider="test", model="test/model", temperature=-0.5)
 
 
@@ -95,27 +107,40 @@ class TestARAconfig:
     def test_default_values_are_correct(self):
         """Tests that the model initializes with correct default values."""
         config = ARAconfig()
-        assert config.ext_code_dirs == [{"source_dir": "./src"}, {"source_dir": "./tests"}]
+        assert config.ext_code_dirs == [
+            {"source_dir": "./src"},
+            {"source_dir": "./tests"},
+        ]
         assert config.glossary_dir == "./glossary"
-        assert config.default_llm == "gpt-5"
-        assert "gpt-5" in config.llm_config
+        assert config.default_llm == "gpt-5.2"
+        assert "gpt-5.2" in config.llm_config
 
-    @patch('sys.stdout', new_callable=StringIO)
-    def test_check_critical_fields_with_empty_list_reverts_to_default(self, mock_stdout):
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_check_critical_fields_with_empty_list_reverts_to_default(
+        self, mock_stdout
+    ):
         """Tests that an empty list for a critical field is reverted to its default."""
         config = ARAconfig(ext_code_dirs=[])
         assert len(config.ext_code_dirs) == 2
         assert config.ext_code_dirs[0] == {"source_dir": "./src"}
-        assert "Warning: Value for 'ext_code_dirs' is missing or empty. Using default." in mock_stdout.getvalue()
-
-    @patch('sys.stdout', new_callable=StringIO)
-    def test_check_critical_fields_with_empty_string_reverts_to_default(self, mock_stdout):
+        assert (
+            "Warning: Value for 'ext_code_dirs' is missing or empty. Using default."
+            in mock_stdout.getvalue()
+        )
+
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_check_critical_fields_with_empty_string_reverts_to_default(
+        self, mock_stdout
+    ):
         """Tests that an empty string for a critical field is reverted to its default."""
         config = ARAconfig(glossary_dir="")
         assert config.glossary_dir == "./glossary"
-        assert "Warning: Value for 'glossary_dir' is missing or empty. Using default." in mock_stdout.getvalue()
+        assert (
+            "Warning: Value for 'glossary_dir' is missing or empty. Using default."
+            in mock_stdout.getvalue()
+        )
 
-    @patch('sys.stdout', new_callable=StringIO)
+    @patch("sys.stdout", new_callable=StringIO)
     def test_validator_with_empty_llm_config(self, mock_stdout):
         """Tests validator when llm_config is empty, setting default and extraction to None."""
         config = ARAconfig(llm_config={})
@@ -124,37 +149,59 @@ class TestARAconfig:
         assert config.extraction_llm is None
         assert "Warning: 'llm_config' is empty" in mock_stdout.getvalue()
 
-    @patch('sys.stdout', new_callable=StringIO)
+    @patch("sys.stdout", new_callable=StringIO)
     def test_validator_with_invalid_default_llm(self, mock_stdout):
         """Tests that an invalid default_llm is reverted to the first available model."""
         config = ARAconfig(default_llm="non_existent_model")
         first_llm = next(iter(config.llm_config))
         assert config.default_llm == first_llm
         output = mock_stdout.getvalue()
-        assert "Warning: The configured 'default_llm' ('non_existent_model') does not exist" in output
+        assert (
+            "Warning: The configured 'default_llm' ('non_existent_model') does not exist"
+            in output
+        )
         assert f"-> Reverting to the first available model: '{first_llm}'" in output
 
-    @patch('sys.stdout', new_callable=StringIO)
+    @patch("sys.stdout", new_callable=StringIO)
     def test_validator_with_invalid_extraction_llm(self, mock_stdout):
         """Tests that an invalid extraction_llm is reverted to the default_llm."""
         config = ARAconfig(default_llm="gpt-4o", extraction_llm="non_existent_model")
         assert config.extraction_llm == "gpt-4o"
         output = mock_stdout.getvalue()
-        assert "Warning: The configured 'extraction_llm' ('non_existent_model') does not exist" in output
+        assert (
+            "Warning: The configured 'extraction_llm' ('non_existent_model') does not exist"
+            in output
+        )
         assert "-> Reverting to the 'default_llm' value: 'gpt-4o'" in output
 
+    @patch("sys.stdout", new_callable=StringIO)
+    def test_validator_with_invalid_conversion_llm(self, mock_stdout):
+        """Tests that an invalid conversion_llm is reverted to the default_llm."""
+        config = ARAconfig(default_llm="gpt-4o", conversion_llm="non_existent_model")
+        assert config.conversion_llm == "gpt-4o"
+        output = mock_stdout.getvalue()
+        assert (
+            "Warning: The configured 'conversion_llm' ('non_existent_model') does not exist"
+            in output
+        )
+        assert "-> Reverting to the 'default_llm' value: 'gpt-4o'" in output
+
+
 # --- Test Helper Functions ---
 
+
 class TestEnsureDirectoryExists:
-    @patch('sys.stdout', new_callable=StringIO)
+    @patch("sys.stdout", new_callable=StringIO)
     @patch("os.makedirs")
     @patch("ara_cli.ara_config.exists", return_value=False)
-    def test_directory_creation_when_not_exists(self, mock_exists, mock_makedirs, mock_stdout):
+    def test_directory_creation_when_not_exists(
+        self, mock_exists, mock_makedirs, mock_stdout
+    ):
         """Tests that a directory is created if it doesn't exist."""
         ensure_directory_exists.cache_clear()
         directory = "/tmp/new/dir"
         result = ensure_directory_exists(directory)
-        
+
         mock_exists.assert_called_once_with(directory)
         mock_makedirs.assert_called_once_with(directory)
         assert result == directory
@@ -167,34 +214,39 @@ class TestEnsureDirectoryExists:
         ensure_directory_exists.cache_clear()
         directory = "/tmp/existing/dir"
         result = ensure_directory_exists(directory)
-        
+
         mock_exists.assert_called_once_with(directory)
         mock_makedirs.assert_not_called()
         assert result == directory
 
 
 class TestHandleUnrecognizedKeys:
-    @patch('sys.stdout', new_callable=StringIO)
+    @patch("sys.stdout", new_callable=StringIO)
     def test_removes_unrecognized_keys_and_warns(self, mock_stdout):
         """Tests that unknown keys are removed and a warning is printed."""
         data = {"glossary_dir": "./glossary", "unknown_key": "some_value"}
         cleaned_data = handle_unrecognized_keys(data)
-        
+
         assert "unknown_key" not in cleaned_data
         assert "glossary_dir" in cleaned_data
-        assert "Warning: Unrecognized configuration key 'unknown_key' will be ignored." in mock_stdout.getvalue()
+        assert (
+            "Warning: Unrecognized configuration key 'unknown_key' will be ignored."
+            in mock_stdout.getvalue()
+        )
 
-    @patch('sys.stdout', new_callable=StringIO)
+    @patch("sys.stdout", new_callable=StringIO)
     def test_no_action_for_valid_data(self, mock_stdout):
         """Tests that no changes are made when there are no unrecognized keys."""
         data = {"glossary_dir": "./glossary", "doc_dir": "./docs"}
         cleaned_data = handle_unrecognized_keys(data)
-        
+
         assert cleaned_data == data
         assert mock_stdout.getvalue() == ""
 
+
 # --- Test Core I/O and Logic ---
 
+
 class TestSaveData:
     @patch("builtins.open", new_callable=mock_open)
     def test_save_data_writes_correct_json(self, mock_file, default_config_data):
@@ -204,17 +256,19 @@ class TestSaveData:
 
         mock_file.assert_called_once_with("config.json", "w", encoding="utf-8")
         handle = mock_file()
-        written_data = ''.join(call.args[0] for call in handle.write.call_args_list)
-        
+        written_data = "".join(call.args[0] for call in handle.write.call_args_list)
+
         assert json.loads(written_data) == default_config_data
 
 
 class TestReadData:
-    @patch('sys.stdout', new_callable=StringIO)
-    @patch('ara_cli.ara_config.save_data')
-    @patch('ara_cli.ara_config.ensure_directory_exists')
-    @patch('ara_cli.ara_config.exists', return_value=False)
-    def test_file_not_found_creates_default_and_exits(self, mock_exists, mock_ensure_dir, mock_save, mock_stdout):
+    @patch("sys.stdout", new_callable=StringIO)
+    @patch("ara_cli.ara_config.save_data")
+    @patch("ara_cli.ara_config.ensure_directory_exists")
+    @patch("ara_cli.ara_config.exists", return_value=False)
+    def test_file_not_found_creates_default_and_exits(
+        self, mock_exists, mock_ensure_dir, mock_save, mock_stdout
+    ):
         """Tests that a default config is created and the program exits if no config file is found."""
         with pytest.raises(SystemExit) as exc_info:
             read_data.cache_clear()
@@ -223,16 +277,23 @@ class TestReadData:
         assert exc_info.value.code == 0
         mock_ensure_dir.assert_called_once_with(os.path.dirname("config.json"))
         mock_save.assert_called_once()
-        
+
         output = mock_stdout.getvalue()
-        assert "Configuration file not found. Creating a default one at 'config.json'." in output
-        assert "Please review the default configuration and re-run your command." in output
-
-    @patch('ara_cli.ara_config.save_data')
-    @patch('builtins.open')
-    @patch('ara_cli.ara_config.ensure_directory_exists')
-    @patch('ara_cli.ara_config.exists', return_value=True)
-    def test_valid_config_is_loaded_and_resaved(self, mock_exists, mock_ensure_dir, mock_open_func, mock_save, valid_config_dict):
+        assert (
+            "Configuration file not found. Creating a default one at 'config.json'."
+            in output
+        )
+        assert (
+            "Please review the default configuration and re-run your command." in output
+        )
+
+    @patch("ara_cli.ara_config.save_data")
+    @patch("builtins.open")
+    @patch("ara_cli.ara_config.ensure_directory_exists")
+    @patch("ara_cli.ara_config.exists", return_value=True)
+    def test_valid_config_is_loaded_and_resaved(
+        self, mock_exists, mock_ensure_dir, mock_open_func, mock_save, valid_config_dict
+    ):
         """Tests that a valid config is loaded correctly and re-saved (to clean it)."""
         m = mock_open(read_data=json.dumps(valid_config_dict))
         mock_open_func.return_value = m()
@@ -242,38 +303,48 @@ class TestReadData:
 
         assert isinstance(result, ARAconfig)
         assert result.default_llm == "gpt-4o-custom"
-        mock_save.assert_called_once()
+        # mock_save.assert_called_once()  # Logic does not save if no changes needed
 
-    @patch('sys.stdout', new_callable=StringIO)
-    @patch('ara_cli.ara_config.save_data')
-    @patch('builtins.open', new_callable=mock_open, read_data="this is not json")
-    @patch('ara_cli.ara_config.ensure_directory_exists')
-    @patch('ara_cli.ara_config.exists', return_value=True)
-    def test_invalid_json_creates_default_config(self, mock_exists, mock_ensure_dir, mock_open_func, mock_save, mock_stdout):
+    @patch("sys.stdout", new_callable=StringIO)
+    @patch("ara_cli.ara_config.save_data")
+    @patch("builtins.open", new_callable=mock_open, read_data="this is not json")
+    @patch("ara_cli.ara_config.ensure_directory_exists")
+    @patch("ara_cli.ara_config.exists", return_value=True)
+    def test_invalid_json_creates_default_config(
+        self, mock_exists, mock_ensure_dir, mock_open_func, mock_save, mock_stdout
+    ):
         """Tests that a JSON decoding error results in a new default configuration."""
         read_data.cache_clear()
-        
+
         result = read_data("config.json")
-        
+
         assert isinstance(result, ARAconfig)
-        assert result.default_llm == "gpt-5"  # Should be the default config
-        
+        assert result.default_llm == "gpt-5.2"  # Should be the default config
+
         output = mock_stdout.getvalue()
         assert "Error: Invalid JSON in configuration file" in output
         assert "Creating a new configuration with defaults..." in output
         mock_save.assert_called_once()
 
-    @patch('sys.stdout', new_callable=StringIO)
-    @patch('ara_cli.ara_config.save_data')
-    @patch('builtins.open')
-    @patch('ara_cli.ara_config.ensure_directory_exists')
-    @patch('ara_cli.ara_config.exists', return_value=True)
-    def test_config_with_validation_errors_is_fixed(self, mock_exists, mock_ensure_dir, mock_open_func, mock_save, mock_stdout, corrupted_config_dict):
+    @patch("sys.stdout", new_callable=StringIO)
+    @patch("ara_cli.ara_config.save_data")
+    @patch("builtins.open")
+    @patch("ara_cli.ara_config.ensure_directory_exists")
+    @patch("ara_cli.ara_config.exists", return_value=True)
+    def test_config_with_validation_errors_is_fixed(
+        self,
+        mock_exists,
+        mock_ensure_dir,
+        mock_open_func,
+        mock_save,
+        mock_stdout,
+        corrupted_config_dict,
+    ):
         """Tests that a config with invalid fields is automatically corrected to defaults."""
         m = mock_open(read_data=json.dumps(corrupted_config_dict))
         mock_open_func.return_value = m()
         read_data.cache_clear()
-        
+
         defaults = ARAconfig()
         result = read_data("config.json")
 
@@ -285,29 +356,40 @@ class TestReadData:
 
         output = mock_stdout.getvalue()
         assert "--- Configuration Error Detected ---" in output
-        assert "-> Field 'ext_code_dirs' is invalid and will be reverted to its default value." in output
-        assert "-> Field 'glossary_dir' is invalid and will be reverted to its default value." in output
-        assert "-> Field 'llm_config' is invalid and will be reverted to its default value." in output
+        assert (
+            "-> Field 'ext_code_dirs' is invalid and will be reverted to its default value."
+            in output
+        )
+        assert (
+            "-> Field 'glossary_dir' is invalid and will be reverted to its default value."
+            in output
+        )
+        assert (
+            "-> Field 'llm_config' is invalid and will be reverted to its default value."
+            in output
+        )
         assert "Configuration has been corrected and saved" in output
-        
+
         mock_save.assert_called_once_with("config.json", result)
 
-    @patch('sys.stdout', new_callable=StringIO)
-    @patch('ara_cli.ara_config.save_data')
-    @patch('builtins.open')
-    @patch('ara_cli.ara_config.ensure_directory_exists')
-    @patch('ara_cli.ara_config.exists', return_value=True)
-    def test_preserves_valid_fields_when_fixing_errors(self, mock_exists, mock_ensure_dir, mock_open_func, mock_save, mock_stdout):
+    @patch("sys.stdout", new_callable=StringIO)
+    @patch("ara_cli.ara_config.save_data")
+    @patch("builtins.open")
+    @patch("ara_cli.ara_config.ensure_directory_exists")
+    @patch("ara_cli.ara_config.exists", return_value=True)
+    def test_preserves_valid_fields_when_fixing_errors(
+        self, mock_exists, mock_ensure_dir, mock_open_func, mock_save, mock_stdout
+    ):
         """Tests that valid, non-default values are preserved during a fix."""
         mixed_config = {
             "glossary_dir": "./my-custom-glossary",  # Valid, non-default
-            "default_llm": 12345,                    # Invalid type
-            "unrecognized_key": "will_be_ignored"    # Unrecognized
+            "default_llm": 12345,  # Invalid type
+            "unrecognized_key": "will_be_ignored",  # Unrecognized
         }
         m = mock_open(read_data=json.dumps(mixed_config))
         mock_open_func.return_value = m()
         read_data.cache_clear()
-        
+
         defaults = ARAconfig()
         result = read_data("config.json")
 
@@ -315,7 +397,10 @@ class TestReadData:
         assert result.default_llm == defaults.default_llm
 
         output = mock_stdout.getvalue()
-        assert "Warning: Unrecognized configuration key 'unrecognized_key' will be ignored." in output
+        assert (
+            "Warning: Unrecognized configuration key 'unrecognized_key' will be ignored."
+            in output
+        )
         assert "-> Field 'default_llm' is invalid" in output
         assert "-> Field 'glossary_dir' is invalid" not in output
 
@@ -324,41 +409,43 @@ class TestReadData:
         assert saved_config.glossary_dir == "./my-custom-glossary"
         assert saved_config.default_llm == defaults.default_llm
 
+
 # --- Test Singleton Manager ---
 
+
 class TestConfigManager:
-    @patch('ara_cli.ara_config.read_data')
+    @patch("ara_cli.ara_config.read_data")
     def test_get_config_is_singleton(self, mock_read):
         """Tests that get_config returns the same instance on subsequent calls."""
         mock_read.return_value = MagicMock(spec=ARAconfig)
-        
+
         config1 = ConfigManager.get_config()
         config2 = ConfigManager.get_config()
-        
+
         assert config1 is config2
         mock_read.assert_called_once()
 
-    @patch('ara_cli.ara_config.read_data')
+    @patch("ara_cli.ara_config.read_data")
     def test_reset_clears_instance_and_caches(self, mock_read):
         """Tests that the reset method clears the instance and underlying caches."""
         mock_read.return_value = MagicMock(spec=ARAconfig)
 
         ConfigManager.get_config()
         mock_read.assert_called_once()
-        
+
         ConfigManager.reset()
         assert ConfigManager._config_instance is None
         mock_read.cache_clear.assert_called_once()
 
         ConfigManager.get_config()
-        assert mock_read.call_count == 2 # Called again after reset
+        assert mock_read.call_count == 2  # Called again after reset
 
-    @patch('ara_cli.ara_config.read_data')
+    @patch("ara_cli.ara_config.read_data")
     def test_get_config_with_custom_filepath(self, mock_read):
         """Tests that get_config can be called with a custom file path."""
         mock_read.return_value = MagicMock(spec=ARAconfig)
         custom_path = "/custom/path/config.json"
-        
+
         ConfigManager.get_config(custom_path)
-        
-        mock_read.assert_called_once_with(custom_path)
+
+        mock_read.assert_called_once_with(custom_path)