FastAnime/tests/interactive/menus/README.md

Interactive Menu Tests

This directory contains comprehensive test suites for all interactive menu functionality in FastAnime.

Test Structure

tests/interactive/menus/
├── conftest.py                    # Shared fixtures and utilities
├── __init__.py                    # Package marker
├── run_tests.py                   # Test runner script
├── README.md                      # This file
├── test_main.py                   # Tests for main menu
├── test_results.py                # Tests for results menu
├── test_auth.py                   # Tests for authentication menu
├── test_media_actions.py          # Tests for media actions menu
├── test_episodes.py               # Tests for episodes menu
├── test_servers.py                # Tests for servers menu
├── test_player_controls.py        # Tests for player controls menu
├── test_provider_search.py        # Tests for provider search menu
├── test_session_management.py     # Tests for session management menu
└── test_watch_history.py          # Tests for watch history menu

Test Categories

Unit Tests

Each menu has its own comprehensive test file that covers:

• Menu display and option rendering
• User interaction handling
• State transitions
• Error handling
• Configuration options (icons, preferences)
• Helper function testing

Integration Tests

Tests marked with @pytest.mark.integration require network connectivity and test:

• Real API interactions
• Authentication flows
• Data fetching and processing

Test Coverage

Each test file covers the following aspects:

Main Menu Tests (test_main.py)

• Option display with/without icons
• Navigation to different categories (trending, popular, etc.)
• Search functionality
• User list access (authenticated/unauthenticated)
• Authentication and session management
• Configuration editing
• Helper function testing

Results Menu Tests (test_results.py)

• Search result display
• Pagination handling
• Anime selection
• Preview functionality
• Authentication status display
• Helper function testing

Authentication Menu Tests (test_auth.py)

• Login/logout flows
• OAuth authentication
• Token input handling
• Profile display
• Authentication status management
• Helper function testing

Media Actions Menu Tests (test_media_actions.py)

• Action menu display
• Streaming initiation
• Trailer playback
• List management
• Scoring functionality
• Local history tracking
• Information display
• Helper function testing

Episodes Menu Tests (test_episodes.py)

• Episode list display
• Watch history continuation
• Episode selection
• Translation type handling
• Progress tracking
• Helper function testing

Servers Menu Tests (test_servers.py)

• Server fetching and display
• Server selection
• Quality filtering
• Auto-server selection
• Player integration
• Error handling
• Helper function testing

Player Controls Menu Tests (test_player_controls.py)

• Post-playback options
• Next episode handling
• Auto-next functionality
• Progress tracking
• Replay functionality
• Server switching
• Helper function testing

Provider Search Menu Tests (test_provider_search.py)

• Provider anime search
• Auto-selection based on similarity
• Manual selection handling
• Preview integration
• Error handling
• Helper function testing

Session Management Menu Tests (test_session_management.py)

• Session saving/loading
• Session listing and statistics
• Session deletion
• Auto-save configuration
• Backup creation
• Helper function testing

Watch History Menu Tests (test_watch_history.py)

• History display and navigation
• History management (clear, export, import)
• Statistics calculation
• Anime selection from history
• Helper function testing

Fixtures and Utilities

Shared Fixtures (conftest.py)

• mock_config: Mock application configuration
• mock_provider: Mock anime provider
• mock_selector: Mock UI selector
• mock_player: Mock media player
• mock_media_api: Mock API client
• mock_context: Complete mock context
• sample_media_item: Sample AniList anime data
• sample_provider_anime: Sample provider anime data
• sample_search_results: Sample search results
• Various state fixtures for different scenarios

Test Utilities

• assert_state_transition(): Assert proper state transitions
• assert_control_flow(): Assert control flow returns
• setup_selector_choices(): Configure mock selector choices
• setup_selector_inputs(): Configure mock selector inputs

Running Tests

Run All Menu Tests

python tests/interactive/menus/run_tests.py

Run Specific Menu Tests

python tests/interactive/menus/run_tests.py --menu main
python tests/interactive/menus/run_tests.py --menu auth
python tests/interactive/menus/run_tests.py --menu episodes

Run with Coverage

python tests/interactive/menus/run_tests.py --coverage

Run Integration Tests Only

python tests/interactive/menus/run_tests.py --integration

Using pytest directly

# Run all menu tests
pytest tests/interactive/menus/ -v

# Run specific test file
pytest tests/interactive/menus/test_main.py -v

# Run with coverage
pytest tests/interactive/menus/ --cov=fastanime.cli.interactive.menus --cov-report=html

# Run integration tests only
pytest tests/interactive/menus/ -m integration

# Run specific test class
pytest tests/interactive/menus/test_main.py::TestMainMenu -v

# Run specific test method
pytest tests/interactive/menus/test_main.py::TestMainMenu::test_main_menu_displays_options -v

Test Patterns

Menu Function Testing

def test_menu_function(self, mock_context, test_state):
    """Test the menu function with specific setup."""
    # Setup
    mock_context.selector.choose.return_value = "Expected Choice"

    # Execute
    result = menu_function(mock_context, test_state)

    # Assert
    assert isinstance(result, State)
    assert result.menu_name == "EXPECTED_STATE"

Error Handling Testing

def test_menu_error_handling(self, mock_context, test_state):
    """Test menu handles errors gracefully."""
    # Setup error condition
    mock_context.provider.some_method.side_effect = Exception("Test error")

    # Execute
    result = menu_function(mock_context, test_state)

    # Assert error handling
    assert result == ControlFlow.BACK  # or appropriate error response

State Transition Testing

def test_state_transition(self, mock_context, initial_state):
    """Test proper state transitions."""
    # Setup
    mock_context.selector.choose.return_value = "Next State Option"

    # Execute
    result = menu_function(mock_context, initial_state)

    # Assert state transition
    assert_state_transition(result, "NEXT_STATE")
    assert result.media_api.anime == initial_state.media_api.anime  # State preservation

Mocking Strategies

API Mocking

# Mock successful API calls
mock_context.media_api.search_media.return_value = sample_search_results

# Mock API failures
mock_context.media_api.search_media.side_effect = Exception("API Error")

User Input Mocking

# Mock menu selection
mock_context.selector.choose.return_value = "Selected Option"

# Mock text input
mock_context.selector.ask.return_value = "User Input"

# Mock cancelled selections
mock_context.selector.choose.return_value = None

Configuration Mocking

# Mock configuration options
mock_context.config.general.icons = True
mock_context.config.stream.auto_next = False
mock_context.config.anilist.per_page = 15

Adding New Tests

When adding tests for new menus:

1. Create a new test file: test_[menu_name].py
2. Import the menu function and required fixtures
3. Create test classes for the main menu and helper functions
4. Follow the established patterns for testing:
   • Menu display and options
   • User interactions and selections
   • State transitions
   • Error handling
   • Configuration variations
   • Helper functions
5. Add the menu name to the choices in run_tests.py
6. Update this README with the new test coverage

Best Practices

1. Test Isolation: Each test should be independent and not rely on other tests
2. Clear Naming: Test names should clearly describe what is being tested
3. Comprehensive Coverage: Test both happy paths and error conditions
4. Realistic Mocks: Mock data should represent realistic scenarios
5. State Verification: Always verify that state transitions are correct
6. Error Testing: Test error handling and edge cases
7. Configuration Testing: Test menu behavior with different configuration options
8. Documentation: Document complex test scenarios and mock setups

Continuous Integration

These tests are designed to run in CI environments:

• Unit tests run without external dependencies
• Integration tests can be skipped in CI if needed
• Coverage reports help maintain code quality
• Fast execution for quick feedback loops