moai-adk 0.25.4__py3-none-any.whl → 0.41.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-workflow-testing/modules/tdd-context7/test-patterns.md

@@ -0,0 +1,371 @@
+# Context7 Test Patterns and Best Practices
+
+> Module: Testing patterns, Context7 integration, and industry best practices
+> Complexity: Advanced
+> Time: 15+ minutes
+> Dependencies: Python 3.8+, pytest, Context7 MCP, unittest.mock
+
+## Context7 TDD Integration
+
+```python
+class Context7TDDIntegration:
+    """Integration with Context7 for TDD patterns and best practices."""
+
+    def __init__(self, context7_client=None):
+        self.context7 = context7_client
+        self.pattern_cache = {}
+
+    async def load_tdd_patterns(self, language: str = "python") -> Dict[str, Any]:
+        """Load TDD patterns and best practices from Context7."""
+
+        cache_key = f"tdd_patterns_{language}"
+        if cache_key in self.pattern_cache:
+            return self.pattern_cache[cache_key]
+
+        patterns = {}
+
+        if self.context7:
+            try:
+                # Load TDD best practices
+                tdd_patterns = await self.context7.get_library_docs(
+                    context7_library_id="/testing/pytest",
+                    topic="TDD RED-GREEN-REFACTOR patterns best practices 2025",
+                    tokens=4000
+                )
+                patterns['tdd_best_practices'] = tdd_patterns
+
+                # Load test patterns for specific language
+                if language == "python":
+                    python_patterns = await self.context7.get_library_docs(
+                        context7_library_id="/python/pytest",
+                        topic="advanced testing patterns mocking fixtures 2025",
+                        tokens=3000
+                    )
+                    patterns['python_testing'] = python_patterns
+
+                # Load assertion patterns
+                assertion_patterns = await self.context7.get_library_docs(
+                    context7_library_id="/testing/assertions",
+                    topic="assertion patterns error messages test design 2025",
+                    tokens=2000
+                )
+                patterns['assertions'] = assertion_patterns
+
+                # Load mocking patterns
+                mocking_patterns = await self.context7.get_library_docs(
+                    context7_library_id="/python/unittest-mock",
+                    topic="mocking strategies test doubles isolation patterns 2025",
+                    tokens=3000
+                )
+                patterns['mocking'] = mocking_patterns
+
+            except Exception as e:
+                print(f"Failed to load Context7 patterns: {e}")
+                patterns = self._get_default_patterns()
+        else:
+            patterns = self._get_default_patterns()
+
+        self.pattern_cache[cache_key] = patterns
+        return patterns
+
+    def _get_default_patterns(self) -> Dict[str, Any]:
+        """Get default TDD patterns when Context7 is unavailable."""
+        return {
+            'tdd_best_practices': {
+                'red_phase': [
+                    "Write the simplest possible failing test",
+                    "Test one specific behavior or requirement",
+                    "Ensure test clearly expresses intent",
+                    "Make test fail for the right reason"
+                ],
+                'green_phase': [
+                    "Write the simplest code to make test pass",
+                    "Don't worry about code quality yet",
+                    "Focus on making the test green quickly",
+                    "Avoid premature optimization"
+                ],
+                'refactor_phase': [
+                    "Improve code design while keeping tests green",
+                    "Remove duplication and improve readability",
+                    "Apply design patterns appropriately",
+                    "Ensure all tests still pass"
+                ]
+            },
+            'python_testing': {
+                'pytest_features': [
+                    "Parametrized tests for multiple scenarios",
+                    "Fixtures for test setup and teardown",
+                    "Markers for categorizing tests",
+                    "Plugins for enhanced functionality"
+                ],
+                'assertions': [
+                    "Use pytest's assert statements",
+                    "Provide clear error messages",
+                    "Test expected exceptions with pytest.raises",
+                    "Use pytest.approx for floating point comparisons"
+                ]
+            },
+            'assertions': {
+                'best_practices': [
+                    "One assertion per test when possible",
+                    "Clear and descriptive assertion messages",
+                    "Test both positive and negative cases",
+                    "Use appropriate assertion methods"
+                ]
+            },
+            'mocking': {
+                'strategies': [
+                    "Mock external dependencies",
+                    "Use dependency injection for testability",
+                    "Create test doubles for complex objects",
+                    "Verify interactions with mocks"
+                ]
+            }
+        }
+```
+
+## Testing Patterns
+
+### Given-When-Then Pattern
+
+```python
+def test_user_authentication_valid_credentials():
+    """
+    Test user authentication with valid credentials.
+
+    Given: A registered user with valid credentials
+    When: The user attempts to authenticate
+    Then: The system should return a valid authentication token
+    """
+    # Given
+    user = User(email="test@example.com", password="secure_password")
+    auth_service = AuthenticationService()
+
+    # When
+    result = auth_service.authenticate(user.email, user.password)
+
+    # Then
+    assert result is not None
+    assert result.token is not None
+    assert result.expires_at > datetime.now()
+```
+
+### Arrange-Act-Assert Pattern
+
+```python
+def test_calculate_total_price_with_discount():
+    """
+    Test total price calculation with discount applied.
+    """
+    # Arrange
+    cart = ShoppingCart()
+    cart.add_item("item1", price=100.0, quantity=2)
+    cart.add_item("item2", price=50.0, quantity=1)
+    discount_code = "SAVE10"
+
+    # Act
+    total = cart.calculate_total(discount_code)
+
+    # Assert
+    assert total == 225.0  # (200 + 50) * 0.9
+```
+
+### Parameterized Testing Pattern
+
+```python
+@pytest.mark.parametrize("input,expected", [
+    (2, 4),    # 2^2 = 4
+    (3, 9),    # 3^2 = 9
+    (0, 0),    # 0^2 = 0
+    (-1, 1),   # (-1)^2 = 1
+    (10, 100)  # 10^2 = 100
+])
+def test_square_function(input, expected):
+    """Test square function with various inputs."""
+    result = square(input)
+    assert result == expected
+```
+
+### Exception Testing Pattern
+
+```python
+def test_divide_by_zero_raises_exception():
+    """Test that division by zero raises ZeroDivisionError."""
+    with pytest.raises(ZeroDivisionError) as exc_info:
+        divide(10, 0)
+
+    assert "division by zero" in str(exc_info.value)
+```
+
+### Mock Testing Pattern
+
+```python
+def test_external_api_call_with_mock():
+    """Test external API call with mocked response."""
+    # Create mock
+    mock_api = Mock()
+    mock_api.get_data.return_value = {"status": "success", "data": [1, 2, 3]}
+
+    # Use mock in test
+    service = DataService(api_client=mock_api)
+    result = service.fetch_data()
+
+    # Verify interaction
+    mock_api.get_data.assert_called_once()
+    assert result == [1, 2, 3]
+```
+
+## Pytest Fixtures
+
+### Basic Fixture
+
+```python
+@pytest.fixture
+def sample_user():
+    """Create a sample user for testing."""
+    return User(
+        email="test@example.com",
+        username="testuser",
+        password="secure_password"
+    )
+
+def test_user_email(sample_user):
+    """Test user email attribute."""
+    assert sample_user.email == "test@example.com"
+```
+
+### Fixture with Setup and Teardown
+
+```python
+@pytest.fixture
+def database_connection():
+    """Create database connection with cleanup."""
+    # Setup
+    conn = Database.connect(":memory:")
+    conn.create_tables()
+
+    yield conn  # Provide connection to test
+
+    # Teardown
+    conn.close()
+
+def test_database_query(database_connection):
+    """Test database query with fixture."""
+    result = database_connection.query("SELECT * FROM users")
+    assert len(result) >= 0
+```
+
+### Parametrized Fixture
+
+```python
+@pytest.fixture(params=[
+    ("valid_email@example.com", True),
+    ("invalid_email", False),
+    ("", False)
+])
+def email_validation_data(request):
+    """Provide email validation test data."""
+    return request.param
+
+def test_email_validation(email_validation_data):
+    """Test email validation with various inputs."""
+    email, expected_valid = email_validation_data
+    result = validate_email(email)
+    assert result.is_valid == expected_valid
+```
+
+## Test Organization
+
+### Test Discovery Structure
+
+```
+tests/
+├── unit/              # Unit tests for individual components
+│   ├── test_models.py
+│   ├── test_services.py
+│   └── test_utils.py
+├── integration/       # Integration tests for component interaction
+│   ├── test_api_integration.py
+│   └── test_database_integration.py
+├── acceptance/        # Acceptance tests for user scenarios
+│   ├── test_user_scenarios.py
+│   └── test_business_workflows.py
+└── conftest.py        # Shared fixtures and configuration
+```
+
+### Test Markers
+
+```python
+import pytest
+
+# Define custom markers
+pytest.mark.slow = pytest.mark.slow
+pytest.mark.integration = pytest.mark.integration
+pytest.mark.unit = pytest.mark.unit
+
+# Use markers in tests
+@pytest.mark.unit
+def test_individual_function():
+    """Unit test for individual function."""
+    assert calculate(2, 2) == 4
+
+@pytest.mark.integration
+def test_database_integration():
+    """Integration test for database."""
+    result = db.query("SELECT * FROM users")
+    assert result is not None
+
+@pytest.mark.slow
+def test_performance_benchmark():
+    """Slow performance test."""
+    result = expensive_operation()
+    assert result is not None
+```
+
+## Test Coverage
+
+### Running Coverage Analysis
+
+```bash
+# Run tests with coverage
+pytest --cov=src --cov-report=html --cov-report=term
+
+# Generate coverage report
+pytest --cov=src --cov-report=html
+```
+
+### Coverage Configuration
+
+```ini
+# .coveragerc
+[run]
+source = src
+omit =
+    */tests/*
+    */__init__.py
+
+[report]
+exclude_lines =
+    pragma: no cover
+    def __repr__
+    raise AssertionError
+    raise NotImplementedError
+    if __name__ == .__main__.:
+```
+
+## Best Practices
+
+1. Test Isolation: Each test should be independent and not rely on other tests
+2. Descriptive Names: Test names should clearly describe what is being tested
+3. One Assertion Per Test: Keep tests focused on a single behavior
+4. Arrange-Act-Assert: Structure tests clearly with this pattern
+5. Mock External Dependencies: Use mocks for external services and databases
+6. Test Edge Cases: Include tests for boundary conditions and error cases
+7. Fast Tests: Keep unit tests fast for quick feedback
+8. Maintainable Tests: Keep tests simple and easy to understand
+9. Context7 Integration: Leverage Context7 for latest testing patterns and best practices
+10. Continuous Testing: Run tests automatically with every code change
+
+---
+
+Related: [RED-GREEN-REFACTOR](./red-green-refactor.md) | [Test Generation](./test-generation.md)

moai_adk/templates/.claude/skills/moai-workflow-testing/modules/tdd-context7.md

@@ -0,0 +1,265 @@
+# Test-Driven Development with Context7 Integration
+
+> Module: RED-GREEN-REFACTOR TDD cycle with Context7 patterns and AI-powered testing
+> Complexity: Advanced
+> Time: 25+ minutes
+> Dependencies: Python 3.8+, pytest, Context7 MCP, unittest, asyncio
+
+## Overview
+
+TDD Context7 integration provides a comprehensive test-driven development workflow with AI-powered test generation, Context7-enhanced testing patterns, and automated best practices enforcement.
+
+### Key Features
+
+- AI-Powered Test Generation: Generate comprehensive test suites from specifications
+- Context7 Integration: Access latest testing patterns and best practices
+- RED-GREEN-REFACTOR Cycle: Complete TDD workflow implementation
+- Advanced Testing: Property-based testing, mutation testing, continuous testing
+- Test Patterns: Comprehensive library of testing patterns and fixtures
+
+## Quick Start
+
+### Basic TDD Cycle
+
+```python
+from moai_workflow_testing import TDDManager, TestSpecification, TestType
+
+# Initialize TDD Manager
+tdd_manager = TDDManager(
+    project_path="/path/to/project",
+    context7_client=context7
+)
+
+# Start TDD session
+session = await tdd_manager.start_tdd_session("user_authentication")
+
+# Create test specification
+test_spec = TestSpecification(
+    name="test_user_login_valid_credentials",
+    description="Test that user can login with valid credentials",
+    test_type=TestType.UNIT,
+    requirements=[
+        "User must provide valid email and password",
+        "System should authenticate user credentials"
+    ],
+    acceptance_criteria=[
+        "Valid credentials return user token",
+        "Invalid credentials raise AuthenticationError"
+    ],
+    edge_cases=[
+        "Test with empty email",
+        "Test with empty password"
+    ]
+)
+
+# Run complete TDD cycle
+cycle_results = await tdd_manager.run_full_tdd_cycle(
+    specification=test_spec,
+    target_function="authenticate_user"
+)
+```
+
+## Core Components
+
+### TDD Cycle Phases
+
+1. RED Phase: Write failing test
+   - Create test specification
+   - Generate test code
+   - Verify test fails for right reason
+
+2. GREEN Phase: Implement minimum code
+   - Write simplest implementation
+   - Make tests pass
+   - Focus on functionality, not quality
+
+3. REFACTOR Phase: Improve code quality
+   - Refactor while tests pass
+   - Apply design patterns
+   - Remove duplication
+
+4. REVIEW Phase: Verify and commit
+   - Check test coverage
+   - Review code quality
+   - Commit changes
+
+### Context7 Integration
+
+The TDD Context7 integration provides:
+
+- Pattern Loading: Access latest testing patterns from Context7
+- AI Test Generation: Enhanced test generation with Context7 patterns
+- Best Practices: Industry-standard testing practices
+- Edge Case Detection: Automatic edge case identification
+- Test Suggestions: AI-powered test improvement suggestions
+
+## Module Structure
+
+### Core Modules
+
+**RED-GREEN-REFACTOR Implementation** (`tdd-context7/red-green-refactor.md`)
+- TDD cycle implementation
+- Test execution and validation
+- Coverage analysis
+- Session management
+
+**Test Generation** (`tdd-context7/test-generation.md`)
+- AI-powered test generation
+- Specification-based generation
+- Context7-enhanced generation
+- Template-based generation
+
+**Test Patterns** (`tdd-context7/test-patterns.md`)
+- Testing patterns and best practices
+- Pytest fixtures and organization
+- Test discovery structure
+- Coverage configuration
+
+**Advanced Features** (`tdd-context7/advanced-features.md`)
+- Comprehensive test suite generation
+- Property-based testing
+- Mutation testing
+- Continuous testing
+
+## Common Use Cases
+
+### Unit Testing
+
+```python
+# Generate unit test from specification
+test_spec = TestSpecification(
+    name="test_calculate_sum",
+    description="Test sum calculation",
+    test_type=TestType.UNIT,
+    requirements=["Function should sum two numbers"],
+    acceptance_criteria=["Returns correct sum"],
+    edge_cases=["Zero values", "Negative numbers", "Large numbers"]
+)
+
+test_code = await test_generator.generate_test_case(test_spec)
+```
+
+### Integration Testing
+
+```python
+# Integration test specification
+integration_spec = TestSpecification(
+    name="test_database_integration",
+    description="Test database connection and query",
+    test_type=TestType.INTEGRATION,
+    requirements=["Database connection", "Query execution"],
+    acceptance_criteria=["Connection succeeds", "Query returns data"],
+    edge_cases=["Connection failure", "Empty results", "Large datasets"]
+)
+```
+
+### Exception Testing
+
+```python
+# Exception test specification
+exception_spec = TestSpecification(
+    name="test_divide_by_zero",
+    description="Test division by zero exception",
+    test_type=TestType.UNIT,
+    requirements=["Division function", "Error handling"],
+    acceptance_criteria=["Raises ZeroDivisionError"],
+    edge_cases=["Divisor is zero", "Dividend is zero"]
+)
+```
+
+## Best Practices
+
+### Test Design
+
+1. One Test One Behavior: Each test should verify one specific behavior
+2. Descriptive Names: Test names should clearly describe what is being tested
+3. Arrange-Act-Assert: Structure tests with this pattern for clarity
+4. Independent Tests: Tests should not depend on each other
+5. Fast Execution: Keep tests fast for quick feedback
+
+### Context7 Integration
+
+1. Pattern Loading: Load Context7 patterns for latest best practices
+2. Edge Case Detection: Use Context7 to identify missing edge cases
+3. Test Suggestions: Leverage AI suggestions for test improvements
+4. Quality Analysis: Use Context7 for test quality analysis
+
+### TDD Workflow
+
+1. Write Failing Test First: Always start with a failing test
+2. Keep Tests Green: Never commit failing tests
+3. Refactor Confidently: Use tests as safety net for refactoring
+4. High Coverage: Aim for 80%+ test coverage
+5. Continuous Testing: Run tests automatically with every change
+
+## Advanced Features
+
+### Property-Based Testing
+
+Use Hypothesis for property-based testing to verify code properties across many random inputs.
+
+### Mutation Testing
+
+Use mutation testing to verify test suite quality by introducing code mutations and checking if tests catch them.
+
+### Continuous Testing
+
+Implement watch mode for automatic test execution on file changes.
+
+### AI-Powered Generation
+
+Leverage Context7 for intelligent test generation and suggestions.
+
+## Performance Considerations
+
+- Test Execution: Use parallel test execution for faster feedback
+- Test Isolation: Ensure tests are isolated to prevent interference
+- Mock External Dependencies: Mock external services for fast, reliable tests
+- Optimize Setup: Use fixtures and test factories for efficient test setup
+
+## Troubleshooting
+
+### Common Issues
+
+1. Tests Failing Intermittently
+   - Check for shared state between tests
+   - Verify test isolation
+   - Add proper cleanup in fixtures
+
+2. Slow Test Execution
+   - Use parallel test execution
+   - Mock external dependencies
+   - Optimize test setup
+
+3. Context7 Integration Issues
+   - Verify Context7 client configuration
+   - Check network connectivity
+   - Use default patterns as fallback
+
+## Resources
+
+### Detailed Modules
+
+- [RED-GREEN-REFACTOR Implementation](./tdd-context7/red-green-refactor.md) - Core TDD cycle
+- [Test Generation](./tdd-context7/test-generation.md) - AI-powered generation
+- [Test Patterns](./tdd-context7/test-patterns.md) - Patterns and best practices
+- [Advanced Features](./tdd-context7/advanced-features.md) - Advanced testing techniques
+
+### Related Modules
+
+- [AI Debugging](./ai-debugging.md) - Debugging techniques
+- [Performance Optimization](./performance-optimization.md) - Performance testing
+- [Smart Refactoring](./smart-refactoring.md) - Refactoring with tests
+
+### External Resources
+
+- [Pytest Documentation](https://docs.pytest.org/)
+- [Python Testing Best Practices](https://docs.python-guide.org/writing/tests/)
+- [Hypothesis Property-Based Testing](https://hypothesis.works/)
+- [Context7 MCP Documentation](https://context7.io/docs)
+
+---
+
+Module: `modules/tdd-context7.md`
+Version: 2.0.0 (Modular Structure)
+Last Updated: 2026-01-06