HTTPClient in Go

go-httpclient.md

In Go, usually an HTTP client is:

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

Go's HTTP situation is that the http.RoundTripper interface is explicitly designed to provide customization of how an HTTP request executes,as that's exactly what it's there for.

If you take a look at the definition of RoundTripper and compare it to the doer interface above, I think you'll see that the similarity is striking:

type RoundTripper interface {
        RoundTrip(*Request) (*Response, error)
}

(See: https://golang.org/pkg/net/http/#RoundTripper)

It's exactly the same down to every type!

For instance:

type tracingRoundTripper struct {
	http.RoundTripper
	tr opentracing.Tracer
}

func (tr *tracingRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
	req, ht := nethttp.TraceRequest(tr.tr, req)
	defer ht.Finish()

	return tr.RoundTripper.RoundTrip(req)
}

See also https://www.0value.com/let-the-doer-do-it

Testing can use the httptest package and the roundtripper:

type mockRoundTripper struct {
    response *http.Response
}

func (rt *mockRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
    return rt.response, nil
}

You unittest test would look like this:

func TestGetOverview(t *testing.T) {
    // Set up your response
    json := `{"code": 0, "message": "success"}`
    recorder := httptest.NewRecorder()
    recorder.Header().Add("Content-Type", "application/json")
    recorder.WriteString(json)
    expectedResponse := recorder.Result()

    // Create an HTTP client
    client := http.Client{Transport: &mockRoundTripper{expectedResponse}}

    // Call your function
    overview, err := yourlib.GetOverview(client, &yourlib.Overview{})
    ....
}

http_test.go

// https://go.dev/play/p/l9HJQW37bi
package main

import (
	"net/http"
	"testing"
)

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

type MockClient struct {
	DoFunc func(req *http.Request) (*http.Response, error)
}

func (m *MockClient) Do(req *http.Request) (*http.Response, error) {
	if m.DoFunc != nil {
		return m.DoFunc(req)
	}
	// just in case you want default correct return value
	return &http.Response{}, nil
}


func TestClient(t *testing.T) {
	client := &MockClient{
		DoFunc: func(req *http.Request) (*http.Response, error) {
			// do whatever you want
			return &http.Response{
				StatusCode: http.StatusBadRequest,
			}, nil
		},
	}

	request, _ := http.NewRequest("GET", "https://www.reallycoolurl.com/bad_request", nil)
	// as this is a test, we may skip error handling

	response, _ := client.Do(request)
	if response.StatusCode != http.StatusBadRequest {
		t.Error("invalid response status code")
	}
}



func main() {
	// test example
}