client_test.go

package client

import (
	"bytes"
	"context"
	"crypto/tls"
	"fmt"
	"io"
	"net"
	"net/http"
	"net/http/httptest"
	"net/url"
	"reflect"
	"strconv"
	"strings"
	"testing"
	"time"
	"unsafe"

	"git.sr.ht/~mariusor/cache"
	"git.sr.ht/~mariusor/lw"
	"github.com/carlmjohnson/requests"
	vocab "github.com/go-ap/activitypub"
	"github.com/go-ap/client/c2s"
	"github.com/go-ap/client/debug"
	"github.com/go-ap/client/s2s"
	"github.com/go-ap/errors"
	"github.com/google/go-cmp/cmp"
	"github.com/google/go-cmp/cmp/cmpopts"
	"golang.org/x/oauth2"
)

func TestClient_LoadIRI1(t *testing.T) {
	empty := vocab.IRI("")
	c := New()

	var err error
	_, err = c.LoadIRI(empty)
	if err == nil {
		t.Errorf("LoadIRI should have failed when using empty IRI value")
	}

	inv := vocab.IRI("example.com")
	_, err = c.LoadIRI(inv)
	if err == nil {
		t.Errorf("LoadIRI should have failed when using invalid http url")
	} else {
		t.Logf("Valid error received: %s", err)
	}
}

func Test_getTransportWithTLSValidation(t *testing.T) {
	type args struct {
		rt   http.RoundTripper
		skip bool
	}
	tests := []struct {
		name string
		args args
		want http.RoundTripper
	}{
		{
			name: "empty",
			args: args{},
			want: defaultTransport,
		},
		{
			name: "cache, skip false",
			args: args{rt: &cache.Transport{Base: defaultTransport}, skip: false},
			want: &cache.Transport{Base: defaultTransport},
		},
		{
			name: "cache, skip true",
			args: args{rt: &cache.Transport{Base: defaultTransport}, skip: true},
			// NOTE(marius): this is defaultTransport with InsecureSkipVerify set to true
			want: &cache.Transport{Base: &http.Transport{
				Proxy:               http.ProxyFromEnvironment,
				MaxIdleConns:        100,
				IdleConnTimeout:     90 * time.Second,
				MaxIdleConnsPerHost: 20,
				DialContext:         (&net.Dialer{Timeout: longTimeout}).DialContext,
				TLSClientConfig:     &tls.Config{InsecureSkipVerify: true},
				TLSHandshakeTimeout: longTimeout,
			},
			},
		},
		{
			name: "empty oauth2, skip false",
			args: args{rt: &oauth2.Transport{}, skip: false},
			want: &oauth2.Transport{Base: defaultTransport},
		},
		{
			name: "empty oauth2, skip true",
			args: args{rt: &oauth2.Transport{}, skip: true},
			// NOTE(marius): this is defaultTransport with InsecureSkipVerify set to true
			want: &oauth2.Transport{
				Base: &http.Transport{
					Proxy:               http.ProxyFromEnvironment,
					MaxIdleConns:        100,
					IdleConnTimeout:     90 * time.Second,
					MaxIdleConnsPerHost: 20,
					DialContext:         (&net.Dialer{Timeout: longTimeout}).DialContext,
					TLSClientConfig:     &tls.Config{InsecureSkipVerify: true},
					TLSHandshakeTimeout: longTimeout,
				},
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := getTransportWithTLSValidation(tt.args.rt, tt.args.skip)
			if !cmp.Equal(got, tt.want, ignoredTransports, equateFuncs) {
				t.Errorf("getTransportWithTLSValidation() = %s", cmp.Diff(tt.want, got, ignoredTransports, equateFuncs))
			}
		})
	}
}

var ignoredTransports = cmpopts.IgnoreUnexported(http.Transport{}, tls.Config{}, cache.Transport{}, s2s.Signer{})

func TestSkipTLSValidation(t *testing.T) {
	tests := []struct {
		name    string
		skip    bool
		tr      http.RoundTripper
		wantErr error
	}{
		{
			name: "false empty transport",
			skip: false,
		},
		{
			name: "true empty transport",
			skip: true,
		},
		{
			name: "false http.Transport",
			tr:   &http.Transport{},
			skip: false,
		},
		{
			name: "true http.Transport",
			tr:   &http.Transport{},
			skip: true,
		},
		{
			name: "false debug.Transport",
			tr:   &debug.Transport{},
			skip: false,
		},
		{
			name: "true debug.Transport",
			tr:   &debug.Transport{},
			skip: true,
		},
		{
			name: "false cache.Transport",
			tr:   &cache.Transport{},
			skip: false,
		},
		{
			name: "true cache.Transport",
			tr:   &cache.Transport{},
			skip: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cl := new(C)
			cl.c = &http.Client{Transport: tt.tr}

			SkipTLSValidation(tt.skip)(cl)
			switch tr := cl.c.(*http.Client).Transport.(type) {
			case *http.Transport:
				if tr.TLSClientConfig.InsecureSkipVerify != tt.skip {
					t.Errorf("SkipTLSValidation() got skip validation %t, wanted %t", tt.skip, tr.TLSClientConfig.InsecureSkipVerify)
				}
			}
		})
	}
}

func areErrors(a, b any) bool {
	_, ok1 := a.(error)
	_, ok2 := b.(error)
	return ok1 && ok2
}

func compareErrorsWithUrl(url string) func(x, y any) bool {
	return func(x, y any) bool {
		xe := x.(error)
		ye := y.(error)
		if errors.Is(xe, ye) || errors.Is(ye, xe) {
			return true
		}
		xs := strings.ReplaceAll(xe.Error(), "http://example.com", url)
		ys := strings.ReplaceAll(ye.Error(), "http://example.com", url)
		return xs == ys
	}
}

var EquateWeakErrors = func(url string) cmp.Option {
	return cmp.FilterValues(areErrors, cmp.Comparer(compareErrorsWithUrl(url)))
}

func areFuncs(a, b any) bool {
	ta := reflect.TypeOf(a)
	tb := reflect.TypeOf(b)
	return ta != nil && ta.Kind() == reflect.Func && tb != nil && tb.Kind() == reflect.Func
}

func compareFuncs(x, y any) bool {
	px := *(*unsafe.Pointer)(unsafe.Pointer(&x))
	py := *(*unsafe.Pointer)(unsafe.Pointer(&y))
	return px == py
}

var equateFuncs = cmp.FilterValues(areFuncs, cmp.Comparer(compareFuncs))

func TestWithLogger(t *testing.T) {
	tests := []struct {
		name    string
		l       lw.Logger
		wantErr error
	}{
		{
			name:    "empty",
			l:       nil,
			wantErr: nil,
		},
		{
			name:    "nil logger",
			l:       lw.Nil(),
			wantErr: nil,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cl := new(C)

			WithLogger(tt.l)(cl)
			if !cmp.Equal(cl.l, tt.l) {
				t.Errorf("WithLogger() = %s", cmp.Diff(tt.l, cl.l))
			}
		})
	}
}

func TestWithHTTPClient(t *testing.T) {
	tests := []struct {
		name    string
		h       *http.Client
		wantErr error
	}{
		{
			name:    "empty",
			h:       nil,
			wantErr: nil,
		},
		{
			name:    "default client",
			h:       defaultClient,
			wantErr: nil,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cl := new(C)

			WithHTTPClient(tt.h)(cl)
			if !cmp.Equal(cl.c, tt.h, ignoredTransports, equateFuncs) {
				t.Errorf("WithHTTPClient() = %s", cmp.Diff(tt.h, cl.c, ignoredTransports, equateFuncs))
			}
		})
	}
}

var emptyAuthFn = func(r *http.Request) error {
	return nil
}

func TestWithAuthorizationFn(t *testing.T) {
	tests := []struct {
		name    string
		args    []func(*http.Request) error
		want    []func(*http.Request) error
		wantErr error
	}{
		{
			name:    "empty",
			wantErr: fmt.Errorf("nil sign function"),
		},
		{
			name: "empty fn",
			args: []func(*http.Request) error{emptyAuthFn},
			want: []func(*http.Request) error{emptyAuthFn},
		},
		{
			name: "RFC9421 Sign Fn",
			args: []func(*http.Request) error{new(s2s.Signer).SignRFC9421},
			want: []func(*http.Request) error{new(s2s.Signer).SignRFC9421},
		},
		{
			name: "Draft Sign Fn",
			args: []func(*http.Request) error{new(s2s.Signer).SignDraft},
			want: []func(*http.Request) error{new(s2s.Signer).SignDraft},
		},
		{
			name: "RFC9421+Draft Sign Fns",
			args: []func(*http.Request) error{new(s2s.Signer).SignRFC9421, new(s2s.Signer).SignDraft},
			want: []func(*http.Request) error{new(s2s.Signer).SignRFC9421, new(s2s.Signer).SignDraft},
		},
		{
			name: "C2S Sign Fn",
			args: []func(*http.Request) error{(*c2s.BearerSigner)(&oauth2.Token{AccessToken: "t", TokenType: "B"}).Sign},
			want: []func(*http.Request) error{(*c2s.BearerSigner)(&oauth2.Token{AccessToken: "t", TokenType: "B"}).Sign},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cl := new(C)

			WithAuthorizationFn(tt.args...)(cl)
			if !cmp.Equal(cl.authFns, tt.want, equateFuncs) {
				t.Errorf("WithAuthorizationFn() = %s", cmp.Diff(tt.want, cl.authFns, equateFuncs))
			}
		})
	}
}

func TestWithUserAgent(t *testing.T) {
	tests := []struct {
		name    string
		ua      string
		want    string
		wantErr error
	}{
		{
			name: "empty",
			ua:   "",
			want: UserAgent,
		},
		{
			name: "random UA",
			ua:   "//RANDOM UA//",
			want: "//RANDOM UA//",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cl := new(C)

			WithUserAgent(tt.ua)(cl)
			if !cmp.Equal(cl.ua, tt.ua) {
				t.Errorf("WithUserAgent() = %s", cmp.Diff(tt.ua, cl.ua))
			}
		})
	}
}

func TestHTTPClient(t *testing.T) {
	tests := []struct {
		name   string
		client *C
		want   *http.Client
	}{
		{
			name: "empty",
			want: nil,
		},
		{
			name:   "with http.Client",
			client: &C{c: &http.Client{Timeout: 666 * time.Second}},
			want:   &http.Client{Timeout: 666 * time.Second},
		},
		{
			name:   "with C client",
			client: &C{c: &C{c: &http.Client{Timeout: 66 * time.Second}}},
			want:   &http.Client{Timeout: 66 * time.Second},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := HTTPClient(tt.client); !cmp.Equal(got, tt.want, ignoredTransports, equateFuncs) {
				t.Errorf("HTTPClient() = %s", cmp.Diff(tt.want, got, ignoredTransports, equateFuncs))
			}
		})
	}
}

func TestC_ToCollection(t *testing.T) {
	type args struct {
		toSend   vocab.Item
		colPaths vocab.CollectionPaths
	}
	tests := []struct {
		name    string
		args    args
		wantIRI vocab.IRI
		wantIt  vocab.Item
		wantErr error
	}{
		{
			name:    "empty",
			args:    args{},
			wantIRI: "",
			wantIt:  nil,
		},
		{
			name: "no collection IRIs",
			args: args{toSend: &vocab.Actor{}},
		},
		{
			name: "activity type",
			args: args{toSend: &vocab.Activity{}, colPaths: vocab.CollectionPaths{vocab.Inbox}},
		},
		{
			name: "activity type with multiple paths",
			args: args{toSend: &vocab.Activity{}, colPaths: vocab.CollectionPaths{vocab.Inbox, vocab.Outbox}},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				raw, _ := vocab.MarshalJSON(tt.wantIt)
				w.WriteHeader(http.StatusOK)
				_, _ = w.Write(raw)
			}))
			defer srv.Close()

			name := "jdoe"
			toCollections := make(vocab.IRIs, 0, len(tt.args.colPaths))

			actor := mockActor("http://example.com", name)
			_ = vocab.OnIntransitiveActivity(tt.args.toSend, func(act *vocab.IntransitiveActivity) error {
				act.Actor = actor
				return nil
			})

			for _, col := range tt.args.colPaths {
				toCollections = append(toCollections, col.IRI(actor))
			}

			c := C{
				c: srv.Client(),
				l: lw.Dev(lw.SetOutput(t.Output())),
			}

			gotIRI, gotIt, err := c.ToCollection(tt.args.toSend, toCollections...)
			if !cmp.Equal(err, tt.wantErr, EquateWeakErrors("")) {
				t.Errorf("ToCollection() error = %s", cmp.Diff(tt.wantErr, err, EquateWeakErrors("")))
				return
			}
			if gotIRI != tt.wantIRI {
				t.Errorf("ToCollection() got IRI = %v, want %v", gotIRI, tt.wantIRI)
			}
			if !cmp.Equal(gotIt, tt.wantIt, EquateItems) {
				t.Errorf("ToCollection() got Item = %s", cmp.Diff(tt.wantIt, gotIt, EquateItems))
			}
		})
	}
}

func TestC_toCollection(t *testing.T) {
	type args struct {
		ctx     context.Context
		act     vocab.Item
		colPath vocab.CollectionPath
	}
	tests := []struct {
		name      string
		handlerFn http.HandlerFunc
		args      args
		wantIRI   vocab.IRI
		wantIt    vocab.Item
		wantErr   error
	}{
		{
			name:    "empty",
			wantErr: errors.Newf("invalid IRI to POST to"),
		},
		{
			name: "nil response",
			args: args{
				ctx:     context.Background(),
				act:     mockActivity(),
				colPath: vocab.Outbox,
			},
			handlerFn: func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
			},
			wantIRI: "",
			wantIt:  nil,
			wantErr: nil,
		},
		{
			name: "nil response with Location",
			args: args{
				ctx:     context.Background(),
				act:     mockActivity(),
				colPath: vocab.Outbox,
			},
			handlerFn: func(w http.ResponseWriter, r *http.Request) {
				w.Header().Add("Location", "http://example.com/1")
				w.WriteHeader(http.StatusOK)
			},
			wantIRI: "http://example.com/1",
			wantIt:  nil,
			wantErr: nil,
		},
		{
			name: "response with Location",
			args: args{
				ctx:     context.Background(),
				act:     mockActivity(),
				colPath: vocab.Outbox,
			},
			handlerFn: func(w http.ResponseWriter, r *http.Request) {
				w.Header().Add("Location", "http://example.com/666")
				w.WriteHeader(http.StatusOK)
				raw, _ := vocab.MarshalJSON(vocab.Object{ID: "http://example.com/note-1", Type: vocab.NoteType})
				_, _ = w.Write(raw)
			},
			wantIRI: "http://example.com/666",
			wantIt:  &vocab.Object{ID: "http://example.com/note-1", Type: vocab.NoteType},
			wantErr: nil,
		},
		{
			name: "404 response",
			args: args{
				ctx:     context.Background(),
				act:     mockActivity(),
				colPath: vocab.Outbox,
			},
			handlerFn: errors.HandleError(errors.NotFoundf("test")).ServeHTTP,
			wantErr:   errors.Annotatef(errors.NotFoundf("test"), "invalid status received: 404"),
		},
		{
			name: "401 response",
			args: args{
				ctx:     context.Background(),
				act:     mockActivity(),
				colPath: vocab.Outbox,
			},
			handlerFn: errors.HandleError(errors.Unauthorizedf("STOP")).ServeHTTP,
			wantErr:   errors.Annotatef(errors.Unauthorizedf("STOP"), "invalid status received: 401"),
		},
		{
			name: "500 response",
			args: args{
				ctx:     context.Background(),
				act:     mockActivity(),
				colPath: vocab.Outbox,
			},
			handlerFn: errors.HandleError(errors.Errorf("¡OOPS!")).ServeHTTP,
			wantErr:   errors.Errorf("invalid status received: 500: ¡OOPS!"),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			c := C{
				l: lw.Dev(lw.SetOutput(t.Output())),
			}

			var colIRI vocab.IRI
			if tt.args.colPath != "" {
				srv := httptest.NewServer(tt.handlerFn)
				defer srv.Close()
				colIRI = tt.args.colPath.IRI(tt.args.act)
				c.c = srv.Client()
			}

			gotIRI, gotIt, err := c.toCollection(tt.args.ctx, tt.args.act, colIRI)
			if !cmp.Equal(err, tt.wantErr, EquateWeakErrors("")) {
				t.Errorf("toCollection() error = %s", cmp.Diff(tt.wantErr, err, EquateWeakErrors("")))
				return
			}
			if gotIRI != tt.wantIRI {
				t.Errorf("toCollection() got IRI = %s, want %s", gotIRI, tt.wantIRI)
			}
			if !cmp.Equal(gotIt, tt.wantIt, EquateItems) {
				t.Errorf("toCollection() got item = %s", cmp.Diff(tt.wantIt, gotIt, EquateItems))
			}
		})
	}
}

func TestC_LoadIRI(t *testing.T) {
	tests := []struct {
		name      string
		handlerFn http.HandlerFunc
		id        vocab.IRI
		want      vocab.Item
		wantErr   cerr
	}{
		{
			name:    "empty",
			wantErr: errf("invalid nil IRI"),
		},
		{
			name:    "invalid IRI",
			id:      ":",
			wantErr: errf("trying to load an invalid IRI").iri(":").annotate(errors.Newf("parse \":\": missing protocol scheme")),
		},
		{
			name:    "no valid handler",
			id:      "http://example.com",
			wantErr: errf("invalid status received").status(http.StatusGatewayTimeout),
		},
		{
			name: "404 response",
			handlerFn: func(w http.ResponseWriter, r *http.Request) {
				errors.HandleError(errors.NotFoundf("NOT FOUND")).ServeHTTP(w, r)
			},
			id:      "http://example.com",
			wantErr: errf("invalid status received").status(http.StatusNotFound).annotate(errors.NotFoundf("NOT FOUND")),
		},
		{
			name: "empty body",
			handlerFn: func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
			},
			id:      "http://example.com",
			wantErr: errf("invalid response from ActivityPub server").annotate(errors.NotImplementedf("not a document and not an error")),
		},
		{
			name: "invalid json body",
			handlerFn: func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusOK)
				_, _ = w.Write([]byte(`{`))
			},
			id:      "http://example.com",
			wantErr: errf("invalid ActivityPub object returned").iri("http://example.com").annotate(errors.Newf("cannot parse JSON: cannot parse object: missing '}'; unparsed tail: \"\"")),
		},
		{
			name: "empty body but Gone",
			handlerFn: func(w http.ResponseWriter, r *http.Request) {
				w.WriteHeader(http.StatusGone)
			},
			id:      "http://example.com",
			wantErr: errf("").annotate(errors.Gonef("gone")).iri("http://example.com"),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.handlerFn == nil {
				tt.handlerFn = func(w http.ResponseWriter, r *http.Request) {
					w.WriteHeader(http.StatusGatewayTimeout)
				}
			}

			srv := httptest.NewServer(tt.handlerFn)
			defer srv.Close()

			c := C{
				c: srv.Client(),
				l: lw.Dev(lw.SetOutput(t.Output())),
			}

			if tt.id != "" {
				u, err := url.Parse(string(tt.id))
				if err == nil {
					su, _ := url.Parse(srv.URL)
					u.Host = su.Host

					if tt.wantErr.msg != "" || tt.wantErr.err != nil {
						tt.wantErr.i = vocab.IRI(u.String())
					}
				}
			}

			got, err := c.LoadIRI(tt.id)
			if !cmp.Equal(err, tt.wantErr, EquateWeakErrors(srv.URL)) {
				t.Errorf("LoadIRI() error = %s", cmp.Diff(tt.wantErr, err, EquateWeakErrors(srv.URL)))
				return
			}
			if !cmp.Equal(got, tt.want) {
				t.Errorf("LoadIRI() got = %s", cmp.Diff(tt.want, got))
			}
		})
	}
}

func mockPostReq(body []byte, hh ...url.Values) *http.Request {
	r := httptest.NewRequest(http.MethodPost, "http://example.com", bytes.NewReader(body))
	for _, h := range hh {
		for k, v := range h {
			r.Header[k] = v
		}
	}
	r.Header.Add("Content-Length", strconv.Itoa(len(body)))
	r.RequestURI = ""
	return r
}

func mockGetReq(hh ...url.Values) *http.Request {
	r := requests.URL("http://example.com")
	r.Header("Date", TimeNow().Format(http.TimeFormat))
	for _, h := range hh {
		for k, v := range h {
			r.Header(k, v...)
		}
	}
	req, _ := r.Request(context.Background())
	return req
}

func TestC_Do(t *testing.T) {
	TimeNow = mockTimeFn

	type fields struct {
		ua      string
		authFns []func(*http.Request) error
	}
	tests := []struct {
		name    string
		fields  fields
		req     *http.Request
		handler http.Handler
		want    *http.Response
		wantErr error
	}{
		{
			name:   "empty",
			fields: fields{},
			req:    mockGetReq(),
			want: &http.Response{
				Status:     "404 Not Found",
				StatusCode: http.StatusNotFound,
				Header: http.Header{
					"Content-Length": []string{"19"},
					"Content-Type":   []string{"text/plain; charset=utf-8"},
				},
				ContentLength: 19,
				Body:          io.NopCloser(bytes.NewBufferString("404 page not found\n")),
			},
		},
		{
			name:   "with UA",
			fields: fields{ua: "test-ua"},
			req:    mockGetReq(),
			handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				if ua := r.Header.Get("User-Agent"); ua != "test-ua" {
					t.Errorf("Invalid user-agent %s, wanted %s", ua, "test-ua")
				}
				w.WriteHeader(http.StatusOK)
			}),
			want: &http.Response{
				Status:     "200 OK",
				StatusCode: http.StatusOK,
				Header:     http.Header{"Content-Length": []string{"0"}},
			},
		},
		{
			name:   "Post with UA",
			fields: fields{ua: "test-ua"},
			req:    mockPostReq([]byte("{}")),
			handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				if ua := r.Header.Get("User-Agent"); ua != "test-ua" {
					t.Errorf("Invalid user-agent %s, wanted %s", ua, "test-ua")
				}
				if r.Method != http.MethodPost {
					t.Errorf("Invalid request method %s, wanted %s", r.Method, http.MethodPost)
				}
				w.WriteHeader(http.StatusOK)
			}),
			want: &http.Response{
				Status:     "200 OK",
				StatusCode: http.StatusOK,
				Header:     http.Header{"Content-Length": []string{"0"}},
			},
		},
		{
			name: "with random authorization function",
			fields: fields{authFns: []func(*http.Request) error{
				func(r *http.Request) error {
					r.Header.Add("Authorization", "test")
					return nil
				},
			}},
			req: mockGetReq(),
			handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				if auth := r.Header.Get("Authorization"); auth != "test" {
					t.Errorf("Invalid Authorization header %s, wanted %s", auth, "test")
				}
				w.WriteHeader(http.StatusOK)
			}),
			want: &http.Response{
				Status:     "200 OK",
				StatusCode: http.StatusOK,
				Header:     http.Header{"Content-Length": []string{"0"}},
			},
		},
		{
			name: "Post with random authorization function",
			fields: fields{authFns: []func(*http.Request) error{
				func(r *http.Request) error {
					r.Header.Add("Authorization", "test")
					return nil
				},
			}},
			req: mockPostReq([]byte("{}")),
			handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				if r.Method != http.MethodPost {
					t.Errorf("Invalid request method %s, wanted %s", r.Method, http.MethodPost)
				}
				w.WriteHeader(http.StatusOK)
			}),
			want: &http.Response{
				Status:     "200 OK",
				StatusCode: http.StatusOK,
				Header:     http.Header{"Content-Length": []string{"0"}},
			},
		},
		{
			name: "Post receives 403/200",
			fields: fields{authFns: []func(*http.Request) error{
				func(r *http.Request) error {
					r.Header.Add("Authorization", "test")
					return nil
				},
				func(r *http.Request) error {
					r.Header.Add("Authorization", "test1")
					return nil
				},
			}},
			req: mockPostReq([]byte("{}")),
			handler: func() http.HandlerFunc {
				cnt := 0
				return func(w http.ResponseWriter, r *http.Request) {
					status := http.StatusUnauthorized
					if cnt > 0 {
						status = http.StatusOK
					}
					w.WriteHeader(status)
				}
			}(),
			want: &http.Response{
				Status:     "200 OK",
				StatusCode: http.StatusOK,
				Header:     http.Header{"Content-Length": []string{"0"}},
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			srv := httptest.NewServer(tt.handler)

			cl := srv.Client()
			c := C{
				c:       cl,
				l:       lw.Nil(),
				ua:      tt.fields.ua,
				authFns: tt.fields.authFns,
			}

			got, err := c.Do(tt.req)
			if !cmp.Equal(err, tt.wantErr, EquateWeakErrors(srv.URL)) {
				t.Errorf("Do() error = %s", cmp.Diff(tt.wantErr, err, EquateWeakErrors(srv.URL)))
				return
			}
			tt.want.Request = tt.req
			if !cmp.Equal(got, tt.want, EquateResponses) {
				t.Errorf("Do() got = %s", cmp.Diff(tt.want, got, EquateResponses))
			}
		})
	}
}