chore: refactor test code to reduce file complexity

Author: Really Him

tests/fixtures/stats_test_data/__init__.py

@@ -0,0 +1,18 @@
+"""
+Static test data directory for the stats CLI command.
+
+This directory contains a snapshot of the antipasta codebase that was intended
+to be used for testing the stats command against real code with varying complexity
+metrics. However, it is currently NOT USED in any active tests.
+
+Current status:
+- The stats tests use dynamically generated temporary test files via the
+  temp_project_dir fixture instead of this static data
+- This directory could potentially be removed to reduce codebase complexity
+- Alternatively, it could be incorporated into tests for more realistic testing
+  scenarios with actual production code patterns
+
+The fixture mimics the real antipasta project structure (antipasta/cli/,
+antipasta/core/, etc.) and provides consistent, reproducible test data for
+analyzing code metrics like cyclomatic complexity, LOC, and other metrics.
+"""

tests/fixtures/stats_test_data/antipasta/cli/stats.py

@@ -491,7 +491,7 @@ def _collect_directory_stats(
 
         # Apply truncation for relative and parent styles (NOT for full)
         if path_style != "full" and len(display_path) > 30:
-            display_path = "..." + display_path[-(30 - 3) :]
+            display_path = "..." + display_path[-(30 - 3):]
 
         # Remove duplicate counts (a file might be counted multiple times in aggregation)
         unique_files = list({id(f): f for f in data["all_files"]}.values())
@@ -748,7 +748,7 @@ def _truncate_path(path: str, max_length: int) -> str:
     """Truncate long paths for display."""
     if len(path) <= max_length:
         return path
-    return "..." + path[-(max_length - 3) :]
+    return "..." + path[-(max_length - 3):]
 
 
 def _display_json(stats_data: dict[str, Any]) -> None:

tests/unit/cli/stats/__init__.py

@@ -0,0 +1,58 @@
+"""Shared fixtures and utilities for stats tests."""
+
+import tempfile
+from collections.abc import Generator
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def temp_project_dir() -> Generator[Path, None, None]:
+    """Create a temporary project directory with nested Python files."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        base = Path(tmpdir) / "test_project"
+        base.mkdir()
+
+        # Create a nested directory structure with Python files
+        # Root level
+        (base / "main.py").write_text("def main():\n    pass\n")
+        (base / "utils.py").write_text("def util():\n    return 42\n")
+
+        # Level 1 - cli directory
+        cli_dir = base / "cli"
+        cli_dir.mkdir()
+        (cli_dir / "commands.py").write_text(
+            "def cmd():\n    for i in range(10):\n        print(i)\n"
+        )
+        (cli_dir / "options.py").write_text("OPTIONS = {}\n")
+
+        # Level 1 - core directory
+        core_dir = base / "core"
+        core_dir.mkdir()
+        (core_dir / "engine.py").write_text("class Engine:\n    def run(self):\n        pass\n")
+        (core_dir / "config.py").write_text("CONFIG = {'debug': True}\n")
+
+        # Level 2 - cli/subcommands
+        sub_dir = cli_dir / "subcommands"
+        sub_dir.mkdir()
+        (sub_dir / "analyze.py").write_text(
+            "def analyze():\n    if True:\n        return 1\n    return 0\n"
+        )
+
+        # Level 2 - core/modules
+        mod_dir = core_dir / "modules"
+        mod_dir.mkdir()
+        (mod_dir / "parser.py").write_text("def parse(data):\n    return data\n")
+
+        # Level 3 - deeper nesting
+        deep_dir = mod_dir / "validators"
+        deep_dir.mkdir()
+        (deep_dir / "rules.py").write_text("RULES = []\n")
+
+        # Level 4 - even deeper
+        deeper_dir = deep_dir / "builtin"
+        deeper_dir.mkdir()
+        (deeper_dir / "basic.py").write_text("def validate():\n    pass\n")
+
+        yield base

tests/unit/cli/stats/conftest.py

@@ -0,0 +1,118 @@
+"""Tests for unlimited depth traversal feature."""
+
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from antipasta.cli.stats import MAX_DEPTH, stats
+
+
+class TestUnlimitedDepthFeature:
+    """Test suite for TICKET-STATS-001: --depth 0 for unlimited traversal."""
+
+    def test_depth_zero_shows_all_levels(self, temp_project_dir: Path) -> None:
+        """Test that --depth 0 shows all directory levels."""
+        runner = CliRunner()
+        result = runner.invoke(
+            stats, ["-d", str(temp_project_dir), "--by-directory", "--depth", "0"]
+        )
+
+        assert result.exit_code == 0
+        # Should show nested directories
+        assert "modules/validators" in result.output or "validators" in result.output
+        assert "validators/builtin" in result.output or "builtin" in result.output
+
+    def test_depth_one_shows_only_top_level(self, temp_project_dir: Path) -> None:
+        """Test that --depth 1 shows only top-level directories."""
+        runner = CliRunner()
+        result = runner.invoke(
+            stats, ["-d", str(temp_project_dir), "--by-directory", "--depth", "1"]
+        )
+
+        assert result.exit_code == 0
+        output_lines = result.output.split("\n")
+
+        # Should show only top-level directories
+        for line in output_lines:
+            if "Location" in line or "---" in line or not line.strip():
+                continue
+            # Check that no nested paths appear (no slashes in directory names)
+            if line.strip() and not line.startswith("Found") and not line.startswith("Analyzing"):
+                parts = line.split()[0]
+                if parts not in ["test_project", "."]:
+                    assert "/" not in parts, f"Found nested path {parts} in depth=1 output"
+
+    def test_depth_two_shows_two_levels(self, temp_project_dir: Path) -> None:
+        """Test that --depth 2 shows exactly two levels."""
+        runner = CliRunner()
+        result = runner.invoke(
+            stats, ["-d", str(temp_project_dir), "--by-directory", "--depth", "2"]
+        )
+
+        assert result.exit_code == 0
+        output_lines = result.output.split("\n")
+
+        # Extract directory names from the output
+        directories = []
+        for line in output_lines:
+            if line.strip() and not any(
+                skip in line
+                for skip in ["Found", "Analyzing", "CODE METRICS", "Location", "---", "="]
+            ):
+                parts = line.split()
+                if parts and any(c.isdigit() for c in line):  # Has metrics data
+                    directories.append(parts[0])
+
+        # Should show first-level subdirs
+        assert "cli" in directories
+        assert "core" in directories
+
+        # For depth=2, we should see these directories
+        # Note: depth=2 shows dirs up to 2 levels deep from base
+        # The exact subdirectories shown depend on aggregation
+
+    def test_max_depth_boundary(self, temp_project_dir: Path) -> None:
+        """Test that unlimited depth respects MAX_DEPTH boundary."""
+        runner = CliRunner()
+
+        # depth=0 should be equivalent to depth=MAX_DEPTH
+        result_zero = runner.invoke(
+            stats, ["-d", str(temp_project_dir), "--by-directory", "--depth", "0"]
+        )
+
+        result_max = runner.invoke(
+            stats, ["-d", str(temp_project_dir), "--by-directory", "--depth", str(MAX_DEPTH)]
+        )
+
+        # Both should succeed
+        assert result_zero.exit_code == 0
+        assert result_max.exit_code == 0
+
+        # Output should be similar (may differ in formatting)
+        # Count number of directory entries
+        def count_directories(output: str) -> int:
+            lines = output.split("\n")
+            count = 0
+            for line in lines:
+                if (
+                    line.strip()
+                    and not any(
+                        skip in line
+                        for skip in ["Found", "Analyzing", "CODE METRICS", "Location", "---", "="]
+                    )
+                    and any(c.isdigit() for c in line)
+                ):  # Has metrics data
+                    count += 1
+            return count
+
+        assert count_directories(result_zero.output) == count_directories(result_max.output)
+
+    def test_depth_greater_than_max(self, temp_project_dir: Path) -> None:
+        """Test that depth > MAX_DEPTH works correctly."""
+        runner = CliRunner()
+        result = runner.invoke(
+            stats, ["-d", str(temp_project_dir), "--by-directory", "--depth", str(MAX_DEPTH + 5)]
+        )
+
+        # Should work without error
+        assert result.exit_code == 0

tests/unit/cli/stats/test_stats_depth.py

@@ -0,0 +1,83 @@
+"""Tests for edge cases and error conditions."""""
+
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from antipasta.cli.stats import stats
+
+
+class TestEdgeCasesAndErrors:
+    """Test edge cases and error conditions."""
+
+    def test_invalid_path_style(self) -> None:
+        """Test that invalid path style is rejected."""
+        runner = CliRunner()
+
+        result = runner.invoke(stats, ["-d", ".", "--by-directory", "--path-style", "invalid"])
+
+        assert result.exit_code != 0
+        assert "Invalid value" in result.output or "invalid" in result.output.lower()
+
+    def test_negative_depth(self, temp_project_dir: Path) -> None:
+        """Test that negative depth values are handled."""
+        runner = CliRunner()
+
+        result = runner.invoke(
+            stats, ["-d", str(temp_project_dir), "--by-directory", "--depth", "-1"]
+        )
+
+        # Should either error or treat as 0/1
+        # Implementation might vary
+        assert result.exit_code == 0 or "Invalid" in result.output
+
+    def test_very_large_depth(self, temp_project_dir: Path) -> None:
+        """Test extremely large depth values."""
+        runner = CliRunner()
+
+        result = runner.invoke(
+            stats, ["-d", str(temp_project_dir), "--by-directory", "--depth", "999999"]
+        )
+
+        # Should work (capped by actual directory depth)
+        assert result.exit_code == 0
+
+    def test_nonexistent_directory(self) -> None:
+        """Test with non-existent directory."""
+        runner = CliRunner()
+
+        result = runner.invoke(
+            stats, ["-d", "/nonexistent/directory/path", "--by-directory", "--depth", "2"]
+        )
+
+        assert result.exit_code != 0
+
+    def test_empty_directory(self, tmp_path: Path) -> None:
+        """Test with empty directory."""
+        runner = CliRunner()
+
+        empty_dir = tmp_path / "empty"
+        empty_dir.mkdir()
+
+        result = runner.invoke(stats, ["-d", str(empty_dir), "--by-directory", "--depth", "1"])
+
+        # Should handle gracefully
+        assert "No files found" in result.output or "No analyzable files" in result.output
+
+    def test_mixed_file_types(self, tmp_path: Path) -> None:
+        """Test directory with non-Python files."""
+        runner = CliRunner()
+
+        mixed_dir = tmp_path / "mixed"
+        mixed_dir.mkdir()
+
+        # Create various file types
+        (mixed_dir / "test.py").write_text("def hello(): pass")
+        (mixed_dir / "readme.md").write_text("# README")
+        (mixed_dir / "data.json").write_text("{}")
+
+        result = runner.invoke(stats, ["-d", str(mixed_dir), "--by-directory", "--depth", "1"])
+
+        assert result.exit_code == 0
+        # Should only analyze Python files
+        assert "1 python files" in result.output.lower()