test-generator

What this skill does

# Test Generator

Generate comprehensive unit tests for existing code.

## Overview

This skill creates production-ready unit tests by analyzing your code, detecting the appropriate testing framework, and generating test cases that cover happy paths, boundary values, edge cases, and error handling. Tests follow the AAA (Arrange-Act-Assert) pattern and language-specific best practices.

**What it creates:**
- Test files matching project conventions
- Parameterized tests for multiple scenarios
- Mock setups for dependencies
- Coverage-focused test cases

## Framework Detection

| Language | Framework | Test File Pattern |
|----------|-----------|-------------------|
| Python | pytest | `test_*.py` or `*_test.py` |
| TypeScript/JS | Jest/Vitest | `*.test.ts` or `*.spec.ts` |
| Java | JUnit 5 | `*Test.java` |
| Go | testing | `*_test.go` |
| Rust | built-in | `#[cfg(test)]` module |

## Workflow

### Step 1: Analyze Source Code

I'll read the target file and identify:
- Functions/methods to test
- Parameter types and constraints
- Return types and possible values
- Dependencies that need mocking
- Existing test patterns in the project

### Step 2: Detect Testing Framework

Check for existing test configuration:
- `pytest.ini`, `pyproject.toml` (Python)
- `jest.config.js`, `vitest.config.ts` (JS/TS)
- `pom.xml` with JUnit (Java)
- Go module with `_test.go` files
- Rust `Cargo.toml` with test configuration

### Step 3: Generate Test Cases

For each function, I generate tests covering:

**Happy Path**
- Normal expected inputs
- Primary success scenarios

**Boundary Values**
- Minimum/maximum valid inputs
- Empty collections, zero values
- String length limits

**Edge Cases**
- Null/None/undefined inputs
- Empty strings, empty arrays
- Negative numbers (when unexpected)

**Error Handling**
- Invalid input types
- Out-of-range values
- Expected exceptions

### Step 4: Structure Tests (AAA Pattern)

Each test follows Arrange-Act-Assert:

```python
def test_calculate_discount_valid_percentage():
    # Arrange
    price = 100.0
    percentage = 20

    # Act
    result = calculate_discount(price, percentage)

    # Assert
    assert result == 80.0
```

### Step 5: Write Test File

Create the test file following project conventions:
- Place in appropriate test directory
- Use consistent naming
- Include necessary imports
- Add fixture setup if needed

## Examples

### Example 1: Python Function

**Source:** `src/utils/calculator.py`
```python
def calculate_discount(price: float, percentage: int) -> float:
    if not 0 <= percentage <= 100:
        raise ValueError("Percentage must be 0-100")
    return price * (1 - percentage / 100)
```

**Generated:** `tests/test_calculator.py`
```python
import pytest
from src.utils.calculator import calculate_discount


class TestCalculateDiscount:
    """Tests for calculate_discount function."""

    # Happy path tests
    def test_applies_discount_correctly(self):
        assert calculate_discount(100.0, 20) == 80.0

    def test_zero_discount_returns_original(self):
        assert calculate_discount(100.0, 0) == 100.0

    def test_full_discount_returns_zero(self):
        assert calculate_discount(100.0, 100) == 0.0

    # Boundary value tests
    @pytest.mark.parametrize("price,percentage,expected", [
        (100.0, 0, 100.0),    # Min boundary
        (100.0, 100, 0.0),    # Max boundary
        (100.0, 1, 99.0),     # Just above min
        (100.0, 99, 1.0),     # Just below max
    ])
    def test_boundary_values(self, price, percentage, expected):
        assert calculate_discount(price, percentage) == expected

    # Error handling tests
    def test_negative_percentage_raises_error(self):
        with pytest.raises(ValueError):
            calculate_discount(100.0, -1)

    def test_percentage_over_100_raises_error(self):
        with pytest.raises(ValueError):
            calculate_discount(100.0, 101)
```

### Example 2: TypeScript Function

**Source:** `src/utils/validator.ts`
```typescript
export function isValidEmail(email: string): boolean {
  const pattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return pattern.test(email);
}
```

**Generated:** `src/utils/validator.test.ts`
```typescript
import { isValidEmail } from './validator';

describe('isValidEmail', () => {
  // Happy path
  it('returns true for valid email', () => {
    expect(isValidEmail('[email protected]')).toBe(true);
  });

  // Valid variations
  it.each([
    ['[email protected]'],
    ['[email protected]'],
    ['[email protected]'],
  ])('returns true for %s', (email) => {
    expect(isValidEmail(email)).toBe(true);
  });

  // Invalid cases
  it.each([
    [''],
    ['invalid'],
    ['@example.com'],
    ['user@'],
    ['[email protected]'],
    ['user [email protected]'],
  ])('returns false for invalid email: %s', (email) => {
    expect(isValidEmail(email)).toBe(false);
  });
});
```

### Example 3: Go Function

**Source:** `pkg/math/operations.go`
```go
func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}
```

**Generated:** `pkg/math/operations_test.go`
```go
func TestDivide(t *testing.T) {
    tests := []struct {
        name    string
        a, b    float64
        want    float64
        wantErr bool
    }{
        {"positive numbers", 10, 2, 5, false},
        {"negative dividend", -10, 2, -5, false},
        {"negative divisor", 10, -2, -5, false},
        {"division by zero", 10, 0, 0, true},
        {"zero dividend", 0, 5, 0, false},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := Divide(tt.a, tt.b)
            if (err != nil) != tt.wantErr {
                t.Errorf("error = %v, wantErr %v", err, tt.wantErr)
                return
            }
            if got != tt.want {
                t.Errorf("got %v, want %v", got, tt.want)
            }
        })
    }
}
```

## Test Case Categories

| Category | What to Test | Example |
|----------|--------------|---------|
| Happy Path | Normal valid inputs | `add(2, 3)` returns `5` |
| Boundaries | Min/max valid values | `0`, `100` for percentage |
| Edge Cases | Unusual but valid | Empty string, single item |
| Null/None | Missing values | `None`, `null`, `undefined` |
| Type Errors | Wrong input types | String where number expected |
| Exceptions | Error conditions | Division by zero |

## Output Checklist

Before finalizing generated tests:

- [ ] Tests follow AAA pattern
- [ ] Naming convention matches project
- [ ] Happy path covered
- [ ] Boundary values tested
- [ ] Edge cases included
- [ ] Error handling verified
- [ ] Mocks properly configured
- [ ] Tests are deterministic
- [ ] No hardcoded paths or secrets
- [ ] Tests can run independently