Why Write Tests and How to Write Unit Tests in Go

Unit testing may seem tedious, but its long‑term benefits are clear: it ensures code quality before deployment, saves time and money throughout the product lifecycle, and helps developers write better code.

Tests catch errors early in the build stage, preventing costly fixes later and improving the end‑user experience. They also serve as documentation, allowing newcomers to understand code behavior quickly.

Complex code with many conditional paths is harder to test; measuring complexity (e.g., code coverage) highlights problematic areas. Good tests encourage the single‑responsibility principle, making code easier to maintain.

With solid test coverage, developers can safely modify code, detect regressions, and assess performance. Unit tests can simulate various scenarios, such as handling large hash tables, to evaluate how code scales.

Go provides a lightweight testing framework via the go test command and the testing package. A complete test for strings.Index looks like this:

package strings_test
import (
    "strings"
    "testing"
)
func TestIndex(t *testing.T) {
    const s, sep, want = "chicken", "ken", 4
    got := strings.Index(s, sep)
    if got != want {
        t.Errorf("Index(%q,%q) = %v; want %v", s, sep, got, want)
    }
}

Test files must end with _test.go and contain functions named TestXxx (Xxx starts with an uppercase letter). Place the test file in the same package as the code under test; it is excluded from normal builds and only compiled when go test runs.

Typical project layout:

project
|-main.go
|-main_test.go
|-api
|   |-route.go
|   |-route_test.go
|   |-handlers.go
|   `-handlers_test.go
|-storage.go
`-storage_test.go

Testing conventions include example functions ( Example , ExampleF , etc.) and benchmark functions using type B struct{} . The testing.T type provides methods such as Log , Errorf , Fatal , SkipNow , and Parallel for reporting and controlling test execution.

For setup and teardown, define func TestMain(m *testing.M) to run code before and after tests, handling flags and exiting with os.Exit(m.Run()) .

Running tests is done with go test , optionally with -v for verbose output. To test HTTP handlers, use the net/http/httptest package, which provides httptest.Server and httptest.ResponseRecorder for end‑to‑end and handler testing.

ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, client")
}))
defer ts.Close()
res, err := http.Get(ts.URL)
if err != nil { log.Fatal(err) }
body, _ := ioutil.ReadAll(res.Body)
res.Body.Close()
fmt.Printf("%s", body)

Using httptest.NewRecorder() allows inspection of response codes and bodies without a real network request.