ara-cli 0.1.9.69__py3-none-any.whl → 0.1.10.8__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"
@@ -241,7 +264,7 @@ def test_find_closest_artefact_name_match(mock_file_system):
         'file1', 'py') == 'file1'
 
     # Fuzzy match
-    with patch('ara_cli.file_classifier.find_closest_name_match', return_value='file2') as mock_fuzzy:
+    with patch('ara_cli.file_classifier.find_closest_name_matches', return_value='file2') as mock_fuzzy:
         assert classifier.find_closest_artefact_name_match(
             'file3', 'py') == 'file2'
         mock_fuzzy.assert_called_once_with('file3', ['file1', 'file2'])

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_file_lister.py

@@ -55,7 +55,7 @@ def test_generate_markdown_listing_multiple_directories(setup_test_environment):
 
         generate_markdown_listing([temp_dir, another_temp_dir], ['*.py'], output_file_path)
 
-        with open(output_file_path, 'r') as f:
+        with open(output_file_path, 'r', encoding='utf-8') as f:
             output_content = f.read().splitlines()
 
         assert output_content == expected_content

tests/test_global_file_lister.py

@@ -0,0 +1,131 @@
+# tests/test_global_file_lister.py
+
+import os
+import pytest
+from unittest.mock import patch
+from io import StringIO
+from ara_cli.global_file_lister import (
+    _build_tree,
+    _write_tree_to_markdown,
+    generate_global_markdown_listing,
+)
+
+@pytest.fixture
+def temp_dir_structure(tmp_path):
+    """Create a temporary directory structure for comprehensive testing."""
+    root = tmp_path / "global_root"
+    root.mkdir()
+    (root / "src").mkdir()
+    (root / "src" / "main.py").touch()
+    (root / "src" / "utils.py").touch()
+    (root / "docs").mkdir()
+    (root / "docs" / "guide.md").touch()
+    (root / "docs" / "images").mkdir() # Empty dir, should be ignored
+    (root / "tests").mkdir()
+    (root / "tests" / "test_main.py").touch()
+    (root / "config.txt").touch() # Should be ignored by patterns
+    (root / "empty_dir").mkdir() # Should be ignored
+    return str(root)
+
+class TestBuildTree:
+    """Tests for the _build_tree function."""
+    def test_build_tree_with_matching_files(self, temp_dir_structure):
+        """Tests building a tree, correctly filtering by patterns and excluding empty dirs."""
+        patterns = ["*.py", "*.md"]
+        tree = _build_tree(temp_dir_structure, patterns)
+
+        assert sorted(tree["dirs"]["src"]["files"]) == ["main.py", "utils.py"]
+        assert tree["dirs"]["docs"]["files"] == ["guide.md"]
+        assert tree["dirs"]["tests"]["files"] == ["test_main.py"]
+        assert "images" not in tree["dirs"]["docs"]["dirs"] # Empty dir excluded
+        assert "empty_dir" not in tree["dirs"] # Empty dir excluded
+        assert not tree["files"] # No files in root
+
+    def test_build_tree_no_matching_files(self, temp_dir_structure):
+        """Tests building a tree where no files match the given patterns."""
+        patterns = ["*.json", "*.yml"]
+        tree = _build_tree(temp_dir_structure, patterns)
+        assert not tree["files"] and not tree["dirs"]
+
+    def test_build_tree_on_empty_directory(self, tmp_path):
+        """Tests that an empty directory results in an empty tree."""
+        empty_dir = tmp_path / "empty"
+        empty_dir.mkdir()
+        tree = _build_tree(str(empty_dir), ["*.*"])
+        assert not tree["files"] and not tree["dirs"]
+
+    @patch('os.listdir')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_build_tree_handles_os_error(self, mock_stdout, mock_listdir):
+        """Tests that an OSError during directory listing is caught and handled."""
+        mock_listdir.side_effect = OSError("Permission denied")
+        tree = _build_tree("/unreadable_dir", ["*.*"])
+        assert "Warning: Could not access path /unreadable_dir" in mock_stdout.getvalue()
+        assert not tree["files"] and not tree["dirs"]
+
+class TestWriteTreeToMarkdown:
+    """Tests for the _write_tree_to_markdown function."""
+    def test_write_tree_to_markdown_output_format(self):
+        """Verifies that the markdown output is correctly formatted with proper indentation."""
+        tree = {
+            'files': ['root_file.md'],
+            'dirs': {
+                'dir1': {'files': ['a.py', 'b.py'], 'dirs': {}},
+                'dir2': {'files': [], 'dirs': {'subdir': {'files': ['c.md'], 'dirs': {}}}}
+            }
+        }
+        
+        md_file = StringIO()
+        _write_tree_to_markdown(md_file, tree, level=1)
+        output = md_file.getvalue()
+
+        # FIX: Added 4 spaces before "### subdir\n" to match the actual output.
+        expected = (
+            "    - [] root_file.md\n"
+            "## dir1\n"
+            "        - [] a.py\n"
+            "        - [] b.py\n"
+            "## dir2\n"
+            "    ### subdir\n"
+            "            - [] c.md\n"
+        )
+        assert output == expected
+
+class TestGenerateGlobalMarkdownListing:
+    """Tests for the main generate_global_markdown_listing function."""
+    def test_generate_listing_with_valid_dirs(self, temp_dir_structure, tmp_path):
+        """Tests the end-to-end generation of a markdown file from a valid directory."""
+        output_file = tmp_path / "output.md"
+        patterns = ["*.py"]
+        
+        generate_global_markdown_listing([temp_dir_structure], patterns, str(output_file))
+        
+        content = output_file.read_text()
+        abs_dir = os.path.abspath(temp_dir_structure)
+        
+        assert f"# {abs_dir}\n" in content
+        assert "## src\n" in content
+        assert "        - [] main.py\n" in content
+        assert "## tests\n" in content
+        assert "guide.md" not in content # Does not match pattern
+
+    def test_generate_listing_with_nonexistent_dir(self, tmp_path):
+        """Tests that a warning is written to the file for a non-existent directory."""
+        output_file = tmp_path / "output.md"
+        non_existent_dir = "/path/to/nothing"
+        
+        generate_global_markdown_listing([non_existent_dir], ["*.*"], str(output_file))
+        
+        content = output_file.read_text()
+        abs_path = os.path.abspath(non_existent_dir)
+        
+        assert f"# {non_existent_dir}\n" in content
+        assert f"    - !! Warning: Global directory not found: {abs_path}" in content
+
+    def test_generate_listing_with_no_matching_files(self, temp_dir_structure, tmp_path):
+        """Tests that the output file is empty if no files match the patterns."""
+        output_file = tmp_path / "output.md"
+        
+        generate_global_markdown_listing([temp_dir_structure], ["*.nonexistent"], str(output_file))
+        
+        assert output_file.read_text() == ""

tests/test_list_filter.py

@@ -65,7 +65,7 @@ def test_default_content_retrieval():
     with patch("builtins.open", mock_open(read_data=mock_data)) as mocked_file:
         content = ListFilterMonad.default_content_retrieval("dummy_path")
         assert content == mock_data
-        mocked_file.assert_called_once_with("dummy_path", 'r')
+        mocked_file.assert_called_once_with("dummy_path", 'r', encoding='utf-8')
 
 
 def test_default_tag_retrieval():
@@ -77,7 +77,7 @@ def test_default_content_retrieval_exception():
     with patch("builtins.open", side_effect=Exception("Mocked exception")) as mocked_file:
         content = ListFilterMonad.default_content_retrieval("dummy_path")
         assert content == ""  # Expect empty string on exception
-        mocked_file.assert_called_once_with("dummy_path", 'r')
+        mocked_file.assert_called_once_with("dummy_path", 'r', encoding='utf-8')
 
 
 @pytest.mark.parametrize("include, exclude, expected", [