Testing plays a fundamental role in the development of quality software. Shipping and deploying software with undetected bugs and regressions opens up a can of terrible consequences such as losing the trust of end users or costing the business time and resources. In a large collaborative setting, having developers manually test each and every feature and user flow for bugs and regressions wastes valuable time that can be put towards improving other aspects of the software. As the codebase and team grows, this approach will not scale. By writing unit/integration/end-to-end tests, identifying and catching bugs and regressions throughout an entire codebase becomes a painless, automatable task that can easily be integrated into any continuous integration pipeline. 

Unlike most other languages, the Go programming language provides a built-in, standard library package for testing: 

 package offers many utilities for automating the testing of Go source files. To write a test in Go, define a function with a name prefixed with 

 (followed by a capitalized segment of text) and accepts an argument of struct type 

, which contains methods for failing and skipping tests, running multiple tests in parallel, formatting test logs, etc. 

import (
  "testing"
)

func TestSum(t *testing.T) {
  expected := 3
  result := Sum(1, 2)

  if result != expected {
    t.Errorf("Expected: %d. Got: %d.", expected, result)
  }
}

 function correctly calculates the sum of two integer numbers. If the sum does not match the expected value, then the test logs an error message and marks itself as having failed.

 RESTful API from GitHub to your machine:

git clone --branch testless https://github.com/newline-sandbox/go-chi-restful-api.git

This RESTful API specifies five endpoints for performing operations on posts:

If you would like to learn how to build this RESTful API, then please visit this 

 branch's version of the RESTful API, the 

 subdirectory, and the route handlers within this file have been refactored into a 

 package to allow the testing of packages independent of the 

Run the following command to install the project's dependencies:

: If you run into installation issues, then verify that the version of Go running on your machine is 

 subdirectory. This file will contain tests for each of the route handlers within the 

 router via a corresponding routing method named as an HTTP method. To register the 

 sub-router is attached to the main router along the 

 struct) is a route handler method defined on the 

 struct. It retrieves a list of posts from the JSONPlaceholder API:

// A package-scoped variable. Other packages can access this variable by referencing this package's name.
var (
  GetPosts = (&JsonPlaceholder{}).GetPosts
)

type JsonPlaceholder struct {}

func (*JsonPlaceholder) GetPosts() (*http.Response, error) {
  resp, err := http.Get("https://jsonplaceholder.typicode.com/posts")

  if err != nil {
    return &http.Response{
      // An empty placeholder body to satisfy the `http.Response` struct while still  returning an error. Body is of type `io.ReadCloser`.
      Body: ioutil.NopCloser(bytes.NewBuffer(nil)),
    }, err
  }

  return resp, nil
}

func (rs PostsResource) List(w http.ResponseWriter, r *http.Request) {
  resp, err := GetPosts()

  if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
  }

  // Close the response body. `defer` postpones the execution of a function until the function's surrounding outside function returns. 
  defer resp.Body.Close()

  // Set the `Content-Type` header of the response to `application/json`.
  w.Header().Set("Content-Type", "application/json")

  // Copy the response body from the JSONPlaceholder API to `ResponseWriter`.
  if _, err := io.Copy(w, resp.Body); err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
  }
}

, which tests a single unit of code (commonly a function), for the 

 route handler function. Start off with a simple failing test that will immediately fail and print the message "Not yet implemented." to the terminal:

package routes

import "testing"

func TestGetPostsHandler(t *testing.T) {
  t.Fatal("Not yet implemented.")
}

To test all packages within the current working directory recursively...

req, err := http.NewRequest("GET", "/posts", nil)

if err != nil {
  t.Errorf("Error creating a new request: %v", err)
}

handler := http.HandlerFunc(PostsResource{}.List)

if status := rr.Code; status != http.StatusOK {
  t.Errorf("Handler returned wrong status code. Expected: %d. Got: %d.", http.StatusOK, status)
}

var posts []Post

if err := json.NewDecoder(rr.Body).Decode(&posts); err != nil {
  t.Errorf("Error decoding response body: %v", err)
}

resultTotal := len(posts)
expectedTotal := 100

if resultTotal != expectedTotal {
  t.Errorf("Expected: %d. Got: %d.", expectedTotal, resultTotal)
}

Let's combine these code snippets together:

package routes

import (
  "encoding/json"
  "net/http"
  "net/http/httptest"
  "testing"
)

type Post struct {
  Id int
  UserId int
  Title string
  Body string
}

func TestGetPostsHandler(t *testing.T) {
  req, err := http.NewRequest("GET", "/posts", nil)

  if err != nil {
    t.Errorf("Error creating a new request: %v", err)
  }

  rr := httptest.NewRecorder()
  handler := http.HandlerFunc(PostsResource{}.List)
  handler.ServeHTTP(rr, req)

  if status := rr.Code; status != http.StatusOK {
    t.Errorf("Handler returned wrong status code. Expected: %d. Got: %d.", http.StatusOK, status)
  }

  var posts []Post

  if err := json.NewDecoder(rr.Body).Decode(&posts); err != nil {
    t.Errorf("Error decoding response body: %v", err)
  }

  resultTotal := len(posts)
  expectedTotal := 100

  if resultTotal != expectedTotal {
    t.Errorf("Expected: %d. Got: %d.", expectedTotal, resultTotal)
  }
}

Mocking a Function Called Within a Route Handler

 takes approximately half a second to run due to the network request the 

 route handler sent to the JSONPlaceholder API. If the JSONPlaceholder API experiences heavy traffic or any server outages/downtime, then the network request may either take too long to send back a response or completely time out. Because our tests rely on the status of a third-party service, which we have no control over, our tests take much longer to finish running. Let's work on eliminating this unreliability factor from 

 function, which sends this network request and pipes the response back into 

 if there was no network request error encountered. 

// ...

var (
  GetPosts = (&JsonPlaceholder{}).GetPosts
)

func (*JsonPlaceholder) GetPosts() (*http.Response, error) {
  resp, err := http.Get("https://jsonplaceholder.typicode.com/posts")

  if err != nil {
    return &http.Response{
      Body: ioutil.NopCloser(bytes.NewBuffer(nil)),
    }, err
  }

  return resp, nil
}

func (rs PostsResource) List(w http.ResponseWriter, r *http.Request) {
  resp, err := GetPosts()

  // ...
}

// ...

Since the function responsible for sending the network request (

) is a package-scoped variable within the 

 package, this function can be replaced with a 

, which replaces the actual implementation of a function with one that simulates its behavior. Particularly, the network request will be simulated. As long as the mock function has the same function signature as the original function, calling the route handler in a test will remain the same.   

// ...

import (
  "bytes"
  "encoding/json"
  "io/ioutil"
  "log"
  "net/http"
  "net/http/httptest"
  "testing"
)

// ...

type JsonPlaceholderMock struct {}

func (*JsonPlaceholderMock) GetPosts() (*http.Response, error) {
  mockedPosts := []Post{{
    Id: 1,
    UserId: 2,
    Title: "Hello World",
    Body: "Foo Bar",
  }}

  respBody, err := json.Marshal(mockedPosts)

  if err != nil {
    log.Panicf("Error reading mocked response data: %v", err)
  }

  return &http.Response{
    StatusCode: http.StatusOK,
    Body: ioutil.NopCloser(bytes.NewBuffer(respBody)),
  }, nil
}

This mock function creates some dummy data (

, which is a list containing one post), encodes this data as JSON via 

 and returns a minimal HTTP response with a status code and body. These fields adhere to the 

 package-scoped variable to this mock function and change the 

func TestGetPostsHandler(t *testing.T) {
  GetPosts = (&JsonPlaceholderMock{}).GetPosts

  // ...

  expectedTotal := 1

  // ...
}

Wow! The mock allows our test to run much faster.

 for a final version of the route handler unit test.

Try writing tests for the other route handlers.

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Tutorials on Route Handler

Testing a Go and chi RESTful API - Route Handlers (Part 1)

Email Newsletter

Popular Topics

Masterclasses

Tutorials

Fullstack React with TypeScript