go-tdd-baby-steps

Go TDD Baby Steps

Test-Driven Development using the smallest possible increments, with Go idioms.

Three Laws of TDD

1. Don't write production code until you have a failing test
2. Don't write more test code than is sufficient to fail (compilation failures count)
3. Don't write more production code than is sufficient to pass the currently failing test

These laws create a tight feedback loop: write a tiny test, watch it fail, write just enough code to pass.

Red-Green-Refactor

1. Red - Write a small test that fails
2. Green - Write the minimal code to make it pass
3. Refactor - Clean up while keeping tests green

Each cycle should take ~2 minutes. If longer, the step is too big.

The Revert Rule

If stuck or code is getting messy:

1. Revert to the last green state
2. Rethink the approach
3. Take a smaller step

Never debug longer than the cycle itself. Revert instead.

Baby Steps with Go Table-Driven Tests

Build up the test table incrementally — each row adds ONE behavior.

Step 1: Zero/empty case

func TestParseAmount(t *testing.T) {
	tests := []struct {
		name    string
		input   string
		want    int
		wantErr bool
	}{
		{name: "empty string", input: "", want: 0, wantErr: true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := ParseAmount(tt.input)
			if tt.wantErr {
				require.Error(t, err)
				return
			}
			require.NoError(t, err)
			assert.Equal(t, tt.want, got)
		})
	}
}

Production code (fake it):

func ParseAmount(s string) (int, error) {
	return 0, errors.New("empty")
}

Step 2: Single simple case

Add one row, generalize production code:

{name: "single digit", input: "5", want: 5},

func ParseAmount(s string) (int, error) {
	if s == "" {
		return 0, errors.New("empty input")
	}
	return strconv.Atoi(s)
}

Step 3: Edge cases, one at a time

{name: "negative number", input: "-3", want: -3},
{name: "leading zeros", input: "007", want: 7},
{name: "non-numeric", input: "abc", wantErr: true},