go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/sdk/r2/request_test.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package r2

import (
	"bytes"
	"context"
	"encoding/gob"
	"errors"
	"fmt"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"

	. "go.charczuk.com/sdk/assert"
)

func Test_New(t *testing.T) {
	r := New("https://foo.com/bar?buzz=fuzz")
	ItsNotNil(t, r)
	ItsNil(t, r.err)
	ItsEqual(t, http.MethodGet, r.req.Method)
	ItsNotNil(t, r.req.URL)
	ItsEqual(t, "https://foo.com/bar?buzz=fuzz", r.req.URL.String())

	rErr := New("\n")
	ItsNotNil(t, rErr)
	ItsNotNil(t, rErr.err)
}

func Test_Request_WithContext(t *testing.T) {
	r := New("https://foo.com/bar?buzz=fuzz")
	type valueKey struct{}
	const value = "hello!"
	r = r.WithContext(context.WithValue(context.Background(), valueKey{}, value))
	ItsNotNil(t, r.req.Context())
	ItsEqual(t, value, r.req.Context().Value(valueKey{}))
}

func Test_Request_Do(t *testing.T) {
	server := mockServerOK()
	defer server.Close()

	res, err := New(server.URL).Do()
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)
}

func Test_Request_Do_earlyAbortsOnError(t *testing.T) {
	var didCallServer bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		didCallServer = true
		w.WriteHeader(http.StatusOK)
		fmt.Fprintf(w, "OK!\n")
	}))
	defer server.Close()

	r := New(server.URL)
	r.err = errors.New("this is only a test")
	_, err := r.Do()
	ItsNotNil(t, err)
	ItsEqual(t, "this is only a test", err.Error())
	ItsEqual(t, false, didCallServer)
}

func Test_Request_Do_headers(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if value := r.Header.Get("foo"); value != "bar" {
			w.WriteHeader(http.StatusBadRequest)
			fmt.Fprintf(w, "bad value for header foo: %v\n", value)
			return
		}
		w.WriteHeader(http.StatusOK)
		fmt.Fprintf(w, "OK!\n")
	}))
	defer server.Close()

	res, err := New(server.URL, OptHeader("foo", "bar")).Do()
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)
}

func Test_Request_Do_query(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if value := r.URL.Query().Get("foo"); value != "bar" {
			w.WriteHeader(http.StatusBadRequest)
			fmt.Fprintf(w, "bad value for query string key foo: %v\n", value)
			return
		}
		w.WriteHeader(http.StatusOK)
		fmt.Fprintf(w, "OK!\n")
	}))
	defer server.Close()

	res, err := New(server.URL, OptQuery("foo", "bar")).Do()
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)
}

func Test_Request_Discard(t *testing.T) {
	server := mockServerOK()
	defer server.Close()
	res, err := New(server.URL).Discard()
	ItsNil(t, err)
	ItsNotNil(t, res)
}

func Test_Request_CopyTo(t *testing.T) {
	server := mockServerOK()
	defer server.Close()
	buf := new(bytes.Buffer)
	_, err := New(server.URL).CopyTo(buf)
	ItsNil(t, err)
	ItsEqual(t, "OK!\n", buf.String())
}

func Test_Request_Bytes(t *testing.T) {
	server := mockServerOK()
	defer server.Close()
	contents, meta, err := New(server.URL).Bytes()
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, meta.StatusCode)
	ItsEqual(t, "OK!\n", contents)
}

func Test_Request_JSON(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		fmt.Fprintf(w, "{\"status\":\"ok!\"}\n")
	}))
	defer server.Close()

	var deserialized map[string]interface{}
	res, err := New(server.URL).JSON(&deserialized)
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)
	ItsEqual(t, "ok!", deserialized["status"])
}

func Test_Request_JSON_noContent(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusNoContent)
	}))
	defer server.Close()

	var deserialized map[string]interface{}
	res, err := New(server.URL).JSON(&deserialized)
	ItsEqual(t, true, errors.Is(err, ErrNoContentJSON))
	ItsEqual(t, http.StatusNoContent, res.StatusCode)
}

func Test_Request_Gob(t *testing.T) {

	type gobValue struct {
		Foo string
		Bar string
	}

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		_ = gob.NewEncoder(w).Encode(gobValue{"FooValue", "BarValue"})
	}))
	defer server.Close()

	var deserialized gobValue
	res, err := New(server.URL).Gob(&deserialized)
	ItsNil(t, err)
	ItsEqual(t, http.StatusOK, res.StatusCode)
	ItsEqual(t, "FooValue", deserialized.Foo)
	ItsEqual(t, "BarValue", deserialized.Bar)
}

func Test_Request_listeners(t *testing.T) {
	server := mockServerOK()
	defer server.Close()

	var didCallRequest1, didCallRequest2, didCallResponse1, didCallResponse2 bool
	_, err := New(server.URL,
		OptOnRequest(func(_ *http.Request) error {
			didCallRequest1 = true
			return nil
		}),
		OptOnRequest(func(_ *http.Request) error {
			didCallRequest2 = true
			return nil
		}),
		OptOnResponse(func(_ *http.Request, _ *http.Response, _ time.Time, _ error) error {
			didCallResponse1 = true
			return nil
		}),
		OptOnResponse(func(_ *http.Request, _ *http.Response, _ time.Time, _ error) error {
			didCallResponse2 = true
			return nil
		}),
	).Discard()
	ItsNil(t, err)
	ItsEqual(t, true, didCallRequest1)
	ItsEqual(t, true, didCallRequest2)
	ItsEqual(t, true, didCallResponse1)
	ItsEqual(t, true, didCallResponse2)
}