woolly 0.4.0__tar.gz → 0.5.0__tar.gz

{woolly-0.4.0 → woolly-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: woolly
-Version: 0.4.0
+Version: 0.5.0
 Summary: Check if package dependencies are available in Fedora. Supports Rust, Python, and more.
 Author-email: Rodolfo Olivieri <rodolfo.olivieri3@gmail.com>
 License-File: LICENSE

{woolly-0.4.0 → woolly-0.5.0}/tests/conftest.py

@@ -24,6 +24,10 @@ def temp_cache_dir(tmp_path, monkeypatch):
     cache_dir = tmp_path / "cache"
     cache_dir.mkdir()
     monkeypatch.setattr("woolly.cache.CACHE_DIR", cache_dir)
+    # Reset the ensured-namespaces set so that the new CACHE_DIR is used
+    import woolly.cache as _cache_mod
+
+    _cache_mod._ensured_namespaces.clear()
     return cache_dir
 
 
@@ -119,6 +123,7 @@ def mock_crates_io_response():
             "description": "A serialization framework for Rust",
             "homepage": "https://serde.rs",
             "repository": "https://github.com/serde-rs/serde",
+            "license": "MIT OR Apache-2.0",
         }
     }
 
@@ -154,12 +159,55 @@ def mock_pypi_response():
             "summary": "Python HTTP for Humans",
             "home_page": "https://requests.readthedocs.io",
             "project_url": "https://github.com/psf/requests",
+            "license": "Apache-2.0",
+            "license_expression": None,
+            "provides_extra": ["socks"],
+            "requires_dist": [
+                "charset-normalizer<4,>=2",
+                "idna<4,>=2.5",
+                "urllib3<3,>=1.21.1",
+                "certifi>=2017.4.17",
+                "PySocks!=1.5.7,>=1.5.6; extra == 'socks'",
+            ],
+        }
+    }
+
+
+@pytest.fixture
+def mock_crates_io_version_response():
+    """Create a mock crates.io version API response (for features)."""
+    return {
+        "version": {
+            "num": "1.0.200",
+            "features": {
+                "default": ["std", "derive"],
+                "std": [],
+                "derive": ["serde_derive"],
+                "alloc": [],
+            },
+        }
+    }
+
+
+@pytest.fixture
+def mock_pypi_version_response():
+    """Create a mock PyPI version API response (for extras/features)."""
+    return {
+        "info": {
+            "name": "requests",
+            "version": "2.31.0",
+            "summary": "Python HTTP for Humans",
+            "license": "Apache-2.0",
+            "license_expression": None,
+            "provides_extra": ["socks", "security"],
             "requires_dist": [
                 "charset-normalizer<4,>=2",
                 "idna<4,>=2.5",
                 "urllib3<3,>=1.21.1",
                 "certifi>=2017.4.17",
                 "PySocks!=1.5.7,>=1.5.6; extra == 'socks'",
+                "pyOpenSSL>=0.14; extra == 'security'",
+                "cryptography>=1.3.4; extra == 'security'",
             ],
         }
     }
@@ -174,6 +222,7 @@ def mock_pypi_response():
 def mock_console():
     """Create a mock Rich console."""
     console = MagicMock(spec=Console)
+    console.width = 120  # Wide enough for side-by-side layout
     return console
 
 

{woolly-0.4.0 → woolly-0.5.0}/tests/unit/test_commands/test_check.py

@@ -12,7 +12,7 @@ from unittest.mock import MagicMock
 import pytest
 from rich.tree import Tree
 
-from woolly.commands.check import TreeStats, build_tree, collect_stats
+from woolly.commands.check import TreeStats, _compute_stats_from_visited, build_tree
 from woolly.languages.base import (
     Dependency,
     FedoraPackageStatus,
@@ -41,6 +41,9 @@ class MockProvider(LanguageProvider):
     def fetch_dependencies(self, package_name: str, version: str):
         return self.dependencies.get(f"{package_name}:{version}", [])
 
+    def fetch_features(self, package_name: str, version: str):
+        return []
+
     def check_fedora_packaging(self, package_name: str):
         return self.fedora_status.get(
             package_name, FedoraPackageStatus(is_packaged=False)
@@ -106,7 +109,7 @@ class TestBuildTree:
     @pytest.mark.unit
     def test_returns_visited_marker_for_duplicate(self, provider):
         """Critical path: returns visited marker for already-visited packages."""
-        visited = {"root": (True, "1.0.0")}
+        visited = {"root": (True, "1.0.0", False)}
 
         result = build_tree(provider, "root", visited=visited)
 
@@ -157,6 +160,32 @@ class TestBuildTree:
         label = str(tree.label)
         assert "1.0.0" in label
 
+    @pytest.mark.unit
+    def test_includes_license_in_label(self, provider):
+        """Good path: license is shown in tree label."""
+        provider.packages["licensed-pkg"] = PackageInfo(
+            name="licensed-pkg", latest_version="1.0.0", license="MIT"
+        )
+        provider.fedora_status["licensed-pkg"] = FedoraPackageStatus(
+            is_packaged=True, versions=["1.0.0"]
+        )
+
+        tree = build_tree(provider, "licensed-pkg")
+
+        assert isinstance(tree, Tree)
+        label = str(tree.label)
+        assert "MIT" in label
+
+    @pytest.mark.unit
+    def test_no_license_marker_when_no_license(self, provider):
+        """Good path: no license marker when package has no license."""
+        tree = build_tree(provider, "root")
+
+        assert isinstance(tree, Tree)
+        label = str(tree.label)
+        # License info from mock_package_info is None, so no license marker
+        assert "(None)" not in label
+
     @pytest.mark.unit
     def test_updates_progress_tracker(self, provider):
         """Good path: updates progress tracker when provided."""
@@ -291,115 +320,121 @@ class TestBuildTree:
         assert len(tree.children) == 1
 
 
-class TestCollectStats:
-    """Tests for collect_stats function."""
+class TestComputeStatsFromVisited:
+    """Tests for _compute_stats_from_visited function."""
 
     @pytest.mark.unit
     def test_returns_tree_stats_model(self):
         """Good path: returns TreeStats model."""
-        tree = Tree("[bold]root[/bold] v1.0.0 • [green]✓ packaged[/green]")
+        visited = {"root": (True, "1.0.0", False)}
 
-        stats = collect_stats(tree)
+        stats = _compute_stats_from_visited(visited)
 
         assert isinstance(stats, TreeStats)
 
     @pytest.mark.unit
     def test_counts_packaged(self):
         """Good path: counts packaged packages."""
-        tree = Tree("[bold]root[/bold] v1.0.0 • [green]✓ packaged[/green]")
+        visited = {"root": (True, "1.0.0", False)}
 
-        stats = collect_stats(tree)
+        stats = _compute_stats_from_visited(visited)
 
-        assert stats.packaged >= 1
+        assert stats.packaged == 1
 
     @pytest.mark.unit
     def test_counts_missing(self):
         """Good path: counts missing packages."""
-        tree = Tree("[bold]root[/bold] v1.0.0 • [red]✗ not packaged[/red]")
+        visited = {"root": (False, "1.0.0", False)}
 
-        stats = collect_stats(tree)
+        stats = _compute_stats_from_visited(visited)
 
-        assert stats.missing >= 1
+        assert stats.missing == 1
 
     @pytest.mark.unit
     def test_collects_missing_list(self):
         """Good path: collects list of missing packages."""
-        tree = Tree("[bold]missing-pkg[/bold] v1.0.0 • [red]✗ not packaged[/red]")
+        visited = {"missing-pkg": (False, "1.0.0", False)}
 
-        stats = collect_stats(tree)
+        stats = _compute_stats_from_visited(visited)
 
-        assert len(stats.missing_list) >= 1
+        assert len(stats.missing_list) == 1
+        assert "missing-pkg" in stats.missing_list
 
     @pytest.mark.unit
     def test_collects_packaged_list(self):
         """Good path: collects list of packaged packages."""
-        tree = Tree("[bold]pkg[/bold] v1.0.0 • [green]✓ packaged[/green]")
+        visited = {"pkg": (True, "1.0.0", False)}
 
-        stats = collect_stats(tree)
+        stats = _compute_stats_from_visited(visited)
 
-        assert len(stats.packaged_list) >= 1
+        assert len(stats.packaged_list) == 1
+        assert "pkg" in stats.packaged_list
 
     @pytest.mark.unit
-    def test_handles_string_children(self):
-        """Good path: handles string children (visited markers)."""
-        tree = Tree("[bold]root[/bold]")
-        tree.add("[dim]child[/dim] • [green]✓[/green] (already visited)")
+    def test_counts_not_found_as_missing(self):
+        """Good path: counts not-found packages (version=None) as missing."""
+        visited = {"unknown": (False, None, False)}
 
-        stats = collect_stats(tree)
+        stats = _compute_stats_from_visited(visited)
 
-        assert stats.total >= 1
+        assert stats.missing == 1
+        assert "unknown" in stats.missing_list
 
     @pytest.mark.unit
-    def test_counts_not_found_as_missing(self):
-        """Good path: counts 'not found' as missing."""
-        tree = Tree("[bold]unknown[/bold] • [red]not found on registry[/red]")
+    def test_multiple_packages(self):
+        """Critical path: counts all packages from visited dict."""
+        visited = {
+            "root": (True, "1.0.0", False),
+            "child1": (True, "1.0.0", False),
+            "child2": (False, "1.0.0", False),
+        }
 
-        stats = collect_stats(tree)
+        stats = _compute_stats_from_visited(visited)
 
-        assert stats.missing >= 1
+        assert stats.total == 3
+        assert stats.packaged == 2
+        assert stats.missing == 1
 
     @pytest.mark.unit
-    def test_extracts_name_from_not_found_string(self):
-        """Bug fix: correctly extracts package name from 'not found' string with [bold red] format."""
-        # This is the format returned by build_tree when a package is not found on the registry
-        tree = Tree("[bold]root[/bold] v1.0.0 • [green]✓ packaged[/green]")
-        # Add a child that represents a package not found on the registry (string format)
-        tree.add(
-            "[bold red]nonexistent-pkg[/bold red] • [red]not found on crates.io[/red]"
-        )
-
-        stats = collect_stats(tree)
+    def test_empty_visited(self):
+        """Good path: handles empty visited dict."""
+        stats = _compute_stats_from_visited({})
 
-        assert stats.missing == 1
-        assert "nonexistent-pkg" in stats.missing_list
-        # Ensure we don't have malformed names like "[bold"
-        for name in stats.missing_list:
-            assert not name.startswith("["), f"Malformed package name: {name}"
+        assert stats.total == 0
+        assert stats.packaged == 0
+        assert stats.missing == 0
+        assert stats.missing_list == []
+        assert stats.packaged_list == []
 
     @pytest.mark.unit
-    def test_recursive_counting(self):
-        """Critical path: counts all nodes recursively."""
-        root = Tree("[bold]root[/bold] v1.0.0 • [green]✓ packaged[/green]")
-        child1 = Tree("[bold]child1[/bold] v1.0.0 • [green]✓ packaged[/green]")
-        child2 = Tree("[bold]child2[/bold] v1.0.0 • [red]✗ not packaged[/red]")
-        root.children.append(child1)
-        root.children.append(child2)
+    def test_has_dev_build_stats(self):
+        """Good path: stats model has dev/build dependency stats (zeroed by default)."""
+        visited = {"pkg": (True, "1.0.0", False)}
 
-        stats = collect_stats(root)
+        stats = _compute_stats_from_visited(visited)
 
-        assert stats.total == 3
-        assert stats.packaged == 2
-        assert stats.missing == 1
+        assert hasattr(stats, "dev_total")
+        assert hasattr(stats, "dev_packaged")
+        assert hasattr(stats, "dev_missing")
+        assert hasattr(stats, "build_total")
+        assert hasattr(stats, "build_packaged")
+        assert hasattr(stats, "build_missing")
+        assert stats.dev_total == 0
+        assert stats.build_total == 0
 
     @pytest.mark.unit
-    def test_initializes_stats_if_not_provided(self):
-        """Good path: initializes stats model if not provided."""
-        tree = Tree("[bold]pkg[/bold]")
+    def test_optional_dependency_tracking(self):
+        """Good path: tracks optional dependency statistics."""
+        visited = {
+            "required": (True, "1.0.0", False),
+            "opt-packaged": (True, "2.0.0", True),
+            "opt-missing": (False, "3.0.0", True),
+        }
 
-        stats = collect_stats(tree)
+        stats = _compute_stats_from_visited(visited)
 
-        assert hasattr(stats, "total")
-        assert hasattr(stats, "packaged")
-        assert hasattr(stats, "missing")
-        assert hasattr(stats, "missing_list")
-        assert hasattr(stats, "packaged_list")
+        assert stats.total == 3
+        assert stats.optional_total == 2
+        assert stats.optional_packaged == 1
+        assert stats.optional_missing == 1
+        assert "opt-missing" in stats.optional_missing_list