🧪 Expand test coverage beyond basic import tests

[anthropic-code-agent]

Description

The current test suite (test_redbot_setup.py) only validates basic Python syntax and import functionality. There are no tests for actual cog behavior, command logic, or edge cases.

Current Testing

The existing test_redbot_setup.py tests:

• ✅ Red-DiscordBot core imports work
• ✅ All cog Python files have valid syntax
• ✅ All cogs can be imported
• ✅ All cogs have the required setup function

What's missing: Tests for actual functionality and business logic.

Testing Gaps

1. Party Cog

• No tests for party signup/leave logic
• No tests for role limits and validation
• No tests for party creation/deletion
• No tests for concurrent signups
• No tests for modal input validation

2. Secret Santa Cog

• No tests for participant matching algorithm
• No tests for anonymous messaging
• No tests for gift tracking status
• No tests for import/export functionality
• No tests for edge cases (odd number of participants, etc.)

3. React Roles Cog

• No tests for reaction role assignment
• No tests for reaction role removal
• No tests for config persistence
• No tests for the type inconsistency bug (see issue 🐛 [CRITICAL] Type inconsistency in react_roles causes reaction role removal to fail #119)

4. Empty Voices Cog

• No tests for voice channel creation
• No tests for cleanup on channel empty
• No tests for watched category management

5. Hat Cog

• No tests for image overlay rendering
• No tests for hat positioning/scaling/rotation
• No tests for invalid image handling

6. Movie Vote Cog

• No tests for IMDB link parsing
• No tests for vote counting
• No tests for leaderboard generation

7. Quote DB Cog

• No tests for quote storage/retrieval
• No tests for quote deletion
• No tests for trigger handling

Benefits of Better Testing

1. Catch bugs early: Many issues found in this review could be caught by tests
2. Prevent regressions: Ensure fixes don't break existing functionality
3. Document behavior: Tests serve as examples of how code should work
4. Refactoring confidence: Make changes without fear of breaking things
5. CI/CD validation: Automatically verify code changes before merging

Recommended Testing Framework

Use pytest with pytest-asyncio for async test support:

pip install pytest pytest-asyncio pytest-cov discord.py-stubs

Example Test Structure

# tests/test_party.py
import pytest
from unittest.mock import AsyncMock, MagicMock
from party.party import Party

@pytest.fixture
async def party_cog(bot):
    """Fixture to create a Party cog instance."""
    cog = Party(bot)
    await cog.initialize()
    return cog

@pytest.mark.asyncio
async def test_party_creation(party_cog, mock_ctx):
    """Test creating a party with valid inputs."""
    await party_cog.party_create(mock_ctx, "Test Party", "Tank", "Healer", "DPS")
    
    # Verify party was created
    parties = await party_cog.config.guild(mock_ctx.guild).parties()
    assert len(parties) == 1
    
    party = list(parties.values())[0]
    assert party["name"] == "Test Party"
    assert "Tank" in party["roles"]
    assert "Healer" in party["roles"]
    assert "DPS" in party["roles"]

@pytest.mark.asyncio
async def test_party_signup_full_role(party_cog, mock_ctx, mock_interaction):
    """Test signing up for a role that's already full."""
    # Create party with 1 Tank slot
    party_id = await create_test_party(party_cog, mock_ctx, roles={"Tank": 1})
    
    # First signup should succeed
    await signup_for_role(party_cog, mock_interaction, party_id, "Tank")
    
    # Second signup should fail (role full)
    with pytest.raises(Exception) as exc_info:
        await signup_for_role(party_cog, mock_interaction, party_id, "Tank")
    
    assert "full" in str(exc_info.value).lower()

@pytest.mark.asyncio
async def test_concurrent_party_signups(party_cog, mock_ctx):
    """Test that concurrent signups don't cause race conditions."""
    import asyncio
    
    party_id = await create_test_party(party_cog, mock_ctx, roles={"DPS": 3})
    
    # Create 10 users trying to signup concurrently
    tasks = []
    for i in range(10):
        interaction = create_mock_interaction(user_id=i)
        tasks.append(signup_for_role(party_cog, interaction, party_id, "DPS"))
    
    # Run all signups concurrently
    results = await asyncio.gather(*tasks, return_exceptions=True)
    
    # Verify only 3 succeeded (DPS limit is 3)
    successes = [r for r in results if not isinstance(r, Exception)]
    assert len(successes) == 3

Test Categories to Implement

Unit Tests

• Individual command logic
• Helper functions
• Data validation
• Configuration management

Integration Tests

• Discord.py interaction patterns
• Config persistence
• Background tasks
• Error handling

Edge Case Tests

• Concurrent operations
• Invalid inputs
• Corrupted data
• Missing configuration
• Permission errors
• Rate limiting

Priority Test Areas (based on review findings)

1. HIGH: Type handling in react_roles (issue 🐛 [CRITICAL] Type inconsistency in react_roles causes reaction role removal to fail #119)
2. HIGH: Async await patterns in nw_server_status (issue 🐛 [CRITICAL] Missing await in nw_server_status causes monitor channels to never update #118)
3. MEDIUM: Party error handling (issue 🐛 Missing error handling in party cog could cause crashes #123)
4. MEDIUM: Null pointer checks (issue 🐛 Null pointer risk in nw_server_status forcemonitor command #120)
5. LOW: Exception handling patterns (issue 🔧 Improve exception handling to avoid broad exception catching #122)

Implementation Plan

1. Phase 1: Set up pytest infrastructure

   • Add pytest.ini configuration
   • Add conftest.py with shared fixtures
   • Add tests/ directory structure

2. Phase 2: Add critical bug tests

   • Test for issues found in code review
   • Ensure tests fail before fixes, pass after

3. Phase 3: Add unit tests for core logic

   • Command handlers
   • Data validation
   • Helper functions

4. Phase 4: Add integration tests

   • Discord interactions
   • Config persistence
   • Background tasks

5. Phase 5: Continuous improvement

   • Monitor coverage reports
   • Add tests for new features
   • Add tests for bug fixes

CI Integration

Update .github/workflows/lint.yml to run tests:

- name: Run tests
  run: |
    pytest tests/ -v --cov=. --cov-report=term-missing

Priority

LOW - Doesn't affect current functionality but critical for long-term maintainability.

Success Metrics

• Achieve >70% code coverage for critical cogs
• All bugs found in review have corresponding regression tests
• CI catches issues before they reach production

Related

This is part of a comprehensive code review. See other issues for additional improvements.

References

• pytest documentation
• pytest-asyncio
• Discord.py testing guide