Testing in Go

# CHAPTER 26

Testing in Go #

1. Introduction #

2. Learning Objectives #

• Name and structure Go test files.

• Write basic Unit Tests.

• Run tests using the go test command.

• Implement Table-Driven Tests (the Go community standard).

• Write Benchmark Tests to measure performance.

3. File Naming and Structure #

When you compile your application for production (go build), the compiler automatically ignores all _test.go files, keeping your production binary incredibly small!

4. Writing Your First Unit Test #

math.go

package main

func Add(a, b int) int {
    return a + b
}

math_test.go

package main

import "testing"

// Test functions MUST start with the word 'Test' followed by a capital letter.
// They MUST accept a pointer to testing.T
func TestAdd(t *testing.T) {
    result := Add(2, 3)
    expected := 5

    if result != expected {
        // t.Errorf logs the failure and marks the test as FAILED
        t.Errorf("Add(2, 3) FAILED. Expected %d, got %d", expected, result)
    }
}

5. Running Tests #

go test

*Output:* PASS ok my-app 0.001s

To get verbose, detailed output of every single test, run:

go test -v

6. Table-Driven Tests (The Go Standard) #

func TestAddTableDriven(t *testing.T) {
    // 1. Define the "Table" of test cases
    tests := []struct {
        name     string
        a        int
        b        int
        expected int
    }{
        {"Positive Numbers", 2, 3, 5},
        {"Negative Numbers", -5, -2, -7},
        {"Zeroes", 0, 0, 0},
    }

    // 2. Loop through and execute
    for _, tc := range tests {
        t.Run(tc.name, func(t *testing.T) {
            result := Add(tc.a, tc.b)
            if result != tc.expected {
                t.Errorf("Expected %d, got %d", tc.expected, result)
            }
        })
    }
}

7. Benchmark Tests #

// Benchmark functions test performance
func BenchmarkAdd(b *testing.B) {
    // b.N is automatically adjusted by Go to run the loop millions of times
    // until it gets a statistically accurate time measurement.
    for i := 0; i < b.N; i++ {
        Add(100, 200)
    }
}

Run benchmarks in the terminal using:

go test -bench=.

*Output Example:* BenchmarkAdd-8 1000000000 0.314 ns/op (Meaning it ran 1 Billion times, and took 0.314 nanoseconds per operation!)

8. Common Mistakes #

• Wrong Function Names: Naming your test testAdd() (lowercase 't') or Testadd() (lowercase second word). The function MUST start with Test followed by a Capital letter. If it doesn't, go test completely ignores it.

• Not using Table-Driven Tests: Writing 50 blocks of copy-pasted if result != expected code. It makes tests unreadable and hard to maintain.

9. Best Practices #

• Test Coverage: You can check what percentage of your code is covered by tests using: go test -cover. Aim for 70-80% coverage in enterprise applications.

10. Exercises #

1. 1. Write a function IsEven(n int) bool in main.go.

1. 2. Create maintest.go and write a standard unit test to verify IsEven(4) returns true.

1. 2. How do you ensure that test files do not bloat the production binary size? (Answer: By adhering to the test.go naming convention, the compiler handles it automatically).

1. 3. How do you measure the nanosecond performance of a specific function in Go?

13. Summary #

14. Next Chapter Recommendation #