How to Mock HTTP Requests in Go Tests

Introduction
Prerequisites
Setting Up the Project
Mocking HTTP Requests
Testing the Mocked HTTP Requests
Conclusion

Introduction

In Go, testing is an essential part of writing reliable and robust applications. When writing tests for code that makes HTTP requests, it is often necessary to mock those requests to control their behavior and ensure reliable testing. In this tutorial, we will explore how to mock HTTP requests in Go tests using the net/http/httptest package.

By the end of this tutorial, you will learn how to:

Set up a Go project for testing HTTP requests.
Create mock HTTP servers to simulate various scenarios.
Test the behavior of your code based on different HTTP responses.
Handle common errors and troubleshoot issues while mocking HTTP requests.

Let’s get started!

Prerequisites

To follow along with this tutorial, you should have a basic understanding of the Go programming language. You should also have Go installed on your machine and a text editor or integrated development environment (IDE) of your choice.

Setting Up the Project

Create a new directory for your project and navigate into it.

Initialize a new Go module using the following command:

```
go mod init mock-http-tutorial
```

This command will create a `go.mod` file to manage your project's dependencies.

Create a new file named main.go and open it in your text editor.

Inside main.go, create a simple function named GetResponse that makes an HTTP GET request to a given URL and returns the response body as a string. Here’s an example implementation:

```go
package main

import (
	"io/ioutil"
	"net/http"
)

func GetResponse(url string) (string, error) {
	resp, err := http.Get(url)
	if err != nil {
		return "", err
	}

	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", err
	}

	return string(body), nil
}
```

Save the file and close it.

Now, let’s write a test file to verify the behavior of our GetResponse function. Create a new file named main_test.go in the same directory as main.go.

Open main_test.go and import the necessary testing packages.

```go
package main

import (
	"net/http"
	"net/http/httptest"
	"testing"
)
```

We will use `http` and `httptest` packages to create mock servers and perform HTTP requests during testing.

Mocking HTTP Requests

To mock an HTTP request, we will utilize the httptest package provided by the Go standard library. This package allows us to create mock servers with various response scenarios.

Let’s create our first mock server to simulate a successful HTTP response.

Inside main_test.go, create a new test function named TestGetResponse_Success.

```go
func TestGetResponse_Success(t *testing.T) {
	// Setup mock server
	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		w.Write([]byte(`OK`))
	}))
	defer mockServer.Close()

	// Call the GetResponse function with the mocked server URL
	response, err := GetResponse(mockServer.URL)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Verify the response
	expectedResponse := "OK"
	if response != expectedResponse {
		t.Errorf("expected response %q, but got %q", expectedResponse, response)
	}
}
```

In this test function, we create a new mock server using `httptest.NewServer`. Inside the server's handler function, we set the HTTP response status code to 200 (OK) and write the response body as "OK". The deferred `mockServer.Close()` ensures that the mock server is properly closed after the test function completes.

We then call our `GetResponse` function with the URL of the mock server and verify that the response matches our expectations.

To run the test, navigate to the project directory in your terminal and execute the following command:
```
```
go test
```

You should see the test output, indicating that it ran successfully.
```
Congratulations! You have successfully mocked an HTTP request and tested the behavior of your code based on the response.

Testing the Mocked HTTP Requests

So far, we have tested the success scenario. Now, let’s explore how to handle other scenarios, such as server errors and empty responses.

Create a new test function named TestGetResponse_ServerError in main_test.go.

```go
func TestGetResponse_ServerError(t *testing.T) {
	// Setup mock server
	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusInternalServerError)
	}))
	defer mockServer.Close()

	// Call the GetResponse function with the mocked server URL
	_, err := GetResponse(mockServer.URL)
	if err == nil {
		t.Error("expected an error, but got nil")
	}
}
```

In this test, we create a mock server that returns a 500 (Internal Server Error) status code. We then call `GetResponse` and expect it to return an error.

Create another test function named TestGetResponse_EmptyResponse in main_test.go.

```go
func TestGetResponse_EmptyResponse(t *testing.T) {
	// Setup mock server
	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))
	defer mockServer.Close()

	// Call the GetResponse function with the mocked server URL
	response, err := GetResponse(mockServer.URL)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Verify the response
	expectedResponse := ""
	if response != expectedResponse {
		t.Errorf("expected response %q, but got %q", expectedResponse, response)
	}
}
```

In this test, we create a mock server that returns a 200 (OK) status code but with an empty response body. We expect `GetResponse` to return an empty string as well.

Now, you can run the tests again using go test command. You should see that all the tests pass, indicating that our code handles different scenarios correctly.

Conclusion

In this tutorial, you learned how to mock HTTP requests in Go tests using the httptest package. You explored various scenarios like success, server errors, and empty responses and tested your code’s behavior accordingly. You also gained knowledge on handling common errors and troubleshooting issues related to mocking HTTP requests.

By effectively mocking HTTP requests, you can write comprehensive tests for your Go applications and ensure their reliability. This will ultimately lead to more robust and bug-free software.

Feel free to explore more advanced concepts like mocking specific HTTP endpoints, testing different HTTP methods, or handling more complex scenarios using the provided examples as a starting point. Happy testing!

Published: 1 October 2020