Mock/test basic http.get request

I am leaning to write unit tests and I was wondering the correct way to unit test a basic http.get request.

I found an API online that returns fake data and wrote a basic program that gets some user data and prints out an ID:

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
)

type UserData struct {
	Meta interface{} `json:"meta"`
	Data struct {
		ID     int    `json:"id"`
		Name   string `json:"name"`
		Email  string `json:"email"`
		Gender string `json:"gender"`
		Status string `json:"status"`
	} `json:"data"`
}

func main() {
	resp := sendRequest()
	body := readBody(resp)
    id := unmarshallData(body)
    fmt.Println(id)
}

func  sendRequest() *http.Response {
	resp, err := http.Get("https://gorest.co.in/public/v1/users/1841")
	if err != nil {
		log.Fatalln(err)
	}
	return resp
}

func readBody(resp *http.Response) []byte {
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatalln(err)
	}
	return body
}

func unmarshallData(body []byte) int {
	var userData UserData
	json.Unmarshal(body, &userData)
	return userData.Data.ID
}

This works and prints out 1841. I then wanted to write some tests that validate that the code is behaving as expected, e.g. that it correctly fails if an error is returned, that the data returned can be unmarshalled. I have been reading online and looking at examples but they are all far more complex that what I feel I am trying to achieve.

I have started with the following test that ensures that the data passed to the unmarshallData function can be unmarshalled:

package main

import (
	"testing"
)

func Test_unmarshallData(t *testing.T) {
	type args struct {
		body []byte
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		{name: "Unmarshall", args: struct{ body []byte }{body: []byte("{\"meta\":null,\"data\":{\"id\":1841,\"name\":\"Piya\",\"email\":\"priya@gmai.com\",\"gender\":\"female\",\"status\":\"active\"}}")}, want: 1841},
	}
		for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := unmarshallData(tt.args.body); got != tt.want {
				t.Errorf("unmarshallData() = %v, want %v", got, tt.want)
			}
		})
	}
}

Any advise on where to go from here would be appreciated.

before moving on to the testing, your code has a serious flow, which will become a problem if you don't take care about it in your future programming tasks.

https://pkg.go.dev/net/http See the second example

> The client must close the response body when finished with it

Let's fix that now (we will have to come back on this subject later), two possibilities.

1/ within main, use defer to Close that resource after you have drained it;

func main() {
    resp := sendRequest()
    defer body.Close()
    body := readBody(resp)
    id := unmarshallData(body)
    fmt.Println(id)
}

2/ Do that within readBody

func readBody(resp *http.Response) []byte {
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatalln(err)
    }
    return body
}

Using a defer is the expected manner to close the resource. It helps the reader to identify the lifetime span of the resource and improve readability.

Notes : I will not be using much of the table test driven pattern, but you should, like you did in your OP.

Moving on to the testing part.

Tests can be written under the same package or its fellow version with a trailing _test, such as [package target]_test. This has implications in two ways.

• Using a separate package, they will be ignored in the final build. Which will help to produce smaller binaries.
• Using a separate package, you test the API in a black box manner, you can access only the identifiers it explicitly exposes.

Your current tests are white boxed, meaning you can access any declaration of main, public or not.

About sendRequest, writing a test around this is not very interesting because it does too little, and your tests should not be written to test the std library.

But for the sake of the demonstration, and for good reasons we might want to not rely on external resources to execute our tests.

In order to achieve that we must make the global dependencies consumed within it, an injected dependency. So that later on, it is possible to replace the one thing it depends on to react, the http.Get method.

func  sendRequest(client interface{Get() (*http.Response, error)}) *http.Response {
    resp, err := client.Get("https://gorest.co.in/public/v1/users/1841")
    if err != nil {
        log.Fatalln(err)
    }
    return resp
}

Here i use an inlined interface declaration interface{Get() (*http.Response, error)}.

Now we can add a new test which injects a piece of code that will return exactly the values that will trigger the behavior we want to test within our code.

type fakeGetter struct {
	resp *http.Response
	err  error
}

func (f fakeGetter) Get(u string) (*http.Response, error) {
	return f.resp, f.err
}
func TestSendRequestReturnsNilResponseOnError(t *testing.T) {

	c := fakeGetter{
		err: fmt.Errorf("whatever error will do"),
	}

	resp := sendRequest(c)
	if resp != nil {
		t.Fatal("it should return a nil response when an error arises")
	}
}

Now run this test and see the result. It is not conclusive because your function contains a call to log.Fatal, which in turns executes an os.Exit; We cannot test that.

If we try to change that, we might think we might call for panic instead because we can recover.

I don't recommend doing that, in my opinion, this is smelly and bad, but it exists, so we might consider. This is also the least possible change to the function signature. Returning an error would break even more the current signatures. I want to minimize this for that demonstration. But, as a rule of thumb, return an error and always check them.

In the sendRequest function, replace this call log.Fatalln(err) with panic(err) and update the test to capture the panic.

func TestSendRequestReturnsNilResponseOnError(t *testing.T) {
    var hasPanicked bool
    defer func() {
        _ = recover() // if you capture the output value or recover, you get the error gave to the panic call. We have no use of it.
        hasPanicked = true
    }()

	c := fakeGetter{
		err: fmt.Errorf("whatever error will do"),
	}

	resp := sendRequest(c)
	if resp != nil {
		t.Fatal("it should return a nil response when an error arises")
	}
    if !hasPanicked {
		t.Fatal("it should have panicked")
    }
}

We can now move on to the other execution path, the non error return.

For that we forge the desired *http.Response instance we want to pass into our function, we will then check its properties to figure out if what the function does is inline with what we expect.

We will consider we want to ensure it is returned unmodified : /

Below test only sets two properties, and I will do it to demonstrate how to set the Body with a NopCloser and strings.NewReader as it is often needed later on using the Go language;

I also use reflect.DeepEqual as brute force equality checker, usually you can be more fine grained and get better tests. DeepEqual does the job in this case but it introduces complexity that does not justify systematic use of it.

func TestSendRequestReturnsUnmodifiedResponse(t *testing.T) {

	c := fakeGetter{
		err: nil,
		resp: &http.Response{
			Status: http.StatusOK,
			Body:   ioutil.NopCloser(strings.NewReader("some text")),
		},
	}

	resp := sendRequest(c)
	if !reflect.DeepEqual(resp, c.resp) {
		t.Fatal("the response should not have been modified")
	}
}

At that point you may have figured that this small function sendRequest is not good, if you did not I ensure you it is not. It does too little, it merely wraps the http.Get method and its testing is of little interest for the survival of the business logic.

Moving on to readBody function.

All remarks that applied for sendRequest apply here too.

• it does too little
• it os.Exits

One thing does not apply. As the call to ioutil.ReadAll does not rely on external resources, there is no point in attempting to inject that dependency. We can test around.

Though, for the sake of the demonstration, it is the time to talk about the missing call to defer resp.Body.Close().

Let us assume we go for the second proposition made in introduction and test for that.

The http.Response struct adequately exposes its Body recipient as an interface.

To ensure the code calls for the `Close, we can write a stub for it.
That stub will record if that call was made, the test can then check for that and trigger an error if it was not.

type closeCallRecorder struct {
	hasClosed bool
}

func (c *closeCallRecorder) Close() error {
	c.hasClosed = true
	return nil
}
func (c *closeCallRecorder) Read(p []byte) (int, error) {
	return 0, nil
}

func TestReadBodyCallsClose(t *testing.T) {

	body := &closeCallRecorder{}
	res := &http.Response{
		Body: body,
	}

	_ = readBody(res)
	if !body.hasClosed {
		t.Fatal("the response body was not closed")
	}
}

Similarly, and for the sake of the demonstration, we might want to test if the function has called for Read.

type readCallRecorder struct {
	hasRead bool
}

func (c *readCallRecorder) Read(p []byte) (int, error) {
	c.hasRead = true
	return 0, nil
}

func TestReadBodyHasReadAnything(t *testing.T) {

	body := &readCallRecorder{}
	res := &http.Response{
		Body: ioutil.NopCloser(body),
	}

	_ = readBody(res)
	if !body.hasRead {
		t.Fatal("the response body was not read")
	}
}

We an also verify the body was not modified in betwen,

func TestReadBodyDidNotModifyTheResponse(t *testing.T) {
	want := "this"
	res := &http.Response{
		Body: ioutil.NopCloser(strings.NewReader(want)),
	}

	resp := readBody(res)
	if got := string(resp); want != got {
		t.Fatal("invalid response, wanted=%q got %q", want, got)
	}
}

We have almost done, lets move one to the unmarshallData function.

You have already wrote a test about it. It is okish, though, i would write it this way to make it leaner:

type UserData struct {
	Meta interface{} `json:"meta"`
	Data Data        `json:"data"`
}
type Data struct {
	ID     int    `json:"id"`
	Name   string `json:"name"`
	Email  string `json:"email"`
	Gender string `json:"gender"`
	Status string `json:"status"`
}

func Test_unmarshallData(t *testing.T) {
	type args struct {
		body []byte
	}
	tests := []UserData{
		UserData{Data: Data{ID: 1841}},
	}
	for _, u := range tests {
		want := u.ID
		b, _ := json.Marshal(u)
		t.Run("Unmarshal", func(t *testing.T) {
			if got := unmarshallData(b); got != want {
				t.Errorf("unmarshallData() = %v, want %v", got, want)
			}
		})
	}
}

Then, the usual apply :

• don't log.Fatal
• what are you testing ? the marshaller ?

Finally, now that we have gathered all those pieces, we can refactor to write a more sensible function and re use all those pieces to help us testing such code.

I won't do it, but here is a starter, which still panics, and I still don't recommend, but the previous demonstration has shown everything needed to test a version of it that returns an error.

type userFetcher struct {
	Requester interface {
		Get(u string) (*http.Response, error)
	}
}

func (u userFetcher) Fetch() int {
	resp, err := u.Requester.Get("https://gorest.co.in/public/v1/users/1841") // it does not really matter that this string is static, using the requester we can mock the response, its body and the error.
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close() //always.
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	var userData UserData
	err = json.Unmarshal(body, &userData)
	if err != nil {
		panic(err)
	}
	return userData.Data.ID
}