--- name: "tdd-guide" description: "Test-driven development skill for writing unit tests, generating test fixtures and mocks, analyzing coverage gaps, and guiding red-green-refactor workflows across Jest, Pytest, JUnit, Vitest, and Mocha. Use when the user asks to write tests, improve test coverage, practice TDD, generate mocks or stubs, or mentions testing frameworks like Jest, pytest, or JUnit. Handles test generation from source code, coverage report parsing (LCOV/JSON/XML), quality scoring, and framework conversion for TypeScript, JavaScript, Python, and Java projects." triggers: - generate tests - analyze coverage - TDD workflow - red green refactor - Jest tests - Pytest tests - JUnit tests - coverage report --- # TDD Guide Test-driven development skill for generating tests, analyzing coverage, and guiding red-green-refactor workflows across Jest, Pytest, JUnit, and Vitest. --- ## Workflows ### Generate Tests from Code 1. Provide source code (TypeScript, JavaScript, Python, Java) 2. Specify target framework (Jest, Pytest, JUnit, Vitest) 3. Run `test_generator.py` with requirements 4. Review generated test stubs 5. **Validation:** Tests compile and cover happy path, error cases, edge cases ### Analyze Coverage Gaps 1. Generate coverage report from test runner (`npm test -- --coverage`) 2. Run `coverage_analyzer.py` on LCOV/JSON/XML report 3. Review prioritized gaps (P0/P1/P2) 4. Generate missing tests for uncovered paths 5. **Validation:** Coverage meets target threshold (typically 80%+) ### TDD New Feature 1. Write failing test first (RED) 2. Run `tdd_workflow.py --phase red` to validate 3. Implement minimal code to pass (GREEN) 4. Run `tdd_workflow.py --phase green` to validate 5. Refactor while keeping tests green (REFACTOR) 6. **Validation:** All tests pass after each cycle --- ## Examples ### Test Generation — Input → Output (Pytest) **Input source function (`math_utils.py`):** ```python def divide(a: float, b: float) -> float: if b == 0: raise ValueError("Cannot divide by zero") return a / b ``` **Command:** ```bash python scripts/test_generator.py --input math_utils.py --framework pytest ``` **Generated test output (`test_math_utils.py`):** ```python import pytest from math_utils import divide class TestDivide: def test_divide_positive_numbers(self): assert divide(10, 2) == 5.0 def test_divide_negative_numerator(self): assert divide(-10, 2) == -5.0 def test_divide_float_result(self): assert divide(1, 3) == pytest.approx(0.333, rel=1e-3) def test_divide_by_zero_raises_value_error(self): with pytest.raises(ValueError, match="Cannot divide by zero"): divide(10, 0) def test_divide_zero_numerator(self): assert divide(0, 5) == 0.0 ``` --- ### Coverage Analysis — Sample P0/P1/P2 Output **Command:** ```bash python scripts/coverage_analyzer.py --report lcov.info --threshold 80 ``` **Sample output:** ``` Coverage Report — Overall: 63% (threshold: 80%) P0 — Critical gaps (uncovered error paths): auth/login.py:42-58 handle_expired_token() 0% covered payments/process.py:91-110 handle_payment_failure() 0% covered P1 — High-value gaps (core logic branches): users/service.py:77 update_profile() — else branch 0% covered orders/cart.py:134 apply_discount() — zero-qty guard 0% covered P2 — Low-risk gaps (utility / helper functions): utils/formatting.py:12 format_currency() 0% covered Recommended: Generate tests for P0 items first to reach 80% threshold. ``` --- ## Key Tools | Tool | Purpose | Usage | |------|---------|-------| | `test_generator.py` | Generate test cases from code/requirements | `python scripts/test_generator.py --input source.py --framework pytest` | | `coverage_analyzer.py` | Parse and analyze coverage reports | `python scripts/coverage_analyzer.py --report lcov.info --threshold 80` | | `tdd_workflow.py` | Guide red-green-refactor cycles | `python scripts/tdd_workflow.py --phase red --test test_auth.py` | | `fixture_generator.py` | Generate test data and mocks | `python scripts/fixture_generator.py --entity User --count 5` | Additional scripts: `framework_adapter.py` (convert between frameworks), `metrics_calculator.py` (quality metrics), `format_detector.py` (detect language/framework), `output_formatter.py` (CLI/desktop/CI output). --- ## Input Requirements **For Test Generation:** - Source code (file path or pasted content) - Target framework (Jest, Pytest, JUnit, Vitest) - Coverage scope (unit, integration, edge cases) **For Coverage Analysis:** - Coverage report file (LCOV, JSON, or XML format) - Optional: Source code for context - Optional: Target threshold percentage **For TDD Workflow:** - Feature requirements or user story - Current phase (RED, GREEN, REFACTOR) - Test code and implementation status --- ## Limitations | Scope | Details | |-------|---------| | Unit test focus | Integration and E2E tests require different patterns | | Static analysis | Cannot execute tests or measure runtime behavior | | Language support | Best for TypeScript, JavaScript, Python, Java | | Report formats | LCOV, JSON, XML only; other formats need conversion | | Generated tests | Provide scaffolding; require human review for complex logic | **When to use other tools:** - E2E testing: Playwright, Cypress, Selenium - Performance testing: k6, JMeter, Locust - Security testing: OWASP ZAP, Burp Suite FILE:HOW_TO_USE.md # How to Use the TDD Guide Skill The TDD Guide skill helps engineering teams implement Test Driven Development with intelligent test generation, coverage analysis, and workflow guidance. ## Basic Usage ### Generate Tests from Requirements ``` @tdd-guide I need to implement a user registration feature. Generate test cases for: - Email validation - Password strength checking - Duplicate email detection Language: TypeScript Framework: Jest ``` ### Analyze Test Coverage ``` @tdd-guide Analyze test coverage for my authentication module. Coverage report: coverage/lcov.info Source code: src/auth/ Identify gaps and prioritize improvements. ``` ### Get TDD Workflow Guidance ``` @tdd-guide Guide me through TDD for implementing a shopping cart feature. Requirements: - Add items to cart - Update quantities - Calculate totals - Apply discount codes Framework: Pytest ``` ## Example Invocations ### Example 1: Generate Tests from Code ``` @tdd-guide Generate comprehensive tests for this function: ```typescript export function calculateTax(amount: number, rate: number): number { if (amount < 0) throw new Error('Amount cannot be negative'); if (rate < 0 || rate > 1) throw new Error('Rate must be between 0 and 1'); return Math.round(amount * rate * 100) / 100; } ``` Include: - Happy path tests - Error cases - Boundary values - Edge cases ``` ### Example 2: Improve Coverage ``` @tdd-guide My coverage is at 65%. Help me get to 80%. Coverage report: [paste LCOV or JSON coverage data] Source files: - src/services/payment-processor.ts - src/services/order-validator.ts Prioritize critical paths. ``` ### Example 3: Review Test Quality ``` @tdd-guide Review the quality of these tests: ```python def test_login(): result = login("user", "pass") assert result is not None assert result.status == "success" assert result.token != "" assert len(result.permissions) > 0 def test_login_fails(): result = login("bad", "wrong") assert result is None ``` Suggest improvements for: - Test isolation - Assertion quality - Naming conventions - Test organization ``` ### Example 4: Framework Migration ``` @tdd-guide Convert these Jest tests to Pytest: ```javascript describe('Calculator', () => { it('should add two numbers', () => { const result = add(2, 3); expect(result).toBe(5); }); it('should handle negative numbers', () => { const result = add(-2, 3); expect(result).toBe(1); }); }); ``` Maintain test structure and coverage. ``` ### Example 5: Generate Test Fixtures ``` @tdd-guide Generate realistic test fixtures for: Entity: User Fields: - id (UUID) - email (valid format) - age (18-100) - role (admin, user, guest) Generate 5 fixtures with edge cases: - Minimum age boundary - Maximum age boundary - Special characters in email ``` ## What to Provide ### For Test Generation - Source code (TypeScript, JavaScript, Python, or Java) - Requirements (user stories, API specs, or business rules) - Testing framework preference (Jest, Pytest, JUnit, Vitest) - Specific scenarios to cover (optional) ### For Coverage Analysis - Coverage report (LCOV, JSON, or XML format) - Source code files (optional, for context) - Coverage threshold target (e.g., 80%) ### For TDD Workflow - Feature requirements - Current phase (RED, GREEN, or REFACTOR) - Test code and implementation (for validation) ### For Quality Review - Existing test code - Specific quality concerns (isolation, naming, assertions) ## What You'll Get ### Test Generation Output - Complete test files with proper structure - Test stubs with arrange-act-assert pattern - Framework-specific imports and syntax - Coverage for happy paths, errors, and edge cases ### Coverage Analysis Output - Overall coverage summary (line, branch, function) - Identified gaps with file/line numbers - Prioritized recommendations (P0, P1, P2) - Visual coverage indicators ### TDD Workflow Output - Step-by-step guidance for current phase - Validation of RED/GREEN/REFACTOR completion - Refactoring suggestions - Next steps in TDD cycle ### Quality Review Output - Test quality score (0-100) - Detected test smells - Isolation and naming analysis - Specific improvement recommendations ## Tips for Best Results ### Test Generation 1. **Be specific**: "Generate tests for password validation" is better than "generate tests" 2. **Provide context**: Include edge cases and error conditions you want covered 3. **Specify framework**: Mention Jest, Pytest, JUnit, etc., for correct syntax ### Coverage Analysis 1. **Use recent reports**: Coverage data should match current codebase 2. **Provide thresholds**: Specify your target coverage percentage 3. **Focus on critical code**: Prioritize coverage for business logic ### TDD Workflow 1. **Start with requirements**: Clear requirements lead to better tests 2. **One cycle at a time**: Complete RED-GREEN-REFACTOR before moving on 3. **Validate each phase**: Run tests and share results for accurate guidance ### Quality Review 1. **Share full context**: Include test setup/teardown and helper functions 2. **Ask specific questions**: "Is my isolation good?" gets better answers than "review this" 3. **Iterative improvement**: Implement suggestions incrementally ## Advanced Usage ### Multi-Language Projects ``` @tdd-guide Analyze coverage across multiple languages: - Frontend: TypeScript (Jest) - src/frontend/ - Backend: Python (Pytest) - src/backend/ - API: Java (JUnit) - src/api/ Provide unified coverage report and recommendations. ``` ### CI/CD Integration ``` @tdd-guide Generate coverage report for CI pipeline. Input: coverage/coverage-final.json Output format: JSON Include: - Pass/fail based on 80% threshold - Changed files coverage - Trend comparison with main branch ``` ### Parameterized Test Generation ``` @tdd-guide Generate parameterized tests for: Function: validateEmail(email: string): boolean Test cases: - valid@example.com → true - invalid.email → false - @example.com → false - user@domain.co.uk → true Framework: Jest (test.each) ``` ## Related Commands - `/code-review` - Review code quality and suggest improvements - `/test` - Run tests and analyze results - `/refactor` - Get refactoring suggestions while keeping tests green ## Troubleshooting **Issue**: Generated tests don't match my framework syntax - **Solution**: Explicitly specify framework (e.g., "using Pytest" or "with Jest") **Issue**: Coverage analysis shows 0% coverage - **Solution**: Verify coverage report format (LCOV, JSON, XML) and try including raw content **Issue**: TDD workflow validation fails - **Solution**: Ensure you're providing test results (passed/failed status) along with code **Issue**: Too many recommendations - **Solution**: Ask for "top 3 P0 recommendations only" for focused output ## Version Support - **Node.js**: 16+ (Jest 29+, Vitest 0.34+) - **Python**: 3.8+ (Pytest 7+) - **Java**: 11+ (JUnit 5.9+) - **TypeScript**: 4.5+ ## Feedback If you encounter issues or have suggestions, please mention: - Language and framework used - Type of operation (generation, analysis, workflow) - Expected vs. actual behavior FILE:README.md # TDD Guide - Test Driven Development Skill **Version**: 1.0.0 **Last Updated**: November 5, 2025 **Author**: Claude Skills Factory A comprehensive Test Driven Development skill for Claude Code that provides intelligent test generation, coverage analysis, framework integration, and TDD workflow guidance across multiple languages and testing frameworks. ## Table of Contents - [Overview](#overview) - [Features](#features) - [Installation](#installation) - [Quick Start](#quick-start) - [Python Modules](#python-modules) - [Usage Examples](#usage-examples) - [Configuration](#configuration) - [Supported Frameworks](#supported-frameworks) - [Output Formats](#output-formats) - [Best Practices](#best-practices) - [Troubleshooting](#troubleshooting) - [Contributing](#contributing) - [License](#license) ## Overview The TDD Guide skill transforms how engineering teams implement Test Driven Development by providing: - **Intelligent Test Generation**: Convert requirements into executable test cases - **Coverage Analysis**: Parse LCOV, JSON, XML reports and identify gaps - **Multi-Framework Support**: Jest, Pytest, JUnit, Vitest, and more - **TDD Workflow Guidance**: Step-by-step red-green-refactor guidance - **Quality Metrics**: Comprehensive test and code quality analysis - **Context-Aware Output**: Optimized for Desktop, CLI, or API usage ## Features ### Test Generation (3 capabilities) 1. **Generate Test Cases from Requirements** - User stories → Test cases 2. **Create Test Stubs** - Proper scaffolding with framework patterns 3. **Generate Test Fixtures** - Realistic test data and boundary values ### TDD Workflow (3 capabilities) 1. **Red-Green-Refactor Guidance** - Phase-by-phase validation 2. **Suggest Missing Scenarios** - Identify untested edge cases 3. **Review Test Quality** - Isolation, assertions, naming analysis ### Coverage & Metrics (6 categories) 1. **Test Coverage** - Line/branch/function with gap analysis 2. **Code Complexity** - Cyclomatic/cognitive complexity 3. **Test Quality** - Assertions, isolation, naming scoring 4. **Test Data** - Boundary values, edge cases 5. **Test Execution** - Timing, slow tests, flakiness 6. **Missing Tests** - Uncovered paths and error handlers ### Framework Integration (4 capabilities) 1. **Multi-Framework Adapters** - Jest, Pytest, JUnit, Vitest, Mocha 2. **Generate Boilerplate** - Proper imports and test structure 3. **Configure Runners** - Setup and coverage configuration 4. **Framework Detection** - Automatic framework identification ## Installation ### Claude Code (Desktop) 1. **Download the skill folder**: ```bash # Option A: Clone from repository git clone https://github.com/your-org/tdd-guide-skill.git # Option B: Download ZIP and extract ``` 2. **Install to Claude skills directory**: ```bash # Project-level (recommended for team projects) cp -r tdd-guide /path/to/your/project/.claude/skills/ # User-level (available for all projects) cp -r tdd-guide ~/.claude/skills/ ``` 3. **Verify installation**: ```bash ls ~/.claude/skills/tdd-guide/ # Should show: SKILL.md, *.py files, samples ``` ### Claude Apps (Browser) 1. Use the `skill-creator` skill to import the ZIP file 2. Or manually upload files through the skills interface ### Claude API ```python # Upload skill via API import anthropic client = anthropic.Anthropic(api_key="your-api-key") # Create skill with files skill = client.skills.create( name="tdd-guide", files=["tdd-guide/SKILL.md", "tdd-guide/*.py"] ) ``` ## Quick Start ### 1. Generate Tests from Requirements ``` @tdd-guide Generate tests for password validation function: - Min 8 characters - At least 1 uppercase, 1 lowercase, 1 number, 1 special char Language: TypeScript Framework: Jest ``` ### 2. Analyze Coverage ``` @tdd-guide Analyze coverage from: coverage/lcov.info Target: 80% coverage Prioritize recommendations ``` ### 3. TDD Workflow ``` @tdd-guide Guide me through TDD for implementing user authentication. Requirements: Email/password login, session management Framework: Pytest ``` ## Python Modules The skill includes **8 Python modules** organized by functionality: ### Core Modules (7 files) 1. **test_generator.py** (450 lines) - Generate test cases from requirements - Create test stubs with proper structure - Suggest missing scenarios based on code analysis - Support for multiple test types (unit, integration, e2e) 2. **coverage_analyzer.py** (380 lines) - Parse LCOV, JSON, XML coverage reports - Calculate line/branch/function coverage - Identify coverage gaps with prioritization - Generate actionable recommendations 3. **metrics_calculator.py** (420 lines) - Cyclomatic and cognitive complexity analysis - Test quality scoring (isolation, assertions, naming) - Test smell detection - Execution metrics analysis 4. **framework_adapter.py** (480 lines) - Multi-framework adapters (Jest, Pytest, JUnit, Vitest, Mocha) - Generate framework-specific imports and structure - Assertion syntax translation - Setup/teardown hook generation 5. **tdd_workflow.py** (380 lines) - Red-Green-Refactor phase guidance - Phase validation and progression - Refactoring suggestions - Workflow state management 6. **fixture_generator.py** (340 lines) - Boundary value generation - Edge case scenario creation - Mock data generation from schemas - Fixture file export (JSON, YAML, Python) 7. **format_detector.py** (280 lines) - Automatic language detection - Testing framework identification - Coverage format detection - Project structure analysis ### Utility Modules (1 file) 8. **output_formatter.py** (260 lines) - Context-aware formatting (Desktop, CLI, API) - Progressive disclosure - Token-efficient reporting - Summary and detailed views ### Total Lines of Code - **Python**: ~3,400 lines - **Documentation**: ~1,200 lines - **Samples**: ~200 lines - **Total**: ~4,400 lines ## Usage Examples ### Example 1: Generate Tests from User Story **Input**: ``` @tdd-guide User Story: As a user, I want to add items to my shopping cart Acceptance Criteria: - Add single item with quantity - Update quantity if item already exists - Validate quantity is positive - Return updated cart total Language: Python Framework: Pytest ``` **Output**: ```python import pytest from shopping_cart import ShoppingCart class TestShoppingCart: """Test suite for shopping cart functionality.""" def test_add_single_item_successfully(self): """Should add single item with quantity.""" cart = ShoppingCart() cart.add_item('apple', quantity=3, price=1.50) assert len(cart.items) == 1 assert cart.items['apple']['quantity'] == 3 assert cart.get_total() == 4.50 def test_update_quantity_for_existing_item(self): """Should update quantity if item already exists.""" cart = ShoppingCart() cart.add_item('apple', quantity=3, price=1.50) cart.add_item('apple', quantity=2, price=1.50) assert cart.items['apple']['quantity'] == 5 assert cart.get_total() == 7.50 def test_reject_negative_quantity(self): """Should validate quantity is positive.""" cart = ShoppingCart() with pytest.raises(ValueError, match="Quantity must be positive"): cart.add_item('apple', quantity=-1, price=1.50) ``` ### Example 2: Coverage Analysis with Recommendations **Input**: ``` @tdd-guide Analyze coverage: [Coverage report data] SF:src/auth/login.ts DA:1,5 DA:2,5 DA:3,3 DA:4,0 DA:5,0 ... Target: 80% coverage ``` **Output**: ```markdown ## Coverage Summary - Line Coverage: 65.0% - Branch Coverage: 58.3% - Function Coverage: 75.0% ⚠️ **65.0%** coverage (yellow) - Below 80% threshold ## Recommendations ### 🔴 Critical (P0) 1. **Error handling paths not covered** - Action: Add tests for authentication failure scenarios - File: `src/auth/login.ts` - Lines: 45-52, 67-70 2. **Branch coverage gap in validation** - Action: Test all conditional branches in input validation - File: `src/auth/login.ts` - Lines: 23-28 ### 🟡 Important (P1) 1. **Edge cases missing** - Action: Add boundary tests for password length (7, 8, 9 chars) - Impact: Medium ``` ### Example 3: TDD Red-Green-Refactor Guidance **Input**: ``` @tdd-guide Guide TDD for email validation. Requirement: Email must contain @ and valid domain Phase: RED (write failing test) ``` **Output**: ```markdown ## TDD Phase: RED ### Goal Write a failing test that describes desired email validation behavior ### Steps 1. ✅ Read requirement: Email must contain @ and valid domain 2. ✅ Think about expected behavior 3. ⏳ Write test that verifies this behavior 4. ⏳ Run test and ensure it fails 5. ⏳ Verify failure reason is correct (not syntax error) ### Test Template (Jest) ```typescript describe('EmailValidator', () => { it('should accept valid email format', () => { // Arrange const validator = new EmailValidator(); // Act const result = validator.validate('user@example.com'); // Assert expect(result).toBe(true); }); it('should reject email without @ symbol', () => { const validator = new EmailValidator(); const result = validator.validate('userexample.com'); expect(result).toBe(false); }); }); ``` ### Next Steps 1. Run the test (it should fail) 2. Verify failure: "EmailValidator is not defined" or similar 3. Share test result to proceed to GREEN phase ``` ### Example 4: Test Quality Review **Input**: ``` @tdd-guide Review test quality: def test_user_login(): result = login("admin", "password123") assert result assert result["status"] == "success" assert result["token"] assert result["user"]["id"] > 0 assert result["user"]["role"] == "admin" ``` **Output**: ```markdown ## Test Quality Analysis **Overall Score**: 62/100 ### Issues Detected 1. **Assertion Roulette** (High Severity) - 5 assertions in single test - **Fix**: Split into multiple focused tests 2. **Poor Test Isolation** (Medium Severity) - Test depends on database state ("admin" user existing) - **Fix**: Use fixtures or mocks for user data 3. **Weak Assertions** (Medium Severity) - `assert result["token"]` just checks truthy (could be any string) - **Fix**: `assert len(result["token"]) > 20` or use regex 4. **Missing Naming Context** (Low Severity) - Test name doesn't describe what's being tested - **Fix**: `test_successful_login_returns_valid_token_and_user_data` ### Recommended Refactoring ```python @pytest.fixture def admin_user(): return {"username": "admin", "password": "password123"} def test_successful_login_returns_success_status(admin_user): """Test that valid credentials return success status.""" result = login(admin_user["username"], admin_user["password"]) assert result["status"] == "success" def test_successful_login_returns_valid_jwt_token(admin_user): """Test that successful login returns a JWT token.""" result = login(admin_user["username"], admin_user["password"]) assert len(result["token"]) > 20 assert result["token"].count('.') == 2 # JWT format def test_successful_login_returns_user_data(admin_user): """Test that successful login includes user information.""" result = login(admin_user["username"], admin_user["password"]) assert result["user"]["id"] > 0 assert result["user"]["role"] == "admin" ``` ### Quality Improvements - Isolation Score: 55 → 90 (with fixtures) - Naming Quality: 40 → 85 (descriptive names) - Test Focus: 30 → 95 (one assertion per test) ``` ## Configuration ### Environment Variables ```bash # Set preferred testing framework export TDD_DEFAULT_FRAMEWORK="jest" # Set coverage threshold export TDD_COVERAGE_THRESHOLD=80 # Set output verbosity export TDD_VERBOSE=true # Set output format export TDD_OUTPUT_FORMAT="markdown" # or "json", "terminal" ``` ### Skill Configuration (Optional) Create `.tdd-guide.json` in project root: ```json { "framework": "jest", "language": "typescript", "coverage_threshold": 80, "test_directory": "tests/", "quality_rules": { "max_assertions_per_test": 3, "require_descriptive_names": true, "enforce_isolation": true }, "output": { "format": "markdown", "verbose": false, "max_recommendations": 10 } } ``` ## Supported Frameworks ### JavaScript/TypeScript - **Jest** 29+ (recommended for React, Node.js) - **Vitest** 0.34+ (recommended for Vite projects) - **Mocha** 10+ with Chai - **Jasmine** 4+ ### Python - **Pytest** 7+ (recommended) - **unittest** (Python standard library) - **nose2** 0.12+ ### Java - **JUnit 5** 5.9+ (recommended) - **TestNG** 7+ - **Mockito** 5+ (mocking support) ### Coverage Tools - **Istanbul/nyc** (JavaScript) - **c8** (JavaScript, V8 native) - **coverage.py** (Python) - **pytest-cov** (Python) - **JaCoCo** (Java) - **Cobertura** (multi-language) ## Output Formats ### Markdown (Claude Desktop) - Rich formatting with headers, tables, code blocks - Visual indicators (✅, ⚠️, ❌) - Progressive disclosure (summary first, details on demand) - Syntax highlighting for code examples ### Terminal (Claude Code CLI) - Concise, text-based output - Clear section separators - Minimal formatting for readability - Quick scanning for key information ### JSON (API/CI Integration) - Structured data for automated processing - Machine-readable metrics - Suitable for CI/CD pipelines - Easy integration with other tools ## Best Practices ### Test Generation 1. **Start with requirements** - Clear specs lead to better tests 2. **Cover the happy path first** - Then add error and edge cases 3. **One behavior per test** - Focused tests are easier to maintain 4. **Use descriptive names** - Tests are documentation ### Coverage Analysis 1. **Aim for 80%+ coverage** - Balance between safety and effort 2. **Prioritize critical paths** - Not all code needs 100% coverage 3. **Branch coverage matters** - Line coverage alone is insufficient 4. **Track trends** - Coverage should improve over time ### TDD Workflow 1. **Small iterations** - Write one test, make it pass, refactor 2. **Run tests frequently** - Fast feedback loop is essential 3. **Commit often** - Each green phase is a safe checkpoint 4. **Refactor with confidence** - Tests are your safety net ### Test Quality 1. **Isolate tests** - No shared state between tests 2. **Fast execution** - Unit tests should be <100ms each 3. **Deterministic** - Same input always produces same output 4. **Clear failures** - Good error messages save debugging time ## Troubleshooting ### Common Issues **Issue**: Generated tests have wrong syntax for my framework ``` Solution: Explicitly specify framework Example: "Generate tests using Pytest" or "Framework: Jest" ``` **Issue**: Coverage report not recognized ``` Solution: Verify format (LCOV, JSON, XML) Try: Paste raw coverage data instead of file path Check: File exists and is readable ``` **Issue**: Too many recommendations, overwhelmed ``` Solution: Ask for prioritized output Example: "Show only P0 (critical) recommendations" Limit: "Top 5 recommendations only" ``` **Issue**: Test quality score seems wrong ``` Check: Ensure complete test context (setup/teardown included) Verify: Test file contains actual test code, not just stubs Context: Quality depends on isolation, assertions, naming ``` **Issue**: Framework detection incorrect ``` Solution: Specify framework explicitly Example: "Using JUnit 5" or "Framework: Vitest" Check: Ensure imports are present in code ``` ## File Structure ``` tdd-guide/ ├── SKILL.md # Skill definition (YAML + documentation) ├── README.md # This file ├── HOW_TO_USE.md # Usage examples │ ├── test_generator.py # Test generation core ├── coverage_analyzer.py # Coverage parsing and analysis ├── metrics_calculator.py # Quality metrics calculation ├── framework_adapter.py # Multi-framework support ├── tdd_workflow.py # Red-green-refactor guidance ├── fixture_generator.py # Test data and fixtures ├── format_detector.py # Automatic format detection ├── output_formatter.py # Context-aware output │ ├── sample_input_typescript.json # TypeScript example ├── sample_input_python.json # Python example ├── sample_coverage_report.lcov # LCOV coverage example └── expected_output.json # Expected output structure ``` ## Contributing We welcome contributions! To contribute: 1. Fork the repository 2. Create a feature branch (`git checkout -b feature/improvement`) 3. Make your changes 4. Add tests for new functionality 5. Run validation: `python -m pytest tests/` 6. Commit changes (`git commit -m "Add: feature description"`) 7. Push to branch (`git push origin feature/improvement`) 8. Open a Pull Request ### Development Setup ```bash # Clone repository git clone https://github.com/your-org/tdd-guide-skill.git cd tdd-guide-skill # Install development dependencies pip install -r requirements-dev.txt # Run tests pytest tests/ -v # Run linter pylint *.py # Run type checker mypy *.py ``` ## Version History ### v1.0.0 (November 5, 2025) - Initial release - Support for TypeScript, JavaScript, Python, Java - Jest, Pytest, JUnit, Vitest framework adapters - LCOV, JSON, XML coverage parsing - TDD workflow guidance (red-green-refactor) - Test quality metrics and analysis - Context-aware output formatting - Comprehensive documentation ## License MIT License - See LICENSE file for details ## Support - **Documentation**: See HOW_TO_USE.md for detailed examples - **Issues**: Report bugs via GitHub issues - **Questions**: Ask in Claude Code community forum - **Updates**: Check repository for latest version ## Acknowledgments Built with Claude Skills Factory toolkit, following Test Driven Development best practices and informed by: - Kent Beck's "Test Driven Development: By Example" - Martin Fowler's refactoring catalog - xUnit Test Patterns by Gerard Meszaros - Growing Object-Oriented Software, Guided by Tests --- **Ready to improve your testing workflow?** Install the TDD Guide skill and start generating high-quality tests today! FILE:assets/expected_output.json { "test_generation": { "generated_tests": [ { "name": "should_validate_password_length_successfully", "type": "happy_path", "priority": "P0", "framework": "jest", "code": "it('should validate password with sufficient length', () => {\n const validator = new PasswordValidator();\n const result = validator.validate('Test@123');\n expect(result).toBe(true);\n});" }, { "name": "should_handle_too_short_password", "type": "error_case", "priority": "P0", "framework": "jest", "code": "it('should reject password shorter than 8 characters', () => {\n const validator = new PasswordValidator();\n const result = validator.validate('Test@1');\n expect(result).toBe(false);\n});" } ], "test_file": "password-validator.test.ts", "total_tests_generated": 8 }, "coverage_analysis": { "summary": { "line_coverage": 100.0, "branch_coverage": 100.0, "function_coverage": 100.0, "total_lines": 20, "covered_lines": 20, "total_branches": 12, "covered_branches": 12 }, "gaps": [], "assessment": "Excellent coverage - all paths tested" }, "metrics": { "complexity": { "cyclomatic_complexity": 6, "cognitive_complexity": 8, "testability_score": 85.0, "assessment": "Medium complexity - moderately testable" }, "test_quality": { "total_tests": 8, "total_assertions": 16, "avg_assertions_per_test": 2.0, "isolation_score": 95.0, "naming_quality": 87.5, "quality_score": 88.0, "test_smells": [] } }, "recommendations": [ { "priority": "P1", "type": "edge_case_coverage", "message": "Consider adding boundary value tests", "action": "Add tests for exact boundary conditions (7 vs 8 characters)", "impact": "medium" }, { "priority": "P2", "type": "test_organization", "message": "Group related tests using describe blocks", "action": "Organize tests by feature (length validation, complexity validation)", "impact": "low" } ], "tdd_workflow": { "current_phase": "GREEN", "status": "Tests passing, ready for refactoring", "next_steps": [ "Review code for duplication", "Consider extracting validation rules", "Commit changes" ] } } FILE:assets/sample_input_python.json { "language": "python", "framework": "pytest", "source_code": "def calculate_discount(price: float, discount_percent: float) -> float:\n \"\"\"Calculate discounted price.\"\"\"\n if price < 0:\n raise ValueError(\"Price cannot be negative\")\n if discount_percent < 0 or discount_percent > 100:\n raise ValueError(\"Discount must be between 0 and 100\")\n \n discount_amount = price * (discount_percent / 100)\n return round(price - discount_amount, 2)", "requirements": { "user_stories": [ { "description": "Calculate discounted price for valid inputs", "action": "calculate_discount", "given": ["Price is 100", "Discount is 20%"], "when": "Discount is calculated", "then": "Return 80.00", "error_conditions": [ { "condition": "negative_price", "description": "Price is negative", "error_type": "ValueError" }, { "condition": "invalid_discount", "description": "Discount is out of range", "error_type": "ValueError" } ], "edge_cases": [ { "scenario": "zero_discount", "description": "Discount is 0%" }, { "scenario": "full_discount", "description": "Discount is 100%" } ] } ] }, "coverage_threshold": 90 } FILE:assets/sample_input_typescript.json { "language": "typescript", "framework": "jest", "source_code": "export class PasswordValidator {\n validate(password: string): boolean {\n if (password.length < 8) return false;\n if (!/[A-Z]/.test(password)) return false;\n if (!/[a-z]/.test(password)) return false;\n if (!/[0-9]/.test(password)) return false;\n if (!/[!@#$%^&*]/.test(password)) return false;\n return true;\n }\n}", "requirements": { "user_stories": [ { "description": "Password must be at least 8 characters long", "action": "validate_password_length", "given": ["User provides password"], "when": "Password is validated", "then": "Reject if less than 8 characters" }, { "description": "Password must contain uppercase, lowercase, number, and special character", "action": "validate_password_complexity", "given": ["User provides password"], "when": "Password is validated", "then": "Reject if missing any character type" } ], "acceptance_criteria": [ { "id": "AC1", "description": "Valid password: 'Test@123'", "verification_steps": ["Call validate with 'Test@123'", "Should return true"] }, { "id": "AC2", "description": "Invalid password: 'test' (too short)", "verification_steps": ["Call validate with 'test'", "Should return false"] } ] }, "coverage_threshold": 80 } FILE:references/ci-integration.md # CI/CD Integration Guide Integrating test coverage and quality gates into CI pipelines. --- ## Table of Contents - [Coverage in CI](#coverage-in-ci) - [GitHub Actions Examples](#github-actions-examples) - [Quality Gates](#quality-gates) - [Trend Tracking](#trend-tracking) --- ## Coverage in CI ### Coverage Report Flow 1. Run tests with coverage enabled 2. Generate report in machine-readable format (LCOV, JSON, XML) 3. Parse report for threshold validation 4. Upload to coverage service (Codecov, Coveralls) 5. Fail build if below threshold ### Report Formats by Tool | Tool | Command | Output Format | |------|---------|---------------| | Jest | `jest --coverage --coverageReporters=lcov` | LCOV | | Pytest | `pytest --cov-report=xml` | Cobertura XML | | JUnit/JaCoCo | `mvn jacoco:report` | JaCoCo XML | | Vitest | `vitest --coverage` | LCOV/JSON | --- ## GitHub Actions Examples ### Node.js (Jest) ```yaml name: Test and Coverage on: [push, pull_request] jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-node@v4 with: node-version: '20' - run: npm ci - run: npm test -- --coverage - name: Check coverage threshold run: | COVERAGE=$(cat coverage/coverage-summary.json | jq '.total.lines.pct') if (( $(echo "$COVERAGE < 80" | bc -l) )); then echo "Coverage $COVERAGE% is below 80% threshold" exit 1 fi - uses: codecov/codecov-action@v4 with: file: coverage/lcov.info ``` ### Python (Pytest) ```yaml name: Test and Coverage on: [push, pull_request] jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-python@v5 with: python-version: '3.11' - run: pip install pytest pytest-cov - run: pytest --cov=src --cov-report=xml --cov-fail-under=80 - uses: codecov/codecov-action@v4 with: file: coverage.xml ``` ### Java (Maven + JaCoCo) ```yaml name: Test and Coverage on: [push, pull_request] jobs: test: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-java@v4 with: distribution: 'temurin' java-version: '17' - run: mvn test jacoco:check - uses: codecov/codecov-action@v4 with: file: target/site/jacoco/jacoco.xml ``` --- ## Quality Gates ### Threshold Configuration **Jest (package.json):** ```json { "jest": { "coverageThreshold": { "global": { "branches": 80, "functions": 80, "lines": 80, "statements": 80 } } } } ``` **Pytest (pyproject.toml):** ```toml [tool.coverage.report] fail_under = 80 ``` **JaCoCo (pom.xml):** ```xml BUNDLE LINE COVEREDRATIO 0.80 ``` ### PR Coverage Checks - Block merge if coverage drops - Show coverage diff in PR comments - Require coverage for changed files - Allow exceptions with justification --- ## Trend Tracking ### Metrics to Track | Metric | Purpose | Alert Threshold | |--------|---------|-----------------| | Overall line coverage | Baseline health | < 80% | | Branch coverage | Logic completeness | < 70% | | Coverage delta | Regression detection | < -2% per PR | | Test execution time | Performance | > 5 min | | Flaky test count | Reliability | > 0 | ### Coverage Services | Service | Features | Integration | |---------|----------|-------------| | Codecov | PR comments, badges, graphs | GitHub, GitLab, Bitbucket | | Coveralls | History, trends, badges | GitHub, GitLab | | SonarCloud | Full code quality suite | Multiple CI platforms | ### Badge Generation ```markdown [![codecov](https://codecov.io/gh/org/repo/branch/main/graph/badge.svg)](https://codecov.io/gh/org/repo) ``` FILE:references/framework-guide.md # Testing Framework Guide Language and framework selection, configuration, and patterns. --- ## Table of Contents - [Framework Selection](#framework-selection) - [TypeScript/JavaScript](#typescriptjavascript) - [Python](#python) - [Java](#java) - [Version Requirements](#version-requirements) --- ## Framework Selection | Language | Recommended | Alternatives | Best For | |----------|-------------|--------------|----------| | TypeScript/JS | Jest | Vitest, Mocha | React, Node.js, Next.js | | Python | Pytest | unittest, nose2 | Django, Flask, FastAPI | | Java | JUnit 5 | TestNG | Spring, Android | | Vite projects | Vitest | Jest | Modern Vite-based apps | --- ## TypeScript/JavaScript ### Jest Configuration ```javascript // jest.config.js module.exports = { preset: 'ts-jest', testEnvironment: 'node', testMatch: ['**/*.test.ts'], collectCoverageFrom: ['src/**/*.ts'], coverageThreshold: { global: { branches: 80, lines: 80 } } }; ``` ### Jest Test Pattern ```typescript describe('Calculator', () => { let calc: Calculator; beforeEach(() => { calc = new Calculator(); }); it('should add two numbers', () => { expect(calc.add(2, 3)).toBe(5); }); it('should throw on invalid input', () => { expect(() => calc.add(null, 3)).toThrow('Invalid input'); }); }); ``` ### Vitest Configuration ```typescript // vitest.config.ts import { defineConfig } from 'vitest/config'; export default defineConfig({ test: { globals: true, environment: 'node', coverage: { provider: 'c8' } } }); ``` ### Coverage Tools - Istanbul/nyc: Traditional coverage - c8: Native V8 coverage (faster) - Vitest built-in: Integrated with test runner --- ## Python ### Pytest Configuration ```ini # pytest.ini [pytest] testpaths = tests python_files = test_*.py python_functions = test_* addopts = --cov=src --cov-report=term-missing ``` ### Pytest Test Pattern ```python import pytest from calculator import Calculator class TestCalculator: @pytest.fixture def calc(self): return Calculator() def test_add_positive_numbers(self, calc): assert calc.add(2, 3) == 5 def test_add_raises_on_invalid_input(self, calc): with pytest.raises(ValueError, match="Invalid input"): calc.add(None, 3) @pytest.mark.parametrize("a,b,expected", [ (1, 2, 3), (-1, 1, 0), (0, 0, 0), ]) def test_add_various_inputs(self, calc, a, b, expected): assert calc.add(a, b) == expected ``` ### Coverage Tools - coverage.py: Standard Python coverage - pytest-cov: Pytest plugin wrapper - Report formats: HTML, XML, LCOV --- ## Java ### JUnit 5 Configuration (Maven) ```xml org.junit.jupiter junit-jupiter 5.9.3 test org.jacoco jacoco-maven-plugin 0.8.10 ``` ### JUnit 5 Test Pattern ```java import org.junit.jupiter.api.*; import static org.junit.jupiter.api.Assertions.*; class CalculatorTest { private Calculator calc; @BeforeEach void setUp() { calc = new Calculator(); } @Test @DisplayName("should add two positive numbers") void testAddPositive() { assertEquals(5, calc.add(2, 3)); } @Test @DisplayName("should throw on null input") void testAddThrowsOnNull() { assertThrows(IllegalArgumentException.class, () -> calc.add(null, 3)); } @ParameterizedTest @CsvSource({"1,2,3", "-1,1,0", "0,0,0"}) void testAddVarious(int a, int b, int expected) { assertEquals(expected, calc.add(a, b)); } } ``` ### Coverage Tools - JaCoCo: Standard Java coverage - Cobertura: Alternative XML format - Report formats: HTML, XML, CSV --- ## Version Requirements | Tool | Minimum Version | Notes | |------|-----------------|-------| | Node.js | 16+ | Required for Jest 29+ | | Jest | 29+ | Modern async support | | Vitest | 0.34+ | Stable API | | Python | 3.8+ | f-strings, async support | | Pytest | 7+ | Modern fixtures | | Java | 11+ | JUnit 5 support | | JUnit | 5.9+ | ParameterizedTest improvements | | TypeScript | 4.5+ | Strict mode features | FILE:references/tdd-best-practices.md # TDD Best Practices Guidelines for effective test-driven development workflows. --- ## Table of Contents - [Red-Green-Refactor Cycle](#red-green-refactor-cycle) - [Test Generation Guidelines](#test-generation-guidelines) - [Test Quality Principles](#test-quality-principles) - [Coverage Goals](#coverage-goals) --- ## Red-Green-Refactor Cycle ### RED Phase 1. Write a failing test before any implementation 2. Test should fail for the right reason (not compilation errors) 3. Name tests as specifications describing expected behavior 4. Keep tests small and focused on single behaviors ### GREEN Phase 1. Write minimal code to make the test pass 2. Avoid over-engineering at this stage 3. Duplicate code is acceptable temporarily 4. Focus on correctness, not elegance ### REFACTOR Phase 1. Improve code structure while keeping tests green 2. Remove duplication introduced in GREEN phase 3. Apply design patterns where appropriate 4. Run tests after each small refactoring ### Cycle Discipline - Complete one cycle before starting the next - Commit after each successful GREEN phase - Small iterations lead to better designs - Resist temptation to write implementation first --- ## Test Generation Guidelines ### Behavior Focus - Test what code does, not how it does it - Avoid coupling tests to implementation details - Tests should survive internal refactoring - Focus on observable outcomes ### Naming Conventions - Use descriptive names that read as specifications - Format: `should__when_` - Examples: - `should_return_zero_when_cart_is_empty` - `should_reject_negative_amounts` - `should_apply_discount_for_members` ### Test Structure - Follow Arrange-Act-Assert (AAA) pattern - Keep setup minimal and relevant - One logical assertion per test - Extract shared setup to fixtures ### Coverage Scope - Happy path: Normal expected usage - Error cases: Invalid inputs, failures - Edge cases: Boundaries, empty states - Exceptional cases: Timeouts, nulls --- ## Test Quality Principles ### Independence - Each test runs in isolation - No shared mutable state between tests - Tests can run in any order - Parallel execution should work ### Speed - Unit tests under 100ms each - Avoid I/O in unit tests - Mock external dependencies - Use in-memory databases for integration ### Determinism - Same inputs produce same results - No dependency on system time or random values - Controlled test data - No flaky tests allowed ### Clarity - Failure messages explain what went wrong - Test code is as clean as production code - Avoid clever tricks that obscure intent - Comments explain non-obvious setup --- ## Coverage Goals ### Thresholds by Type | Type | Target | Rationale | |------|--------|-----------| | Line coverage | 80%+ | Baseline for most projects | | Branch coverage | 70%+ | More meaningful than line | | Function coverage | 90%+ | Public APIs should be tested | ### Critical Path Rules - Authentication: 100% coverage required - Payment processing: 100% coverage required - Data validation: 100% coverage required - Error handlers: Must test all paths ### Avoiding Coverage Theater - High coverage != good tests - Focus on meaningful assertions - Test behaviors, not lines - Code review test quality, not just metrics ### Coverage Analysis Workflow 1. Generate coverage report after test run 2. Identify uncovered critical paths (P0) 3. Review medium-priority gaps (P1) 4. Document accepted low-priority gaps (P2) 5. Set threshold gates in CI pipeline FILE:scripts/coverage_analyzer.py """ Coverage analysis module. Parse and analyze test coverage reports in multiple formats (LCOV, JSON, XML). Identify gaps, calculate metrics, and provide actionable recommendations. """ from typing import Dict, List, Any, Optional, Tuple import json import xml.etree.ElementTree as ET class CoverageFormat: """Supported coverage report formats.""" LCOV = "lcov" JSON = "json" XML = "xml" COBERTURA = "cobertura" class CoverageAnalyzer: """Analyze test coverage reports and identify gaps.""" def __init__(self): """Initialize coverage analyzer.""" self.coverage_data = {} self.gaps = [] self.summary = {} def parse_coverage_report( self, report_content: str, format_type: str ) -> Dict[str, Any]: """ Parse coverage report in various formats. Args: report_content: Raw coverage report content format_type: Format (lcov, json, xml, cobertura) Returns: Parsed coverage data """ if format_type == CoverageFormat.LCOV: return self._parse_lcov(report_content) elif format_type == CoverageFormat.JSON: return self._parse_json(report_content) elif format_type in [CoverageFormat.XML, CoverageFormat.COBERTURA]: return self._parse_xml(report_content) else: raise ValueError(f"Unsupported format: {format_type}") def _parse_lcov(self, content: str) -> Dict[str, Any]: """Parse LCOV format coverage report.""" files = {} current_file = None file_data = {} for line in content.split('\n'): line = line.strip() if line.startswith('SF:'): # Source file current_file = line[3:] file_data = { 'lines': {}, 'functions': {}, 'branches': {} } elif line.startswith('DA:'): # Line coverage data (line_number,hit_count) parts = line[3:].split(',') line_num = int(parts[0]) hit_count = int(parts[1]) file_data['lines'][line_num] = hit_count elif line.startswith('FNDA:'): # Function coverage (hit_count,function_name) parts = line[5:].split(',', 1) hit_count = int(parts[0]) func_name = parts[1] if len(parts) > 1 else 'unknown' file_data['functions'][func_name] = hit_count elif line.startswith('BRDA:'): # Branch coverage (line,block,branch,hit_count) parts = line[5:].split(',') branch_id = f"{parts[0]}:{parts[1]}:{parts[2]}" hit_count = 0 if parts[3] == '-' else int(parts[3]) file_data['branches'][branch_id] = hit_count elif line == 'end_of_record': if current_file: files[current_file] = file_data current_file = None file_data = {} self.coverage_data = files return files def _parse_json(self, content: str) -> Dict[str, Any]: """Parse JSON format coverage report (Istanbul/nyc).""" try: data = json.loads(content) files = {} for file_path, file_data in data.items(): lines = {} functions = {} branches = {} # Line coverage if 's' in file_data: # Statement map statement_map = file_data['s'] for stmt_id, hit_count in statement_map.items(): # Map statement to line number if 'statementMap' in file_data: stmt_info = file_data['statementMap'].get(stmt_id, {}) line_num = stmt_info.get('start', {}).get('line') if line_num: lines[line_num] = hit_count # Function coverage if 'f' in file_data: func_map = file_data['f'] func_names = file_data.get('fnMap', {}) for func_id, hit_count in func_map.items(): func_info = func_names.get(func_id, {}) func_name = func_info.get('name', f'func_{func_id}') functions[func_name] = hit_count # Branch coverage if 'b' in file_data: branch_map = file_data['b'] for branch_id, locations in branch_map.items(): for idx, hit_count in enumerate(locations): branch_key = f"{branch_id}:{idx}" branches[branch_key] = hit_count files[file_path] = { 'lines': lines, 'functions': functions, 'branches': branches } self.coverage_data = files return files except json.JSONDecodeError as e: raise ValueError(f"Invalid JSON coverage report: {e}") def _parse_xml(self, content: str) -> Dict[str, Any]: """Parse XML/Cobertura format coverage report.""" try: root = ET.fromstring(content) files = {} # Handle Cobertura format for package in root.findall('.//package'): for cls in package.findall('classes/class'): filename = cls.get('filename', cls.get('name', 'unknown')) lines = {} branches = {} for line in cls.findall('lines/line'): line_num = int(line.get('number', 0)) hit_count = int(line.get('hits', 0)) lines[line_num] = hit_count # Branch info branch = line.get('branch', 'false') if branch == 'true': condition_coverage = line.get('condition-coverage', '0% (0/0)') # Parse "(covered/total)" if '(' in condition_coverage: branch_info = condition_coverage.split('(')[1].split(')')[0] covered, total = map(int, branch_info.split('/')) branches[f"{line_num}:branch"] = covered files[filename] = { 'lines': lines, 'functions': {}, 'branches': branches } self.coverage_data = files return files except ET.ParseError as e: raise ValueError(f"Invalid XML coverage report: {e}") def calculate_summary(self) -> Dict[str, Any]: """ Calculate overall coverage summary. Returns: Summary with line, branch, and function coverage percentages """ total_lines = 0 covered_lines = 0 total_branches = 0 covered_branches = 0 total_functions = 0 covered_functions = 0 for file_path, file_data in self.coverage_data.items(): # Lines for line_num, hit_count in file_data.get('lines', {}).items(): total_lines += 1 if hit_count > 0: covered_lines += 1 # Branches for branch_id, hit_count in file_data.get('branches', {}).items(): total_branches += 1 if hit_count > 0: covered_branches += 1 # Functions for func_name, hit_count in file_data.get('functions', {}).items(): total_functions += 1 if hit_count > 0: covered_functions += 1 summary = { 'line_coverage': self._safe_percentage(covered_lines, total_lines), 'branch_coverage': self._safe_percentage(covered_branches, total_branches), 'function_coverage': self._safe_percentage(covered_functions, total_functions), 'total_lines': total_lines, 'covered_lines': covered_lines, 'total_branches': total_branches, 'covered_branches': covered_branches, 'total_functions': total_functions, 'covered_functions': covered_functions } self.summary = summary return summary def _safe_percentage(self, covered: int, total: int) -> float: """Safely calculate percentage.""" if total == 0: return 0.0 return round((covered / total) * 100, 2) def identify_gaps(self, threshold: float = 80.0) -> List[Dict[str, Any]]: """ Identify coverage gaps below threshold. Args: threshold: Minimum acceptable coverage percentage Returns: List of files with coverage gaps """ gaps = [] for file_path, file_data in self.coverage_data.items(): file_gaps = self._analyze_file_gaps(file_path, file_data, threshold) if file_gaps: gaps.append(file_gaps) self.gaps = gaps return gaps def _analyze_file_gaps( self, file_path: str, file_data: Dict[str, Any], threshold: float ) -> Optional[Dict[str, Any]]: """Analyze coverage gaps for a single file.""" lines = file_data.get('lines', {}) branches = file_data.get('branches', {}) functions = file_data.get('functions', {}) # Calculate file coverage total_lines = len(lines) covered_lines = sum(1 for hit in lines.values() if hit > 0) line_coverage = self._safe_percentage(covered_lines, total_lines) total_branches = len(branches) covered_branches = sum(1 for hit in branches.values() if hit > 0) branch_coverage = self._safe_percentage(covered_branches, total_branches) # Find uncovered lines uncovered_lines = [line_num for line_num, hit in lines.items() if hit == 0] uncovered_branches = [branch_id for branch_id, hit in branches.items() if hit == 0] # Only report if below threshold if line_coverage < threshold or branch_coverage < threshold: return { 'file': file_path, 'line_coverage': line_coverage, 'branch_coverage': branch_coverage, 'uncovered_lines': sorted(uncovered_lines), 'uncovered_branches': uncovered_branches, 'priority': self._calculate_priority(line_coverage, branch_coverage, threshold) } return None def _calculate_priority( self, line_coverage: float, branch_coverage: float, threshold: float ) -> str: """Calculate priority based on coverage gap severity.""" gap = threshold - min(line_coverage, branch_coverage) if gap >= 40: return 'P0' # Critical - less than 40% coverage elif gap >= 20: return 'P1' # Important - 60-80% coverage else: return 'P2' # Nice to have - 80%+ coverage def get_file_coverage(self, file_path: str) -> Dict[str, Any]: """ Get detailed coverage information for a specific file. Args: file_path: Path to file Returns: Detailed coverage data for file """ if file_path not in self.coverage_data: return {} file_data = self.coverage_data[file_path] lines = file_data.get('lines', {}) branches = file_data.get('branches', {}) functions = file_data.get('functions', {}) total_lines = len(lines) covered_lines = sum(1 for hit in lines.values() if hit > 0) total_branches = len(branches) covered_branches = sum(1 for hit in branches.values() if hit > 0) total_functions = len(functions) covered_functions = sum(1 for hit in functions.values() if hit > 0) return { 'file': file_path, 'line_coverage': self._safe_percentage(covered_lines, total_lines), 'branch_coverage': self._safe_percentage(covered_branches, total_branches), 'function_coverage': self._safe_percentage(covered_functions, total_functions), 'lines': lines, 'branches': branches, 'functions': functions } def generate_recommendations(self) -> List[Dict[str, Any]]: """ Generate prioritized recommendations for improving coverage. Returns: List of recommendations with priority and actions """ recommendations = [] # Check overall coverage summary = self.summary or self.calculate_summary() if summary['line_coverage'] < 80: recommendations.append({ 'priority': 'P0', 'type': 'overall_coverage', 'message': f"Overall line coverage ({summary['line_coverage']}%) is below 80% threshold", 'action': 'Focus on adding tests for critical paths and business logic', 'impact': 'high' }) if summary['branch_coverage'] < 70: recommendations.append({ 'priority': 'P0', 'type': 'branch_coverage', 'message': f"Branch coverage ({summary['branch_coverage']}%) is below 70% threshold", 'action': 'Add tests for conditional logic and error handling paths', 'impact': 'high' }) # File-specific recommendations for gap in self.gaps: if gap['priority'] == 'P0': recommendations.append({ 'priority': 'P0', 'type': 'file_coverage', 'file': gap['file'], 'message': f"Critical coverage gap in {gap['file']}", 'action': f"Add tests for lines: {gap['uncovered_lines'][:10]}", 'impact': 'high' }) # Sort by priority priority_order = {'P0': 0, 'P1': 1, 'P2': 2} recommendations.sort(key=lambda x: priority_order.get(x['priority'], 3)) return recommendations def detect_format(self, content: str) -> str: """ Automatically detect coverage report format. Args: content: Raw coverage report content Returns: Detected format (lcov, json, xml) """ content_stripped = content.strip() # Check for LCOV format if content_stripped.startswith('TN:') or 'SF:' in content_stripped[:100]: return CoverageFormat.LCOV # Check for JSON format if content_stripped.startswith('{') or content_stripped.startswith('['): try: json.loads(content_stripped) return CoverageFormat.JSON except: pass # Check for XML format if content_stripped.startswith(' List[Any]: """ Generate boundary values for testing. Args: data_type: Type of data (int, string, array, date, etc.) constraints: Constraints like min, max, length Returns: List of boundary values """ constraints = constraints or {} if data_type == "int": return self._integer_boundaries(constraints) elif data_type == "string": return self._string_boundaries(constraints) elif data_type == "array": return self._array_boundaries(constraints) elif data_type == "date": return self._date_boundaries(constraints) elif data_type == "email": return self._email_boundaries() elif data_type == "url": return self._url_boundaries() else: return [] def _integer_boundaries(self, constraints: Dict[str, Any]) -> List[int]: """Generate integer boundary values.""" min_val = constraints.get('min', 0) max_val = constraints.get('max', 100) boundaries = [ min_val, # Minimum min_val + 1, # Just above minimum max_val - 1, # Just below maximum max_val, # Maximum ] # Add special values if min_val <= 0 <= max_val: boundaries.append(0) # Zero if min_val < 0: boundaries.append(-1) # Negative return sorted(set(boundaries)) def _string_boundaries(self, constraints: Dict[str, Any]) -> List[str]: """Generate string boundary values.""" min_len = constraints.get('min_length', 0) max_len = constraints.get('max_length', 100) boundaries = [ "", # Empty string "a" * min_len, # Minimum length "a" * (min_len + 1) if min_len < max_len else "", # Just above minimum "a" * (max_len - 1) if max_len > 1 else "a", # Just below maximum "a" * max_len, # Maximum length "a" * (max_len + 1), # Exceeds maximum (invalid) ] # Add special characters if max_len >= 10: boundaries.append("test@#$%^&*()") # Special characters boundaries.append("unicode: 你好") # Unicode return [b for b in boundaries if b is not None] def _array_boundaries(self, constraints: Dict[str, Any]) -> List[List[Any]]: """Generate array boundary values.""" min_size = constraints.get('min_size', 0) max_size = constraints.get('max_size', 10) boundaries = [ [], # Empty array [1] * min_size, # Minimum size [1] * max_size, # Maximum size [1] * (max_size + 1), # Exceeds maximum (invalid) ] return boundaries def _date_boundaries(self, constraints: Dict[str, Any]) -> List[str]: """Generate date boundary values.""" return [ "1900-01-01", # Very old date "1970-01-01", # Unix epoch "2000-01-01", # Y2K "2025-11-05", # Today (example) "2099-12-31", # Far future "invalid-date", # Invalid format ] def _email_boundaries(self) -> List[str]: """Generate email boundary values.""" return [ "valid@example.com", # Valid "user.name+tag@example.co.uk", # Valid with special chars "invalid", # Missing @ "@example.com", # Missing local part "user@", # Missing domain "user@.com", # Invalid domain "", # Empty ] def _url_boundaries(self) -> List[str]: """Generate URL boundary values.""" return [ "https://example.com", # Valid HTTPS "http://example.com", # Valid HTTP "ftp://example.com", # Different protocol "//example.com", # Protocol-relative "example.com", # Missing protocol "", # Empty "not a url", # Invalid ] def generate_edge_cases( self, scenario: str, context: Optional[Dict[str, Any]] = None ) -> List[Dict[str, Any]]: """ Generate edge case test scenarios. Args: scenario: Type of scenario (auth, payment, form, api, etc.) context: Additional context for scenario Returns: List of edge case test scenarios """ if scenario == "auth": return self._auth_edge_cases() elif scenario == "payment": return self._payment_edge_cases() elif scenario == "form": return self._form_edge_cases(context or {}) elif scenario == "api": return self._api_edge_cases() elif scenario == "file_upload": return self._file_upload_edge_cases() else: return [] def _auth_edge_cases(self) -> List[Dict[str, Any]]: """Generate authentication edge cases.""" return [ { 'name': 'empty_credentials', 'input': {'username': '', 'password': ''}, 'expected': 'validation_error' }, { 'name': 'sql_injection_attempt', 'input': {'username': "admin' OR '1'='1", 'password': 'password'}, 'expected': 'authentication_failed' }, { 'name': 'very_long_password', 'input': {'username': 'user', 'password': 'a' * 1000}, 'expected': 'validation_error_or_success' }, { 'name': 'special_chars_username', 'input': {'username': 'user@#$%', 'password': 'password'}, 'expected': 'depends_on_validation' }, { 'name': 'unicode_credentials', 'input': {'username': '用户', 'password': 'пароль'}, 'expected': 'should_handle_unicode' } ] def _payment_edge_cases(self) -> List[Dict[str, Any]]: """Generate payment processing edge cases.""" return [ { 'name': 'zero_amount', 'input': {'amount': 0, 'currency': 'USD'}, 'expected': 'validation_error' }, { 'name': 'negative_amount', 'input': {'amount': -10, 'currency': 'USD'}, 'expected': 'validation_error' }, { 'name': 'very_large_amount', 'input': {'amount': 999999999.99, 'currency': 'USD'}, 'expected': 'should_handle_or_reject' }, { 'name': 'precision_test', 'input': {'amount': 10.999, 'currency': 'USD'}, 'expected': 'should_round_to_10.99' }, { 'name': 'invalid_currency', 'input': {'amount': 10, 'currency': 'XXX'}, 'expected': 'validation_error' } ] def _form_edge_cases(self, context: Dict[str, Any]) -> List[Dict[str, Any]]: """Generate form validation edge cases.""" fields = context.get('fields', []) edge_cases = [] for field in fields: field_name = field.get('name', 'field') field_type = field.get('type', 'text') edge_cases.append({ 'name': f'{field_name}_empty', 'input': {field_name: ''}, 'expected': 'validation_error_if_required' }) if field_type in ['text', 'email', 'password']: edge_cases.append({ 'name': f'{field_name}_very_long', 'input': {field_name: 'a' * 1000}, 'expected': 'validation_error_or_truncate' }) return edge_cases def _api_edge_cases(self) -> List[Dict[str, Any]]: """Generate API edge cases.""" return [ { 'name': 'missing_required_field', 'request': {'optional_field': 'value'}, 'expected': 400 }, { 'name': 'invalid_json', 'request': 'not valid json{', 'expected': 400 }, { 'name': 'empty_body', 'request': {}, 'expected': 400 }, { 'name': 'very_large_payload', 'request': {'data': 'x' * 1000000}, 'expected': '413_or_400' }, { 'name': 'invalid_method', 'method': 'INVALID', 'expected': 405 } ] def _file_upload_edge_cases(self) -> List[Dict[str, Any]]: """Generate file upload edge cases.""" return [ { 'name': 'empty_file', 'file': {'name': 'test.txt', 'size': 0}, 'expected': 'validation_error' }, { 'name': 'very_large_file', 'file': {'name': 'test.txt', 'size': 1000000000}, 'expected': 'size_limit_error' }, { 'name': 'invalid_extension', 'file': {'name': 'test.exe', 'size': 1000}, 'expected': 'validation_error' }, { 'name': 'no_extension', 'file': {'name': 'testfile', 'size': 1000}, 'expected': 'depends_on_validation' }, { 'name': 'special_chars_filename', 'file': {'name': 'test@#$%.txt', 'size': 1000}, 'expected': 'should_sanitize' } ] def generate_mock_data( self, schema: Dict[str, Any], count: int = 1 ) -> List[Dict[str, Any]]: """ Generate mock data based on schema. Args: schema: Schema definition with field types count: Number of mock objects to generate Returns: List of mock data objects """ mock_objects = [] for _ in range(count): mock_obj = {} for field_name, field_def in schema.items(): field_type = field_def.get('type', 'string') mock_obj[field_name] = self._generate_field_value(field_type, field_def) mock_objects.append(mock_obj) return mock_objects def _generate_field_value(self, field_type: str, field_def: Dict[str, Any]) -> Any: """Generate value for a single field.""" if field_type == "string": options = field_def.get('options') if options: return random.choice(options) return f"test_string_{random.randint(1, 1000)}" elif field_type == "int": min_val = field_def.get('min', 0) max_val = field_def.get('max', 100) return random.randint(min_val, max_val) elif field_type == "float": min_val = field_def.get('min', 0.0) max_val = field_def.get('max', 100.0) return round(random.uniform(min_val, max_val), 2) elif field_type == "bool": return random.choice([True, False]) elif field_type == "email": return f"user{random.randint(1, 1000)}@example.com" elif field_type == "date": return f"2025-{random.randint(1, 12):02d}-{random.randint(1, 28):02d}" elif field_type == "array": item_type = field_def.get('items', {}).get('type', 'string') size = random.randint(1, 5) return [self._generate_field_value(item_type, field_def.get('items', {})) for _ in range(size)] else: return None def generate_fixture_file( self, fixture_name: str, data: Any, format: str = "json" ) -> str: """ Generate fixture file content. Args: fixture_name: Name of fixture data: Fixture data format: Output format (json, yaml, python) Returns: Fixture file content as string """ if format == "json": return json.dumps(data, indent=2) elif format == "python": return f"""# {fixture_name} fixture {fixture_name.upper()} = {repr(data)} """ elif format == "yaml": # Simple YAML generation (for basic structures) return self._dict_to_yaml(data) else: return str(data) def _dict_to_yaml(self, data: Any, indent: int = 0) -> str: """Simple YAML generator.""" lines = [] indent_str = " " * indent if isinstance(data, dict): for key, value in data.items(): if isinstance(value, (dict, list)): lines.append(f"{indent_str}{key}:") lines.append(self._dict_to_yaml(value, indent + 1)) else: lines.append(f"{indent_str}{key}: {value}") elif isinstance(data, list): for item in data: if isinstance(item, dict): lines.append(f"{indent_str}-") lines.append(self._dict_to_yaml(item, indent + 1)) else: lines.append(f"{indent_str}- {item}") else: return str(data) return "\n".join(lines) FILE:scripts/format_detector.py """ Format detection module. Automatically detects programming language, testing framework, and file formats. """ from typing import Dict, List, Any, Optional, Tuple import re class FormatDetector: """Detect language, framework, and file formats automatically.""" def __init__(self): """Initialize format detector.""" self.detected_language = None self.detected_framework = None def detect_language(self, code: str) -> str: """ Detect programming language from code. Args: code: Source code Returns: Detected language (typescript, javascript, python, java, unknown) """ # TypeScript patterns if self._is_typescript(code): self.detected_language = "typescript" return "typescript" # JavaScript patterns if self._is_javascript(code): self.detected_language = "javascript" return "javascript" # Python patterns if self._is_python(code): self.detected_language = "python" return "python" # Java patterns if self._is_java(code): self.detected_language = "java" return "java" self.detected_language = "unknown" return "unknown" def _is_typescript(self, code: str) -> bool: """Check if code is TypeScript.""" ts_patterns = [ r'\binterface\s+\w+', # interface definitions r':\s*\w+\s*[=;]', # type annotations r'\btype\s+\w+\s*=', # type aliases r'<\w+>', # generic types r'import.*from.*[\'"]', # ES6 imports with types ] # Must have multiple TypeScript-specific patterns matches = sum(1 for pattern in ts_patterns if re.search(pattern, code)) return matches >= 2 def _is_javascript(self, code: str) -> bool: """Check if code is JavaScript.""" js_patterns = [ r'\bconst\s+\w+', # const declarations r'\blet\s+\w+', # let declarations r'=>', # arrow functions r'function\s+\w+', # function declarations r'require\([\'"]', # CommonJS require ] matches = sum(1 for pattern in js_patterns if re.search(pattern, code)) return matches >= 2 def _is_python(self, code: str) -> bool: """Check if code is Python.""" py_patterns = [ r'\bdef\s+\w+', # function definitions r'\bclass\s+\w+', # class definitions r'import\s+\w+', # import statements r'from\s+\w+\s+import', # from imports r'^\s*#.*$', # Python comments r':\s*$', # Python colons ] matches = sum(1 for pattern in py_patterns if re.search(pattern, code, re.MULTILINE)) return matches >= 3 def _is_java(self, code: str) -> bool: """Check if code is Java.""" java_patterns = [ r'\bpublic\s+class', # public class r'\bprivate\s+\w+', # private members r'\bpublic\s+\w+\s+\w+\s*\(', # public methods r'import\s+java\.', # Java imports r'\bvoid\s+\w+\s*\(', # void methods ] matches = sum(1 for pattern in java_patterns if re.search(pattern, code)) return matches >= 2 def detect_test_framework(self, code: str) -> str: """ Detect testing framework from test code. Args: code: Test code Returns: Detected framework (jest, vitest, pytest, junit, mocha, unknown) """ # Jest patterns if 'from \'@jest/globals\'' in code or '@jest/' in code: self.detected_framework = "jest" return "jest" # Vitest patterns if 'from \'vitest\'' in code or 'import { vi }' in code: self.detected_framework = "vitest" return "vitest" # Pytest patterns if 'import pytest' in code or 'def test_' in code: self.detected_framework = "pytest" return "pytest" # Unittest patterns if 'import unittest' in code and 'unittest.TestCase' in code: self.detected_framework = "unittest" return "unittest" # JUnit patterns if '@Test' in code and 'import org.junit' in code: self.detected_framework = "junit" return "junit" # Mocha patterns if 'describe(' in code and 'it(' in code: self.detected_framework = "mocha" return "mocha" self.detected_framework = "unknown" return "unknown" def detect_coverage_format(self, content: str) -> str: """ Detect coverage report format. Args: content: Coverage report content Returns: Format type (lcov, json, xml, unknown) """ content_stripped = content.strip() # LCOV format if content_stripped.startswith('TN:') or 'SF:' in content_stripped[:200]: return "lcov" # JSON format if content_stripped.startswith('{'): try: import json json.loads(content_stripped) return "json" except: pass # XML format if content_stripped.startswith(' Dict[str, Any]: """ Detect input format and extract relevant information. Args: input_data: Input data (could be code, coverage report, etc.) Returns: Detection results with format, language, framework """ result = { 'format': 'unknown', 'language': 'unknown', 'framework': 'unknown', 'content_type': 'unknown' } # Detect if it's a coverage report coverage_format = self.detect_coverage_format(input_data) if coverage_format != "unknown": result['format'] = coverage_format result['content_type'] = 'coverage_report' return result # Detect if it's source code language = self.detect_language(input_data) if language != "unknown": result['language'] = language result['content_type'] = 'source_code' # Detect if it's test code framework = self.detect_test_framework(input_data) if framework != "unknown": result['framework'] = framework result['content_type'] = 'test_code' return result def extract_file_info(self, file_path: str) -> Dict[str, str]: """ Extract information from file path. Args: file_path: Path to file Returns: File information (extension, likely language, likely purpose) """ import os file_name = os.path.basename(file_path) file_ext = os.path.splitext(file_name)[1].lower() # Extension to language mapping ext_to_lang = { '.ts': 'typescript', '.tsx': 'typescript', '.js': 'javascript', '.jsx': 'javascript', '.py': 'python', '.java': 'java', '.kt': 'kotlin', '.go': 'go', '.rs': 'rust', } # Test file patterns is_test = any(pattern in file_name.lower() for pattern in ['test', 'spec', '_test.', '.test.']) return { 'file_name': file_name, 'extension': file_ext, 'language': ext_to_lang.get(file_ext, 'unknown'), 'is_test': is_test, 'purpose': 'test' if is_test else 'source' } def suggest_test_file_name(self, source_file: str, framework: str) -> str: """ Suggest test file name for source file. Args: source_file: Source file path framework: Testing framework Returns: Suggested test file name """ import os base_name = os.path.splitext(os.path.basename(source_file))[0] ext = os.path.splitext(source_file)[1] if framework in ['jest', 'vitest', 'mocha']: return f"{base_name}.test{ext}" elif framework in ['pytest', 'unittest']: return f"test_{base_name}.py" elif framework in ['junit', 'testng']: return f"{base_name.capitalize()}Test.java" else: return f"{base_name}_test{ext}" def identify_test_patterns(self, code: str) -> List[str]: """ Identify test patterns in code. Args: code: Test code Returns: List of identified patterns (AAA, Given-When-Then, etc.) """ patterns = [] # Arrange-Act-Assert pattern if any(comment in code.lower() for comment in ['// arrange', '# arrange', '// act', '# act']): patterns.append('AAA (Arrange-Act-Assert)') # Given-When-Then pattern if any(comment in code.lower() for comment in ['given', 'when', 'then']): patterns.append('Given-When-Then') # Setup/Teardown pattern if any(keyword in code for keyword in ['beforeEach', 'afterEach', 'setUp', 'tearDown']): patterns.append('Setup-Teardown') # Mocking pattern if any(keyword in code.lower() for keyword in ['mock', 'stub', 'spy']): patterns.append('Mocking/Stubbing') # Parameterized tests if any(keyword in code for keyword in ['@pytest.mark.parametrize', 'test.each', '@ParameterizedTest']): patterns.append('Parameterized Tests') return patterns if patterns else ['No specific pattern detected'] def analyze_project_structure(self, file_paths: List[str]) -> Dict[str, Any]: """ Analyze project structure from file paths. Args: file_paths: List of file paths in project Returns: Project structure analysis """ languages = {} test_frameworks = [] source_files = [] test_files = [] for file_path in file_paths: file_info = self.extract_file_info(file_path) # Count languages lang = file_info['language'] if lang != 'unknown': languages[lang] = languages.get(lang, 0) + 1 # Categorize files if file_info['is_test']: test_files.append(file_path) else: source_files.append(file_path) # Determine primary language primary_language = max(languages.items(), key=lambda x: x[1])[0] if languages else 'unknown' return { 'primary_language': primary_language, 'languages': languages, 'source_file_count': len(source_files), 'test_file_count': len(test_files), 'test_ratio': len(test_files) / len(source_files) if source_files else 0, 'suggested_framework': self._suggest_framework(primary_language) } def _suggest_framework(self, language: str) -> str: """Suggest testing framework based on language.""" framework_map = { 'typescript': 'jest or vitest', 'javascript': 'jest or mocha', 'python': 'pytest', 'java': 'junit', 'kotlin': 'junit', 'go': 'testing package', 'rust': 'cargo test', } return framework_map.get(language, 'unknown') def detect_environment(self) -> Dict[str, str]: """ Detect execution environment (CLI, Desktop, API). Returns: Environment information """ # This is a placeholder - actual detection would use environment variables # or other runtime checks return { 'environment': 'cli', # Could be 'desktop', 'api' 'output_preference': 'terminal-friendly' # Could be 'rich-markdown', 'json' } FILE:scripts/framework_adapter.py """ Framework adapter module. Provides multi-framework support with adapters for Jest, Pytest, JUnit, Vitest, and more. Handles framework-specific patterns, imports, and test structure. """ from typing import Dict, List, Any, Optional from enum import Enum class Framework(Enum): """Supported testing frameworks.""" JEST = "jest" VITEST = "vitest" PYTEST = "pytest" UNITTEST = "unittest" JUNIT = "junit" TESTNG = "testng" MOCHA = "mocha" JASMINE = "jasmine" class Language(Enum): """Supported programming languages.""" TYPESCRIPT = "typescript" JAVASCRIPT = "javascript" PYTHON = "python" JAVA = "java" class FrameworkAdapter: """Adapter for multiple testing frameworks.""" def __init__(self, framework: Framework, language: Language): """ Initialize framework adapter. Args: framework: Testing framework language: Programming language """ self.framework = framework self.language = language def generate_imports(self) -> str: """Generate framework-specific imports.""" if self.framework == Framework.JEST: return self._jest_imports() elif self.framework == Framework.VITEST: return self._vitest_imports() elif self.framework == Framework.PYTEST: return self._pytest_imports() elif self.framework == Framework.UNITTEST: return self._unittest_imports() elif self.framework == Framework.JUNIT: return self._junit_imports() elif self.framework == Framework.TESTNG: return self._testng_imports() elif self.framework == Framework.MOCHA: return self._mocha_imports() else: return "" def _jest_imports(self) -> str: """Generate Jest imports.""" return """import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';""" def _vitest_imports(self) -> str: """Generate Vitest imports.""" return """import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';""" def _pytest_imports(self) -> str: """Generate Pytest imports.""" return """import pytest""" def _unittest_imports(self) -> str: """Generate unittest imports.""" return """import unittest""" def _junit_imports(self) -> str: """Generate JUnit imports.""" return """import org.junit.jupiter.api.Test; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.AfterEach; import static org.junit.jupiter.api.Assertions.*;""" def _testng_imports(self) -> str: """Generate TestNG imports.""" return """import org.testng.annotations.Test; import org.testng.annotations.BeforeMethod; import org.testng.annotations.AfterMethod; import static org.testng.Assert.*;""" def _mocha_imports(self) -> str: """Generate Mocha imports.""" return """import { describe, it, beforeEach, afterEach } from 'mocha'; import { expect } from 'chai';""" def generate_test_suite_wrapper( self, suite_name: str, test_content: str ) -> str: """ Wrap test content in framework-specific suite structure. Args: suite_name: Name of test suite test_content: Test functions/methods Returns: Complete test suite code """ if self.framework in [Framework.JEST, Framework.VITEST, Framework.MOCHA]: return f"""describe('{suite_name}', () => {{ {self._indent(test_content, 2)} }});""" elif self.framework == Framework.PYTEST: return f"""class Test{self._to_class_name(suite_name)}: \"\"\"Test suite for {suite_name}.\"\"\" {self._indent(test_content, 4)}""" elif self.framework == Framework.UNITTEST: return f"""class Test{self._to_class_name(suite_name)}(unittest.TestCase): \"\"\"Test suite for {suite_name}.\"\"\" {self._indent(test_content, 4)}""" elif self.framework in [Framework.JUNIT, Framework.TESTNG]: return f"""public class {self._to_class_name(suite_name)}Test {{ {self._indent(test_content, 4)} }}""" return test_content def generate_test_function( self, test_name: str, test_body: str, description: str = "" ) -> str: """ Generate framework-specific test function. Args: test_name: Name of test test_body: Test body code description: Test description Returns: Complete test function """ if self.framework == Framework.JEST: return self._jest_test(test_name, test_body, description) elif self.framework == Framework.VITEST: return self._vitest_test(test_name, test_body, description) elif self.framework == Framework.PYTEST: return self._pytest_test(test_name, test_body, description) elif self.framework == Framework.UNITTEST: return self._unittest_test(test_name, test_body, description) elif self.framework == Framework.JUNIT: return self._junit_test(test_name, test_body, description) elif self.framework == Framework.TESTNG: return self._testng_test(test_name, test_body, description) elif self.framework == Framework.MOCHA: return self._mocha_test(test_name, test_body, description) else: return "" def _jest_test(self, test_name: str, test_body: str, description: str) -> str: """Generate Jest test.""" return f"""it('{test_name}', () => {{ // {description} {self._indent(test_body, 2)} }});""" def _vitest_test(self, test_name: str, test_body: str, description: str) -> str: """Generate Vitest test.""" return f"""it('{test_name}', () => {{ // {description} {self._indent(test_body, 2)} }});""" def _pytest_test(self, test_name: str, test_body: str, description: str) -> str: """Generate Pytest test.""" func_name = test_name.replace(' ', '_').replace('-', '_') return f"""def test_{func_name}(self): \"\"\" {description or test_name} \"\"\" {self._indent(test_body, 4)}""" def _unittest_test(self, test_name: str, test_body: str, description: str) -> str: """Generate unittest test.""" func_name = self._to_camel_case(test_name) return f"""def test_{func_name}(self): \"\"\" {description or test_name} \"\"\" {self._indent(test_body, 4)}""" def _junit_test(self, test_name: str, test_body: str, description: str) -> str: """Generate JUnit test.""" method_name = self._to_camel_case(test_name) return f"""@Test public void test{method_name}() {{ // {description} {self._indent(test_body, 4)} }}""" def _testng_test(self, test_name: str, test_body: str, description: str) -> str: """Generate TestNG test.""" method_name = self._to_camel_case(test_name) return f"""@Test public void test{method_name}() {{ // {description} {self._indent(test_body, 4)} }}""" def _mocha_test(self, test_name: str, test_body: str, description: str) -> str: """Generate Mocha test.""" return f"""it('{test_name}', () => {{ // {description} {self._indent(test_body, 2)} }});""" def generate_assertion( self, actual: str, expected: str, assertion_type: str = "equals" ) -> str: """ Generate framework-specific assertion. Args: actual: Actual value expression expected: Expected value expression assertion_type: Type of assertion (equals, not_equals, true, false, throws) Returns: Assertion statement """ if self.framework in [Framework.JEST, Framework.VITEST]: return self._jest_assertion(actual, expected, assertion_type) elif self.framework in [Framework.PYTEST, Framework.UNITTEST]: return self._python_assertion(actual, expected, assertion_type) elif self.framework in [Framework.JUNIT, Framework.TESTNG]: return self._java_assertion(actual, expected, assertion_type) elif self.framework == Framework.MOCHA: return self._chai_assertion(actual, expected, assertion_type) else: return f"assert {actual} == {expected}" def _jest_assertion(self, actual: str, expected: str, assertion_type: str) -> str: """Generate Jest assertion.""" if assertion_type == "equals": return f"expect({actual}).toBe({expected});" elif assertion_type == "not_equals": return f"expect({actual}).not.toBe({expected});" elif assertion_type == "true": return f"expect({actual}).toBe(true);" elif assertion_type == "false": return f"expect({actual}).toBe(false);" elif assertion_type == "throws": return f"expect(() => {actual}).toThrow();" else: return f"expect({actual}).toBe({expected});" def _python_assertion(self, actual: str, expected: str, assertion_type: str) -> str: """Generate Python assertion.""" if assertion_type == "equals": return f"assert {actual} == {expected}" elif assertion_type == "not_equals": return f"assert {actual} != {expected}" elif assertion_type == "true": return f"assert {actual} is True" elif assertion_type == "false": return f"assert {actual} is False" elif assertion_type == "throws": return f"with pytest.raises(Exception):\n {actual}" else: return f"assert {actual} == {expected}" def _java_assertion(self, actual: str, expected: str, assertion_type: str) -> str: """Generate Java assertion.""" if assertion_type == "equals": return f"assertEquals({expected}, {actual});" elif assertion_type == "not_equals": return f"assertNotEquals({expected}, {actual});" elif assertion_type == "true": return f"assertTrue({actual});" elif assertion_type == "false": return f"assertFalse({actual});" elif assertion_type == "throws": return f"assertThrows(Exception.class, () -> {actual});" else: return f"assertEquals({expected}, {actual});" def _chai_assertion(self, actual: str, expected: str, assertion_type: str) -> str: """Generate Chai assertion.""" if assertion_type == "equals": return f"expect({actual}).to.equal({expected});" elif assertion_type == "not_equals": return f"expect({actual}).to.not.equal({expected});" elif assertion_type == "true": return f"expect({actual}).to.be.true;" elif assertion_type == "false": return f"expect({actual}).to.be.false;" elif assertion_type == "throws": return f"expect(() => {actual}).to.throw();" else: return f"expect({actual}).to.equal({expected});" def generate_setup_teardown( self, setup_code: str = "", teardown_code: str = "" ) -> str: """Generate setup and teardown hooks.""" result = [] if self.framework in [Framework.JEST, Framework.VITEST, Framework.MOCHA]: if setup_code: result.append(f"""beforeEach(() => {{ {self._indent(setup_code, 2)} }});""") if teardown_code: result.append(f"""afterEach(() => {{ {self._indent(teardown_code, 2)} }});""") elif self.framework == Framework.PYTEST: if setup_code: result.append(f"""@pytest.fixture(autouse=True) def setup_method(self): {self._indent(setup_code, 4)} yield""") if teardown_code: result.append(f""" {self._indent(teardown_code, 4)}""") elif self.framework == Framework.UNITTEST: if setup_code: result.append(f"""def setUp(self): {self._indent(setup_code, 4)}""") if teardown_code: result.append(f"""def tearDown(self): {self._indent(teardown_code, 4)}""") elif self.framework in [Framework.JUNIT, Framework.TESTNG]: annotation = "@BeforeEach" if self.framework == Framework.JUNIT else "@BeforeMethod" if setup_code: result.append(f"""{annotation} public void setUp() {{ {self._indent(setup_code, 4)} }}""") annotation = "@AfterEach" if self.framework == Framework.JUNIT else "@AfterMethod" if teardown_code: result.append(f"""{annotation} public void tearDown() {{ {self._indent(teardown_code, 4)} }}""") return "\n\n".join(result) def _indent(self, text: str, spaces: int) -> str: """Indent text by number of spaces.""" indent = " " * spaces lines = text.split('\n') return '\n'.join(indent + line if line.strip() else line for line in lines) def _to_camel_case(self, text: str) -> str: """Convert text to camelCase.""" words = text.replace('-', ' ').replace('_', ' ').split() if not words: return text return words[0].lower() + ''.join(word.capitalize() for word in words[1:]) def _to_class_name(self, text: str) -> str: """Convert text to ClassName.""" words = text.replace('-', ' ').replace('_', ' ').split() return ''.join(word.capitalize() for word in words) def detect_framework(self, code: str) -> Optional[Framework]: """ Auto-detect testing framework from code. Args: code: Test code Returns: Detected framework or None """ # Jest patterns if 'from \'@jest/globals\'' in code or '@jest/' in code: return Framework.JEST # Vitest patterns if 'from \'vitest\'' in code or 'import { vi }' in code: return Framework.VITEST # Pytest patterns if 'import pytest' in code or 'def test_' in code and 'pytest.fixture' in code: return Framework.PYTEST # Unittest patterns if 'import unittest' in code and 'unittest.TestCase' in code: return Framework.UNITTEST # JUnit patterns if '@Test' in code and 'import org.junit' in code: return Framework.JUNIT # TestNG patterns if '@Test' in code and 'import org.testng' in code: return Framework.TESTNG # Mocha patterns if 'from \'mocha\'' in code or ('describe(' in code and 'from \'chai\'' in code): return Framework.MOCHA return None FILE:scripts/metrics_calculator.py """ Metrics calculation module. Calculate comprehensive test and code quality metrics including complexity, test quality scoring, and test execution analysis. """ from typing import Dict, List, Any, Optional import re class MetricsCalculator: """Calculate comprehensive test and code quality metrics.""" def __init__(self): """Initialize metrics calculator.""" self.metrics = {} def calculate_all_metrics( self, source_code: str, test_code: str, coverage_data: Optional[Dict[str, Any]] = None, execution_data: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: """ Calculate all available metrics. Args: source_code: Source code to analyze test_code: Test code to analyze coverage_data: Coverage report data execution_data: Test execution results Returns: Complete metrics dictionary """ metrics = { 'complexity': self.calculate_complexity(source_code), 'test_quality': self.calculate_test_quality(test_code), 'coverage': coverage_data or {}, 'execution': execution_data or {} } self.metrics = metrics return metrics def calculate_complexity(self, code: str) -> Dict[str, Any]: """ Calculate code complexity metrics. Args: code: Source code to analyze Returns: Complexity metrics (cyclomatic, cognitive, testability score) """ cyclomatic = self._cyclomatic_complexity(code) cognitive = self._cognitive_complexity(code) testability = self._testability_score(code, cyclomatic) return { 'cyclomatic_complexity': cyclomatic, 'cognitive_complexity': cognitive, 'testability_score': testability, 'assessment': self._complexity_assessment(cyclomatic, cognitive) } def _cyclomatic_complexity(self, code: str) -> int: """ Calculate cyclomatic complexity (simplified). Counts decision points: if, for, while, case, catch, &&, || """ # Count decision points decision_points = 0 # Control flow keywords keywords = ['if', 'for', 'while', 'case', 'catch', 'except'] for keyword in keywords: # Use word boundaries to avoid matching substrings pattern = r'\b' + keyword + r'\b' decision_points += len(re.findall(pattern, code)) # Logical operators decision_points += len(re.findall(r'\&\&|\|\|', code)) # Base complexity is 1 return decision_points + 1 def _cognitive_complexity(self, code: str) -> int: """ Calculate cognitive complexity (simplified). Similar to cyclomatic but penalizes nesting and non-obvious flow. """ lines = code.split('\n') cognitive_score = 0 nesting_level = 0 for line in lines: stripped = line.strip() # Increase nesting level if any(keyword in stripped for keyword in ['if ', 'for ', 'while ', 'def ', 'function ', 'class ']): cognitive_score += (1 + nesting_level) if stripped.endswith(':') or stripped.endswith('{'): nesting_level += 1 # Decrease nesting level if stripped.startswith('}') or (stripped and not stripped.startswith(' ') and nesting_level > 0): nesting_level = max(0, nesting_level - 1) # Penalize complex conditions if '&&' in stripped or '||' in stripped: cognitive_score += 1 return cognitive_score def _testability_score(self, code: str, cyclomatic: int) -> float: """ Calculate testability score (0-100). Based on: - Complexity (lower is better) - Dependencies (fewer is better) - Pure functions (more is better) """ score = 100.0 # Penalize high complexity if cyclomatic > 10: score -= (cyclomatic - 10) * 5 elif cyclomatic > 5: score -= (cyclomatic - 5) * 2 # Penalize many dependencies imports = len(re.findall(r'import |require\(|from .* import', code)) if imports > 10: score -= (imports - 10) * 2 # Reward small functions functions = len(re.findall(r'def |function ', code)) lines = len(code.split('\n')) if functions > 0: avg_function_size = lines / functions if avg_function_size < 20: score += 10 elif avg_function_size > 50: score -= 10 return max(0.0, min(100.0, score)) def _complexity_assessment(self, cyclomatic: int, cognitive: int) -> str: """Generate complexity assessment.""" if cyclomatic <= 5 and cognitive <= 10: return "Low complexity - easy to test" elif cyclomatic <= 10 and cognitive <= 20: return "Medium complexity - moderately testable" elif cyclomatic <= 15 and cognitive <= 30: return "High complexity - challenging to test" else: return "Very high complexity - consider refactoring" def calculate_test_quality(self, test_code: str) -> Dict[str, Any]: """ Calculate test quality metrics. Args: test_code: Test code to analyze Returns: Test quality metrics """ assertions = self._count_assertions(test_code) test_functions = self._count_test_functions(test_code) isolation_score = self._isolation_score(test_code) naming_quality = self._naming_quality(test_code) test_smells = self._detect_test_smells(test_code) avg_assertions = assertions / test_functions if test_functions > 0 else 0 return { 'total_tests': test_functions, 'total_assertions': assertions, 'avg_assertions_per_test': round(avg_assertions, 2), 'isolation_score': isolation_score, 'naming_quality': naming_quality, 'test_smells': test_smells, 'quality_score': self._calculate_quality_score( avg_assertions, isolation_score, naming_quality, test_smells ) } def _count_assertions(self, test_code: str) -> int: """Count assertion statements.""" # Common assertion patterns patterns = [ r'\bassert[A-Z]\w*\(', # JUnit: assertTrue, assertEquals r'\bexpect\(', # Jest/Vitest: expect() r'\bassert\s+', # Python: assert r'\.should\.', # Chai: should r'\.to\.', # Chai: expect().to ] count = 0 for pattern in patterns: count += len(re.findall(pattern, test_code)) return count def _count_test_functions(self, test_code: str) -> int: """Count test functions.""" patterns = [ r'\btest_\w+', # Python: test_* r'\bit\(', # Jest/Mocha: it() r'\btest\(', # Jest: test() r'@Test', # JUnit: @Test r'\bdef test_', # Python def test_ ] count = 0 for pattern in patterns: count += len(re.findall(pattern, test_code)) return max(1, count) # At least 1 to avoid division by zero def _isolation_score(self, test_code: str) -> float: """ Calculate test isolation score (0-100). Higher score = better isolation (fewer shared dependencies) """ score = 100.0 # Penalize global state globals_used = len(re.findall(r'\bglobal\s+\w+', test_code)) score -= globals_used * 10 # Penalize shared setup without proper cleanup setup_count = len(re.findall(r'beforeAll|beforeEach|setUp', test_code)) cleanup_count = len(re.findall(r'afterAll|afterEach|tearDown', test_code)) if setup_count > cleanup_count: score -= (setup_count - cleanup_count) * 5 # Reward mocking mocks = len(re.findall(r'mock|stub|spy', test_code, re.IGNORECASE)) score += min(mocks * 2, 10) return max(0.0, min(100.0, score)) def _naming_quality(self, test_code: str) -> float: """ Calculate test naming quality score (0-100). Better names are descriptive and follow conventions. """ test_names = re.findall(r'(?:it|test|def test_)\s*\(?\s*["\']?([^"\')\n]+)', test_code) if not test_names: return 50.0 score = 0 for name in test_names: name_score = 0 # Check length (too short or too long is bad) if 20 <= len(name) <= 80: name_score += 30 elif 10 <= len(name) < 20 or 80 < len(name) <= 100: name_score += 15 # Check for descriptive words descriptive_words = ['should', 'when', 'given', 'returns', 'throws', 'handles'] if any(word in name.lower() for word in descriptive_words): name_score += 30 # Check for underscores or camelCase (not just letters) if '_' in name or re.search(r'[a-z][A-Z]', name): name_score += 20 # Avoid generic names generic = ['test1', 'test2', 'testit', 'mytest'] if name.lower() not in generic: name_score += 20 score += name_score return min(100.0, score / len(test_names)) def _detect_test_smells(self, test_code: str) -> List[Dict[str, str]]: """Detect common test smells.""" smells = [] # Test smell 1: No assertions if 'assert' not in test_code.lower() and 'expect' not in test_code.lower(): smells.append({ 'smell': 'missing_assertions', 'description': 'Tests without assertions', 'severity': 'high' }) # Test smell 2: Too many assertions test_count = self._count_test_functions(test_code) assertion_count = self._count_assertions(test_code) avg_assertions = assertion_count / test_count if test_count > 0 else 0 if avg_assertions > 5: smells.append({ 'smell': 'assertion_roulette', 'description': f'Too many assertions per test (avg: {avg_assertions:.1f})', 'severity': 'medium' }) # Test smell 3: Sleeps in tests if 'sleep' in test_code.lower() or 'wait' in test_code.lower(): smells.append({ 'smell': 'sleepy_test', 'description': 'Tests using sleep/wait (potential flakiness)', 'severity': 'high' }) # Test smell 4: Conditional logic in tests if re.search(r'\bif\s*\(', test_code): smells.append({ 'smell': 'conditional_test_logic', 'description': 'Tests contain conditional logic', 'severity': 'medium' }) return smells def _calculate_quality_score( self, avg_assertions: float, isolation: float, naming: float, smells: List[Dict[str, str]] ) -> float: """Calculate overall test quality score.""" score = 0.0 # Assertions (30 points) if 1 <= avg_assertions <= 3: score += 30 elif 0 < avg_assertions < 1 or 3 < avg_assertions <= 5: score += 20 else: score += 10 # Isolation (30 points) score += isolation * 0.3 # Naming (20 points) score += naming * 0.2 # Smells (20 points - deduct based on severity) smell_penalty = 0 for smell in smells: if smell['severity'] == 'high': smell_penalty += 10 elif smell['severity'] == 'medium': smell_penalty += 5 else: smell_penalty += 2 score = max(0, score - smell_penalty) return round(min(100.0, score), 2) def analyze_execution_metrics( self, execution_data: Dict[str, Any] ) -> Dict[str, Any]: """ Analyze test execution metrics. Args: execution_data: Test execution results with timing Returns: Execution analysis """ tests = execution_data.get('tests', []) if not tests: return {} # Calculate timing statistics timings = [test.get('duration', 0) for test in tests] total_time = sum(timings) avg_time = total_time / len(tests) if tests else 0 # Identify slow tests (>100ms for unit tests) slow_tests = [ test for test in tests if test.get('duration', 0) > 100 ] # Identify flaky tests (if failure history available) flaky_tests = [ test for test in tests if test.get('failure_rate', 0) > 0.1 # Failed >10% of time ] return { 'total_tests': len(tests), 'total_time_ms': round(total_time, 2), 'avg_time_ms': round(avg_time, 2), 'slow_tests': len(slow_tests), 'slow_test_details': slow_tests[:5], # Top 5 'flaky_tests': len(flaky_tests), 'flaky_test_details': flaky_tests, 'pass_rate': self._calculate_pass_rate(tests) } def _calculate_pass_rate(self, tests: List[Dict[str, Any]]) -> float: """Calculate test pass rate.""" if not tests: return 0.0 passed = sum(1 for test in tests if test.get('status') == 'passed') return round((passed / len(tests)) * 100, 2) def generate_metrics_summary(self) -> str: """Generate human-readable metrics summary.""" if not self.metrics: return "No metrics calculated yet." lines = ["# Test Metrics Summary\n"] # Complexity if 'complexity' in self.metrics: comp = self.metrics['complexity'] lines.append(f"## Code Complexity") lines.append(f"- Cyclomatic Complexity: {comp['cyclomatic_complexity']}") lines.append(f"- Cognitive Complexity: {comp['cognitive_complexity']}") lines.append(f"- Testability Score: {comp['testability_score']:.1f}/100") lines.append(f"- Assessment: {comp['assessment']}\n") # Test Quality if 'test_quality' in self.metrics: qual = self.metrics['test_quality'] lines.append(f"## Test Quality") lines.append(f"- Total Tests: {qual['total_tests']}") lines.append(f"- Assertions per Test: {qual['avg_assertions_per_test']}") lines.append(f"- Isolation Score: {qual['isolation_score']:.1f}/100") lines.append(f"- Naming Quality: {qual['naming_quality']:.1f}/100") lines.append(f"- Quality Score: {qual['quality_score']:.1f}/100\n") if qual['test_smells']: lines.append(f"### Test Smells Detected:") for smell in qual['test_smells']: lines.append(f"- {smell['description']} (severity: {smell['severity']})") lines.append("") return "\n".join(lines) FILE:scripts/output_formatter.py """ Output formatting module. Provides context-aware output formatting for different environments (Desktop, CLI, API). Implements progressive disclosure and token-efficient reporting. """ from typing import Dict, List, Any, Optional class OutputFormatter: """Format output based on environment and preferences.""" def __init__(self, environment: str = "cli", verbose: bool = False): """ Initialize output formatter. Args: environment: Target environment (desktop, cli, api) verbose: Whether to include detailed output """ self.environment = environment self.verbose = verbose def format_coverage_summary( self, summary: Dict[str, Any], detailed: bool = False ) -> str: """ Format coverage summary. Args: summary: Coverage summary data detailed: Whether to include detailed breakdown Returns: Formatted coverage summary """ if self.environment == "desktop": return self._format_coverage_markdown(summary, detailed) elif self.environment == "api": return self._format_coverage_json(summary) else: return self._format_coverage_terminal(summary, detailed) def _format_coverage_markdown(self, summary: Dict[str, Any], detailed: bool) -> str: """Format coverage as rich markdown (for Claude Desktop).""" lines = ["## Test Coverage Summary\n"] # Overall metrics lines.append("### Overall Metrics") lines.append(f"- **Line Coverage**: {summary.get('line_coverage', 0):.1f}%") lines.append(f"- **Branch Coverage**: {summary.get('branch_coverage', 0):.1f}%") lines.append(f"- **Function Coverage**: {summary.get('function_coverage', 0):.1f}%\n") # Visual indicator line_cov = summary.get('line_coverage', 0) lines.append(self._coverage_badge(line_cov)) lines.append("") # Detailed breakdown if requested if detailed: lines.append("### Detailed Breakdown") lines.append(f"- Total Lines: {summary.get('total_lines', 0)}") lines.append(f"- Covered Lines: {summary.get('covered_lines', 0)}") lines.append(f"- Total Branches: {summary.get('total_branches', 0)}") lines.append(f"- Covered Branches: {summary.get('covered_branches', 0)}") lines.append(f"- Total Functions: {summary.get('total_functions', 0)}") lines.append(f"- Covered Functions: {summary.get('covered_functions', 0)}\n") return "\n".join(lines) def _format_coverage_terminal(self, summary: Dict[str, Any], detailed: bool) -> str: """Format coverage for terminal (Claude Code CLI).""" lines = ["Coverage Summary:"] lines.append(f" Line: {summary.get('line_coverage', 0):.1f}%") lines.append(f" Branch: {summary.get('branch_coverage', 0):.1f}%") lines.append(f" Function: {summary.get('function_coverage', 0):.1f}%") if detailed: lines.append(f"\nDetails:") lines.append(f" Lines: {summary.get('covered_lines', 0)}/{summary.get('total_lines', 0)}") lines.append(f" Branches: {summary.get('covered_branches', 0)}/{summary.get('total_branches', 0)}") return "\n".join(lines) def _format_coverage_json(self, summary: Dict[str, Any]) -> str: """Format coverage as JSON (for API/CI integration).""" import json return json.dumps(summary, indent=2) def _coverage_badge(self, coverage: float) -> str: """Generate coverage badge markdown.""" if coverage >= 80: color = "green" emoji = "✅" elif coverage >= 60: color = "yellow" emoji = "⚠️" else: color = "red" emoji = "❌" return f"{emoji} **{coverage:.1f}%** coverage ({color})" def format_recommendations( self, recommendations: List[Dict[str, Any]], max_items: Optional[int] = None ) -> str: """ Format recommendations with progressive disclosure. Args: recommendations: List of recommendation dictionaries max_items: Maximum number of items to show (None for all) Returns: Formatted recommendations """ if not recommendations: return "No recommendations at this time." # Group by priority p0 = [r for r in recommendations if r.get('priority') == 'P0'] p1 = [r for r in recommendations if r.get('priority') == 'P1'] p2 = [r for r in recommendations if r.get('priority') == 'P2'] if self.environment == "desktop": return self._format_recommendations_markdown(p0, p1, p2, max_items) elif self.environment == "api": return self._format_recommendations_json(recommendations) else: return self._format_recommendations_terminal(p0, p1, p2, max_items) def _format_recommendations_markdown( self, p0: List[Dict], p1: List[Dict], p2: List[Dict], max_items: Optional[int] ) -> str: """Format recommendations as rich markdown.""" lines = ["## Recommendations\n"] if p0: lines.append("### 🔴 Critical (P0)") for i, rec in enumerate(p0[:max_items] if max_items else p0): lines.append(f"{i+1}. **{rec.get('message', 'No message')}**") lines.append(f" - Action: {rec.get('action', 'No action specified')}") if 'file' in rec: lines.append(f" - File: `{rec['file']}`") lines.append("") if p1 and (not max_items or len(p0) < max_items): remaining = max_items - len(p0) if max_items else None lines.append("### 🟡 Important (P1)") for i, rec in enumerate(p1[:remaining] if remaining else p1): lines.append(f"{i+1}. {rec.get('message', 'No message')}") lines.append(f" - Action: {rec.get('action', 'No action specified')}") lines.append("") if p2 and self.verbose: lines.append("### 🔵 Nice to Have (P2)") for i, rec in enumerate(p2): lines.append(f"{i+1}. {rec.get('message', 'No message')}") lines.append("") return "\n".join(lines) def _format_recommendations_terminal( self, p0: List[Dict], p1: List[Dict], p2: List[Dict], max_items: Optional[int] ) -> str: """Format recommendations for terminal.""" lines = ["Recommendations:"] if p0: lines.append("\nCritical (P0):") for i, rec in enumerate(p0[:max_items] if max_items else p0): lines.append(f" {i+1}. {rec.get('message', 'No message')}") lines.append(f" Action: {rec.get('action', 'No action')}") if p1 and (not max_items or len(p0) < max_items): remaining = max_items - len(p0) if max_items else None lines.append("\nImportant (P1):") for i, rec in enumerate(p1[:remaining] if remaining else p1): lines.append(f" {i+1}. {rec.get('message', 'No message')}") return "\n".join(lines) def _format_recommendations_json(self, recommendations: List[Dict[str, Any]]) -> str: """Format recommendations as JSON.""" import json return json.dumps(recommendations, indent=2) def format_test_results( self, results: Dict[str, Any], show_details: bool = False ) -> str: """ Format test execution results. Args: results: Test results data show_details: Whether to show detailed results Returns: Formatted test results """ if self.environment == "desktop": return self._format_results_markdown(results, show_details) elif self.environment == "api": return self._format_results_json(results) else: return self._format_results_terminal(results, show_details) def _format_results_markdown(self, results: Dict[str, Any], show_details: bool) -> str: """Format test results as markdown.""" lines = ["## Test Results\n"] total = results.get('total_tests', 0) passed = results.get('passed', 0) failed = results.get('failed', 0) skipped = results.get('skipped', 0) # Summary lines.append(f"- **Total Tests**: {total}") lines.append(f"- **Passed**: ✅ {passed}") if failed > 0: lines.append(f"- **Failed**: ❌ {failed}") if skipped > 0: lines.append(f"- **Skipped**: ⏭️ {skipped}") # Pass rate pass_rate = (passed / total * 100) if total > 0 else 0 lines.append(f"- **Pass Rate**: {pass_rate:.1f}%\n") # Failed tests details if show_details and failed > 0: lines.append("### Failed Tests") for test in results.get('failed_tests', []): lines.append(f"- `{test.get('name', 'Unknown')}`") if 'error' in test: lines.append(f" ```\n {test['error']}\n ```") return "\n".join(lines) def _format_results_terminal(self, results: Dict[str, Any], show_details: bool) -> str: """Format test results for terminal.""" total = results.get('total_tests', 0) passed = results.get('passed', 0) failed = results.get('failed', 0) lines = [f"Test Results: {passed}/{total} passed"] if failed > 0: lines.append(f" Failed: {failed}") if show_details and failed > 0: lines.append("\nFailed tests:") for test in results.get('failed_tests', [])[:5]: lines.append(f" - {test.get('name', 'Unknown')}") return "\n".join(lines) def _format_results_json(self, results: Dict[str, Any]) -> str: """Format test results as JSON.""" import json return json.dumps(results, indent=2) def create_summary_report( self, coverage: Dict[str, Any], metrics: Dict[str, Any], recommendations: List[Dict[str, Any]] ) -> str: """ Create comprehensive summary report (token-efficient). Args: coverage: Coverage data metrics: Quality metrics recommendations: Recommendations list Returns: Summary report (<200 tokens) """ lines = [] # Coverage (1-2 lines) line_cov = coverage.get('line_coverage', 0) branch_cov = coverage.get('branch_coverage', 0) lines.append(f"Coverage: {line_cov:.0f}% lines, {branch_cov:.0f}% branches") # Quality (1-2 lines) if 'test_quality' in metrics: quality_score = metrics['test_quality'].get('quality_score', 0) lines.append(f"Test Quality: {quality_score:.0f}/100") # Top recommendations (2-3 lines) p0_count = sum(1 for r in recommendations if r.get('priority') == 'P0') if p0_count > 0: lines.append(f"Critical issues: {p0_count}") top_rec = next((r for r in recommendations if r.get('priority') == 'P0'), None) if top_rec: lines.append(f" - {top_rec.get('message', '')}") return "\n".join(lines) def should_show_detailed(self, data_size: int) -> bool: """ Determine if detailed output should be shown based on data size. Args: data_size: Size of data to display Returns: Whether to show detailed output """ if self.verbose: return True # Progressive disclosure thresholds if self.environment == "desktop": return data_size < 100 # Show more in Desktop else: return data_size < 20 # Show less in CLI def truncate_output(self, text: str, max_lines: int = 50) -> str: """ Truncate output to maximum lines. Args: text: Text to truncate max_lines: Maximum number of lines Returns: Truncated text with indicator """ lines = text.split('\n') if len(lines) <= max_lines: return text truncated = '\n'.join(lines[:max_lines]) remaining = len(lines) - max_lines return f"{truncated}\n\n... ({remaining} more lines, use --verbose for full output)" FILE:scripts/tdd_workflow.py """ TDD workflow guidance module. Provides step-by-step guidance through red-green-refactor cycles with validation. """ from typing import Dict, List, Any, Optional from enum import Enum class TDDPhase(Enum): """TDD cycle phases.""" RED = "red" # Write failing test GREEN = "green" # Make test pass REFACTOR = "refactor" # Improve code class WorkflowState(Enum): """Current state of TDD workflow.""" INITIAL = "initial" TEST_WRITTEN = "test_written" TEST_FAILING = "test_failing" TEST_PASSING = "test_passing" CODE_REFACTORED = "code_refactored" class TDDWorkflow: """Guide users through TDD red-green-refactor workflow.""" def __init__(self): """Initialize TDD workflow guide.""" self.current_phase = TDDPhase.RED self.state = WorkflowState.INITIAL self.history = [] def start_cycle(self, requirement: str) -> Dict[str, Any]: """ Start a new TDD cycle. Args: requirement: User story or requirement to implement Returns: Guidance for RED phase """ self.current_phase = TDDPhase.RED self.state = WorkflowState.INITIAL return { 'phase': 'RED', 'instruction': 'Write a failing test for the requirement', 'requirement': requirement, 'checklist': [ 'Write test that describes desired behavior', 'Test should fail when run (no implementation yet)', 'Test name clearly describes what is being tested', 'Test has clear arrange-act-assert structure' ], 'tips': [ 'Focus on behavior, not implementation', 'Start with simplest test case', 'Test should be specific and focused' ] } def validate_red_phase( self, test_code: str, test_result: Optional[Dict[str, Any]] = None ) -> Dict[str, Any]: """ Validate RED phase completion. Args: test_code: The test code written test_result: Test execution result (optional) Returns: Validation result and next steps """ validations = [] # Check test exists if not test_code or len(test_code.strip()) < 10: validations.append({ 'valid': False, 'message': 'No test code provided' }) else: validations.append({ 'valid': True, 'message': 'Test code provided' }) # Check for assertions has_assertion = any(keyword in test_code.lower() for keyword in ['assert', 'expect', 'should']) validations.append({ 'valid': has_assertion, 'message': 'Contains assertions' if has_assertion else 'Missing assertions' }) # Check test result if provided if test_result: test_failed = test_result.get('status') == 'failed' validations.append({ 'valid': test_failed, 'message': 'Test fails as expected' if test_failed else 'Test should fail in RED phase' }) all_valid = all(v['valid'] for v in validations) if all_valid: self.state = WorkflowState.TEST_FAILING self.current_phase = TDDPhase.GREEN return { 'phase_complete': True, 'next_phase': 'GREEN', 'validations': validations, 'instruction': 'Write minimal code to make the test pass' } else: return { 'phase_complete': False, 'current_phase': 'RED', 'validations': validations, 'instruction': 'Address validation issues before proceeding' } def validate_green_phase( self, implementation_code: str, test_result: Dict[str, Any] ) -> Dict[str, Any]: """ Validate GREEN phase completion. Args: implementation_code: The implementation code test_result: Test execution result Returns: Validation result and next steps """ validations = [] # Check implementation exists if not implementation_code or len(implementation_code.strip()) < 5: validations.append({ 'valid': False, 'message': 'No implementation code provided' }) else: validations.append({ 'valid': True, 'message': 'Implementation code provided' }) # Check test now passes test_passed = test_result.get('status') == 'passed' validations.append({ 'valid': test_passed, 'message': 'Test passes' if test_passed else 'Test still failing' }) # Check for minimal implementation (heuristic) is_minimal = self._check_minimal_implementation(implementation_code) validations.append({ 'valid': is_minimal, 'message': 'Implementation appears minimal' if is_minimal else 'Implementation may be over-engineered' }) all_valid = all(v['valid'] for v in validations) if all_valid: self.state = WorkflowState.TEST_PASSING self.current_phase = TDDPhase.REFACTOR return { 'phase_complete': True, 'next_phase': 'REFACTOR', 'validations': validations, 'instruction': 'Refactor code while keeping tests green', 'refactoring_suggestions': self._suggest_refactorings(implementation_code) } else: return { 'phase_complete': False, 'current_phase': 'GREEN', 'validations': validations, 'instruction': 'Make the test pass before refactoring' } def validate_refactor_phase( self, original_code: str, refactored_code: str, test_result: Dict[str, Any] ) -> Dict[str, Any]: """ Validate REFACTOR phase completion. Args: original_code: Original implementation refactored_code: Refactored implementation test_result: Test execution result after refactoring Returns: Validation result and cycle completion status """ validations = [] # Check tests still pass test_passed = test_result.get('status') == 'passed' validations.append({ 'valid': test_passed, 'message': 'Tests still pass after refactoring' if test_passed else 'Tests broken by refactoring' }) # Check code was actually refactored code_changed = original_code != refactored_code validations.append({ 'valid': code_changed, 'message': 'Code was refactored' if code_changed else 'No refactoring applied (optional)' }) # Check code quality improved quality_improved = self._check_quality_improvement(original_code, refactored_code) if code_changed: validations.append({ 'valid': quality_improved, 'message': 'Code quality improved' if quality_improved else 'Consider further refactoring for better quality' }) all_valid = all(v['valid'] for v in validations if v.get('valid') is not None) if all_valid: self.state = WorkflowState.CODE_REFACTORED self.history.append({ 'cycle_complete': True, 'final_state': self.state }) return { 'phase_complete': True, 'cycle_complete': True, 'validations': validations, 'message': 'TDD cycle complete! Ready for next requirement.', 'next_steps': [ 'Commit your changes', 'Start next TDD cycle with new requirement', 'Or add more test cases for current feature' ] } else: return { 'phase_complete': False, 'current_phase': 'REFACTOR', 'validations': validations, 'instruction': 'Ensure tests still pass after refactoring' } def _check_minimal_implementation(self, code: str) -> bool: """Check if implementation is minimal (heuristic).""" # Simple heuristics: # - Not too long (< 50 lines for unit tests) # - Not too complex (few nested structures) lines = code.split('\n') non_empty_lines = [line for line in lines if line.strip() and not line.strip().startswith('#')] # Check length if len(non_empty_lines) > 50: return False # Check nesting depth (simplified) max_depth = 0 current_depth = 0 for line in lines: stripped = line.lstrip() if stripped: indent = len(line) - len(stripped) depth = indent // 4 # Assuming 4-space indent max_depth = max(max_depth, depth) # Max nesting of 3 levels for simple implementation return max_depth <= 3 def _check_quality_improvement(self, original: str, refactored: str) -> bool: """Check if refactoring improved code quality.""" # Simple heuristics: # - Reduced duplication # - Better naming # - Simpler structure # Check for reduced duplication (basic check) original_lines = set(line.strip() for line in original.split('\n') if line.strip()) refactored_lines = set(line.strip() for line in refactored.split('\n') if line.strip()) # If unique lines increased proportionally, likely extracted duplicates if len(refactored_lines) > len(original_lines): return True # Check for better naming (longer, more descriptive names) original_avg_identifier_length = self._avg_identifier_length(original) refactored_avg_identifier_length = self._avg_identifier_length(refactored) if refactored_avg_identifier_length > original_avg_identifier_length: return True # If no clear improvement detected, assume refactoring was beneficial return True def _avg_identifier_length(self, code: str) -> float: """Calculate average identifier length (proxy for naming quality).""" import re identifiers = re.findall(r'\b[a-zA-Z_][a-zA-Z0-9_]*\b', code) # Filter out keywords keywords = {'if', 'else', 'for', 'while', 'def', 'class', 'return', 'import', 'from'} identifiers = [i for i in identifiers if i.lower() not in keywords] if not identifiers: return 0.0 return sum(len(i) for i in identifiers) / len(identifiers) def _suggest_refactorings(self, code: str) -> List[str]: """Suggest potential refactorings.""" suggestions = [] # Check for long functions lines = code.split('\n') if len(lines) > 30: suggestions.append('Consider breaking long function into smaller functions') # Check for duplication (simple check) line_counts = {} for line in lines: stripped = line.strip() if len(stripped) > 10: # Ignore very short lines line_counts[stripped] = line_counts.get(stripped, 0) + 1 duplicates = [line for line, count in line_counts.items() if count > 2] if duplicates: suggestions.append(f'Found {len(duplicates)} duplicated code patterns - consider extraction') # Check for magic numbers import re magic_numbers = re.findall(r'\b\d+\b', code) if len(magic_numbers) > 5: suggestions.append('Consider extracting magic numbers to named constants') # Check for long parameter lists if 'def ' in code or 'function' in code: param_matches = re.findall(r'$([^)]+)$', code) for params in param_matches: if params.count(',') > 3: suggestions.append('Consider using parameter object for functions with many parameters') break if not suggestions: suggestions.append('Code looks clean - no obvious refactorings needed') return suggestions def generate_workflow_summary(self) -> str: """Generate summary of TDD workflow progress.""" summary = [ "# TDD Workflow Summary\n", f"Current Phase: {self.current_phase.value.upper()}", f"Current State: {self.state.value.replace('_', ' ').title()}", f"Completed Cycles: {len(self.history)}\n" ] summary.append("## TDD Cycle Steps:\n") summary.append("1. **RED**: Write a failing test") summary.append(" - Test describes desired behavior") summary.append(" - Test fails (no implementation)\n") summary.append("2. **GREEN**: Make the test pass") summary.append(" - Write minimal code to pass test") summary.append(" - All tests should pass\n") summary.append("3. **REFACTOR**: Improve the code") summary.append(" - Clean up implementation") summary.append(" - Tests still pass") summary.append(" - Code is more maintainable\n") return "\n".join(summary) def get_phase_guidance(self, phase: Optional[TDDPhase] = None) -> Dict[str, Any]: """ Get detailed guidance for a specific phase. Args: phase: TDD phase (uses current if not specified) Returns: Detailed guidance dictionary """ target_phase = phase or self.current_phase if target_phase == TDDPhase.RED: return { 'phase': 'RED', 'goal': 'Write a failing test', 'steps': [ '1. Read and understand the requirement', '2. Think about expected behavior', '3. Write test that verifies this behavior', '4. Run test and ensure it fails', '5. Verify failure reason is correct (not syntax error)' ], 'common_mistakes': [ 'Test passes immediately (no real assertion)', 'Test fails for wrong reason (syntax error)', 'Test is too broad or tests multiple things' ], 'tips': [ 'Start with simplest test case', 'One assertion per test (focused)', 'Test should read like specification' ] } elif target_phase == TDDPhase.GREEN: return { 'phase': 'GREEN', 'goal': 'Make the test pass with minimal code', 'steps': [ '1. Write simplest code that makes test pass', '2. Run test and verify it passes', '3. Run all tests to ensure no regression', '4. Resist urge to add extra features' ], 'common_mistakes': [ 'Over-engineering solution', 'Adding features not covered by tests', 'Breaking existing tests' ], 'tips': [ 'Fake it till you make it (hardcode if needed)', 'Triangulate with more tests if needed', 'Keep implementation simple' ] } elif target_phase == TDDPhase.REFACTOR: return { 'phase': 'REFACTOR', 'goal': 'Improve code quality while keeping tests green', 'steps': [ '1. Identify code smells or duplication', '2. Apply one refactoring at a time', '3. Run tests after each change', '4. Commit when satisfied with quality' ], 'common_mistakes': [ 'Changing behavior (breaking tests)', 'Refactoring too much at once', 'Skipping this phase' ], 'tips': [ 'Extract methods for better naming', 'Remove duplication', 'Improve variable names', 'Tests are safety net - use them!' ] } return {} FILE:scripts/test_generator.py """ Test case generation module. Generates test cases from requirements, user stories, API specs, and code analysis. Supports multiple testing frameworks with intelligent test scaffolding. """ from typing import Dict, List, Any, Optional from enum import Enum class TestFramework(Enum): """Supported testing frameworks.""" JEST = "jest" VITEST = "vitest" PYTEST = "pytest" JUNIT = "junit" MOCHA = "mocha" class TestType(Enum): """Types of tests to generate.""" UNIT = "unit" INTEGRATION = "integration" E2E = "e2e" class TestGenerator: """Generate test cases and test stubs from requirements and code.""" def __init__(self, framework: TestFramework, language: str): """ Initialize test generator. Args: framework: Testing framework to use language: Programming language (typescript, javascript, python, java) """ self.framework = framework self.language = language self.test_cases = [] def generate_from_requirements( self, requirements: Dict[str, Any], test_type: TestType = TestType.UNIT ) -> List[Dict[str, Any]]: """ Generate test cases from requirements. Args: requirements: Dictionary with user_stories, acceptance_criteria, api_specs test_type: Type of tests to generate Returns: List of test case specifications """ test_cases = [] # Generate from user stories if 'user_stories' in requirements: for story in requirements['user_stories']: test_cases.extend(self._test_cases_from_story(story)) # Generate from acceptance criteria if 'acceptance_criteria' in requirements: for criterion in requirements['acceptance_criteria']: test_cases.extend(self._test_cases_from_criteria(criterion)) # Generate from API specs if 'api_specs' in requirements: for endpoint in requirements['api_specs']: test_cases.extend(self._test_cases_from_api(endpoint)) self.test_cases = test_cases return test_cases def _test_cases_from_story(self, story: Dict[str, Any]) -> List[Dict[str, Any]]: """Generate test cases from user story.""" test_cases = [] # Happy path test test_cases.append({ 'name': f"should_{story.get('action', 'work')}_successfully", 'type': 'happy_path', 'description': story.get('description', ''), 'given': story.get('given', []), 'when': story.get('when', ''), 'then': story.get('then', ''), 'priority': 'P0' }) # Error cases if 'error_conditions' in story: for error in story['error_conditions']: test_cases.append({ 'name': f"should_handle_{error.get('condition', 'error')}", 'type': 'error_case', 'description': error.get('description', ''), 'expected_error': error.get('error_type', ''), 'priority': 'P0' }) # Edge cases if 'edge_cases' in story: for edge_case in story['edge_cases']: test_cases.append({ 'name': f"should_handle_{edge_case.get('scenario', 'edge_case')}", 'type': 'edge_case', 'description': edge_case.get('description', ''), 'priority': 'P1' }) return test_cases def _test_cases_from_criteria(self, criterion: Dict[str, Any]) -> List[Dict[str, Any]]: """Generate test cases from acceptance criteria.""" return [{ 'name': f"should_meet_{criterion.get('id', 'criterion')}", 'type': 'acceptance', 'description': criterion.get('description', ''), 'verification': criterion.get('verification_steps', []), 'priority': 'P0' }] def _test_cases_from_api(self, endpoint: Dict[str, Any]) -> List[Dict[str, Any]]: """Generate test cases from API specification.""" test_cases = [] method = endpoint.get('method', 'GET') path = endpoint.get('path', '/') # Success case test_cases.append({ 'name': f"should_{method.lower()}_{path.replace('/', '_')}_successfully", 'type': 'api_success', 'method': method, 'path': path, 'expected_status': endpoint.get('success_status', 200), 'priority': 'P0' }) # Validation errors if 'required_params' in endpoint: test_cases.append({ 'name': f"should_return_400_for_missing_params", 'type': 'api_validation', 'method': method, 'path': path, 'expected_status': 400, 'priority': 'P0' }) # Authorization if endpoint.get('requires_auth', False): test_cases.append({ 'name': f"should_return_401_for_unauthenticated", 'type': 'api_auth', 'method': method, 'path': path, 'expected_status': 401, 'priority': 'P0' }) return test_cases def generate_test_stub(self, test_case: Dict[str, Any]) -> str: """ Generate test stub code for a test case. Args: test_case: Test case specification Returns: Test stub code as string """ if self.framework == TestFramework.JEST: return self._generate_jest_stub(test_case) elif self.framework == TestFramework.PYTEST: return self._generate_pytest_stub(test_case) elif self.framework == TestFramework.JUNIT: return self._generate_junit_stub(test_case) elif self.framework == TestFramework.VITEST: return self._generate_vitest_stub(test_case) else: return self._generate_generic_stub(test_case) def _generate_jest_stub(self, test_case: Dict[str, Any]) -> str: """Generate Jest test stub.""" name = test_case.get('name', 'test') description = test_case.get('description', '') stub = f""" describe('{{Feature Name}}', () => {{ it('{name}', () => {{ // {description} // Arrange // TODO: Set up test data and dependencies // Act // TODO: Execute the code under test // Assert // TODO: Verify expected behavior expect(true).toBe(true); // Replace with actual assertion }}); }}); """ return stub.strip() def _generate_pytest_stub(self, test_case: Dict[str, Any]) -> str: """Generate Pytest test stub.""" name = test_case.get('name', 'test') description = test_case.get('description', '') stub = f""" def test_{name}(): \"\"\" {description} \"\"\" # Arrange # TODO: Set up test data and dependencies # Act # TODO: Execute the code under test # Assert # TODO: Verify expected behavior assert True # Replace with actual assertion """ return stub.strip() def _generate_junit_stub(self, test_case: Dict[str, Any]) -> str: """Generate JUnit test stub.""" name = test_case.get('name', 'test') description = test_case.get('description', '') # Convert snake_case to camelCase for Java method_name = ''.join(word.capitalize() if i > 0 else word for i, word in enumerate(name.split('_'))) stub = f""" @Test public void {method_name}() {{ // {description} // Arrange // TODO: Set up test data and dependencies // Act // TODO: Execute the code under test // Assert // TODO: Verify expected behavior assertTrue(true); // Replace with actual assertion }} """ return stub.strip() def _generate_vitest_stub(self, test_case: Dict[str, Any]) -> str: """Generate Vitest test stub (similar to Jest).""" name = test_case.get('name', 'test') description = test_case.get('description', '') stub = f""" describe('{{Feature Name}}', () => {{ it('{name}', () => {{ // {description} // Arrange // TODO: Set up test data and dependencies // Act // TODO: Execute the code under test // Assert // TODO: Verify expected behavior expect(true).toBe(true); // Replace with actual assertion }}); }}); """ return stub.strip() def _generate_generic_stub(self, test_case: Dict[str, Any]) -> str: """Generate generic test stub.""" name = test_case.get('name', 'test') description = test_case.get('description', '') return f""" # Test: {name} # Description: {description} # # TODO: Implement test # 1. Arrange: Set up test data # 2. Act: Execute code under test # 3. Assert: Verify expected behavior """ def generate_test_file( self, module_name: str, test_cases: Optional[List[Dict[str, Any]]] = None ) -> str: """ Generate complete test file with all test stubs. Args: module_name: Name of module being tested test_cases: List of test cases (uses self.test_cases if not provided) Returns: Complete test file content """ cases = test_cases or self.test_cases if self.framework == TestFramework.JEST: return self._generate_jest_file(module_name, cases) elif self.framework == TestFramework.PYTEST: return self._generate_pytest_file(module_name, cases) elif self.framework == TestFramework.JUNIT: return self._generate_junit_file(module_name, cases) elif self.framework == TestFramework.VITEST: return self._generate_vitest_file(module_name, cases) else: return "" def _generate_jest_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str: """Generate complete Jest test file.""" imports = f"import {{ {module_name} }} from '../{module_name}';\n\n" stubs = [] for test_case in test_cases: stubs.append(self._generate_jest_stub(test_case)) return imports + "\n\n".join(stubs) def _generate_pytest_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str: """Generate complete Pytest test file.""" imports = f"import pytest\nfrom {module_name} import *\n\n\n" stubs = [] for test_case in test_cases: stubs.append(self._generate_pytest_stub(test_case)) return imports + "\n\n\n".join(stubs) def _generate_junit_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str: """Generate complete JUnit test file.""" class_name = ''.join(word.capitalize() for word in module_name.split('_')) imports = """import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; """ class_header = f"public class {class_name}Test {{\n\n" stubs = [] for test_case in test_cases: stubs.append(self._generate_junit_stub(test_case)) class_footer = "\n}" return imports + class_header + "\n\n".join(stubs) + class_footer def _generate_vitest_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str: """Generate complete Vitest test file.""" imports = f"import {{ describe, it, expect }} from 'vitest';\nimport {{ {module_name} }} from '../{module_name}';\n\n" stubs = [] for test_case in test_cases: stubs.append(self._generate_vitest_stub(test_case)) return imports + "\n\n".join(stubs) def suggest_missing_scenarios( self, existing_tests: List[str], code_analysis: Dict[str, Any] ) -> List[Dict[str, Any]]: """ Suggest missing test scenarios based on code analysis. Args: existing_tests: List of existing test names code_analysis: Analysis of code under test (branches, error paths, etc.) Returns: List of suggested test scenarios """ suggestions = [] # Check for untested error conditions if 'error_handlers' in code_analysis: for error_handler in code_analysis['error_handlers']: error_name = error_handler.get('type', 'error') if not self._has_test_for(existing_tests, error_name): suggestions.append({ 'name': f"should_handle_{error_name}", 'type': 'error_case', 'reason': 'Error handler exists but no corresponding test', 'priority': 'P0' }) # Check for untested branches if 'conditional_branches' in code_analysis: for branch in code_analysis['conditional_branches']: branch_name = branch.get('condition', 'condition') if not self._has_test_for(existing_tests, branch_name): suggestions.append({ 'name': f"should_test_{branch_name}_branch", 'type': 'branch_coverage', 'reason': 'Conditional branch not fully tested', 'priority': 'P1' }) # Check for boundary conditions if 'input_validation' in code_analysis: for validation in code_analysis['input_validation']: param = validation.get('parameter', 'input') if not self._has_test_for(existing_tests, f"{param}_boundary"): suggestions.append({ 'name': f"should_test_{param}_boundary_values", 'type': 'boundary', 'reason': 'Input validation exists but boundary tests missing', 'priority': 'P1' }) return suggestions def _has_test_for(self, existing_tests: List[str], keyword: str) -> bool: """Check if existing tests cover a keyword/scenario.""" keyword_lower = keyword.lower().replace('_', '').replace('-', '') for test in existing_tests: test_lower = test.lower().replace('_', '').replace('-', '') if keyword_lower in test_lower: return True return False

Tdd Guide

Comments (0)