test-generation

Test Generation

For any given code, produce all of the following — not just the happy-path test that's easiest to write.

What to generate

1. Unit tests, per exported function/method:

• Happy path — normal inputs produce expected outputs
• Error paths — every error condition is triggered and its content verified (not just err != nil)
• Nil/zero inputs — behavior with empty or zero values
• Boundary values — min, max, empty slice, single element, max slice

2. Table-driven tests (Go) — for any function with multiple input variants:

func TestFoo(t *testing.T) {
    tests := []struct {
        name    string
        input   InputType
        want    OutputType
        wantErr bool
    }{
        {"happy path", validInput, expectedOutput, false},
        {"nil input", nil, zero, true},
        {"empty string", "", zero, true},
    }
    for _, tc := range tests {
        tc := tc // capture range variable (needed pre-Go 1.22; see Gotchas)
        t.Run(tc.name, func(t *testing.T) {
            t.Parallel()
            got, err := Foo(tc.input)
            if (err != nil) != tc.wantErr {
                t.Fatalf("err = %v, wantErr %v", err, tc.wantErr)
            }
            if !tc.wantErr && got != tc.want {
                t.Errorf("got %v, want %v", got, tc.want)
            }
        })
    }
}

3. Concurrency tests (Go) — for any function touching shared state, channels, or goroutines:

• Design the test to run under go test -race, not just to pass without it.
• Use sync.WaitGroup to synchronize multiple goroutines exercising the code concurrently.
• Assert the invariant holds after concurrent access, not just that it doesn't panic — a race can corrupt data silently without crashing.

4. Mock patterns — for external dependencies (database, HTTP, filesystem):

• Mock through an interface (hand-written or golang/mock/uber-go/mock), not by monkey-patching a concrete type.
• Cover both the success and error return from the mock.
• Verify the mock was called the expected number of times when call count is part of the contract (e.g., "retries exactly twice").