moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

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

@@ -5,1109 +5,29 @@
 > Time: 25+ minutes
 > Dependencies: Python 3.8+, pytest, Context7 MCP, unittest, asyncio
 
-## Core Implementation
+## Overview
 
-### TDDManager Class
+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
-import pytest
-import unittest
-import asyncio
-import subprocess
-import os
-import sys
-import time
-from typing import Dict, List, Optional, Any, Union, Callable
-from dataclasses import dataclass, field
-from enum import Enum
-import ast
-import inspect
-import json
-from pathlib import Path
-
-class TDDPhase(Enum):
- """TDD cycle phases."""
- RED = "red" # Write failing test
- GREEN = "green" # Make test pass
- REFACTOR = "refactor" # Improve code while keeping tests green
- REVIEW = "review" # Review and commit changes
-
-class TestType(Enum):
- """Types of tests in TDD."""
- UNIT = "unit"
- INTEGRATION = "integration"
- ACCEPTANCE = "acceptance"
- PERFORMANCE = "performance"
- SECURITY = "security"
- REGRESSION = "regression"
-
-class TestStatus(Enum):
- """Test execution status."""
- PENDING = "pending"
- RUNNING = "running"
- PASSED = "passed"
- FAILED = "failed"
- SKIPPED = "skipped"
- ERROR = "error"
-
-@dataclass
-class TestSpecification:
- """Specification for a TDD test."""
- name: str
- description: str
- test_type: TestType
- requirements: List[str]
- acceptance_criteria: List[str]
- edge_cases: List[str]
- preconditions: List[str] = field(default_factory=list)
- postconditions: List[str] = field(default_factory=list)
- dependencies: List[str] = field(default_factory=list)
- mock_requirements: Dict[str, Any] = field(default_factory=dict)
-
-@dataclass
-class TestCase:
- """Individual test case with metadata."""
- id: str
- name: str
- file_path: str
- line_number: int
- specification: TestSpecification
- status: TestStatus
- execution_time: float
- error_message: Optional[str] = None
- coverage_data: Dict[str, Any] = field(default_factory=dict)
-
-@dataclass
-class TDDSession:
- """TDD development session with cycle tracking."""
- id: str
- project_path: str
- current_phase: TDDPhase
- test_cases: List[TestCase]
- start_time: float
- context7_patterns: Dict[str, Any] = field(default_factory=dict)
- metrics: Dict[str, Any] = field(default_factory=dict)
-
-class Context7TDDIntegration:
- """Integration with Context7 for TDD patterns and best practices."""
-
- def __init__(self, context7_client=None):
- self.context7 = context7_client
- self.pattern_cache = {}
- self.test_generators = {}
-
- 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"
- ]
- }
- }
-
-class TestGenerator:
- """AI-powered test case generation based on specifications."""
-
- def __init__(self, context7_client=None):
- self.context7 = context7_client
- self.templates = self._load_test_templates()
-
- def _load_test_templates(self) -> Dict[str, str]:
- """Load test templates for different scenarios."""
- return {
- 'unit_function': '''
-def test_{function_name}_{scenario}():
- """
- Test {description}
-
- Given: {preconditions}
- When: {action}
- Then: {expected_outcome}
- """
- # Arrange
- {setup_code}
-
- # Act
- result = {function_call}
-
- # Assert
- assert result == {expected_value}, f"Expected {expected_value}, got {result}"
-''',
- 'unit_method': '''
-class Test{ClassName}:
- def test_{method_name}_{scenario}(self):
- """
- Test {description}
- """
- # Arrange
- {setup_code}
- instance = {ClassName}({constructor_args})
-
- # Act
- result = instance.{method_name}({method_args})
-
- # Assert
- {assertions}
-''',
- 'integration_test': '''
-def test_{feature_name}_{scenario}():
- """
- Test integration: {description}
- """
- # Arrange
- {setup_code}
-
- # Act
- result = {action}
-
- # Assert
- {assertions}
-
- # Cleanup
- {cleanup_code}
-''',
- 'exception_test': '''
-def test_{function_name}_raises_{exception}_{scenario}():
- """
- Test that {function_name} raises {exception} when {condition}
- """
- # Arrange
- {setup_code}
-
- # Act & Assert
- with pytest.raises({exception}) as exc_info:
- {function_call}
-
- assert "{expected_message}" in str(exc_info.value)
-''',
- 'parameterized_test': '''
-@pytest.mark.parametrize("{param_names}", {test_values})
-def test_{function_name}_{scenario}({param_names}):
- """
- Test {function_name} with different inputs: {description}
- """
- # Arrange
- {setup_code}
-
- # Act
- result = {function_call}
-
- # Assert
- assert result == {expected_value}, f"For {param_names}={{param_names}}, expected {expected_value}, got {{result}}"
-'''
- }
-
- async def generate_test_case(
- self, specification: TestSpecification,
- context7_patterns: Dict[str, Any] = None
- ) -> str:
- """Generate test code based on specification."""
-
- if self.context7 and context7_patterns:
- try:
- # Use Context7 to enhance test generation
- enhanced_spec = await self._enhance_specification_with_context7(
- specification, context7_patterns
- )
- return self._generate_test_from_enhanced_spec(enhanced_spec)
- except Exception as e:
- print(f"Context7 test generation failed: {e}")
-
- return self._generate_test_from_specification(specification)
-
- async def _enhance_specification_with_context7(
- self, specification: TestSpecification,
- context7_patterns: Dict[str, Any]
- ) -> TestSpecification:
- """Enhance test specification using Context7 patterns."""
-
- # Add additional edge cases based on Context7 patterns
- additional_edge_cases = []
-
- testing_patterns = context7_patterns.get('python_testing', {})
- if testing_patterns:
- # Add common edge cases for different data types
- if any('number' in str(req).lower() for req in specification.requirements):
- additional_edge_cases.extend([
- "Test with zero value",
- "Test with negative value",
- "Test with maximum/minimum values",
- "Test with floating point edge cases"
- ])
-
- if any('string' in str(req).lower() for req in specification.requirements):
- additional_edge_cases.extend([
- "Test with empty string",
- "Test with very long string",
- "Test with special characters",
- "Test with unicode characters"
- ])
-
- if any('list' in str(req).lower() or 'array' in str(req).lower() for req in specification.requirements):
- additional_edge_cases.extend([
- "Test with empty list",
- "Test with single element",
- "Test with large list",
- "Test with duplicate elements"
- ])
-
- # Combine original and additional edge cases
- combined_edge_cases = list(set(specification.edge_cases + additional_edge_cases))
-
- return TestSpecification(
- name=specification.name,
- description=specification.description,
- test_type=specification.test_type,
- requirements=specification.requirements,
- acceptance_criteria=specification.acceptance_criteria,
- edge_cases=combined_edge_cases,
- preconditions=specification.preconditions,
- postconditions=specification.postconditions,
- dependencies=specification.dependencies,
- mock_requirements=specification.mock_requirements
- )
-
- def _generate_test_from_enhanced_spec(self, spec: TestSpecification) -> str:
- """Generate test code from enhanced specification."""
- return self._generate_test_from_specification(spec)
-
- def _generate_test_from_specification(self, spec: TestSpecification) -> str:
- """Generate test code from specification."""
-
- # Determine appropriate template based on test type and requirements
- if spec.test_type == TestType.UNIT:
- return self._generate_unit_test(spec)
- elif spec.test_type == TestType.INTEGRATION:
- return self._generate_integration_test(spec)
- else:
- return self._generate_generic_test(spec)
-
- def _generate_unit_test(self, spec: TestSpecification) -> str:
- """Generate unit test code."""
-
- # Extract function/class information from specification name
- function_name = spec.name.lower().replace('test_', '').replace('_test', '')
-
- # Check if this is an exception test
- if any('error' in criterion.lower() or 'exception' in criterion.lower()
- for criterion in spec.acceptance_criteria):
- return self._generate_exception_test(spec, function_name)
-
- # Check if this requires parameterization
- if len(spec.acceptance_criteria) > 1 or len(spec.edge_cases) > 2:
- return self._generate_parameterized_test(spec, function_name)
-
- # Generate standard unit test
- return self._generate_standard_unit_test(spec, function_name)
-
- def _generate_standard_unit_test(self, spec: TestSpecification, function_name: str) -> str:
- """Generate standard unit test."""
-
- template = self.templates['unit_function']
-
- # Fill template with specification details
- setup_code = self._generate_setup_code(spec)
- function_call = self._generate_function_call(function_name, spec)
- assertions = self._generate_assertions(spec)
-
- return template.format(
- function_name=function_name,
- scenario=self._extract_scenario(spec),
- description=spec.description,
- preconditions=', '.join(spec.preconditions),
- action=self._describe_action(spec),
- expected_outcome=spec.acceptance_criteria[0] if spec.acceptance_criteria else "expected behavior",
- setup_code=setup_code,
- function_call=function_call,
- expected_value=self._extract_expected_value(spec),
- assertions=assertions
- )
-
- def _generate_exception_test(self, spec: TestSpecification, function_name: str) -> str:
- """Generate exception test."""
-
- template = self.templates['exception_test']
-
- # Extract expected exception and message
- exception_type = "Exception" # Default
- expected_message = "Error occurred"
-
- for criterion in spec.acceptance_criteria:
- if 'raise' in criterion.lower() or 'exception' in criterion.lower():
- # Try to extract exception type
- if 'valueerror' in criterion.lower():
- exception_type = "ValueError"
- elif 'typeerror' in criterion.lower():
- exception_type = "TypeError"
- elif 'attributeerror' in criterion.lower():
- exception_type = "AttributeError"
- elif 'keyerror' in criterion.lower():
- exception_type = "KeyError"
-
- # Try to extract expected message
- if 'message:' in criterion.lower():
- parts = criterion.split('message:')
- if len(parts) > 1:
- expected_message = parts[1].strip().strip('"\'')
-
- return template.format(
- function_name=function_name,
- exception=exception_type,
- scenario=self._extract_scenario(spec),
- condition=self._describe_condition(spec),
- setup_code=self._generate_setup_code(spec),
- function_call=self._generate_function_call(function_name, spec),
- expected_message=expected_message
- )
-
- def _generate_parameterized_test(self, spec: TestSpecification, function_name: str) -> str:
- """Generate parameterized test."""
-
- template = self.templates['parameterized_test']
-
- # Generate test parameters and values
- param_names, test_values = self._generate_test_parameters(spec)
-
- return template.format(
- function_name=function_name,
- scenario=self._extract_scenario(spec),
- description=spec.description,
- param_names=', '.join(param_names),
- test_values=test_values,
- setup_code=self._generate_setup_code(spec),
- function_call=self._generate_function_call(function_name, spec),
- expected_value=self._extract_expected_value(spec)
- )
-
- def _generate_integration_test(self, spec: TestSpecification) -> str:
- """Generate integration test."""
-
- template = self.templates['integration_test']
-
- feature_name = spec.name.lower().replace('test_', '').replace('_test', '')
-
- return template.format(
- feature_name=feature_name,
- scenario=self._extract_scenario(spec),
- description=spec.description,
- setup_code=self._generate_setup_code(spec),
- action=self._describe_action(spec),
- assertions=self._generate_assertions(spec),
- cleanup_code=self._generate_cleanup_code(spec)
- )
-
- def _generate_generic_test(self, spec: TestSpecification) -> str:
- """Generate generic test code."""
-
- test_code = f'''
-def test_{spec.name.replace(' ', '_').lower()}():
- """
- Test: {spec.description}
-
- Requirements:
- {chr(10).join(f" - {req}" for req in spec.requirements)}
-
- Acceptance Criteria:
- {chr(10).join(f" - {crit}" for crit in spec.acceptance_criteria)}
- """
- # TODO: Implement test based on specification
- # This is a generated template - fill in with actual test logic
-
- # Arrange
- # {chr(10).join(f" # {req}" for req in spec.preconditions)}
-
- # Act
- # result = function_to_test()
-
- # Assert
- # assert result is not None
- # Add specific assertions based on acceptance criteria
-'''
-
- return test_code
-
- def _extract_scenario(self, spec: TestSpecification) -> str:
- """Extract scenario name from specification."""
- if '_' in spec.name:
- parts = spec.name.split('_')
- if len(parts) > 1:
- return '_'.join(parts[1:])
- return 'default'
-
- def _describe_action(self, spec: TestSpecification) -> str:
- """Describe the action being tested."""
- return f"Call {spec.name}"
-
- def _describe_condition(self, spec: TestSpecification) -> str:
- """Describe condition for exception test."""
- return spec.requirements[0] if spec.requirements else "invalid input"
-
- def _generate_setup_code(self, spec: TestSpecification) -> str:
- """Generate setup code based on specification."""
- setup_lines = []
-
- # Add mock requirements
- for mock_name, mock_config in spec.mock_requirements.items():
- if isinstance(mock_config, dict) and 'return_value' in mock_config:
- setup_lines.append(f"{mock_name} = Mock(return_value={mock_config['return_value']})")
- else:
- setup_lines.append(f"{mock_name} = Mock()")
-
- # Add preconditions as setup
- for condition in spec.preconditions:
- setup_lines.append(f"# {condition}")
-
- return '\n '.join(setup_lines) if setup_lines else "pass"
-
- def _generate_function_call(self, function_name: str, spec: TestSpecification) -> str:
- """Generate function call with arguments."""
-
- # Extract arguments from mock requirements or requirements
- args = []
-
- if spec.mock_requirements:
- args.extend(spec.mock_requirements.keys())
-
- if not args:
- # Add placeholder arguments based on requirements
- for req in spec.requirements[:3]: # Limit to first 3 requirements
- if 'input' in req.lower() or 'parameter' in req.lower():
- args.append("test_input")
- break
-
- return f"{function_name}({', '.join(args)})" if args else f"{function_name}()"
-
- def _generate_assertions(self, spec: TestSpecification) -> str:
- """Generate assertions based on acceptance criteria."""
- assertions = []
-
- for criterion in spec.acceptance_criteria[:3]: # Limit to first 3 criteria
- if 'returns' in criterion.lower() or 'result' in criterion.lower():
- assertions.append("assert result is not None")
- elif 'equals' in criterion.lower() or 'equal' in criterion.lower():
- assertions.append("assert result == expected_value")
- elif 'length' in criterion.lower():
- assertions.append("assert len(result) > 0")
- else:
- assertions.append(f"# {criterion}")
-
- return '\n '.join(assertions) if assertions else "assert True # Add specific assertions"
-
- def _generate_cleanup_code(self, spec: TestSpecification) -> str:
- """Generate cleanup code for integration tests."""
- cleanup_lines = []
-
- # Add cleanup for any resources mentioned in postconditions
- for condition in spec.postconditions:
- if 'close' in condition.lower():
- cleanup_lines.append("# Close connections")
- elif 'delete' in condition.lower():
- cleanup_lines.append("# Delete temporary resources")
- else:
- cleanup_lines.append(f"# {condition}")
-
- return '\n '.join(cleanup_lines) if cleanup_lines else "pass"
-
- def _extract_expected_value(self, spec: TestSpecification) -> str:
- """Extract expected value from acceptance criteria."""
- for criterion in spec.acceptance_criteria:
- if 'returns' in criterion.lower():
- # Try to extract expected value
- if 'true' in criterion.lower():
- return "True"
- elif 'false' in criterion.lower():
- return "False"
- elif 'none' in criterion.lower():
- return "None"
- elif 'empty' in criterion.lower():
- return "[]"
- else:
- return "expected_result"
- return "expected_result"
-
- def _generate_test_parameters(self, spec: TestSpecification) -> tuple:
- """Generate parameters and values for parameterized tests."""
-
- # Create test cases from acceptance criteria and edge cases
- test_cases = []
-
- # Add acceptance criteria as test cases
- for criterion in spec.acceptance_criteria:
- if 'input' in criterion.lower():
- # Extract input values
- if 'valid' in criterion.lower():
- test_cases.append(('valid_input', 'expected_output'))
- elif 'invalid' in criterion.lower():
- test_cases.append(('invalid_input', 'exception'))
-
- # Add edge cases
- for edge_case in spec.edge_cases:
- if 'zero' in edge_case.lower():
- test_cases.append((0, 'zero_result'))
- elif 'empty' in edge_case.lower():
- test_cases.append(('', 'empty_result'))
- elif 'null' in edge_case.lower() or 'none' in edge_case.lower():
- test_cases.append((None, 'none_result'))
-
- # Convert to pytest format
- if test_cases:
- param_names = ['test_input', 'expected_output']
- test_values = str(test_cases).replace("'", '"')
- return param_names, test_values
-
- # Fallback
- return ['test_input', 'expected_output'], '[("test", "expected")]'
-
-class TDDManager:
- """Main TDD workflow manager with Context7 integration."""
-
- def __init__(self, project_path: str, context7_client=None):
- self.project_path = Path(project_path)
- self.context7 = context7_client
- self.context7_integration = Context7TDDIntegration(context7_client)
- self.test_generator = TestGenerator(context7_client)
- self.current_session = None
- self.test_history = []
-
- async def start_tdd_session(
- self, feature_name: str,
- test_types: List[TestType] = None
- ) -> TDDSession:
- """Start a new TDD development session."""
-
- if test_types is None:
- test_types = [TestType.UNIT, TestType.INTEGRATION]
-
- # Load Context7 patterns
- context7_patterns = await self.context7_integration.load_tdd_patterns()
-
- # Create session
- session = TDDSession(
- id=f"tdd_{feature_name}_{int(time.time())}",
- project_path=str(self.project_path),
- current_phase=TDDPhase.RED,
- test_cases=[],
- start_time=time.time(),
- context7_patterns=context7_patterns,
- metrics={
- 'tests_written': 0,
- 'tests_passing': 0,
- 'tests_failing': 0,
- 'coverage_percentage': 0.0
- }
- )
-
- self.current_session = session
- return session
-
- async def write_failing_test(
- self, specification: TestSpecification,
- file_path: str = None
- ) -> str:
- """RED phase: Write a failing test based on specification."""
-
- if not self.current_session:
- raise ValueError("No active TDD session")
-
- # Generate test code
- test_code = await self.test_generator.generate_test_case(
- specification, self.current_session.context7_patterns
- )
-
- # Determine file path
- if file_path is None:
- file_path = self._determine_test_file_path(specification)
-
- # Write test file
- full_path = self.project_path / file_path
- full_path.parent.mkdir(parents=True, exist_ok=True)
-
- with open(full_path, 'a', encoding='utf-8') as f:
- f.write('\n\n' + test_code)
-
- # Create test case object
- test_case = TestCase(
- id=f"test_{int(time.time())}",
- name=specification.name,
- file_path=str(full_path),
- line_number=self._count_lines_in_file(str(full_path)),
- specification=specification,
- status=TestStatus.PENDING,
- execution_time=0.0
- )
-
- self.current_session.test_cases.append(test_case)
- self.current_session.metrics['tests_written'] += 1
-
- return str(full_path)
-
- async def run_tests_and_verify_failure(self) -> Dict[str, Any]:
- """RED phase: Run tests and verify they fail as expected."""
-
- if not self.current_session:
- raise ValueError("No active TDD session")
-
- # Run tests using pytest
- test_results = await self._run_pytest()
-
- # Update session metrics
- failing_tests = test_results.get('failures', 0)
- self.current_session.metrics['tests_failing'] = failing_tests
-
- # Verify at least one test is failing (RED phase requirement)
- if failing_tests == 0:
- raise ValueError("RED phase violation: No tests are failing. Write a proper failing test first.")
-
- return test_results
-
- async def implement_minimum_code_to_pass(self, target_function: str) -> Dict[str, Any]:
- """GREEN phase: Implement minimum code to make tests pass."""
-
- if not self.current_session:
- raise ValueError("No active TDD session")
-
- # Generate minimum implementation
- implementation = await self._generate_minimum_implementation(target_function)
-
- # Write implementation
- impl_path = self._determine_implementation_file_path(target_function)
- full_path = self.project_path / impl_path
- full_path.parent.mkdir(parents=True, exist_ok=True)
-
- with open(full_path, 'w', encoding='utf-8') as f:
- f.write(implementation)
-
- # Run tests to verify they pass
- test_results = await self._run_pytest()
-
- # Update session metrics
- passing_tests = test_results.get('passed', 0)
- self.current_session.metrics['tests_passing'] = passing_tests
-
- if test_results.get('failures', 0) > 0:
- raise ValueError("GREEN phase violation: Tests are still failing. Implementation needs adjustment.")
-
- self.current_session.current_phase = TDDPhase.GREEN
- return test_results
-
- async def refactor_while_maintaining_tests(self) -> Dict[str, Any]:
- """REFACTOR phase: Improve code while keeping tests green."""
-
- if not self.current_session:
- raise ValueError("No active TDD session")
-
- if self.current_session.current_phase != TDDPhase.GREEN:
- raise ValueError("Must complete GREEN phase before REFACTOR")
-
- # Get Context7 refactoring patterns
- refactoring_patterns = await self._get_refactoring_patterns()
-
- # Generate refactoring suggestions
- suggestions = await self._generate_refactoring_suggestions(refactoring_patterns)
-
- # Apply refactoring suggestions
- for suggestion in suggestions:
- await self._apply_refactoring_suggestion(suggestion)
-
- # Verify tests still pass after each refactoring
- test_results = await self._run_pytest()
- if test_results.get('failures', 0) > 0:
- raise ValueError(f"REFACTOR phase violation: Tests failed after applying suggestion: {suggestion['description']}")
-
- self.current_session.current_phase = TDDPhase.REFACTOR
- return suggestions
-
- async def run_full_tdd_cycle(
- self, specification: TestSpecification,
- target_function: str = None
- ) -> Dict[str, Any]:
- """Run complete RED-GREEN-REFACTOR TDD cycle."""
-
- cycle_results = {}
-
- # RED phase
- print(" RED Phase: Writing failing test...")
- test_file = await self.write_failing_test(specification)
- red_results = await self.run_tests_and_verify_failure()
- cycle_results['red'] = {'test_file': test_file, 'results': red_results}
-
- # GREEN phase
- print("🟢 GREEN Phase: Implementing minimum code...")
- if target_function is None:
- target_function = specification.name.replace('test_', '').replace('_test', '')
- green_results = await self.implement_minimum_code_to_pass(target_function)
- cycle_results['green'] = {'results': green_results}
-
- # REFACTOR phase
- print(" REFACTOR Phase: Improving code quality...")
- refactor_results = await self.refactor_while_maintaining_tests()
- cycle_results['refactor'] = {'suggestions': refactor_results}
-
- # REVIEW phase
- print("🟣 REVIEW Phase: Final verification...")
- coverage_results = await self._run_coverage_analysis()
- cycle_results['review'] = {'coverage': coverage_results}
-
- self.current_session.current_phase = TDDPhase.REVIEW
- return cycle_results
-
- async def _run_pytest(self) -> Dict[str, Any]:
- """Run pytest and return results."""
-
- try:
- # Run pytest with JSON output for parsing
- result = subprocess.run(
- [
- sys.executable, '-m', 'pytest',
- str(self.project_path),
- '--tb=short',
- '--json-report',
- '--json-report-file=/tmp/pytest_results.json'
- ],
- capture_output=True,
- text=True,
- cwd=str(self.project_path)
- )
-
- # Parse results
- try:
- with open('/tmp/pytest_results.json', 'r') as f:
- results_data = json.load(f)
-
- return {
- 'summary': results_data.get('summary', {}),
- 'tests': results_data.get('tests', []),
- 'passed': results_data.get('summary', {}).get('passed', 0),
- 'failed': results_data.get('summary', {}).get('failed', 0),
- 'skipped': results_data.get('summary', {}).get('skipped', 0),
- 'total': results_data.get('summary', {}).get('total', 0),
- 'duration': results_data.get('summary', {}).get('duration', 0)
- }
- except (FileNotFoundError, json.JSONDecodeError):
- # Fallback to parsing stdout
- return self._parse_pytest_output(result.stdout)
-
- except Exception as e:
- print(f"Error running pytest: {e}")
- return {'error': str(e), 'passed': 0, 'failed': 0, 'skipped': 0, 'total': 0}
-
- def _parse_pytest_output(self, output: str) -> Dict[str, Any]:
- """Parse pytest output when JSON is not available."""
-
- lines = output.split('\n')
- results = {'passed': 0, 'failed': 0, 'skipped': 0, 'total': 0, 'duration': 0}
-
- for line in lines:
- if ' passed in ' in line:
- parts = line.split()
- if parts and parts[0].isdigit():
- results['passed'] = int(parts[0])
- results['total'] = int(parts[0])
- elif ' passed' in line and ' failed' in line:
- # Parse format like "2 passed, 1 failed"
- passed_part = line.split(' passed')[0]
- if passed_part.strip().isdigit():
- results['passed'] = int(passed_part.strip())
-
- if ' failed' in line:
- failed_part = line.split(' failed')[0].split(', ')[-1]
- if failed_part.strip().isdigit():
- results['failed'] = int(failed_part.strip())
-
- results['total'] = results['passed'] + results['failed']
-
- return results
-
- def _determine_test_file_path(self, specification: TestSpecification) -> str:
- """Determine appropriate test file path based on specification."""
-
- # Create tests directory structure
- test_dir = "tests"
-
- # Determine subdirectory based on test type
- if specification.test_type == TestType.INTEGRATION:
- test_dir += "/integration"
- elif specification.test_type == TestType.ACCEPTANCE:
- test_dir += "/acceptance"
- elif specification.test_type == TestType.PERFORMANCE:
- test_dir += "/performance"
-
- # Generate filename
- feature_name = specification.name.replace('test_', '').replace('_test', '')
- filename = f"test_{feature_name}.py"
-
- return f"{test_dir}/{filename}"
-
- def _determine_implementation_file_path(self, function_name: str) -> str:
- """Determine implementation file path for target function."""
-
- # Simple heuristic - place in src directory
- # In real implementation, this would be more sophisticated
- return f"src/{function_name}.py"
-
- def _count_lines_in_file(self, file_path: str) -> int:
- """Count lines in a file."""
- try:
- with open(file_path, 'r', encoding='utf-8') as f:
- return len(f.readlines())
- except FileNotFoundError:
- return 0
-
- async def _generate_minimum_implementation(self, target_function: str) -> str:
- """Generate minimum implementation to make tests pass."""
-
- # Get Context7 patterns for implementation
- patterns = self.current_session.context7_patterns
-
- # Simple implementation template
- implementation = f'''
-def {target_function}(*args, kwargs):
- """
- Minimum implementation for {target_function}.
-
- This is a TDD-generated implementation that will be
- refined during the REFACTOR phase.
- """
- # TODO: Implement proper logic based on test requirements
- # This is a placeholder to make tests pass initially
-
- if args:
- return args[0] # Return first argument as default
-
- return None # Default return value
-'''
-
- return implementation
-
- async def _get_refactoring_patterns(self) -> Dict[str, Any]:
- """Get refactoring patterns from Context7."""
-
- if self.context7:
- try:
- patterns = await self.context7.get_library_docs(
- context7_library_id="/refactoring/guru",
- topic="code refactoring patterns clean code 2025",
- tokens=3000
- )
- return patterns
- except Exception as e:
- print(f"Failed to get refactoring patterns: {e}")
-
- return {}
-
- async def _generate_refactoring_suggestions(self, patterns: Dict[str, Any]) -> List[Dict[str, Any]]:
- """Generate refactoring suggestions based on current implementation."""
-
- suggestions = []
-
- # Add general refactoring suggestions
- suggestions.extend([
- {
- 'type': 'extract_method',
- 'description': 'Extract complex logic into separate methods',
- 'priority': 'medium',
- 'applicable_to': ['large_functions']
- },
- {
- 'type': 'improve_naming',
- 'description': 'Improve variable and function naming for clarity',
- 'priority': 'high',
- 'applicable_to': ['all_functions']
- },
- {
- 'type': 'add_documentation',
- 'description': 'Add comprehensive docstrings and comments',
- 'priority': 'medium',
- 'applicable_to': ['all_functions']
- },
- {
- 'type': 'handle_edge_cases',
- 'description': 'Add proper error handling and edge case management',
- 'priority': 'high',
- 'applicable_to': ['public_functions']
- }
- ])
-
- return suggestions
-
- async def _apply_refactoring_suggestion(self, suggestion: Dict[str, Any]) -> bool:
- """Apply a refactoring suggestion to the codebase."""
-
- # In a real implementation, this would analyze the code
- # and apply automated refactoring using tools like Rope
-
- print(f"Applying refactoring: {suggestion['description']}")
-
- # Simulate refactoring application
- await asyncio.sleep(0.1) # Simulate work
-
- return True
-
- async def _run_coverage_analysis(self) -> Dict[str, Any]:
- """Run test coverage analysis."""
-
- try:
- # Run coverage analysis
- result = subprocess.run(
- [
- sys.executable, '-m', 'pytest',
- str(self.project_path),
- '--cov=src',
- '--cov-report=json',
- '--cov-report=term-missing'
- ],
- capture_output=True,
- text=True,
- cwd=str(self.project_path)
- )
-
- # Parse coverage results
- try:
- # Look for coverage file
- import glob
- coverage_files = glob.glob(str(self.project_path) + '/coverage.json')
- if coverage_files:
- with open(coverage_files[0], 'r') as f:
- coverage_data = json.load(f)
-
- total_coverage = coverage_data.get('totals', {}).get('percent_covered', 0)
- self.current_session.metrics['coverage_percentage'] = total_coverage
-
- return {
- 'total_coverage': total_coverage,
- 'files': coverage_data.get('files', {}),
- 'totals': coverage_data.get('totals', {})
- }
- except Exception:
- pass
-
- return {'total_coverage': 0, 'message': 'Coverage analysis failed'}
-
- except Exception as e:
- return {'error': str(e), 'total_coverage': 0}
-
- def get_session_summary(self) -> Dict[str, Any]:
- """Get summary of current TDD session."""
-
- if not self.current_session:
- return {}
-
- duration = time.time() - self.current_session.start_time
-
- return {
- 'session_id': self.current_session.id,
- 'phase': self.current_session.current_phase.value,
- 'duration_seconds': duration,
- 'duration_formatted': f"{duration:.1f} seconds",
- 'metrics': self.current_session.metrics,
- 'test_cases_count': len(self.current_session.test_cases)
- }
-
-# Usage Examples
-"""
+from moai_workflow_testing import TDDManager, TestSpecification, TestType
+
 # Initialize TDD Manager
 tdd_manager = TDDManager(
- project_path="/path/to/project",
- context7_client=context7
+    project_path="/path/to/project",
+    context7_client=context7
 )
 
 # Start TDD session
@@ -1115,146 +35,231 @@ 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",
- "Successful login should return user token"
- ],
- acceptance_criteria=[
- "Valid credentials return user token",
- "Invalid credentials raise AuthenticationError",
- "Empty credentials raise ValidationError"
- ],
- edge_cases=[
- "Test with empty email",
- "Test with empty password",
- "Test with malformed email",
- "Test with very long password"
- ],
- mock_requirements={
- "user_database": {"return_value": "mock_user"},
- "token_generator": {"return_value": "mock_token"}
- }
+    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"
+    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
 
-print("TDD Cycle Results:")
-print(f" RED phase: Test written to {cycle_results['red']['test_file']}")
-print(f" GREEN phase: {cycle_results['green']['results']['passed']} tests passing")
-print(f" REFACTOR phase: {len(cycle_results['refactor']['suggestions'])} improvements made")
-print(f" REVIEW phase: {cycle_results['review']['coverage']['total_coverage']:.1f}% coverage")
-
-# Get session summary
-summary = tdd_manager.get_session_summary()
-print(f"Session completed in {summary['duration_formatted']}")
-print(f"Final phase: {summary['phase']}")
-"""
+### 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)
 ```
 
-## Advanced Features
+### 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"]
+)
+```
 
-### Context7-Enhanced Test Generation
+### Exception Testing
 
-AI-Powered Test Case Generation:
 ```python
-class EnhancedTestGenerator(TestGenerator):
- """Enhanced test generator with advanced Context7 integration."""
-
- async def generate_comprehensive_test_suite(
- self, function_code: str,
- context7_patterns: Dict[str, Any]
- ) -> List[str]:
- """Generate comprehensive test suite from function code."""
-
- # Analyze function using AST
- function_analysis = self._analyze_function_code(function_code)
-
- # Generate tests for different scenarios
- test_cases = []
-
- # Happy path tests
- happy_path_tests = await self._generate_happy_path_tests(
- function_analysis, context7_patterns
- )
- test_cases.extend(happy_path_tests)
-
- # Edge case tests
- edge_case_tests = await self._generate_edge_case_tests(
- function_analysis, context7_patterns
- )
- test_cases.extend(edge_case_tests)
-
- # Error handling tests
- error_tests = await self._generate_error_handling_tests(
- function_analysis, context7_patterns
- )
- test_cases.extend(error_tests)
-
- # Performance tests for critical functions
- if self._is_performance_critical(function_analysis):
- perf_tests = await self._generate_performance_tests(function_analysis)
- test_cases.extend(perf_tests)
-
- return test_cases
-
- def _analyze_function_code(self, code: str) -> Dict[str, Any]:
- """Analyze function code to extract test requirements."""
-
- try:
- tree = ast.parse(code)
-
- analysis = {
- 'functions': [],
- 'parameters': [],
- 'return_statements': [],
- 'exceptions': [],
- 'external_calls': []
- }
-
- for node in ast.walk(tree):
- if isinstance(node, ast.FunctionDef):
- analysis['functions'].append({
- 'name': node.name,
- 'args': [arg.arg for arg in node.args.args],
- 'decorators': [d.id if isinstance(d, ast.Name) else str(d) for d in node.decorator_list]
- })
-
- elif isinstance(node, ast.Raise):
- analysis['exceptions'].append({
- 'type': node.exc.func.id if node.exc and hasattr(node.exc, 'func') else 'Exception',
- 'message': node.exc.msg if node.exc and hasattr(node.exc, 'msg') else None
- })
-
- elif isinstance(node, ast.Call):
- if isinstance(node.func, ast.Attribute):
- analysis['external_calls'].append(f"{node.func.value.id}.{node.func.attr}")
- elif isinstance(node.func, ast.Name):
- analysis['external_calls'].append(node.func.id)
-
- return analysis
-
- except Exception as e:
- print(f"Error analyzing function code: {e}")
- return {}
+# 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
 
-1. RED Phase: Always write failing tests first, ensure they fail for the right reason
-2. GREEN Phase: Write minimum code to pass tests, avoid premature optimization
-3. REFACTOR Phase: Improve design while keeping tests green, apply small incremental changes
-4. Test Coverage: Aim for high coverage but focus on meaningful tests
-5. Context Integration: Leverage Context7 patterns for industry-standard testing approaches
+### 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`
-Related: [AI Debugging](./ai-debugging.md) | [Performance Optimization](./performance-optimization.md)
+Version: 2.0.0 (Modular Structure)
+Last Updated: 2026-01-06