Test Generation Cheat Sheet — AI-Powered Test Coverage

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

function_code = '''
def calculate_discount(price: float, is_member: bool) -> float:
    """Apply 10% discount if member, 5% if not."""
    if price < 0:
        raise ValueError("Price cannot be negative")
    return price * (0.9 if is_member else 0.95)
'''

prompt = f"""Generate pytest unit tests for this function. Include:
- Happy path (member and non-member)
- Edge case: price=0
- Error: negative price
- Type validation

{function_code}

Output ONLY valid Python pytest code."""

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.7
)

generated_tests = response.choices[0].message.content
print(generated_tests)

import json
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

def refine_tests_for_coverage(code: str, current_coverage: float, target: float = 90.0):
    """Iteratively generate tests until coverage threshold is met."""
    tests = []
    iteration = 0
    
    while current_coverage < target and iteration < 5:
        prompt = f"""Code coverage is {current_coverage}%. Generate 3 new pytest test cases
to reach {target}% coverage. Focus on untested branches.

Existing code:\n{code}

Current tests: {len(tests)}
Target coverage: {target}%

Generate ONLY new test functions, not duplicates."""
        
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            temperature=0.8
        )
        
        new_tests = response.choices[0].message.content
        tests.append(new_tests)
        
        # In production: run pytest --cov, parse output
        # current_coverage = run_coverage_check(code, tests)
        iteration += 1
    
    return tests

# Usage
test_suite = refine_tests_for_coverage(
    code="def process_order(items): ...",
    current_coverage=65.0,
    target=90.0
)

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

function_spec = '''
def normalize_email(email: str) -> str:
    """Convert email to lowercase, strip whitespace, validate format."""
    email = email.strip().lower()
    if '@' not in email or '.' not in email.split('@')[1]:
        raise ValueError("Invalid email")
    return email
'''

prompt = f"""Generate Hypothesis property-based tests for this function.
Include invariants that MUST always hold true (e.g., output is lowercase).

{function_spec}

Example invariant: output should always be lowercase and equal to input.strip().lower()

Output a complete, runnable Hypothesis test."""

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": prompt}]
)

print(response.choices[0].message.content)

import json
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

openapi_spec = {
    "paths": {
        "/users/{id}": {
            "get": {
                "parameters": [{"name": "id", "in": "path", "schema": {"type": "integer"}}],
                "responses": {
                    "200": {"description": "User found"},
                    "404": {"description": "User not found"},
                    "401": {"description": "Unauthorized"}
                }
            }
        }
    }
}

prompt = f"""Generate pytest tests for this API endpoint scenario:

1. Valid user ID → 200 response with user object
2. Non-existent user → 404 response
3. Missing auth header → 401 response
4. Malformed ID → 400 response
5. Boundary: ID = 0, ID = 999999999

API Spec:\n{json.dumps(openapi_spec, indent=2)}

Generate complete pytest tests using requests mock or responses library."""

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": prompt}]
)

print(response.choices[0].message.content)

import subprocess
import json
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

def validate_with_mutations(test_file: str, code_file: str):
    """Run mutation testing to ensure tests catch mutations."""
    # Install: pip install mutmut
    result = subprocess.run(
        ["mutmut", "run", "--tests-dir", "tests", "--paths-to-mutate", code_file],
        capture_output=True,
        text=True
    )
    
    output = json.loads(result.stdout)
    total_mutants = output.get("total", 0)
    killed = output.get("killed", 0)
    
    mutation_score = (killed / total_mutants * 100) if total_mutants > 0 else 0
    
    if mutation_score < 80:
        # Ask LLM to improve tests
        prompt = f"""Your tests have {mutation_score}% mutation score (should be >80%).
These mutations survived:\n{result.stdout}

Generate additional tests to kill more mutants."""
        
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    
    return f"Mutation score: {mutation_score}% ✓"

# Usage
print(validate_with_mutations("tests/test_module.py", "src/module.py"))