# Table-Driven Test Generator Generate complete Vitest/Jest/pytest table-driven tests for any function. Covers happy path, boundary values, null/undefined, async rejection, and type edge cases. Ready to run, zero placeholder text. ## Quick Reference # Table-Driven Test Generator > **Purpose:** Generate a complete, runnable test file for any function using table-driven tests (`it.each` / `test.each` in Vitest/Jest, parametrize in pytest). Covers: happy path, boundary values, null/undefined inputs, empty collections, async rejection, and type coercion edge cases. Output can be pasted directly into a `.test.ts` or `_test.py` file and run immediately. --- ## Invocation ``` /test ``` **Examples:** - `/test function add(a: number, b: number): number { return a + b }` - `/test async function fetchUser(id: string): Promise` - `/test def calculate_discount(price: float, pct: float) -> float:` --- ## Process ### Step 1: Analyze the Function Identify: - **Inputs**: types, constraints, optional vs required - **Output**: return type, possible return values - **Side effects**: async operations, mutations, I/O - **Failure modes**: throws, returns null, rejects, etc. --- ### Step 2: Design Test Cases For every function, generate tests covering: | Category | Examples | |----------|---------| | Happy path | Typical inputs, expected output | | Boundary — low | 0, -1, empty string, empty array | | Boundary — high | MAX_SAFE_INTEGER, very long string, large array | | Null / undefined | null, undefined, missing optional param | | Type edge cases | NaN, Infinity, 0.1 + 0.2 floating point | | Async rejection | Network error, timeout, invalid response | | Error path | Invalid input → throws specific error | | Idempotency | Same input twice → same output | --- ### Step 3: Write the Test File **Vitest / Jest output:** ```typescript import { describe, it, expect, vi } from 'vitest' import { functionName } from './module' describe('functionName', () => { it.each([ // [description, input1, input2, ..., expected] ['happy path: typical inputs', arg1, arg2, expectedOutput], ['boundary: zero value', 0, arg2, expectedForZero], ['boundary: negative', -1, arg2, expectedForNegative], ['null input: first arg null', null, arg2, expectedForNull], ])('%s', (description, input1, input2, expected) => { // Arrange const input = buildInput(input1, input2) // Act const result = functionName(input1, input2) // Assert expect(result).toEqual(expected) }) it('throws on invalid input', () => { // Arrange + Act + Assert expect(() => functionName(invalidInput)).toThrow('Expected error message') }) it('handles async rejection gracefully', async () => { // Arrange vi.mocked(dependency).mockRejectedValue(new Error('Network error')) // Act + Assert await expect(functionName(input)).rejects.toThrow('Network error') }) }) ``` **pytest output:** ```python import pytest from module import function_name @pytest.mark.parametrize("description,input_val,expected", [ ("happy path: typical input", typical_input, expected_output), ("boundary: zero", 0, expected_for_zero), ("boundary: negative", -1, expected_for_neg), ("None input", None, expected_for_none), ]) def test_function_name(description, input_val, expected): # Arrange + Act result = function_name(input_val) # Assert assert result == expected, f"Failed: {description}" def test_function_name_raises_on_invalid(): with pytest.raises(ValueError, match="Expected message"): function_name(invalid_input) ``` --- ## Rules - Every test must follow AAA (Arrange / Act / Assert) with comment labels - The table must have at least 5 rows: 1 happy path + 4 edge cases - Async functions must include at least one rejection test - No placeholder text in the output — all test values must be concrete - If the function has side effects (DB write, HTTP call): add a mock setup block - Output must be runnable as-is — the only acceptable TODO is "fill in real mock return value" - Detect framework from function syntax: TypeScript → Vitest, Python → pytest, Go → `testing.T` table tests ## Playground
Table-Driven Test GeneratorExample · SkillSlap
Input: Go function
func Clamp(v, min, max int) int {
    if v < min { return min }
    if v > max { return max }
    return v
}
Output: Table-driven tests
func TestClamp(t *testing.T) {
  tests := []struct{
    name     string
    v,mn,mx  int
    want     int
  }{
    {"below min", -5, 0, 10, 0},
    {"above max", 15, 0, 10, 10},
    {"in range",   5, 0, 10,  5},
    {"at min",     0, 0, 10,  0},
    {"at max",    10, 0, 10, 10},
  }

  for _, tc := range tests {
    t.Run(tc.name, func(t *testing.T) {
      got := Clamp(tc.v, tc.mn, tc.mx)
      if got != tc.want {
        t.Errorf("got %d want %d",
          got, tc.want)
      }
    })
  }
}