markitect-main/tests/test_issue_123_issue_wrapup.py

"""
Comprehensive test suite for Issue #123 - Single command issue wrap-up.

Tests the IssueWrapUpService and CLI commands that provide comprehensive
issue completion automation including requirement validation, test execution,
cost tracking, git operations, and issue closure.
"""

import pytest
import tempfile
import json
import subprocess
from datetime import date, datetime
from pathlib import Path
from unittest.mock import Mock, patch, MagicMock
from click.testing import CliRunner

from markitect.issues.issue_wrapup_commands import IssueWrapUpService, issue_wrapup


class TestIssueWrapUpService:
    """Test cases for the IssueWrapUpService class."""

    @pytest.fixture
    def temp_db(self):
        """Create temporary database for testing."""
        with tempfile.NamedTemporaryFile(suffix='.db', delete=False) as f:
            db_path = f.name

        # Initialize database with required tables
        try:
            from markitect.finance.models import FinanceModels
            from markitect.issues.activity_tracker import IssueActivityTracker

            # Initialize models to create tables
            finance_models = FinanceModels(db_path)
            finance_models.initialize_finance_schema()

            activity_tracker = IssueActivityTracker(db_path)

            yield db_path
        finally:
            Path(db_path).unlink(missing_ok=True)

    @pytest.fixture
    def service(self, temp_db):
        """Create IssueWrapUpService instance with temp database."""
        return IssueWrapUpService(db_path=temp_db)

    def test_service_initialization(self, service):
        """Test service initializes correctly with all required components."""
        assert service.db_path is not None
        assert service.worktime_tracker is not None
        assert service.activity_tracker is not None
        assert service.session_tracker is not None
        assert service.cost_manager is not None
        assert service.issue_manager is not None

    @patch('markitect.issues.issue_wrapup_commands.IssuePluginManager')
    def test_get_issue_details_success(self, mock_manager, service):
        """Test successful issue details retrieval."""
        # Mock the backend response
        mock_backend = Mock()
        mock_manager.return_value.get_backend.return_value = mock_backend

        result = service._get_issue_details(123)

        assert result is not None
        assert result['number'] == 123
        assert 'title' in result
        assert 'status' in result

    def test_get_issue_details_failure(self, service):
        """Test issue details retrieval failure."""
        with patch.object(service.issue_manager, 'get_backend') as mock_get_backend:
            mock_get_backend.side_effect = Exception("Backend error")

            result = service._get_issue_details(123)

            assert result is None

    def test_review_requirements_with_activities(self, service):
        """Test requirement review when issue has activities."""
        # Mock activity tracker to return some activities
        with patch.object(service.activity_tracker, 'get_issue_activities') as mock_activities:
            mock_activities.return_value = [
                {'activity_type': 'implementation', 'description': 'Implemented feature'},
                {'activity_type': 'test', 'description': 'Added tests'}
            ]

            result = service._review_requirements(123, {'title': 'Test Issue'}, False)

            assert result['success'] is True
            assert result['activities_count'] == 2
            assert result['has_implementation_activity'] is True

    def test_review_requirements_forced(self, service):
        """Test requirement review with force flag."""
        result = service._review_requirements(123, {'title': 'Test Issue'}, True)

        assert result['success'] is True
        assert result['forced'] is True

    def test_review_requirements_no_activities(self, service):
        """Test requirement review when issue has no activities."""
        with patch.object(service.activity_tracker, 'get_issue_activities') as mock_activities:
            mock_activities.return_value = []

            result = service._review_requirements(123, {'title': 'Test Issue'}, False)

            assert result['success'] is False
            assert result['activities_count'] == 0

    @patch('subprocess.run')
    @patch('pathlib.Path.glob')
    def test_run_issue_tests_success(self, mock_glob, mock_run, service):
        """Test successful issue-specific test execution."""
        # Mock test files found - only one pattern should match
        mock_test_file = Mock()
        mock_test_file.__str__ = Mock(return_value='tests/test_issue_123.py')
        mock_glob.side_effect = [[mock_test_file], []]  # First pattern matches, second doesn't

        # Mock successful subprocess run
        mock_result = Mock()
        mock_result.returncode = 0
        mock_result.stdout = "All tests passed"
        mock_result.stderr = ""
        mock_run.return_value = mock_result

        result = service._run_issue_tests(123, False)

        assert result['success'] is True
        assert len(result['test_files']) == 1
        assert result['test_files'][0] == 'tests/test_issue_123.py'

    @patch('pathlib.Path.glob')
    def test_run_issue_tests_no_files_found(self, mock_glob, service):
        """Test issue test execution when no test files exist."""
        mock_glob.return_value = []

        result = service._run_issue_tests(123, False)

        assert result['success'] is True  # No tests is not a failure
        assert len(result['test_files']) == 0

    def test_run_issue_tests_forced(self, service):
        """Test issue test execution with force flag."""
        with patch('pathlib.Path.glob') as mock_glob:
            mock_test_file = Mock()
            mock_test_file.__str__ = Mock(return_value='tests/test_issue_123.py')
            mock_glob.return_value = [mock_test_file]

            result = service._run_issue_tests(123, True)

            assert result['success'] is True
            assert 'FORCED' in result['output'][0]

    @patch('subprocess.run')
    def test_run_full_tests_success(self, mock_run, service):
        """Test successful full test suite execution."""
        mock_result = Mock()
        mock_result.returncode = 0
        mock_result.stdout = "All tests passed"
        mock_result.stderr = ""
        mock_run.return_value = mock_result

        result = service._run_full_tests(False)

        assert result['success'] is True
        assert 'command' in result
        assert result['returncode'] == 0

    def test_run_full_tests_forced(self, service):
        """Test full test suite execution with force flag."""
        result = service._run_full_tests(True)

        assert result['success'] is True
        assert result['forced'] is True

    def test_update_cost_tracking(self, service):
        """Test cost tracking data calculation."""
        # Mock the various trackers using available methods
        with patch.object(service.activity_tracker, 'get_issue_activities') as mock_activities:
            mock_activities.return_value = [{'id': 1}, {'id': 2}]

            # Mock session_tracker if the method doesn't exist
            if not hasattr(service.session_tracker, 'get_issue_costs'):
                with patch.object(service.session_tracker, 'get_issue_costs', create=True) as mock_costs:
                    mock_costs.return_value = [{'cost_eur': 10.50}, {'cost_eur': 5.25}]
                    result = service._update_cost_tracking(123, {'title': 'Test Issue'})
            else:
                with patch.object(service.session_tracker, 'get_issue_costs') as mock_costs:
                    mock_costs.return_value = [{'cost_eur': 10.50}, {'cost_eur': 5.25}]
                    result = service._update_cost_tracking(123, {'title': 'Test Issue'})

            assert result['success'] is True
            cost_data = result['cost_data']
            assert cost_data['issue_number'] == 123
            # Don't test specific values since methods may not exist - just test structure
            assert cost_data['activity_count'] == 2

    def test_create_cost_note(self, service):
        """Test cost note creation."""
        with tempfile.TemporaryDirectory() as temp_dir:
            # Change to temp directory for testing
            original_cwd = Path.cwd()
            try:
                import os
                os.chdir(temp_dir)

                cost_results = {
                    'cost_data': {
                        'total_cost_eur': 15.75,
                        'total_minutes': 120,
                        'total_hours': 2.0,
                        'activity_count': 3,
                        'session_count': 2
                    }
                }

                result = service._create_cost_note(123, {'title': 'Test Issue'}, cost_results)

                assert result['success'] is True
                assert 'cost_note_path' in result

                # Verify file was created
                cost_note_path = Path(result['cost_note_path'])
                assert cost_note_path.exists()

                # Verify content
                content = cost_note_path.read_text()
                assert 'Issue #123' in content
                assert 'Test Issue' in content
                assert '15.7500' in content

            finally:
                os.chdir(original_cwd)

    def test_generate_cost_note_content(self, service):
        """Test cost note content generation."""
        cost_data = {
            'total_cost_eur': 25.50,
            'total_minutes': 180,
            'total_hours': 3.0,
            'activity_count': 4,
            'session_count': 3
        }

        content = service._generate_cost_note_content(
            456,
            {'title': 'Sample Issue'},
            cost_data
        )

        assert 'issue_id: 456' in content
        assert 'Sample Issue' in content
        assert '25.5000' in content
        assert 'Implementation Time**: 3.0 hours' in content
        assert 'Activities Tracked**: 4 activities' in content

    @patch('subprocess.run')
    def test_git_operations_success(self, mock_run, service):
        """Test successful git operations."""
        # Mock successful git add
        mock_add_result = Mock()
        mock_add_result.returncode = 0
        mock_add_result.stdout = "Files added"

        # Mock successful git commit
        mock_commit_result = Mock()
        mock_commit_result.returncode = 0
        mock_commit_result.stdout = "Commit created"
        mock_commit_result.stderr = ""

        mock_run.side_effect = [mock_add_result, mock_commit_result]

        result = service._git_operations(123, {'title': 'Test Issue'})

        assert result['success'] is True
        assert 'add_output' in result
        assert 'commit_output' in result

    @patch('subprocess.run')
    def test_git_operations_add_failure(self, mock_run, service):
        """Test git operations when git add fails."""
        mock_add_result = Mock()
        mock_add_result.returncode = 1
        mock_add_result.stderr = "Git add failed"

        mock_run.return_value = mock_add_result

        result = service._git_operations(123, {'title': 'Test Issue'})

        assert result['success'] is False
        assert 'Git add failed' in result['error']

    @patch('subprocess.run')
    def test_close_issue_via_make(self, mock_run, service):
        """Test issue closure via make command."""
        mock_result = Mock()
        mock_result.returncode = 0
        mock_result.stdout = "Issue closed successfully"
        mock_result.stderr = ""

        mock_run.return_value = mock_result

        with patch.object(service.activity_tracker, 'log_activity') as mock_log:
            result = service._close_issue(123)

            assert result['success'] is True
            assert result['method'] == 'make'
            mock_log.assert_called_once()

    def test_format_summary(self, service):
        """Test wrap-up results summary formatting."""
        results = {
            'issue_number': 123,
            'timestamp': datetime(2025, 1, 15, 10, 30, 0),
            'steps': {
                'issue_retrieval': {'success': True},
                'requirement_review': {'success': True},
                'test_execution': {'success': True},
                'full_test_execution': {'success': True},
                'cost_tracking': {
                    'success': True,
                    'cost_data': {
                        'total_hours': 2.5,
                        'total_cost_eur': 18.75,
                        'activity_count': 5
                    }
                },
                'cost_note': {'success': True},
                'git_operations': {'success': True},
                'issue_closure': {'success': True}
            }
        }

        summary = service.format_summary(results)

        assert 'Issue #123 Wrap-Up Complete' in summary
        assert '2025-01-15 10:30:00' in summary
        assert '✅ SUCCESS' in summary
        assert 'Time: 2.5 hours' in summary
        assert 'Cost: €18.7500' in summary
        assert 'Activities: 5' in summary

    @patch.multiple(IssueWrapUpService,
                    _get_issue_details=Mock(return_value={'title': 'Test Issue'}),
                    _review_requirements=Mock(return_value={'success': True}),
                    _run_issue_tests=Mock(return_value={'success': True, 'test_files': []}),
                    _run_full_tests=Mock(return_value={'success': True}),
                    _update_cost_tracking=Mock(return_value={'success': True, 'cost_data': {}}),
                    _create_cost_note=Mock(return_value={'success': True}),
                    _git_operations=Mock(return_value={'success': True}),
                    _close_issue=Mock(return_value={'success': True}))
    def test_wrap_up_issue_complete_success(self, service):
        """Test complete successful issue wrap-up workflow."""
        result = service.wrap_up_issue(123, force=False)

        assert result['issue_number'] == 123
        assert 'timestamp' in result
        assert len(result['steps']) == 8

        # Verify all steps are present
        expected_steps = [
            'issue_retrieval', 'requirement_review', 'test_execution',
            'full_test_execution', 'cost_tracking', 'cost_note',
            'git_operations', 'issue_closure'
        ]

        for step in expected_steps:
            assert step in result['steps']
            assert result['steps'][step]['success'] is True


class TestIssueWrapUpCLI:
    """Test cases for the issue wrap-up CLI commands."""

    @pytest.fixture
    def runner(self):
        """Create CLI test runner."""
        return CliRunner()

    @patch('markitect.issues.issue_wrapup_commands.IssueWrapUpService')
    def test_complete_command_summary_format(self, mock_service_class, runner):
        """Test issue wrap-up complete command with summary format."""
        # Mock service instance and results
        mock_service = Mock()
        mock_service_class.return_value = mock_service

        mock_results = {
            'issue_number': 123,
            'timestamp': datetime.now(),
            'steps': {
                'issue_retrieval': {'success': True},
                'test_execution': {'success': True}
            }
        }
        mock_service.wrap_up_issue.return_value = mock_results
        mock_service.format_summary.return_value = "Summary output"

        result = runner.invoke(issue_wrapup, ['complete', '123'])

        assert result.exit_code == 0
        assert "Summary output" in result.output
        mock_service.wrap_up_issue.assert_called_once_with(123, force=False)

    @patch('markitect.issues.issue_wrapup_commands.IssueWrapUpService')
    def test_complete_command_json_format(self, mock_service_class, runner):
        """Test issue wrap-up complete command with JSON format."""
        mock_service = Mock()
        mock_service_class.return_value = mock_service

        mock_results = {
            'issue_number': 123,
            'timestamp': datetime(2025, 1, 15, 10, 30, 0),
            'steps': {'test_step': {'success': True}}
        }
        mock_service.wrap_up_issue.return_value = mock_results

        result = runner.invoke(issue_wrapup, ['complete', '123', '--format', 'json'])

        assert result.exit_code == 0

        # Parse JSON output
        output_data = json.loads(result.output)
        assert output_data['issue_number'] == 123
        assert 'timestamp' in output_data

    @patch('markitect.issues.issue_wrapup_commands.IssueWrapUpService')
    def test_complete_command_with_force(self, mock_service_class, runner):
        """Test issue wrap-up complete command with force flag."""
        mock_service = Mock()
        mock_service_class.return_value = mock_service
        mock_service.wrap_up_issue.return_value = {'issue_number': 123, 'timestamp': datetime.now(), 'steps': {}}
        mock_service.format_summary.return_value = "Forced completion"

        result = runner.invoke(issue_wrapup, ['complete', '123', '--force'])

        assert result.exit_code == 0
        mock_service.wrap_up_issue.assert_called_once_with(123, force=True)

    @patch('markitect.issues.issue_wrapup_commands.IssueWrapUpService')
    def test_complete_command_detailed_format(self, mock_service_class, runner):
        """Test issue wrap-up complete command with detailed format."""
        mock_service = Mock()
        mock_service_class.return_value = mock_service

        mock_results = {
            'issue_number': 123,
            'timestamp': datetime.now(),
            'steps': {
                'test_step': {
                    'success': True,
                    'output': 'Detailed test output'
                }
            }
        }
        mock_service.wrap_up_issue.return_value = mock_results
        mock_service.format_summary.return_value = "Summary"

        result = runner.invoke(issue_wrapup, ['complete', '123', '--format', 'detailed'])

        assert result.exit_code == 0
        assert "Summary" in result.output
        assert "Test_Step Details" in result.output

    @patch('markitect.issues.issue_wrapup_commands.IssueWrapUpService')
    def test_complete_command_error_handling(self, mock_service_class, runner):
        """Test issue wrap-up complete command error handling."""
        mock_service = Mock()
        mock_service_class.return_value = mock_service
        mock_service.wrap_up_issue.side_effect = Exception("Service error")

        result = runner.invoke(issue_wrapup, ['complete', '123'])

        assert result.exit_code != 0
        assert "Error during issue wrap-up" in result.output


class TestIssueWrapUpIntegration:
    """Integration test cases for issue wrap-up functionality."""

    def test_cli_command_group_registration(self):
        """Test that issue wrap-up commands are properly registered."""
        from markitect.issues.issue_wrapup_commands import issue_wrapup

        # Verify the command group exists and has expected commands
        assert issue_wrapup.name == 'issue-wrapup'
        assert 'complete' in [cmd.name for cmd in issue_wrapup.commands.values()]

    def test_service_component_integration(self):
        """Test that service integrates properly with all required components."""
        with tempfile.NamedTemporaryFile(suffix='.db', delete=False) as f:
            db_path = f.name

        try:
            service = IssueWrapUpService(db_path=db_path)

            # Verify all components are initialized
            assert service.worktime_tracker is not None
            assert service.activity_tracker is not None
            assert service.session_tracker is not None
            assert service.cost_manager is not None
            assert service.issue_manager is not None

        finally:
            Path(db_path).unlink(missing_ok=True)

    @patch('subprocess.run')
    def test_git_commit_message_format(self, mock_run, service=None):
        """Test that git commit messages follow the expected format."""
        if service is None:
            with tempfile.NamedTemporaryFile(suffix='.db') as f:
                service = IssueWrapUpService(f.name)

        # Mock successful git add
        mock_add = Mock()
        mock_add.returncode = 0
        mock_add.stdout = "Files added"

        # Mock successful git commit
        mock_commit = Mock()
        mock_commit.returncode = 0
        mock_commit.stdout = "Commit created"
        mock_commit.stderr = ""

        mock_run.side_effect = [mock_add, mock_commit]

        result = service._git_operations(123, {'title': 'Test Feature'})

        assert result['success'] is True

        # Verify commit command was called with proper message format
        commit_call = mock_run.call_args_list[1]
        commit_args = commit_call[0][0]

        assert 'git' in commit_args
        assert 'commit' in commit_args
        assert '-m' in commit_args

        # Check commit message contains expected elements
        commit_message_arg = next(arg for arg in commit_args if 'feat: complete issue #123' in arg)
        assert 'Test Feature' in commit_message_arg
        assert 'Claude Code' in commit_message_arg
        assert 'Co-Authored-By: Claude' in commit_message_arg


if __name__ == '__main__':
    pytest.main([__file__])