@pennyfarthing/core 11.4.0 → 12.0.0

package/pennyfarthing-dist/src/pf/tests/test_jira_package.py

@@ -0,0 +1,331 @@
+"""Tests for jira/ library package.
+
+Story 63-9: Reorganize pf into fan-out CLI pattern.
+
+These tests verify the jira/ package modules work correctly
+after reorganization from flat modules.
+"""
+
+from typing import Any
+
+
+class TestJiraClient:
+    """Tests for jira/client.py JiraClient class."""
+
+    def test_jira_client_initialization(self) -> None:
+        """JiraClient should initialize with default or custom values."""
+        from pf.jira.client import JiraClient
+
+        # Default initialization
+        client = JiraClient()
+        assert client.base_url is not None
+        assert client.user is not None
+
+        # Custom initialization
+        client = JiraClient(
+            base_url="https://custom.atlassian.net",
+            user="test@example.com",
+            token="test-token",
+        )
+        assert client.base_url == "https://custom.atlassian.net"
+        assert client.user == "test@example.com"
+        assert client.token == "test-token"
+
+    def test_get_auth_header_returns_basic_auth(self) -> None:
+        """_get_auth_header should return Basic auth header."""
+        from pf.jira.client import JiraClient
+
+        client = JiraClient(
+            user="user@example.com",
+            token="my-token",
+        )
+        headers = client._get_auth_header()
+
+        assert "Authorization" in headers
+        assert headers["Authorization"].startswith("Basic ")
+
+    def test_get_auth_header_empty_without_token(self) -> None:
+        """_get_auth_header should return empty dict without token."""
+        from pf.jira.client import JiraClient
+
+        client = JiraClient(token="")
+        headers = client._get_auth_header()
+
+        assert headers == {}
+
+    def test_get_headers_includes_accept(self) -> None:
+        """_get_headers should include Accept header."""
+        from pf.jira.client import JiraClient
+
+        client = JiraClient(token="test")
+        headers = client._get_headers()
+
+        assert "Accept" in headers
+        assert headers["Accept"] == "application/json"
+
+    def test_get_headers_includes_content_type_when_requested(self) -> None:
+        """_get_headers should include Content-Type when content_type=True."""
+        from pf.jira.client import JiraClient
+
+        client = JiraClient(token="test")
+        headers = client._get_headers(content_type=True)
+
+        assert "Content-Type" in headers
+        assert headers["Content-Type"] == "application/json"
+
+
+class TestStatusMappings:
+    """Tests for status mapping functions in jira/client.py."""
+
+    def test_map_status_to_jira_known_status(self) -> None:
+        """map_status_to_jira should map known statuses correctly."""
+        from pf.jira.client import map_status_to_jira
+
+        assert map_status_to_jira("backlog") == "To Do"
+        assert map_status_to_jira("in-progress") == "In Progress"
+        assert map_status_to_jira("in_progress") == "In Progress"
+        assert map_status_to_jira("done") == "Done"
+        assert map_status_to_jira("review") == "In Review"
+
+    def test_map_status_to_jira_unknown_defaults_to_todo(self) -> None:
+        """map_status_to_jira should default to 'To Do' for unknown."""
+        from pf.jira.client import map_status_to_jira
+
+        assert map_status_to_jira("unknown_status") == "To Do"
+        assert map_status_to_jira(None) == "To Do"
+
+    def test_map_jira_to_status_known_status(self) -> None:
+        """map_jira_to_status should map known Jira statuses correctly."""
+        from pf.jira.client import map_jira_to_status
+
+        assert map_jira_to_status("To Do") == "backlog"
+        assert map_jira_to_status("In Progress") == "in_progress"
+        assert map_jira_to_status("Done") == "done"
+        assert map_jira_to_status("In Review") == "in_review"
+
+    def test_map_jira_to_status_unknown_defaults_to_backlog(self) -> None:
+        """map_jira_to_status should default to 'backlog' for unknown."""
+        from pf.jira.client import map_jira_to_status
+
+        assert map_jira_to_status("Unknown Status") == "backlog"
+        assert map_jira_to_status(None) == "backlog"
+
+
+class TestExtractJiraKey:
+    """Tests for extract_jira_key function."""
+
+    def test_extract_jira_key_from_key(self) -> None:
+        """extract_jira_key should return key as-is if already a key."""
+        from pf.jira.client import extract_jira_key
+
+        assert extract_jira_key("MSSCI-12345") == "MSSCI-12345"
+
+    def test_extract_jira_key_from_url(self) -> None:
+        """extract_jira_key should extract key from URL."""
+        from pf.jira.client import extract_jira_key
+
+        url = "https://1898andco.atlassian.net/browse/MSSCI-12345"
+        assert extract_jira_key(url) == "MSSCI-12345"
+
+    def test_extract_jira_key_returns_none_for_none(self) -> None:
+        """extract_jira_key should return None for None input."""
+        from pf.jira.client import extract_jira_key
+
+        assert extract_jira_key(None) is None
+
+
+class TestGetJiraField:
+    """Tests for get_jira_field helper function."""
+
+    def test_get_jira_field_simple_path(self) -> None:
+        """get_jira_field should extract simple field paths."""
+        from pf.jira.client import get_jira_field
+
+        issue = {"key": "MSSCI-123", "id": "10001"}
+        assert get_jira_field(issue, "key") == "MSSCI-123"
+
+    def test_get_jira_field_nested_path(self) -> None:
+        """get_jira_field should extract nested field paths."""
+        from pf.jira.client import get_jira_field
+
+        issue = {
+            "fields": {
+                "status": {"name": "In Progress"},
+                "customfield_10031": 5,
+            }
+        }
+        assert get_jira_field(issue, "fields.status.name") == "In Progress"
+        assert get_jira_field(issue, "fields.customfield_10031") == 5
+
+    def test_get_jira_field_returns_default_if_missing(self) -> None:
+        """get_jira_field should return default for missing paths."""
+        from pf.jira.client import get_jira_field
+
+        issue = {"key": "MSSCI-123"}
+        assert get_jira_field(issue, "fields.missing", "default") == "default"
+        assert get_jira_field(issue, "nonexistent") is None
+
+    def test_get_jira_field_handles_none_input(self) -> None:
+        """get_jira_field should handle None issue input."""
+        from pf.jira.client import get_jira_field
+
+        assert get_jira_field(None, "key", "default") == "default"
+
+
+class TestJiraSyncModule:
+    """Tests for jira/sync.py module."""
+
+    def test_sync_result_dataclass(self) -> None:
+        """SyncResult should be a valid dataclass."""
+        from pf.jira.sync import SyncResult
+
+        result = SyncResult(
+            story_id="63-1",
+            success=True,
+            skipped=False,
+            error=None,
+            actions=["transitioned"],
+            dry_run=False,
+        )
+        assert result.story_id == "63-1"
+        assert result.success is True
+        assert "transitioned" in result.actions
+
+    def test_format_story_line(self) -> None:
+        """format_story_line should format story for display."""
+        from pf.jira.sync import format_story_line
+
+        story = {"id": "63-1", "title": "Test Story", "status": "in_progress"}
+        result = format_story_line(story)
+
+        assert "63-1" in result
+        assert "Test Story" in result
+        assert "in_progress" in result
+
+    def test_format_summary(self) -> None:
+        """format_summary should format sync summary."""
+        from pf.jira.sync import format_summary
+
+        result = format_summary(synced=5, skipped=2, errors=1)
+
+        assert "5" in result
+        assert "2" in result
+        assert "1" in result
+
+
+class TestJiraBidirectionalModule:
+    """Tests for jira/bidirectional.py module."""
+
+    def test_sync_change_dataclass(self) -> None:
+        """SyncChange should be a valid dataclass."""
+        from pf.jira.bidirectional import SyncChange
+
+        change = SyncChange(
+            key="MSSCI-12345",
+            field="status",
+            action="update-jira",
+            yaml_value="in_progress",
+            jira_value="To Do",
+            target_value="In Progress",
+        )
+        assert change.key == "MSSCI-12345"
+        assert change.action == "update-jira"
+
+    def test_sync_plan_dataclass(self) -> None:
+        """SyncPlan should be a valid dataclass."""
+        from pf.jira.bidirectional import SyncPlan
+
+        plan = SyncPlan()
+        assert plan.changes == []
+        assert plan.yaml_only == []
+        assert plan.jira_only == []
+        assert plan.both == []
+
+    def test_generate_sync_plan_empty_inputs(self) -> None:
+        """generate_sync_plan should handle empty inputs."""
+        from pf.jira.bidirectional import generate_sync_plan
+
+        plan = generate_sync_plan([], [], sync_status=True)
+
+        assert plan.changes == []
+        assert plan.yaml_only == []
+        assert plan.jira_only == []
+
+    def test_generate_sync_plan_identifies_yaml_only(self) -> None:
+        """generate_sync_plan should identify stories only in YAML."""
+        from pf.jira.bidirectional import generate_sync_plan
+
+        yaml_stories = [{"id": "63-1", "jira": "MSSCI-12345", "status": "in_progress"}]
+        jira_stories: list[dict[str, Any]] = []
+
+        plan = generate_sync_plan(yaml_stories, jira_stories, sync_status=True)
+
+        assert "MSSCI-12345" in plan.yaml_only
+
+    def test_generate_sync_plan_identifies_jira_only(self) -> None:
+        """generate_sync_plan should identify stories only in Jira."""
+        from pf.jira.bidirectional import generate_sync_plan
+
+        yaml_stories: list[dict[str, Any]] = []
+        jira_stories = [{"key": "MSSCI-12345", "fields": {"status": {"name": "To Do"}}}]
+
+        plan = generate_sync_plan(yaml_stories, jira_stories, sync_status=True)
+
+        assert "MSSCI-12345" in plan.jira_only
+
+    def test_format_sync_plan(self) -> None:
+        """format_sync_plan should return formatted string."""
+        from pf.jira.bidirectional import (
+            SyncPlan,
+            format_sync_plan,
+        )
+
+        plan = SyncPlan(
+            yaml_only=["MSSCI-111"],
+            jira_only=["MSSCI-222"],
+            both=["MSSCI-333"],
+        )
+        result = format_sync_plan(plan)
+
+        assert "MSSCI-111" in result
+        assert "MSSCI-222" in result
+        assert "Sync Plan" in result
+
+
+class TestJiraEpicModule:
+    """Tests for jira/epic.py module."""
+
+    def test_build_epic_payload(self) -> None:
+        """build_epic_payload should create valid Jira API payload."""
+        from pf.jira.epic import build_epic_payload
+
+        epic_data = {"title": "Test Epic", "description": "Epic description"}
+        payload = build_epic_payload(epic_data)
+
+        assert "fields" in payload
+        assert payload["fields"]["summary"] == "Test Epic"
+        assert payload["fields"]["issuetype"]["name"] == "Epic"
+        assert "description" in payload["fields"]
+
+    def test_create_epic_dry_run(self) -> None:
+        """create_epic with dry_run should not call API."""
+        from pf.jira.epic import create_epic
+
+        result = create_epic("Test Epic", "Description", dry_run=True)
+
+        assert result["success"] is True
+        assert result["dry_run"] is True
+        assert "payload" in result
+
+
+class TestJiraStoryModule:
+    """Tests for jira/story.py module."""
+
+    def test_sync_story_missing_story(self) -> None:
+        """sync_story should return error for missing story."""
+        from pf.jira.story import sync_story
+
+        result = sync_story("nonexistent-99", do_transition=False, dry_run=True)
+
+        assert result["success"] is False
+        assert "not found" in result.get("error", "").lower()

package/pennyfarthing-dist/src/pf/tests/test_package_structure.py

@@ -0,0 +1,314 @@
+"""Tests for the fan-out CLI package structure.
+
+Story 63-9: Reorganize pf into fan-out CLI pattern.
+
+These tests verify:
+1. Library packages exist (jira/, sprint/, story/, common/)
+2. CLI modules exist (jira.py, sprint.py, story.py)
+3. Library modules are importable from packages
+4. CLIs delegate to library modules
+5. Backwards compatibility for existing imports
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+# src/ must be on PYTHONPATH for subprocess -m calls (src-layout)
+# src/pf/tests -> src/pf -> src
+_SRC_DIR = str(Path(__file__).resolve().parents[2])
+_ENV = {**os.environ, "PYTHONPATH": _SRC_DIR + os.pathsep + os.environ.get("PYTHONPATH", "")}
+
+
+def _run_module(*args: str) -> subprocess.CompletedProcess[str]:
+    """Run a pf module as subprocess with correct PYTHONPATH."""
+    return subprocess.run(
+        [sys.executable, "-m", *args],
+        capture_output=True,
+        text=True,
+        timeout=30,
+        env=_ENV,
+    )
+
+
+class TestCommonPackage:
+    """Tests for common/ shared utilities package."""
+
+    def test_common_package_exists(self) -> None:
+        """common/ package should exist and be importable."""
+        from pf import common
+
+        assert common is not None
+
+    def test_output_module_in_common(self) -> None:
+        """output.py should be importable from common/."""
+        from pf.common import output
+
+        assert hasattr(output, "success")
+        assert hasattr(output, "info")
+        assert hasattr(output, "warn")
+        assert hasattr(output, "error")
+        assert hasattr(output, "debug")
+
+    def test_config_module_in_common(self) -> None:
+        """config.py should be importable from common/."""
+        from pf.common import config
+
+        assert hasattr(config, "get_project_root")
+        assert hasattr(config, "load_yaml_config")
+        assert hasattr(config, "load_pennyfarthing_config")
+
+
+
+class TestJiraPackage:
+    """Tests for jira/ library package."""
+
+    def test_jira_package_exists(self) -> None:
+        """jira/ package should exist and be importable."""
+        from pf import jira
+
+        # Should be a package, not the old flat module
+        assert hasattr(jira, "__path__")  # Packages have __path__
+
+    def test_client_module_in_jira(self) -> None:
+        """client.py should contain JiraClient and helper functions."""
+        from pf.jira import client
+
+        assert hasattr(client, "JiraClient")
+        assert hasattr(client, "get_client")
+        assert hasattr(client, "map_status_to_jira")
+        assert hasattr(client, "map_jira_to_status")
+        assert hasattr(client, "extract_jira_key")
+
+    def test_claim_module_in_jira(self) -> None:
+        """claim.py should provide story claiming functionality."""
+        from pf.jira import claim
+
+        # Main function for claiming stories
+        assert hasattr(claim, "claim_story")
+        assert hasattr(claim, "check_availability")
+
+    def test_sync_module_in_jira(self) -> None:
+        """sync.py should provide epic sync functionality."""
+        from pf.jira import sync
+
+        assert hasattr(sync, "sync_epic")
+        assert hasattr(sync, "sync_story")
+        assert hasattr(sync, "SyncResult")
+
+    def test_bidirectional_module_in_jira(self) -> None:
+        """bidirectional.py should provide bidirectional sync."""
+        from pf.jira import bidirectional
+
+        assert hasattr(bidirectional, "generate_sync_plan")
+        assert hasattr(bidirectional, "execute_sync_plan")
+        assert hasattr(bidirectional, "SyncPlan")
+        assert hasattr(bidirectional, "SyncChange")
+
+    def test_epic_module_in_jira(self) -> None:
+        """epic.py should provide epic creation functionality."""
+        from pf.jira import epic
+
+        assert hasattr(epic, "create_epic")
+        assert hasattr(epic, "create_epic_from_yaml")
+        assert hasattr(epic, "build_epic_payload")
+
+    def test_story_module_in_jira(self) -> None:
+        """story.py should provide story sync functionality."""
+        from pf.jira import story
+
+        assert hasattr(story, "sync_story")
+        assert hasattr(story, "get_story_from_sprint")
+
+    def test_jira_package_reexports(self) -> None:
+        """jira/__init__.py should re-export commonly used items."""
+        from pf.jira import (
+            JiraClient,
+            extract_jira_key,
+        )
+
+        assert JiraClient is not None
+        assert callable(extract_jira_key)
+
+    def test_jira_backwards_compatibility(self) -> None:
+        """Old-style imports should still work."""
+        from pf.jira import STATUS_TO_JIRA, JiraClient, get_client
+
+        assert JiraClient is not None
+        assert callable(get_client)
+        assert isinstance(STATUS_TO_JIRA, dict)
+
+
+class TestSprintPackage:
+    """Tests for sprint/ library package."""
+
+    def test_sprint_package_exists(self) -> None:
+        """sprint/ package should exist and be importable."""
+        from pf import sprint
+
+        # Should be a package, not the old flat module
+        assert hasattr(sprint, "__path__")
+
+    def test_loader_module_in_sprint(self) -> None:
+        """loader.py should provide sprint YAML loading."""
+        from pf.sprint import loader
+
+        assert hasattr(loader, "load_sprint")
+        assert hasattr(loader, "find_epic")
+        assert hasattr(loader, "find_story")
+        assert hasattr(loader, "get_all_stories")
+        assert hasattr(loader, "get_story_by_id")
+
+    def test_status_module_in_sprint(self) -> None:
+        """status.py should provide sprint status operations."""
+        from pf.sprint import status
+
+        assert hasattr(status, "get_sprint_status")
+        assert hasattr(status, "format_status")
+
+    def test_work_module_in_sprint(self) -> None:
+        """work.py should provide work session management."""
+        from pf.sprint import work
+
+        assert hasattr(work, "start_work")
+        assert hasattr(work, "check_story")
+
+    def test_archive_module_in_sprint(self) -> None:
+        """archive.py should provide story archiving."""
+        from pf.sprint import archive
+
+        assert hasattr(archive, "archive_story")
+
+    def test_sprint_package_reexports(self) -> None:
+        """sprint/__init__.py should re-export commonly used items."""
+        from pf.sprint import (
+            find_epic,
+            load_sprint,
+        )
+
+        assert callable(load_sprint)
+        assert callable(find_epic)
+
+    def test_sprint_backwards_compatibility(self) -> None:
+        """Old-style imports should still work."""
+        from pf.sprint import find_epic, load_current_sprint, load_sprint
+
+        assert callable(load_sprint)
+        assert callable(find_epic)
+        assert callable(load_current_sprint)
+
+
+class TestStoryPackage:
+    """Tests for story/ library package."""
+
+    def test_story_package_exists(self) -> None:
+        """story/ package should exist and be importable."""
+        from pf import story
+
+        # Should be a package
+        assert hasattr(story, "__path__")
+
+    def test_size_module_in_story(self) -> None:
+        """size.py should provide story sizing utilities."""
+        from pf.story import size
+
+        assert hasattr(size, "get_sizing_guidelines")
+        assert hasattr(size, "format_size_info")
+
+    def test_template_module_in_story(self) -> None:
+        """template.py should provide story templates."""
+        from pf.story import template
+
+        assert hasattr(template, "get_template")
+        assert hasattr(template, "get_all_templates")
+
+    def test_create_module_in_story(self) -> None:
+        """create.py should provide story creation."""
+        from pf.story import create
+
+        assert hasattr(create, "create_story")
+        assert hasattr(create, "generate_story_yaml")
+
+
+class TestJiraCLI:
+    """Tests for jira.py CLI entry point."""
+
+    def test_jira_cli_has_main(self) -> None:
+        """jira.py should have a main() entry point."""
+        # Import the CLI module (not the package)
+        import pf.jira as jira_pkg
+
+        # The package's __main__.py or main module should have main()
+        assert hasattr(jira_pkg, "main") or hasattr(jira_pkg, "cli")
+
+    def test_jira_cli_subcommands(self) -> None:
+        """jira CLI should support expected subcommands."""
+        from pf.jira import cli
+
+        # CLI should define these subcommands
+        assert hasattr(cli, "view") or "view" in dir(cli)
+        assert hasattr(cli, "claim") or "claim" in dir(cli)
+        assert hasattr(cli, "sync") or "sync" in dir(cli)
+        assert hasattr(cli, "create") or "create" in dir(cli)
+        assert hasattr(cli, "bidirectional") or "bidirectional" in dir(cli)
+
+    def test_jira_cli_runnable_as_module(self) -> None:
+        """python -m pf.jira should work."""
+        result = _run_module("pf.jira", "--help")
+        # Should exit 0 with help text
+        assert result.returncode == 0
+        assert "usage" in result.stdout.lower() or "Usage" in result.stdout
+
+
+class TestSprintCLI:
+    """Tests for sprint.py CLI entry point."""
+
+    def test_sprint_cli_has_main(self) -> None:
+        """sprint.py should have a main() entry point."""
+        import pf.sprint as sprint_pkg
+
+        assert hasattr(sprint_pkg, "main") or hasattr(sprint_pkg, "cli")
+
+    def test_sprint_cli_subcommands(self) -> None:
+        """sprint CLI should support expected subcommands."""
+        from pf.sprint import cli
+
+        # CLI should define these subcommands based on skill.md
+        assert hasattr(cli, "status") or "status" in dir(cli)
+        assert hasattr(cli, "backlog") or "backlog" in dir(cli)
+        assert hasattr(cli, "work") or "work" in dir(cli)
+        assert hasattr(cli, "archive") or "archive" in dir(cli)
+
+    def test_sprint_cli_runnable_as_module(self) -> None:
+        """python -m pf.sprint should work."""
+        result = _run_module("pf.sprint", "--help")
+        assert result.returncode == 0
+        assert "usage" in result.stdout.lower() or "Usage" in result.stdout
+
+
+class TestStoryCLI:
+    """Tests for story.py CLI entry point."""
+
+    def test_story_cli_has_main(self) -> None:
+        """story.py should have a main() entry point."""
+        import pf.story as story_pkg
+
+        assert hasattr(story_pkg, "main") or hasattr(story_pkg, "cli")
+
+    def test_story_cli_subcommands(self) -> None:
+        """story CLI should support expected subcommands."""
+        from pf.story import cli
+
+        # CLI should define these subcommands based on skill.md
+        assert hasattr(cli, "size") or "size" in dir(cli)
+        assert hasattr(cli, "template") or "template" in dir(cli)
+        assert hasattr(cli, "create") or "create" in dir(cli)
+
+    def test_story_cli_runnable_as_module(self) -> None:
+        """python -m pf.story should work."""
+        result = _run_module("pf.story", "--help")
+        assert result.returncode == 0
+        assert "usage" in result.stdout.lower() or "Usage" in result.stdout
+
+