Write end-to-end exams in Go (Golang) utilizing httptest.Server

Many programming languages, together with Go, have frameworks for performing HTTP end-to-end (e2e) exams. Nevertheless, not everybody is aware of that such exams may be carried out utilizing the httptest bundle constructed into the Go customary library. On this brief article, we’ll present you how you can do it – we’ll put together end-to-end exams for a easy endpoint utilizing solely the httptest.Server from the httptest bundle.

Finish-to-end (e2e) testing is a kind of software program testing that goals to confirm the performance and conduct of an utility from begin to end, simulating real-world eventualities.

Within the case of an HTTP server, simulating real-world eventualities entails making a check surroundings that’s equal to the manufacturing surroundings, together with the database, community and some other exterior dependencies. As soon as created, the check surroundings is utilized in e2e testing to ship actual HTTP requests with varied parameters, headers and content material. The corresponding HTTP responses from the server are verified by the exams to ensure all the things works as supposed, simply as it could on a manufacturing surroundings.

HTTP handler for testing

Earlier than we transfer on to testing, we have to create the online utility that we’ll check. As the best instance, we solely want a single HTTP handler perform akin to HTTP Howdy World:

hello_world.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

bundle most important

import (
    "fmt"
    "internet/http"
)

func HelloWorld(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Howdy World")
}

The one factor this handler does is to write down the string “Howdy World” in response to the HTTP request.

Finish-to-end check instance

We are going to use httptest.Server to carry out e2e exams. The httptest.Server is a construction built-in in Golang’s customary library (within the httptest bundle) that permits builders to create HTTP servers for testing functions. This struct is beneficial when testing HTTP handlers, routers, and middlewares. It permits to check the operation of the applying from begin to end domestically, with out organising a separate testing surroundings on the distant host.

Within the constructor, it accepts http.Handler as an enter argument, so you’ll be able to even use it to attach a complete utility hidden behind a request router:

func NewServer(handler http.Handler) *httptest.Server

In our case, the handler might be our easy HelloWorld perform transformed utilizing http.HandlerFunc().

We are going to carry out end-to-end check in the usual hello_world_test.go file utilizing the testing bundle. Nevertheless, there is no such thing as a drawback to create a separate testing script working in keeping with your personal guidelines.

Check out our pattern end-to-end check under:

hello_world_test.go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

bundle most important

import (
    "io"
    "internet/http"
    "internet/http/httptest"
    "testing"
)

func TestHelloWorld(t *testing.T) {
    testServer := httptest.NewServer(http.HandlerFunc(HelloWorld))
    defer testServer.Shut()
    testClient := testServer.Shopper()

    resp, err := testClient.Get(testServer.URL)
    if err != nil {
        t.Errorf("Get error: %v", err)
    }
    if resp.StatusCode != http.StatusOK {
        t.Errorf("response code is just not 200: %d", resp.StatusCode)
    }
    knowledge, err := io.ReadAll(resp.Physique)
    if err != nil {
        t.Errorf("io.ReadAll error: %v", err)
    }
    if string(knowledge) != "Howdy Worldn" {
        t.Error("response physique doesn't equal to Howdy World")
    }
}

• In traces 11 and 12 we initialize a brand new httptest.Server with our handler and instruct it to shut on the finish of the check with the phrase defer.
• The server has a customized consumer configured to make requests to the server, which we get and use from line 13.
• Utilizing the consumer, we make a request to the server tackle (line 15), after which check the response, checking that it has the correct standing code (line 20) and the correct physique content material (line 27).

In order you’ll be able to see, testing internet functions this fashion may be very straightforward. All you want to do is to initialize httptest.Server, after which use it and its consumer to make HTTP requests, which you’ll be able to then confirm utilizing check capabilities. The httptest.Server considerably simplifies the testing of HTTP functions and it’s value understanding this technique when working with such functions each day.