Testing in Go

The Bug That Cost Us $2,847

It was a Tuesday when our billing system double-charged 127 customers. The bug was in our discount calculation:

func calculateDiscount(price float64, couponCode string) float64 {
    discount := 0.0
    
    if couponCode == "SAVE10" {
        discount = price * 0.10
    } else if couponCode == "SAVE20" {
        discount = price * 0.20
    }
    
    // BUG: Forgot to subtract discount!
    return price
}

I'd written this function on Friday, manually tested it once with fmt.Println(), and shipped it. Over the weekend, the bug processed hundreds of transactions.

The damage:

• $2,847 in refunds

• 3 hours of support tickets

• 1 very angry product manager

• 1 humiliated developer (me)

That Tuesday afternoon, I learned to write tests. Not "eventually" or "if I have time" - first. Before the code even runs.

This article covers the testing practices that prevented every bug since.

---

Test-Driven Development (TDD)

After the billing disaster, I adopted TDD:

1. Write the test first (it fails)

2. Write minimal code to pass the test

3. Refactor while keeping tests green

The Corrected Version (TDD Style)

Step 1: Write the test

// discount_test.go
package main

import "testing"

func TestCalculateDiscount(t *testing.T) {
    // Test SAVE10 coupon
    result := calculateDiscount(100.0, "SAVE10")
    expected := 90.0  // 100 - (100 * 0.10)
    
    if result != expected {
        t.Errorf("Expected %.2f, got %.2f", expected, result)
    }
}

Run it:

go test
# FAIL: undefined: calculateDiscount

Step 2: Write minimal code

// discount.go
package main

func calculateDiscount(price float64, couponCode string) float64 {
    discount := 0.0
    
    if couponCode == "SAVE10" {
        discount = price * 0.10
    }
    
    return price - discount  // NOW we subtract!
}

Run it:

go test
# PASS

Step 3: Add more test cases

func TestCalculateDiscount(t *testing.T) {
    tests := []struct {
        price      float64
        couponCode string
        expected   float64
    }{
        {100.0, "SAVE10", 90.0},
        {100.0, "SAVE20", 80.0},
        {100.0, "INVALID", 100.0},
        {50.0, "SAVE10", 45.0},
    }
    
    for _, tt := range tests {
        result := calculateDiscount(tt.price, tt.couponCode)
        if result != tt.expected {
            t.Errorf("calculateDiscount(%.2f, %s) = %.2f; want %.2f",
                tt.price, tt.couponCode, result, tt.expected)
        }
    }
}

The bug would never have made it to production.

---

Testing Basics

File Naming Convention

calculator.go        # Implementation
calculator_test.go   # Tests (must end in _test.go)

Test Function Signature

func TestFunctionName(t *testing.T) {
    // Test code
}

Rules:

• Function name starts with Test

• Takes *testing.T parameter

• File ends with _test.go

Running Tests

# Run all tests in current directory
go test

# Run tests in all subdirectories
go test ./...

# Verbose output
go test -v

# Run specific test
go test -run TestCalculateDiscount

# Run tests matching pattern
go test -run TestCalculate

---

Table-Driven Tests

The most idiomatic Go testing pattern.

Basic Pattern

func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive numbers", 2, 3, 5},
        {"negative numbers", -2, -3, -5},
        {"mixed signs", -2, 3, 1},
        {"zero", 0, 0, 0},
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("add(%d, %d) = %d; want %d",
                    tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

Benefits:

• Easy to add new test cases

• Clear test names

• DRY (Don't Repeat Yourself)

Real Example: Email Validator

package main

import (
    "regexp"
    "testing"
)

func isValidEmail(email string) bool {
    re := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
    return re.MatchString(email)
}

func TestIsValidEmail(t *testing.T) {
    tests := []struct {
        name  string
        email string
        want  bool
    }{
        {"valid email", "[email protected]", true},
        {"valid with subdomain", "[email protected]", true},
        {"valid with plus", "[email protected]", true},
        {"missing @", "userexample.com", false},
        {"missing domain", "user@", false},
        {"missing TLD", "user@example", false},
        {"empty string", "", false},
        {"spaces", "user @example.com", false},
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := isValidEmail(tt.email)
            if got != tt.want {
                t.Errorf("isValidEmail(%q) = %v; want %v",
                    tt.email, got, tt.want)
            }
        })
    }
}

Output:

go test -v
=== RUN   TestIsValidEmail
=== RUN   TestIsValidEmail/valid_email
=== RUN   TestIsValidEmail/valid_with_subdomain
=== RUN   TestIsValidEmail/valid_with_plus
=== RUN   TestIsValidEmail/missing_@
=== RUN   TestIsValidEmail/missing_domain
=== RUN   TestIsValidEmail/missing_TLD
=== RUN   TestIsValidEmail/empty_string
=== RUN   TestIsValidEmail/spaces
--- PASS: TestIsValidEmail (0.00s)
PASS

---

Test Coverage

Measuring Coverage

# Run tests with coverage
go test -cover

# Output:
# PASS
# coverage: 87.5% of statements

# Detailed coverage report
go test -coverprofile=coverage.out

# View coverage in browser
go tool cover -html=coverage.out

Example with Coverage Analysis

// math.go
package main

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func multiply(a, b float64) float64 {
    return a * b
}

Test file:

// math_test.go
func TestDivide(t *testing.T) {
    result, err := divide(10, 2)
    if err != nil {
        t.Fatal(err)
    }
    if result != 5.0 {
        t.Errorf("Expected 5.0, got %.2f", result)
    }
}

Check coverage:

go test -cover
# coverage: 50.0% of statements
# Missing: divide by zero case, multiply function

Add missing tests:

func TestDivide(t *testing.T) {
    tests := []struct {
        name        string
        a, b        float64
        expected    float64
        expectError bool
    }{
        {"normal division", 10, 2, 5.0, false},
        {"division by zero", 10, 0, 0, true},
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result, err := divide(tt.a, tt.b)
            
            if tt.expectError {
                if err == nil {
                    t.Error("Expected error, got nil")
                }
            } else {
                if err != nil {
                    t.Fatalf("Unexpected error: %v", err)
                }
                if result != tt.expected {
                    t.Errorf("Expected %.2f, got %.2f", tt.expected, result)
                }
            }
        })
    }
}

func TestMultiply(t *testing.T) {
    result := multiply(3, 4)
    if result != 12 {
        t.Errorf("Expected 12, got %.2f", result)
    }
}

Now:

go test -cover
# coverage: 100.0% of statements

---

Benchmarks

Measure performance with benchmarks.

Basic Benchmark

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        add(2, 3)
    }
}

Run it:

go test -bench=.

# Output:
# BenchmarkAdd-8    1000000000    0.25 ns/op

Means: 1 billion iterations, 0.25 nanoseconds per operation.

Real Example: String Concatenation

package main

import (
    "strings"
    "testing"
)

// Method 1: += operator
func concatPlus(strs []string) string {
    result := ""
    for _, s := range strs {
        result += s
    }
    return result
}

// Method 2: strings.Builder
func concatBuilder(strs []string) string {
    var builder strings.Builder
    for _, s := range strs {
        builder.WriteString(s)
    }
    return builder.String()
}

// Benchmarks
func BenchmarkConcatPlus(b *testing.B) {
    strs := []string{"Hello", " ", "World", "!"}
    
    for i := 0; i < b.N; i++ {
        concatPlus(strs)
    }
}

func BenchmarkConcatBuilder(b *testing.B) {
    strs := []string{"Hello", " ", "World", "!"}
    
    for i := 0; i < b.N; i++ {
        concatBuilder(strs)
    }
}

Results:

go test -bench=. -benchmem

# BenchmarkConcatPlus-8      5000000    312 ns/op    48 B/op    3 allocs/op
# BenchmarkConcatBuilder-8   20000000   67 ns/op     24 B/op    1 allocs/op

Builder is 4.6x faster with fewer allocations!

---

Example Tests

Example tests serve as documentation.

package main

import "fmt"

func ExampleAdd() {
    result := add(2, 3)
    fmt.Println(result)
    // Output: 5
}

func ExampleDivide() {
    result, _ := divide(10, 2)
    fmt.Printf("%.1f", result)
    // Output: 5.0
}

func ExampleDivide_error() {
    _, err := divide(10, 0)
    fmt.Println(err)
    // Output: division by zero
}

Benefits:

• Appears in go doc output

• Verified by go test

• Serves as documentation

---

Test Helpers and Utilities

Helper Functions

func assertEqual(t *testing.T, got, want interface{}) {
    t.Helper()  // Marks this as helper (shows correct line number)
    
    if got != want {
        t.Errorf("got %v; want %v", got, want)
    }
}

func TestSomething(t *testing.T) {
    result := add(2, 3)
    assertEqual(t, result, 5)  // Cleaner!
}

Setup and Teardown

func TestMain(m *testing.M) {
    // Setup
    fmt.Println("Setting up tests...")
    setupDatabase()
    
    // Run tests
    code := m.Run()
    
    // Teardown
    fmt.Println("Cleaning up...")
    cleanupDatabase()
    
    os.Exit(code)
}

Subtests

func TestDatabase(t *testing.T) {
    t.Run("insert", func(t *testing.T) {
        // Test insert
    })
    
    t.Run("update", func(t *testing.T) {
        // Test update
    })
    
    t.Run("delete", func(t *testing.T) {
        // Test delete
    })
}

Run specific subtest:

go test -run TestDatabase/insert

---

Testify Library

The most popular testing library adds assertions and mocks.

Installation

go get github.com/stretchr/testify

Assertions

package main

import (
    "testing"
    "github.com/stretchr/testify/assert"
)

func TestWithAssert(t *testing.T) {
    result := add(2, 3)
    
    // Instead of:
    // if result != 5 { t.Errorf(...) }
    
    // Use:
    assert.Equal(t, 5, result)
    assert.NotNil(t, result)
    assert.True(t, result > 0)
}

Require (Stops Test on Failure)

import "github.com/stretchr/testify/require"

func TestWithRequire(t *testing.T) {
    db, err := openDatabase()
    require.NoError(t, err)  // Stops here if error
    
    // Safe to use db here
    user, err := db.GetUser(123)
    require.NoError(t, err)
    assert.Equal(t, "Alice", user.Name)
}

Common Assertions

// Equality
assert.Equal(t, expected, actual)
assert.NotEqual(t, expected, actual)

// Nil checks
assert.Nil(t, err)
assert.NotNil(t, user)

// Boolean
assert.True(t, condition)
assert.False(t, condition)

// Errors
assert.NoError(t, err)
assert.Error(t, err)

// Collections
assert.Contains(t, []int{1, 2, 3}, 2)
assert.Len(t, slice, 5)
assert.Empty(t, slice)

---

Mocking Strategies

Interface-Based Mocking

// User service interface
type UserService interface {
    GetUser(id int) (*User, error)
    CreateUser(name string) (*User, error)
}

// Real implementation
type RealUserService struct {
    db *sql.DB
}

func (s *RealUserService) GetUser(id int) (*User, error) {
    // Query database
}

// Mock implementation for testing
type MockUserService struct {
    users map[int]*User
}

func (m *MockUserService) GetUser(id int) (*User, error) {
    user, ok := m.users[id]
    if !ok {
        return nil, errors.New("user not found")
    }
    return user, nil
}

func (m *MockUserService) CreateUser(name string) (*User, error) {
    user := &User{ID: len(m.users) + 1, Name: name}
    m.users[user.ID] = user
    return user, nil
}

// Test using mock
func TestHandleUser(t *testing.T) {
    mock := &MockUserService{
        users: map[int]*User{
            1: {ID: 1, Name: "Alice"},
        },
    }
    
    handler := NewUserHandler(mock)
    
    user, err := handler.GetUserByID(1)
    assert.NoError(t, err)
    assert.Equal(t, "Alice", user.Name)
}

Testify Mock

import "github.com/stretchr/testify/mock"

type MockUserService struct {
    mock.Mock
}

func (m *MockUserService) GetUser(id int) (*User, error) {
    args := m.Called(id)
    if args.Get(0) == nil {
        return nil, args.Error(1)
    }
    return args.Get(0).(*User), args.Error(1)
}

// In test
func TestWithMock(t *testing.T) {
    mockService := new(MockUserService)
    
    // Setup expectations
    mockService.On("GetUser", 1).Return(&User{ID: 1, Name: "Alice"}, nil)
    
    // Call code under test
    handler := NewUserHandler(mockService)
    user, err := handler.GetUserByID(1)
    
    // Assertions
    assert.NoError(t, err)
    assert.Equal(t, "Alice", user.Name)
    
    // Verify mock was called correctly
    mockService.AssertExpectations(t)
}

---

Real Example: Testing HTTP Handlers

package main

import (
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"
    "github.com/stretchr/testify/assert"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func getUserHandler(w http.ResponseWriter, r *http.Request) {
    user := User{ID: 1, Name: "Alice"}
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

func TestGetUserHandler(t *testing.T) {
    // Create request
    req := httptest.NewRequest("GET", "/user/1", nil)
    
    // Create response recorder
    rr := httptest.NewRecorder()
    
    // Call handler
    getUserHandler(rr, req)
    
    // Check status code
    assert.Equal(t, http.StatusOK, rr.Code)
    
    // Check content type
    assert.Equal(t, "application/json", rr.Header().Get("Content-Type"))
    
    // Check response body
    var user User
    err := json.NewDecoder(rr.Body).Decode(&user)
    assert.NoError(t, err)
    assert.Equal(t, 1, user.ID)
    assert.Equal(t, "Alice", user.Name)
}

---

Real Project: Complete Test Suite

Here's a test suite from one of my projects:

package calculator

import (
    "testing"
    "github.com/stretchr/testify/assert"
)

// calculator.go
type Calculator struct {
    value float64
}

func (c *Calculator) Add(n float64) *Calculator {
    c.value += n
    return c
}

func (c *Calculator) Subtract(n float64) *Calculator {
    c.value -= n
    return c
}

func (c *Calculator) Multiply(n float64) *Calculator {
    c.value *= n
    return c
}

func (c *Calculator) Divide(n float64) error {
    if n == 0 {
        return errors.New("division by zero")
    }
    c.value /= n
    return nil
}

func (c *Calculator) Result() float64 {
    return c.value
}

// calculator_test.go
func TestCalculator(t *testing.T) {
    t.Run("basic operations", func(t *testing.T) {
        calc := &Calculator{}
        
        result := calc.Add(10).Multiply(2).Subtract(5).Result()
        assert.Equal(t, 15.0, result)
    })
    
    t.Run("division", func(t *testing.T) {
        calc := &Calculator{value: 10}
        
        err := calc.Divide(2)
        assert.NoError(t, err)
        assert.Equal(t, 5.0, calc.Result())
    })
    
    t.Run("division by zero", func(t *testing.T) {
        calc := &Calculator{value: 10}
        
        err := calc.Divide(0)
        assert.Error(t, err)
        assert.Equal(t, 10.0, calc.Result()) // Value unchanged
    })
}

func BenchmarkCalculator(b *testing.B) {
    calc := &Calculator{}
    
    for i := 0; i < b.N; i++ {
        calc.Add(10).Multiply(2).Subtract(5)
    }
}

---

Your Challenge

Write a complete test suite for a URL shortener:

type URLShortener struct {
    urls map[string]string  // short -> long
}

// Implement these methods:
// func (u *URLShortener) Shorten(longURL string) (string, error)
// func (u *URLShortener) Expand(shortURL string) (string, error)

// Write tests for:
// 1. Successful shortening
// 2. Successful expansion
// 3. Invalid URLs
// 4. Duplicate URLs (should return same short URL)
// 5. Expanding non-existent short URL
// 6. Benchmark shortening 1000 URLs

// Bonus: Use testify for assertions

---

Key Takeaways

1. TDD: Write tests first, then code

2. Table-driven tests: Most idiomatic Go pattern

3. Coverage: Aim for >80%, but quality > quantity

4. Benchmarks: Measure performance, compare approaches

5. Example tests: Executable documentation

6. Testify: Popular library for assertions and mocks

7. Interface mocking: Test without dependencies

8. httptest: Test HTTP handlers easily

---

What I Learned

That $2,847 billing bug taught me that tests aren't optional:

• TDD prevented bugs before they reached production

• Table-driven tests made edge cases obvious

• 95% coverage caught issues in code review

• Zero billing bugs in 18 months since adopting TDD

Coming from Python's unittest complexity and JavaScript's Jest configuration hell, Go's testing felt refreshing. No setup. No configuration. Just write tests.

The time saved debugging production issues? Immeasurable. The confidence to refactor fearlessly? Priceless.

---

Next: JSON and REST APIs

In the next article, we'll build a complete REST API client. You'll learn JSON marshaling, HTTP requests, middleware, and the patterns I used to build production-ready API integrations.