@pennyfarthing/core 11.4.0 → 12.0.0

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

@@ -1,331 +0,0 @@
-"""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") == "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/pf/tests/test_package_structure.py

@@ -1,359 +0,0 @@
-"""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 sys
-
-
-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")
-
-    def test_output_backwards_compatibility(self) -> None:
-        """Old import path should still work for backwards compatibility."""
-        from pf import output
-
-        # Should re-export from common.output
-        assert hasattr(output, "success")
-        assert hasattr(output, "error")
-
-    def test_config_backwards_compatibility(self) -> None:
-        """Old import path should still work for backwards compatibility."""
-        from pf import config
-
-        # Should re-export from common.config
-        assert hasattr(config, "get_project_root")
-
-
-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_issue")
-        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."""
-        # These imports should work for backwards compatibility
-        from pf.jira import STATUS_TO_JIRA, JiraClient, get_issue
-
-        assert JiraClient is not None
-        assert callable(get_issue)
-        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."""
-        import subprocess
-
-        result = subprocess.run(
-            [sys.executable, "-m", "pf.jira", "--help"],
-            capture_output=True,
-            text=True,
-        )
-        # 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."""
-        import subprocess
-
-        result = subprocess.run(
-            [sys.executable, "-m", "pf.sprint", "--help"],
-            capture_output=True,
-            text=True,
-        )
-        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."""
-        import subprocess
-
-        result = subprocess.run(
-            [sys.executable, "-m", "pf.story", "--help"],
-            capture_output=True,
-            text=True,
-        )
-        assert result.returncode == 0
-        assert "usage" in result.stdout.lower() or "Usage" in result.stdout
-
-
-class TestOldModuleCompatibility:
-    """Tests ensuring old flat modules still work."""
-
-    def test_jira_sync_module_works(self) -> None:
-        """jira_sync.py should still be importable and functional."""
-        from pf import jira_sync
-
-        assert hasattr(jira_sync, "sync_epic")
-        assert hasattr(jira_sync, "sync_story")
-        assert hasattr(jira_sync, "main")
-
-    def test_jira_bidirectional_sync_module_works(self) -> None:
-        """jira_bidirectional_sync.py should still be importable."""
-        from pf import jira_bidirectional_sync
-
-        assert hasattr(jira_bidirectional_sync, "generate_sync_plan")
-        assert hasattr(jira_bidirectional_sync, "main")
-
-    def test_jira_epic_creation_module_works(self) -> None:
-        """jira_epic_creation.py should still be importable."""
-        from pf import jira_epic_creation
-
-        assert hasattr(jira_epic_creation, "create_epic")
-        assert hasattr(jira_epic_creation, "main")
-
-    def test_jira_sync_story_module_works(self) -> None:
-        """jira_sync_story.py should still be importable."""
-        from pf import jira_sync_story
-
-        assert hasattr(jira_sync_story, "sync_story")
-        assert hasattr(jira_sync_story, "main")