coverage-enhancer

Coverage Enhancer

Analyze existing tests and source code to identify coverage gaps, then suggest specific additional tests to improve overall test coverage and code quality.

Core Capabilities

1. Coverage Gap Analysis

Identify untested areas in source code:

• Uncovered lines - Code never executed by tests
• Uncovered branches - Conditional paths not tested
• Uncovered functions - Methods/functions without tests
• Missing error handling tests - Exception paths not verified
• Untested edge cases - Boundary conditions not covered
• Insufficient scenarios - Limited test diversity

2. Existing Test Analysis

Understand current test coverage by:

• Parsing existing test files
• Identifying tested functions and methods
• Recognizing test patterns and frameworks
• Detecting coverage tools in use
• Analyzing test quality and completeness

3. Test Suggestion Generation

Generate specific, actionable test recommendations:

• Complete test code in the project's framework
• Clear test names describing what's being tested
• Setup, execution, and assertion steps
• Integration with existing test structure
• Prioritized by coverage impact

Coverage Analysis Workflow

Step 1: Analyze Existing Tests

Read and understand the current test suite:

Identify test framework:

# pytest
def test_something():
    assert result == expected

# unittest
class TestSomething(unittest.TestCase):
    def test_method(self):
        self.assertEqual(result, expected)

Map tested functionality:

• Which functions/methods have tests?
• What scenarios are covered?
• What assertions are made?
• What inputs are tested?

Identify test patterns:

• Naming conventions
• Setup/teardown patterns
• Fixture usage
• Mock/stub patterns

Step 2: Analyze Source Code

Examine the implementation to find gaps:

Identify code paths:

def process(value):
    if value < 0:        # Branch 1
        raise ValueError
    elif value == 0:     # Branch 2
        return None
    else:                # Branch 3
        return value * 2

Find untested branches:

• If/else conditions not covered
• Switch/case statements
• Exception handlers (try/except/finally)
• Early returns
• Loop edge cases (zero iterations, one iteration, many)

Identify uncovered functions:

• Helper functions without tests
• Private methods (if testing them is valuable)
• Class methods and properties
• Static/class methods

Step 3: Prioritize Coverage Gaps

Focus on high-value additions:

Priority 1: Critical paths

• Error handling and validation
• Security-sensitive code
• Data integrity operations
• Public API methods

Priority 2: Complex logic

• Conditional logic with multiple branches
• Loops with edge cases
• State transitions
• Algorithm implementations

Priority 3: Completeness

• Untested helper functions
• Missing edge cases
• Property getters/setters
• Simple utility functions

Step 4: Generate Test Suggestions

Create specific, ready-to-use tests:

Format:

# Suggested test for uncovered branch: negative input validation
def test_process_negative_input():
    """Test that negative values raise ValueError."""
    with pytest.raises(ValueError):
        process(-1)

# Reason: This tests the value < 0 branch which is currently uncovered
# Coverage impact: +5 lines, +1 branch

Include:

1. Test name (descriptive)
2. Test implementation (complete code)
3. Explanation of what's being tested
4. Coverage impact estimate
5. Integration notes (where to add in test file)

Step 5: Suggest Coverage Tool Integration

Recommend running coverage analysis:

# Python
pytest --cov=mymodule --cov-report=html

# JavaScript
npm test -- --coverage

# Java
mvn test jacoco:report

# Go
go test -coverprofile=coverage.out
go tool cover -html=coverage.out

Coverage Analysis Patterns

Pattern 1: Branch Coverage

Uncovered code:

def calculate_discount(price, customer_type):
    if customer_type == "premium":
        return price * 0.8
    elif customer_type == "regular":
        return price * 0.9
    else:
        return price

Existing test:

def test_calculate_discount_premium():
    assert calculate_discount(100, "premium") == 80

Suggested additions:

def test_calculate_discount_regular():
    """Test discount calculation for regular customers."""
    assert calculate_discount(100, "regular") == 90
    # Coverage: Tests the 'regular' branch

def test_calculate_discount_no_discount():
    """Test that unknown customer types get no discount."""
    assert calculate_discount(100, "guest") == 100
    # Coverage: Tests the else branch

def test_calculate_discount_edge_cases():
    """Test discount calculation with edge case prices."""
    assert calculate_discount(0, "premium") == 0
    assert calculate_discount(0.01, "premium") == 0.008
    # Coverage: Tests edge cases within covered branches

Pattern 2: Exception Path Coverage

Uncovered code:

def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

Existing test:

def test_divide_normal():
    assert divide(10, 2) == 5

Suggested addition:

def test_divide_by_zero():
    """Test that dividing by zero raises ValueError."""
    with pytest.raises(ValueError, match="Cannot divide by zero"):
        divide(10, 0)
    # Coverage: Tests the exception path (b == 0 branch)
    # Impact: +2 lines, +1 branch

Pattern 3: Loop Coverage

Uncovered code:

def find_max(numbers):
    if not numbers:
        return None

    max_val = numbers[0]
    for num in numbers[1:]:
        if num > max_val:
            max_val = num
    return max_val

Existing test:

def test_find_max_normal():
    assert find_max([1, 5, 3, 2]) == 5

Suggested additions:

def test_find_max_empty():
    """Test that empty list returns None."""
    assert find_max([]) is None
    # Coverage: Tests the 'if not numbers' branch

def test_find_max_single_element():
    """Test with single element (zero loop iterations)."""
    assert find_max([42]) == 42
    # Coverage: Tests loop with zero iterations

def test_find_max_all_equal():
    """Test with all identical elements."""
    assert find_max([5, 5, 5, 5]) == 5
    # Coverage: Tests loop where condition never true

def test_find_max_negative_numbers():
    """Test with negative numbers."""
    assert find_max([-5, -1, -10, -3]) == -1
    # Coverage: Edge case for comparison logic

Pattern 4: Error Handler Coverage

Uncovered code:

def load_config(filename):
    try:
        with open(filename) as f:
            return json.load(f)
    except FileNotFoundError:
        return {}
    except json.JSONDecodeError as e:
        raise ValueError(f"Invalid JSON in {filename}: {e}")
    except Exception as e:
        raise RuntimeError(f"Unexpected error loading {filename}: {e}")

Existing test:

def test_load_config_success(tmp_path):
    config_file = tmp_path / "config.json"
    config_file.write_text('{"key": "value"}')
    assert load_config(str(config_file)) == {"key": "value"}

Suggested additions:

def test_load_config_file_not_found():
    """Test that missing file returns empty dict."""
    assert load_config("nonexistent.json") == {}
    # Coverage: Tests FileNotFoundError exception path

def test_load_config_invalid_json(tmp_path):
    """Test that invalid JSON raises ValueError."""
    config_file = tmp_path / "bad.json"
    config_file.write_text("{invalid json}")

    with pytest.raises(ValueError, match="Invalid JSON"):
        load_config(str(config_file))
    # Coverage: Tests JSONDecodeError exception path

def test_load_config_permission_error(tmp_path):
    """Test that permission errors raise RuntimeError."""
    config_file = tmp_path / "protected.json"
    config_file.writ