Go Testing with Fake HTTP Requests and Responses

Oct 4

Go provides a robust testing framework right out of the box. When working with web applications or services, a common challenge developers face is testing code that involves HTTP requests and responses without actually hitting the real endpoints. In this post, we'll dive deep into creating and using fake HTTP requests and responses for testing in Go.

Why Fake HTTP Transactions?

Speed: Avoid the overhead of network latency.
Reliability: Tests won't fail due to issues with external services.
Control: Simulate any scenario, including edge cases or error states, regardless of the real service's behavior.

Step-by-Step Guide

1. Using `http/httptest`

Go's standard library provides a package named http/httptest specifically designed to help with this.

Creating a Fake Response Server

Use httptest.NewServer to create a mock HTTP server:

server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"message": "Hello, World!"}`))
}))
defer server.Close()

When you call server.URL, you'll get a URL that points to the mock server. Use this as the endpoint in your tests.

Creating a Fake Request

To simulate an HTTP request without actually sending it:

req, err := http.NewRequest(http.MethodGet, "/path", nil)
if err != nil {
    // Handle error
}

rr := httptest.NewRecorder()
handler := http.HandlerFunc(YourActualHandlerFunction)
handler.ServeHTTP(rr, req)

// Check the status code and other assertions
if status := rr.Code; status != http.StatusOK {
    t.Errorf("Handler returned wrong status code: got %v want %v", status, http.StatusOK)
}

2. Testing the HTTP Client

If you want to test how your code behaves when making outbound HTTP requests, you can create a fake HTTP server that responds with controlled responses.

For example:

mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"fake": "data"}`))
}))
defer mockServer.Close()

// Use mockServer.URL as the endpoint when making requests in tests.

3. Beyond Basic Mocks

For more complex scenarios, you may want to use conditional logic in your mock HTTP server to simulate different responses based on request headers, methods, or body contents.

mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    if r.Header.Get("Authorization") == "" {
        w.WriteHeader(http.StatusUnauthorized)
        return
    }

    if r.URL.Path == "/error" {
        w.WriteHeader(http.StatusInternalServerError)
        w.Write([]byte(`{"error": "Something went wrong!"}`))
        return
    }

    w.WriteHeader(http.StatusOK)
    w.Write([]byte(`{"success": true}`))
}))

Tips and Best Practices

Isolate Side Effects: Ensure that your tests don't have side effects. Always clean up resources like mock servers.
Edge Cases: Use mock servers to simulate edge cases that might be hard (or even dangerous) to reproduce with real services.
Parallel Tests: Be cautious when using package-level variables for mock servers in parallel tests. Instead, create a new server for each test.

Alternative Approach

One common approach to handle this is to mock the HTTP client, so let's look at how to do this in Go.

1. Interface First

In Go, interfaces make mocking very straightforward. To mock the HTTP client, start by defining an interface that the real client and the mock client will both satisfy.

Let's say you're using Go's http.Client. Instead of using it directly, define an interface:

type HttpClient interface {
    Do(req *http.Request) (*http.Response, error)
}

2. Real Client

Use the real HTTP client by wrapping the http.Client:

type RealHttpClient struct{}

func (c *RealHttpClient) Do(req *http.Request) (*http.Response, error) {
    return http.DefaultClient.Do(req)
}

3. Mock Client

Now, create a mock version of this client:

type MockHttpClient struct {
    MockDo func(req *http.Request) (*http.Response, error)
}

func (c *MockHttpClient) Do(req *http.Request) (*http.Response, error) {
    return c.MockDo(req)
}

4. Using the Mock

Now you can inject the mock client into the functions or services that need an HTTP client. When testing, provide a custom implementation of the MockDo function to simulate various scenarios.

func TestSomeService(t *testing.T) {
    client := &MockHttpClient{
        MockDo: func(req *http.Request) (*http.Response, error) {
            // Return a fake response and nil error
            return &http.Response{
                StatusCode: 200,
                Body:       ioutil.NopCloser(bytes.NewBufferString(`{"result":"ok"}`)),
            }, nil
        },
    }
    
    // Use client to test
    result, err := SomeService(client)
    if err != nil {
        t.Fatal(err)
    }

    // Assertions
    if result != "expected result" {
        t.Fatalf("Expected %s but got %s", "expected result", result)
    }
}

5. Advanced Mocking with Libraries

There are third-party libraries that can help streamline the mocking process in Go, such as gomock and testify. These can generate mock implementations automatically or provide assertion methods to simplify test writing.

Conclusion

Using fake HTTP transactions in your Go tests allows you to thoroughly test your application's behavior without the unpredictability and overhead of real network requests. With tools like http/httptest, creating mock servers and requests is straightforward. Happy testing!

gogolangtestingmocks

Benjamin Parrish