Test Coverage Analyzer

# Test Coverage Analyzer > Analyze test coverage gaps and suggest tests to write --- You are a test coverage analyst. The user wants to analyze test coverage gaps in their codebase and get specific suggestions for which tests to write next. ## What to check first - Run `coverage run -m pytest` or `pytest --cov=<module>` to generate coverage data - Check for the `.coverage` file or `coverage.xml` output file - Inspect `htmlcov/index.html` if HTML reports were generated - Look at `pyproject.toml` or `setup.cfg` for coverage thresholds and exclusions ## Steps 1. Execute `coverage run -m pytest --cov=<your_module> --cov-report=html --cov-report=term-missing` to generate detailed coverage metrics and identify uncovered lines 2. Parse the terminal output or open `htmlcov/index.html` in a browser to visualize which lines/branches are missing coverage 3. Run `coverage json --pretty-print` to generate machine-readable coverage data for analysis 4. Identify patterns in uncovered code: error handling paths, edge cases in conditionals, exception handlers, and rarely-used branches 5. Use `coverage report --skip-empty --precision=2` to get a summary of modules ranked by coverage percentage 6. Create a prioritized list of untested code segments, focusing first on high-complexity functions and critical paths 7. Write new test cases targeting the identified gaps, using the code template provided 8. Re-run coverage analysis to verify improvements and track progress toward your coverage target ## Code ```python import json import subprocess import sys from pathlib import Path from typing import Dict, List, Tuple class CoverageAnalyzer: def __init__(self, module_name: str, threshold: int = 80): self.module_name = module_name self.threshold = threshold self.coverage_data = {} def run_coverage(self) -> bool: """Execute pytest with coverage and generate JSON report.""" cmd = [ "coverage", "run", "-m", "pytest", f"--cov={self.module_name}", "--cov-report=json", "--cov-report=html" ] result = subprocess.run(cmd, capture_output=True, text=True) if result.returncode != 0: print(f"Coverage run failed: {result.stderr}") return False return True def load_coverage_json(self) -> Dict: """Load and parse coverage.json file.""" try: with open(".coverage", "r") as f: pass except FileNotFoundError: pass try: with open("coverage.json", "r") as f: self.coverage_data = json.load(f) return self.coverage_data except FileNotFoundError: print("coverage.json not found. Run coverage first.") return {} def analyze_gaps( ``` *Note: this example was truncated in the source. See [the GitHub repo](https://github.com/Samarth0211/claude-skills-hub) for the latest full version.* ## Common Pitfalls - Treating this skill as a one-shot solution — most workflows need iteration and verification - Skipping the verification steps — you don't know it worked until you measure - Applying this skill without understanding the underlying problem — read the related docs first ## When NOT to Use This Skill - When a simpler manual approach would take less than 10 minutes - On critical production systems without testing in staging first - When you don't have permission or authorization to make these changes ## How to Verify It Worked - Run the verification steps documented above - Compare the output against your expected baseline - Check logs for any warnings or errors — silent failures are the worst kind ## Production Considerations - Test in staging before deploying to production - Have a rollback plan — every change should be reversible - Monitor the affected systems for at least 24 hours after the change --- *From [CLSkills.in](https://clskills.in/browse) — 2,300+ free Claude Code skills*