ara-cli 0.1.9.95__py3-none-any.whl → 0.1.10.0__py3-none-any.whl

tests/test_file_classifier.py

@@ -11,6 +11,12 @@ def mock_file_system():
     return MagicMock()
 
 
+@pytest.fixture
+def mock_error_handler():
+    with patch('ara_cli.file_classifier.error_handler') as mock_handler:
+        yield mock_handler
+
+
 @pytest.fixture
 def mock_classifier():
     with patch.object(Classifier, 'ordered_classifiers', return_value=['py', 'txt', 'bin']):
@@ -64,6 +70,23 @@ def test_is_binary_file(mock_file_system):
         assert result is False
 
 
+def test_is_binary_file_handles_error(mock_file_system, mock_error_handler):
+    classifier = FileClassifier(mock_file_system)
+    test_binary_file_path = "test_binary_file.bin"
+
+    # Simulate an exception being raised when attempting to open the file
+    with patch("builtins.open", side_effect=Exception("Unexpected error")):
+        result = classifier.is_binary_file(test_binary_file_path)
+        assert result is False
+
+    # Check that the error handler's report_error method was called
+    mock_error_handler.report_error.assert_called_once()
+    # You can also verify the specific arguments if needed
+    args, kwargs = mock_error_handler.report_error.call_args
+    assert "Unexpected error" in str(args[0])
+    assert "checking if file is binary" in args[1]
+
+
 def test_read_file_with_fallback(mock_file_system):
     classifier = FileClassifier(mock_file_system)
     test_file_path = "test_file.txt"

tests/test_file_creator.py

@@ -15,12 +15,10 @@ def test_template_exists_with_valid_path():
     assert result
 
 
-def test_run_with_invalid_classifier_prints_error_message(capfd):
+def test_run_with_invalid_classifier_raises_error(capfd):
     fc = ArtefactCreator()
-    fc.run("filename", "invalid_classifier")
-
-    captured = capfd.readouterr()
-    assert "Invalid classifier provided. Please provide a valid classifier." in captured.out
+    with pytest.raises(ValueError):
+        fc.run("filename", "invalid_classifier")
 
 
 @patch("ara_cli.artefact_creator.input", return_value="n")

tests/test_prompt_handler.py

@@ -10,6 +10,30 @@ from ara_cli import prompt_handler
 from ara_cli.ara_config import ARAconfig, LLMConfigItem, ConfigManager
 from ara_cli.classifier import Classifier
 
+from langfuse.api.resources.commons.errors import NotFoundError
+
+
+@pytest.fixture(autouse=True)
+def mock_langfuse():
+    """Mock Langfuse client to prevent network calls during tests."""
+    with patch.object(prompt_handler.LLMSingleton, 'langfuse', None):
+        mock_langfuse_instance = MagicMock()
+        
+        # Mock the get_prompt method to raise NotFoundError (simulating prompt not found)
+        mock_langfuse_instance.get_prompt.side_effect = NotFoundError(
+            # status_code=404, 
+            body={'message': "Prompt not found", 'error': 'LangfuseNotFoundError'}
+        )
+        
+        # Mock the span context manager
+        mock_span = MagicMock()
+        mock_span.__enter__ = MagicMock(return_value=mock_span)
+        mock_span.__exit__ = MagicMock(return_value=None)
+        mock_langfuse_instance.start_as_current_span.return_value = mock_span
+        
+        with patch.object(prompt_handler.LLMSingleton, 'langfuse', mock_langfuse_instance):
+            yield mock_langfuse_instance
+
 
 @pytest.fixture
 def mock_config():
@@ -30,7 +54,7 @@ def mock_config():
     return config
 
 
-@pytest.fixture
+@pytest.fixture(autouse=True)
 def mock_config_manager(mock_config):
     """Patches ConfigManager to ensure it always returns the mock_config."""
     with patch.object(ConfigManager, 'get_config') as mock_get_config:
@@ -243,13 +267,17 @@ class TestCoreLogic:
         )
 
     @patch('ara_cli.prompt_handler.send_prompt')
-    def test_describe_image(self, mock_send_prompt, tmp_path):
+    def test_describe_image(self, mock_send_prompt, tmp_path, mock_langfuse):
         fake_image_path = tmp_path / "test.jpeg"
         fake_image_content = b"fakeimagedata"
         fake_image_path.write_bytes(fake_image_content)
         
         mock_send_prompt.return_value = iter([])
         
+        # Ensure the langfuse mock is properly set up for this instance
+        instance = prompt_handler.LLMSingleton.get_instance()
+        instance.langfuse = mock_langfuse
+        
         prompt_handler.describe_image(fake_image_path)
         
         mock_send_prompt.assert_called_once()
@@ -265,7 +293,7 @@ class TestCoreLogic:
         assert message_content[1]['image_url']['url'] == expected_url
 
     @patch('ara_cli.prompt_handler.send_prompt')
-    def test_describe_image_returns_response_text(self, mock_send_prompt, tmp_path):
+    def test_describe_image_returns_response_text(self, mock_send_prompt, tmp_path, mock_langfuse):
         fake_image_path = tmp_path / "test.gif"
         fake_image_path.touch()
 
@@ -277,6 +305,10 @@ class TestCoreLogic:
         mock_chunk3.choices[0].delta.content = None # Test empty chunk
         mock_send_prompt.return_value = iter([mock_chunk1, mock_chunk3, mock_chunk2])
 
+        # Ensure the langfuse mock is properly set up for this instance
+        instance = prompt_handler.LLMSingleton.get_instance()
+        instance.langfuse = mock_langfuse
+
         description = prompt_handler.describe_image(fake_image_path)
         assert description == "This is a description."
 
@@ -310,7 +342,11 @@ class TestCoreLogic:
         prompt_handler.write_prompt_result("test_classifier", "my_param", "Test content")
         assert "Test content" in log_file.read_text()
 
-    def test_prepend_system_prompt(self):
+    def test_prepend_system_prompt(self, mock_langfuse):
+        # Ensure the langfuse mock is properly set up for this instance
+        instance = prompt_handler.LLMSingleton.get_instance()
+        instance.langfuse = mock_langfuse
+        
         messages = [{"role": "user", "content": "Hi"}]
         result = prompt_handler.prepend_system_prompt(messages)
         assert len(result) == 2

tests/test_template_loader.py

@@ -0,0 +1,192 @@
+import os
+import pytest
+from unittest.mock import MagicMock, patch, mock_open
+from ara_cli.template_loader import TemplateLoader
+
+
+@pytest.fixture
+def mock_chat_instance():
+    """Fixture for a mocked chat instance."""
+    mock = MagicMock()
+    mock.choose_file_to_load.return_value = "chosen_file.md"
+    mock.load_file.return_value = True
+    return mock
+
+
+@pytest.fixture
+def template_loader_cli():
+    """Fixture for a TemplateLoader in CLI mode."""
+    return TemplateLoader()
+
+
+@pytest.fixture
+def template_loader_chat(mock_chat_instance):
+    """Fixture for a TemplateLoader in chat mode."""
+    return TemplateLoader(chat_instance=mock_chat_instance)
+
+
+def test_init(mock_chat_instance):
+    """Test the constructor."""
+    loader_cli = TemplateLoader()
+    assert loader_cli.chat_instance is None
+
+    loader_chat = TemplateLoader(chat_instance=mock_chat_instance)
+    assert loader_chat.chat_instance == mock_chat_instance
+
+
+@pytest.mark.parametrize("template_name, default_pattern, expected_method_to_call", [
+    ("", "*.rules.md", "load_template_from_prompt_data"),
+    ("my_rule", "*.rules.md", "load_template_from_global_or_local"),
+])
+def test_load_template_routing(template_loader_cli, template_name, default_pattern, expected_method_to_call):
+    """Test that load_template calls the correct downstream method based on inputs."""
+    with patch.object(TemplateLoader, 'load_template_from_prompt_data') as mock_from_prompt, \
+         patch.object(TemplateLoader, 'load_template_from_global_or_local') as mock_from_global_local:
+
+        template_loader_cli.load_template(
+            template_name, "rules", "chat.md", default_pattern)
+
+        if expected_method_to_call == "load_template_from_prompt_data":
+            mock_from_prompt.assert_called_once()
+            mock_from_global_local.assert_not_called()
+        else:
+            mock_from_prompt.assert_not_called()
+            mock_from_global_local.assert_called_once()
+
+
+def test_load_template_no_name_no_pattern(template_loader_cli, capsys):
+    """Test load_template fails gracefully when no name or pattern is given."""
+    result = template_loader_cli.load_template("", "blueprint", "chat.md", None)
+    assert result is False
+    captured = capsys.readouterr()
+    assert "A template name is required for template type 'blueprint'" in captured.out
+
+
+@pytest.mark.parametrize("template_type, expected_plural", [
+    ("rules", "rules"),
+    ("commands", "commands"),
+    ("intention", "intentions"),
+    ("blueprint", "blueprints"),
+    ("custom", "customs"),
+])
+def test_get_plural_template_type(template_loader_cli, template_type, expected_plural):
+    """Test the pluralization of template types."""
+    assert template_loader_cli.get_plural_template_type(
+        template_type) == expected_plural
+
+
+@pytest.mark.parametrize("template_name, expected_method_to_call", [
+    ("global/my_rule", "_load_global_template"),
+    ("my_rule", "_load_local_template"),
+])
+def test_load_template_from_global_or_local_routing(template_loader_cli, template_name, expected_method_to_call):
+    """Test routing between global and local template loading."""
+    with patch.object(TemplateLoader, '_load_global_template') as mock_global, \
+         patch.object(TemplateLoader, '_load_local_template') as mock_local:
+
+        template_loader_cli.load_template_from_global_or_local(
+            template_name, "rules", "chat.md")
+
+        if expected_method_to_call == "_load_global_template":
+            mock_global.assert_called_once()
+            mock_local.assert_not_called()
+        else:
+            mock_global.assert_not_called()
+            mock_local.assert_called_once()
+
+
+@pytest.mark.parametrize("files, pattern, user_input, expected_return", [
+    (["one.md"], "*.md", "", "one.md"),
+    ([], "*.md", "", None),
+    (["a.md", "b.md"], "*", "1", "a.md"),
+    (["a.md", "b.md"], "*", "2", "b.md"),
+    (["a.md", "b.md"], "*", "3", None),
+    (["a.md", "b.md"], "*", "invalid", None),
+])
+def test_choose_file_for_cli(template_loader_cli, files, pattern, user_input, expected_return):
+    """Test the interactive file selection for the CLI."""
+    with patch('builtins.input', return_value=user_input):
+        result = template_loader_cli._choose_file_for_cli(files, pattern)
+        assert result == expected_return
+
+
+def test_load_file_to_chat_cli_context(tmp_path):
+    """Test writing template content to a chat file in a CLI context."""
+    chat_file = tmp_path / "chat.md"
+    chat_file.write_text("# ara prompt:\n")
+    template_file = tmp_path / "template.md"
+    template_content = "This is the template content."
+    template_file.write_text(template_content)
+
+    loader = TemplateLoader()
+    result = loader._load_file_to_chat(
+        str(template_file), "rules", str(chat_file))
+
+    assert result is True
+    final_content = chat_file.read_text()
+    expected_content = f"# ara prompt:\n\n{template_content}\n"
+    assert final_content == expected_content
+
+
+def test_load_file_to_chat_chat_context(template_loader_chat, mock_chat_instance):
+    """Test delegating file loading to the chat instance."""
+    result = template_loader_chat._load_file_to_chat(
+        "file.md", "rules", "chat.md")
+
+    assert result is True
+    mock_chat_instance.add_prompt_tag_if_needed.assert_called_once_with(
+        "chat.md")
+    mock_chat_instance.load_file.assert_called_once_with("file.md")
+
+
+def test_find_project_root(tmp_path):
+    """Test finding the project root directory."""
+    project_root = tmp_path / "project"
+    ara_dir = project_root / "ara"
+    nested_dir = project_root / "src" / "component"
+    ara_dir.mkdir(parents=True)
+    nested_dir.mkdir(parents=True)
+
+    no_ara_dir = tmp_path / "other"
+    no_ara_dir.mkdir()
+
+    loader = TemplateLoader()
+
+    # Test finding the root from a nested directory
+    assert loader._find_project_root(str(nested_dir)) == str(project_root)
+    # Test finding the root from the root itself
+    assert loader._find_project_root(str(project_root)) == str(project_root)
+    # Test not finding the root
+    assert loader._find_project_root(str(no_ara_dir)) is None
+
+
+@patch('ara_cli.template_loader.TemplatePathManager')
+@patch('ara_cli.template_loader.ConfigManager')
+def test_get_available_templates(MockConfigManager, MockTemplatePathManager, tmp_path):
+    """Test the discovery of global and local templates."""
+    # Setup mock paths and config
+    project_root = tmp_path / "project"
+    ara_dir = project_root / "ara"
+    araconfig_dir = project_root / ".araconfig"
+    custom_modules_dir = araconfig_dir / "custom-prompt-modules" / "rules"
+    global_modules_dir = tmp_path / "global_templates" / "prompt-modules" / "rules"
+
+    for d in [ara_dir, custom_modules_dir, global_modules_dir]:
+        d.mkdir(parents=True)
+
+    (custom_modules_dir / "local_rule.md").touch()
+    (global_modules_dir / "global_rule.md").touch()
+
+    mock_config = MagicMock()
+    mock_config.local_prompt_templates_dir = ".araconfig"
+    mock_config.custom_prompt_templates_subdir = "custom-prompt-modules"
+    MockConfigManager.get_config.return_value = mock_config
+    MockTemplatePathManager.get_template_base_path.return_value = str(
+        tmp_path / "global_templates")
+
+    loader = TemplateLoader()
+    templates = loader.get_available_templates(
+        "rules", context_path=str(project_root))
+
+    assert sorted(templates) == sorted(
+        ["global/global_rule.md", "local_rule.md"])