@pennyfarthing/core 7.8.1 → 7.8.4

package/pennyfarthing_scripts/tests/test_cli_modules.py

@@ -0,0 +1,245 @@
+"""Tests for CLI entry point modules.
+
+Story 63-9: Reorganize pennyfarthing_scripts into fan-out CLI pattern.
+
+These tests verify the CLI modules work as entry points and
+properly delegate to library modules.
+"""
+
+import subprocess
+import sys
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+class TestJiraCLIModule:
+    """Tests for jira CLI module."""
+
+    def test_jira_cli_help(self) -> None:
+        """jira CLI should show help with --help."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.jira", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode == 0
+        # Should show usage info
+        assert "usage" in result.stdout.lower() or "Usage" in result.stdout
+
+    def test_jira_cli_view_subcommand(self) -> None:
+        """jira CLI should have view subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.jira", "view", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        # Should exit 0 with help or fail gracefully without --help
+        assert result.returncode in (0, 1, 2)
+
+    def test_jira_cli_sync_subcommand(self) -> None:
+        """jira CLI should have sync subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.jira", "sync", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+    def test_jira_cli_claim_subcommand(self) -> None:
+        """jira CLI should have claim subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.jira", "claim", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+    def test_jira_cli_create_subcommand(self) -> None:
+        """jira CLI should have create subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.jira", "create", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+    def test_jira_cli_bidirectional_subcommand(self) -> None:
+        """jira CLI should have bidirectional subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.jira", "bidirectional", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+
+class TestSprintCLIModule:
+    """Tests for sprint CLI module."""
+
+    def test_sprint_cli_help(self) -> None:
+        """sprint CLI should show help with --help."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.sprint", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode == 0
+        assert "usage" in result.stdout.lower() or "Usage" in result.stdout
+
+    def test_sprint_cli_status_subcommand(self) -> None:
+        """sprint CLI should have status subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.sprint", "status", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+    def test_sprint_cli_backlog_subcommand(self) -> None:
+        """sprint CLI should have backlog subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.sprint", "backlog", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+    def test_sprint_cli_work_subcommand(self) -> None:
+        """sprint CLI should have work subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.sprint", "work", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+    def test_sprint_cli_archive_subcommand(self) -> None:
+        """sprint CLI should have archive subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.sprint", "archive", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+
+class TestStoryCLIModule:
+    """Tests for story CLI module."""
+
+    def test_story_cli_help(self) -> None:
+        """story CLI should show help with --help."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.story", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode == 0
+        assert "usage" in result.stdout.lower() or "Usage" in result.stdout
+
+    def test_story_cli_size_subcommand(self) -> None:
+        """story CLI should have size subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.story", "size", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+    def test_story_cli_template_subcommand(self) -> None:
+        """story CLI should have template subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.story", "template", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+    def test_story_cli_create_subcommand(self) -> None:
+        """story CLI should have create subcommand."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.story", "create", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+
+class TestOldCLICompatibility:
+    """Tests for backwards compatibility of old CLI modules."""
+
+    def test_jira_sync_module_runnable(self) -> None:
+        """jira_sync.py should still be runnable as module."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.jira_sync", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        # Should exit with help or error (not crash)
+        assert result.returncode in (0, 1, 2)
+
+    def test_jira_bidirectional_sync_module_runnable(self) -> None:
+        """jira_bidirectional_sync.py should still be runnable."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.jira_bidirectional_sync", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+    def test_jira_epic_creation_module_runnable(self) -> None:
+        """jira_epic_creation.py should still be runnable."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.jira_epic_creation", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)
+
+    def test_jira_sync_story_module_runnable(self) -> None:
+        """jira_sync_story.py should still be runnable."""
+        result = subprocess.run(
+            [sys.executable, "-m", "pennyfarthing_scripts.jira_sync_story", "--help"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+
+        assert result.returncode in (0, 1, 2)

package/pennyfarthing_scripts/tests/test_common.py

@@ -0,0 +1,180 @@
+"""Tests for common/ shared utilities package.
+
+Story 63-9: Reorganize pennyfarthing_scripts into fan-out CLI pattern.
+
+These tests verify the common/ package provides shared utilities
+that work correctly when imported from the new location.
+"""
+
+import io
+import os
+import sys
+from pathlib import Path
+from typing import Generator
+from unittest.mock import patch
+
+import pytest
+
+
+class TestOutputModule:
+    """Tests for common/output.py module."""
+
+    def test_success_prints_green_prefix(self) -> None:
+        """success() should print with [OK] prefix."""
+        from pennyfarthing_scripts.common import output
+
+        buffer = io.StringIO()
+        # Force color support for testing
+        with patch.object(output, "_supports_color", return_value=True):
+            output.success("Test message", file=buffer)
+
+        result = buffer.getvalue()
+        assert "[OK]" in result or "\x1b[32m" in result  # Green or prefix
+        assert "Test message" in result
+
+    def test_info_prints_blue_prefix(self) -> None:
+        """info() should print with [INFO] prefix."""
+        from pennyfarthing_scripts.common import output
+
+        buffer = io.StringIO()
+        output.info("Info message", file=buffer)
+
+        result = buffer.getvalue()
+        assert "INFO" in result or "Info message" in result
+
+    def test_warn_prints_yellow_prefix(self) -> None:
+        """warn() should print with [WARN] prefix."""
+        from pennyfarthing_scripts.common import output
+
+        buffer = io.StringIO()
+        output.warn("Warning message", file=buffer)
+
+        result = buffer.getvalue()
+        assert "WARN" in result or "Warning message" in result
+
+    def test_error_prints_red_prefix(self) -> None:
+        """error() should print with [ERROR] prefix."""
+        from pennyfarthing_scripts.common import output
+
+        buffer = io.StringIO()
+        output.error("Error message", file=buffer)
+
+        result = buffer.getvalue()
+        assert "ERROR" in result or "Error message" in result
+
+    def test_no_color_env_disables_colors(self) -> None:
+        """NO_COLOR environment variable should disable colors."""
+        from pennyfarthing_scripts.common import output
+
+        with patch.dict(os.environ, {"NO_COLOR": "1"}):
+            buffer = io.StringIO()
+            output.success("Test", file=buffer)
+            result = buffer.getvalue()
+            # Should not contain ANSI escape codes
+            assert "\x1b[" not in result
+
+    def test_force_color_env_enables_colors(self) -> None:
+        """FORCE_COLOR environment variable should enable colors."""
+        from pennyfarthing_scripts.common import output
+
+        with patch.dict(os.environ, {"FORCE_COLOR": "1"}, clear=False):
+            # Remove NO_COLOR if present
+            with patch.dict(os.environ, {"NO_COLOR": ""}, clear=False):
+                assert output._supports_color(sys.stderr) is True
+
+    def test_header_prints_decorated_line(self) -> None:
+        """header() should print decorated header."""
+        from pennyfarthing_scripts.common import output
+
+        buffer = io.StringIO()
+        output.header("Test Header", char="=", width=40, file=buffer)
+
+        result = buffer.getvalue()
+        assert "Test Header" in result
+        assert "=" * 40 in result
+
+    def test_divider_prints_line(self) -> None:
+        """divider() should print a line."""
+        from pennyfarthing_scripts.common import output
+
+        buffer = io.StringIO()
+        output.divider(char="-", width=20, file=buffer)
+
+        result = buffer.getvalue()
+        assert "-" * 20 in result
+
+
+class TestConfigModule:
+    """Tests for common/config.py module."""
+
+    def test_get_project_root_finds_pennyfarthing_dir(self) -> None:
+        """get_project_root() should find .pennyfarthing directory."""
+        from pennyfarthing_scripts.common import config
+
+        # This test assumes we're running from within the pennyfarthing project
+        root = config.get_project_root()
+        assert root is not None
+        assert (root / ".pennyfarthing").is_dir()
+
+    def test_get_project_root_raises_if_not_found(self) -> None:
+        """get_project_root() should raise if no .pennyfarthing found."""
+        from pennyfarthing_scripts.common import config
+
+        # Start from root filesystem where there's no .pennyfarthing
+        with pytest.raises(FileNotFoundError):
+            config.get_project_root(start_dir=Path("/"))
+
+    def test_load_yaml_config_returns_dict(self) -> None:
+        """load_yaml_config() should return parsed YAML as dict."""
+        from pennyfarthing_scripts.common import config
+
+        # Test with existing sprint file
+        root = config.get_project_root()
+        sprint_path = root / "sprint" / "current-sprint.yaml"
+
+        if sprint_path.exists():
+            result = config.load_yaml_config(sprint_path)
+            assert isinstance(result, dict)
+
+    def test_load_yaml_config_returns_none_if_missing(self) -> None:
+        """load_yaml_config() should return None for missing files."""
+        from pennyfarthing_scripts.common import config
+
+        result = config.load_yaml_config(Path("/nonexistent/file.yaml"))
+        assert result is None
+
+    def test_find_project_root_alias(self) -> None:
+        """find_project_root should be an alias for get_project_root."""
+        from pennyfarthing_scripts.common import config
+
+        assert config.find_project_root == config.get_project_root
+
+    def test_load_pennyfarthing_config_returns_dict(self) -> None:
+        """load_pennyfarthing_config() should return config or empty dict."""
+        from pennyfarthing_scripts.common import config
+
+        result = config.load_pennyfarthing_config()
+        assert isinstance(result, dict)
+
+
+class TestColorsClass:
+    """Tests for Colors class with ANSI codes."""
+
+    def test_colors_has_expected_constants(self) -> None:
+        """Colors class should have standard ANSI color codes."""
+        from pennyfarthing_scripts.common.output import Colors
+
+        assert hasattr(Colors, "RED")
+        assert hasattr(Colors, "GREEN")
+        assert hasattr(Colors, "YELLOW")
+        assert hasattr(Colors, "BLUE")
+        assert hasattr(Colors, "RESET")
+        assert hasattr(Colors, "BOLD")
+        assert hasattr(Colors, "DIM")
+
+    def test_colors_are_ansi_escape_codes(self) -> None:
+        """Color constants should be ANSI escape sequences."""
+        from pennyfarthing_scripts.common.output import Colors
+
+        assert Colors.RED.startswith("\x1b[")
+        assert Colors.RESET == "\x1b[0m"