chore: test coverage

Author: cmilesdev

.gitignore

@@ -1,3 +1,4 @@
 .idea
 AGENTS.md
 SPECIFICATION.md
+cover.out

README.md

@@ -14,7 +14,7 @@ It keeps req's power and escape hatches, while making the 90% use case feel effo
     <a href="https://goreportcard.com/report/github.com/goforj/httpx"><img src="https://goreportcard.com/badge/github.com/goforj/httpx" alt="Go Report Card"></a>
     <a href="https://codecov.io/gh/goforj/httpx" ><img src="https://codecov.io/gh/goforj/httpx/graph/badge.svg?token=R5O7LYAD4B"/></a>
 <!-- test-count:embed:start -->
-    <img src="https://img.shields.io/badge/tests-74-brightgreen" alt="Tests">
+    <img src="https://img.shields.io/badge/tests-135-brightgreen" alt="Tests">
 <!-- test-count:embed:end -->
 </p>
 

client_test.go

@@ -1,10 +1,12 @@
 package httpx
 
 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"net/http"
 	"net/http/httptest"
+	"os"
 	"testing"
 
 	"github.com/imroc/req/v3"
@@ -203,3 +205,131 @@ func TestQueryOddPanics(t *testing.T) {
 	req := req.C().R()
 	Query("q")(req)
 }
+
+func TestDefaultReqRaw(t *testing.T) {
+	c1 := Default()
+	c2 := Default()
+	if c1 == nil || c2 == nil || c1 != c2 {
+		t.Fatalf("expected default client singleton")
+	}
+	if c1.Req() == nil {
+		t.Fatalf("expected req client")
+	}
+	if c1.Raw() == nil {
+		t.Fatalf("expected raw client")
+	}
+}
+
+func TestRequestMethods(t *testing.T) {
+	var gotMethod string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotMethod = r.Method
+		_, _ = w.Write([]byte(`{"name":"ok"}`))
+	}))
+	t.Cleanup(server.Close)
+
+	client := New()
+	res := Put[createUser, user](client, server.URL, createUser{Name: "ok"})
+	if res.Err != nil {
+		t.Fatalf("put error: %v", res.Err)
+	}
+	if gotMethod != http.MethodPut {
+		t.Fatalf("method = %q", gotMethod)
+	}
+
+	res = Patch[createUser, user](client, server.URL, createUser{Name: "ok"})
+	if res.Err != nil {
+		t.Fatalf("patch error: %v", res.Err)
+	}
+	if gotMethod != http.MethodPatch {
+		t.Fatalf("method = %q", gotMethod)
+	}
+
+	resDel := Delete[user](client, server.URL)
+	if resDel.Err != nil {
+		t.Fatalf("delete error: %v", resDel.Err)
+	}
+	if gotMethod != http.MethodDelete {
+		t.Fatalf("method = %q", gotMethod)
+	}
+}
+
+func TestContextMethods(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write([]byte(`{"name":"ctx"}`))
+	}))
+	t.Cleanup(server.Close)
+
+	client := New()
+	ctx := context.Background()
+
+	if res := GetCtx[user](client, ctx, server.URL); res.Err != nil {
+		t.Fatalf("getctx error: %v", res.Err)
+	}
+	if res := PostCtx[createUser, user](client, ctx, server.URL, createUser{Name: "ctx"}); res.Err != nil {
+		t.Fatalf("postctx error: %v", res.Err)
+	}
+	if res := PutCtx[createUser, user](client, ctx, server.URL, createUser{Name: "ctx"}); res.Err != nil {
+		t.Fatalf("putctx error: %v", res.Err)
+	}
+	if res := PatchCtx[createUser, user](client, ctx, server.URL, createUser{Name: "ctx"}); res.Err != nil {
+		t.Fatalf("patchctx error: %v", res.Err)
+	}
+	if res := DeleteCtx[user](client, ctx, server.URL); res.Err != nil {
+		t.Fatalf("deletectx error: %v", res.Err)
+	}
+}
+
+func TestSendUnknownMethod(t *testing.T) {
+	_, err := send(req.C().R(), "TRACE-UNKNOWN", "http://example.com")
+	if err == nil {
+		t.Fatalf("expected error for unsupported method")
+	}
+}
+
+func TestNewWithHTTPTrace(t *testing.T) {
+	if err := os.Setenv("HTTP_TRACE", "1"); err != nil {
+		t.Fatalf("set env: %v", err)
+	}
+	defer os.Unsetenv("HTTP_TRACE")
+	_ = New()
+}
+
+func TestDumpExample(t *testing.T) {
+	dumpExample("ok")
+}
+
+func TestDoIgnoresAfterResponseErrorOnEmptyBody(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+
+	client := New()
+	res := Get[user](client, server.URL, Before(func(r *req.Request) {
+		r.OnAfterResponse(func(_ *req.Client, _ *req.Response) error {
+			return errors.New("after response error")
+		})
+	}))
+	if res.Err != nil {
+		t.Fatalf("expected error to be ignored, got %v", res.Err)
+	}
+	if res.Response == nil {
+		t.Fatalf("expected response")
+	}
+}
+
+func TestNilClientDefaults(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_ = json.NewEncoder(w).Encode(user{Name: "default"})
+	}))
+	t.Cleanup(server.Close)
+
+	res := Get[user](nil, server.URL)
+	if res.Err != nil {
+		t.Fatalf("unexpected error: %v", res.Err)
+	}
+	if res.Body.Name != "default" {
+		t.Fatalf("unexpected response: %s", res.Body.Name)
+	}
+}

decode_test.go

@@ -0,0 +1,105 @@
+package httpx
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/imroc/req/v3"
+)
+
+func TestRawKindAndDecode(t *testing.T) {
+	if rawKindOf[string]() != rawString {
+		t.Fatalf("expected rawString")
+	}
+	if rawKindOf[[]byte]() != rawBytes {
+		t.Fatalf("expected rawBytes")
+	}
+	if rawKindOf[[]int]() != rawNone {
+		t.Fatalf("expected rawNone for slice")
+	}
+	if rawKindOf[int]() != rawNone {
+		t.Fatalf("expected rawNone")
+	}
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write([]byte("hello"))
+	}))
+	t.Cleanup(srv.Close)
+
+	resp, err := req.C().R().Get(srv.URL)
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	if got := decodeRaw[string](resp); got != "hello" {
+		t.Fatalf("decode string = %q", got)
+	}
+	if got := decodeRaw[[]byte](resp); string(got) != "hello" {
+		t.Fatalf("decode bytes = %q", string(got))
+	}
+	if got := decodeRaw[int](resp); got != 0 {
+		t.Fatalf("decode int = %d", got)
+	}
+}
+
+func TestEnsureNonNil(t *testing.T) {
+	var p *int
+	ensureNonNil(p)
+
+	var s []int
+	ensureNonNil(&s)
+	if s == nil {
+		t.Fatalf("expected slice initialized")
+	}
+
+	var m map[string]int
+	ensureNonNil(&m)
+	if m == nil {
+		t.Fatalf("expected map initialized")
+	}
+}
+
+func TestIsEmptyBody(t *testing.T) {
+	if isEmptyBody(nil) {
+		t.Fatalf("expected false for nil response")
+	}
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(srv.Close)
+
+	resp, err := req.C().R().Get(srv.URL)
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	if !isEmptyBody(resp) {
+		t.Fatalf("expected empty body")
+	}
+
+	srv2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write([]byte("data"))
+	}))
+	t.Cleanup(srv2.Close)
+
+	resp2, err := req.C().R().Get(srv2.URL)
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	if isEmptyBody(resp2) {
+		t.Fatalf("expected non-empty body")
+	}
+
+	srv3 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write([]byte("   "))
+	}))
+	t.Cleanup(srv3.Close)
+
+	resp3, err := req.C().R().Get(srv3.URL)
+	if err != nil {
+		t.Fatalf("request failed: %v", err)
+	}
+	if !isEmptyBody(resp3) {
+		t.Fatalf("expected empty body for whitespace")
+	}
+}

errors_test.go

@@ -0,0 +1,42 @@
+package httpx
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/imroc/req/v3"
+)
+
+func TestHTTPErrorString(t *testing.T) {
+	err := (&HTTPError{StatusCode: 400, Status: "Bad Request"}).Error()
+	if err == "" {
+		t.Fatalf("expected error string")
+	}
+}
+
+func TestNewHTTPErrorNilResponse(t *testing.T) {
+	err := newHTTPError(nil)
+	if err.StatusCode != 0 {
+		t.Fatalf("expected status 0")
+	}
+	if err.Status == "" {
+		t.Fatalf("expected status message")
+	}
+}
+
+func TestNewHTTPErrorResponse(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	t.Cleanup(srv.Close)
+
+	resp, reqErr := req.C().R().Get(srv.URL)
+	if reqErr != nil {
+		t.Fatalf("request failed: %v", reqErr)
+	}
+	err := newHTTPError(resp)
+	if err.StatusCode != 500 {
+		t.Fatalf("status code = %d", err.StatusCode)
+	}
+}

options_auth_test.go

@@ -0,0 +1,55 @@
+package httpx
+
+import (
+	"encoding/base64"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestAuthHeaders(t *testing.T) {
+	var gotAuth string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotAuth = r.Header.Get("Authorization")
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer srv.Close()
+
+	c := New()
+	res := Get[string](c, srv.URL, Auth("Token", "abc123"))
+	if res.Err != nil {
+		t.Fatalf("auth request failed: %v", res.Err)
+	}
+	if gotAuth != "Token abc123" {
+		t.Fatalf("auth header = %q", gotAuth)
+	}
+}
+
+func TestBearerAndBasic(t *testing.T) {
+	var auths []string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		auths = append(auths, r.Header.Get("Authorization"))
+		w.WriteHeader(http.StatusOK)
+	}))
+	defer srv.Close()
+
+	c := New()
+	res := Get[string](c, srv.URL, Bearer("token"))
+	if res.Err != nil {
+		t.Fatalf("bearer request failed: %v", res.Err)
+	}
+	res = Get[string](c, srv.URL, Basic("user", "pass"))
+	if res.Err != nil {
+		t.Fatalf("basic request failed: %v", res.Err)
+	}
+	if len(auths) != 2 {
+		t.Fatalf("auths len = %d", len(auths))
+	}
+	if auths[0] != "Bearer token" {
+		t.Fatalf("bearer header = %q", auths[0])
+	}
+	wantBasic := "Basic " + base64.StdEncoding.EncodeToString([]byte("user:pass"))
+	if auths[1] != wantBasic {
+		t.Fatalf("basic header = %q", auths[1])
+	}
+}