test: refactor regression tests and enhance assertions

Author: dorzepowski

pkg/internal/regressiontests/http_auth_with_ts_regression_test.go

@@ -1,10 +1,10 @@
 //go:build regressiontest
-// +build regressiontest
 
 package regressiontests
 
 import (
 	"net/http"
+	"net/url"
 	"testing"
 
 	"github.com/bsv-blockchain/go-bsv-middleware/pkg/internal/regressiontests/internal/typescript"
@@ -20,19 +20,19 @@ func TestAuthMiddlewareAuthenticatesTypescriptClient(t *testing.T) {
 		headers map[string]string
 	}{
 		"get request": {
-			method:  "GET",
+			method:  http.MethodGet,
 			query:   "",
 			body:    nil,
 			headers: nil,
 		},
 		"get request with query params": {
-			method:  "GET",
+			method:  http.MethodGet,
 			query:   "test=123&other=abc",
 			body:    nil,
 			headers: nil,
 		},
 		"get request with headers": {
-			method: "GET",
+			method: http.MethodGet,
 			query:  "",
 			body:   nil,
 			headers: map[string]string{
@@ -42,7 +42,7 @@ func TestAuthMiddlewareAuthenticatesTypescriptClient(t *testing.T) {
 			},
 		},
 		"post request": {
-			method: "POST",
+			method: http.MethodPost,
 			query:  "",
 			body: map[string]string{
 				"test":  "123",
@@ -53,6 +53,10 @@ func TestAuthMiddlewareAuthenticatesTypescriptClient(t *testing.T) {
 				"Content-Type": "application/json",
 			},
 		},
+		"invalid query params": {
+			method: http.MethodPost,
+			query:  "shirts size",
+		},
 	}
 	for name, test := range testCases {
 		t.Run(name, func(t *testing.T) {
@@ -69,10 +73,10 @@ func TestAuthMiddlewareAuthenticatesTypescriptClient(t *testing.T) {
 					then.Request(r).
 						HasMethod(test.method).
 						HasHeadersContaining(test.headers).
-						HasQueryMatching(test.query).
+						HasQueryMatching(url.PathEscape(test.query)).
 						HasBodyMatching(test.body)
 
-					// TODO check indentity key
+					// TODO check identity key
 
 					_, err := w.Write([]byte("Pong!"))
 					require.NoError(t, err)
@@ -84,15 +88,15 @@ func TestAuthMiddlewareAuthenticatesTypescriptClient(t *testing.T) {
 			url.Path = "/ping"
 			url.RawQuery = test.query
 
-			response, err := typescript.AuthFetch(t,
+			response := typescript.AuthFetch(t,
 				url.String(),
 				typescript.WithMethod(test.method),
 				typescript.WithHeaders(test.headers),
 				typescript.WithBody(test.body),
 			)
 
 			// then:
-			then.Response(response).WithNoError(err).
+			then.Response(response).
 				HasStatus(200).
 				HasHeader("x-bsv-auth-identity-key").
 				HasBody("Pong!")

pkg/internal/regressiontests/internal/typescript/typescript_auth_fetch_caller.go

@@ -3,6 +3,7 @@ package typescript
 import (
 	"encoding/json"
 	"fmt"
+	"net/http"
 	"os/exec"
 	"path/filepath"
 	"runtime"
@@ -69,15 +70,6 @@ func WithHeaders(headers map[string]string) func(*Options) {
 	}
 }
 
-func WithHeader(key string, value string) func(*Options) {
-	return func(options *Options) {
-		if options.headers == nil {
-			options.headers = make([]string, 0)
-		}
-		options.headers = append(options.headers, key+":"+value)
-	}
-}
-
 var validMethods = []string{"GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"}
 
 const resultIndicator = "==================RESULT==============="
@@ -89,10 +81,10 @@ type AuthFetchResponse struct {
 	Body       string            `json:"body"`
 }
 
-func AuthFetch(t testing.TB, url string, opts ...func(*Options)) (*AuthFetchResponse, error) {
+func AuthFetch(t testing.TB, url string, opts ...func(*Options)) *AuthFetchResponse {
 	options := to.OptionsWithDefault(Options{
 		url:    url,
-		method: "GET",
+		method: http.MethodGet,
 	}, opts...)
 
 	command, args := authFetchCommand()
@@ -116,15 +108,13 @@ func AuthFetch(t testing.TB, url string, opts ...func(*Options)) (*AuthFetchResp
 
 	t.Log(log)
 
-	if err != nil {
-		return nil, fmt.Errorf("AuthFetch failed: %w, %s", err, result)
-	}
+	require.NoErrorf(t, err, "Failed to run auth fetch command\n%s", output)
 
 	var response AuthFetchResponse
 	err = json.Unmarshal([]byte(result), &response)
 	require.NoErrorf(t, err, "Result from js script must be json with response\n%s", result)
 
-	return &response, nil
+	return &response
 }
 
 func authFetchCommand() (string, []string) {

pkg/internal/regressiontests/internal/typescript/typescript_auth_fetch_callet_test.go

@@ -11,7 +11,7 @@ import (
 func TestCheckTypescriptAuthFetchCaller(t *testing.T) {
 	t.Skip("used for auth fetch caller development purposes")
 
-	response, err := typescript.AuthFetch(t, "http://localhost:8100")
+	response := typescript.AuthFetch(t, "http://localhost:8100")
 	assert.NoError(t, err)
 	require.NotNil(t, response)
 	assert.NotEmpty(t, response.Status)

pkg/internal/regressiontests/testabilities/assertion_regression.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/bsv-blockchain/go-bsv-middleware/pkg/internal/regressiontests/internal/typescript"
+	"github.com/stretchr/testify/require"
 )
 
 type RegressionTestAssertion interface {
@@ -28,6 +29,9 @@ func (a *regressionTestAssertion) Request(request *http.Request) RequestAssertio
 }
 
 func (a *regressionTestAssertion) Response(response *typescript.AuthFetchResponse) AuthFetchResponseAssertion {
+	a.Helper()
+	require.NotNil(a, response, "response should not be nil")
+
 	return &authFetchResponseAssertion{
 		TB:       a,
 		response: response,

pkg/internal/regressiontests/testabilities/assertion_request.go

@@ -25,11 +25,13 @@ type requestAssertion struct {
 }
 
 func (a *requestAssertion) HasMethod(httpMethod string) RequestAssertion {
+	a.Helper()
 	assert.Equalf(a, httpMethod, a.request.Method, "Expect to receive %s request", httpMethod)
 	return a
 }
 
 func (a *requestAssertion) HasHeadersContaining(headers map[string]string) RequestAssertion {
+	a.Helper()
 	for headerName, headerValue := range headers {
 		assert.Equalf(a, headerValue, a.request.Header.Get(headerName), "Header %s value received by handler should match", headerName)
 	}
@@ -38,11 +40,13 @@ func (a *requestAssertion) HasHeadersContaining(headers map[string]string) Reque
 }
 
 func (a *requestAssertion) HasQueryMatching(query string) RequestAssertion {
+	a.Helper()
 	assert.Equal(a, query, a.request.URL.RawQuery, "query params received by handler should match")
 	return a
 }
 
 func (a *requestAssertion) HasBodyMatching(expectedBody map[string]string) RequestAssertion {
+	a.Helper()
 	bodyBytes, err := io.ReadAll(a.request.Body)
 	assert.NoError(a, err, "failed to read request body: invalid test setup")
 	// ensure the body is not closed.

pkg/internal/regressiontests/testabilities/assertion_response.go

@@ -5,41 +5,33 @@ import (
 
 	"github.com/bsv-blockchain/go-bsv-middleware/pkg/internal/regressiontests/internal/typescript"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 type AuthFetchResponseAssertion interface {
-	WithNoError(error) SuccessAuthFetchResponseAssertion
-}
-
-type SuccessAuthFetchResponseAssertion interface {
-	HasStatus(int) SuccessAuthFetchResponseAssertion
-	HasHeader(string) SuccessAuthFetchResponseAssertion
-	HasBody(any) SuccessAuthFetchResponseAssertion
+	HasStatus(int) AuthFetchResponseAssertion
+	HasHeader(string) AuthFetchResponseAssertion
+	HasBody(any) AuthFetchResponseAssertion
 }
 
 type authFetchResponseAssertion struct {
 	testing.TB
 	response *typescript.AuthFetchResponse
 }
 
-func (a *authFetchResponseAssertion) WithNoError(err error) SuccessAuthFetchResponseAssertion {
-	assert.NoError(a, err, "fetch should result with no error")
-	require.NotNil(a, a.response, "fetch should return a response")
-	return a
-}
-
-func (a *authFetchResponseAssertion) HasStatus(status int) SuccessAuthFetchResponseAssertion {
+func (a *authFetchResponseAssertion) HasStatus(status int) AuthFetchResponseAssertion {
+	a.Helper()
 	assert.Equal(a, status, a.response.Status, "fetch should return status 200")
 	return a
 }
 
-func (a *authFetchResponseAssertion) HasHeader(headerName string) SuccessAuthFetchResponseAssertion {
-	assert.Contains(a, a.response.Headers, "x-bsv-auth-identity-key")
+func (a *authFetchResponseAssertion) HasHeader(headerName string) AuthFetchResponseAssertion {
+	a.Helper()
+	assert.Contains(a, a.response.Headers, headerName)
 	return a
 }
 
-func (a *authFetchResponseAssertion) HasBody(body any) SuccessAuthFetchResponseAssertion {
+func (a *authFetchResponseAssertion) HasBody(body any) AuthFetchResponseAssertion {
+	a.Helper()
 	assert.Equal(a, a.response.Body, body)
 	return a
 }

pkg/internal/test/mocks/http.go

@@ -13,7 +13,6 @@ import (
 	"testing"
 
 	"github.com/bsv-blockchain/go-bsv-middleware/pkg/interfaces"
-	"github.com/bsv-blockchain/go-bsv-middleware/pkg/internal/logging"
 	middleware "github.com/bsv-blockchain/go-bsv-middleware/pkg/middleware/auth"
 	"github.com/bsv-blockchain/go-bsv-middleware/pkg/transport"
 	"github.com/bsv-blockchain/go-sdk/auth"
@@ -292,14 +291,6 @@ func WithLogger(s *MockHTTPServer) *MockHTTPServer {
 	return s
 }
 
-// WithTestLogger wraps a MockHTTPServer with a test logger for capturing log output during tests.
-func WithTestLogger(t testing.TB) func(s *MockHTTPServer) *MockHTTPServer {
-	return func(s *MockHTTPServer) *MockHTTPServer {
-		s.logger = logging.NewTestLogger(t)
-		return s
-	}
-}
-
 func prepareAndCallRequest(t *testing.T, method, authURL string, headers map[string]string, jsonData []byte) *http.Response {
 	req, err := http.NewRequest(method, authURL, bytes.NewBuffer(jsonData))
 	require.Nil(t, err)

pkg/transport/http/transport.go

@@ -394,11 +394,12 @@ func buildRequestPayload(req *http.Request, requestID string) ([]byte, error) {
 	writer.WriteString(req.Method)
 	writer.WriteOptionalString(req.URL.Path)
 
-	seachParams := req.URL.RawQuery
-	if seachParams != "" {
-		seachParams = "?" + seachParams
+	searchParams := req.URL.RawQuery
+	if searchParams != "" {
+		// auth client is using query string with leading "?", so the middleware need to include that character also.
+		searchParams = "?" + searchParams
 	}
-	writer.WriteOptionalString(seachParams)
+	writer.WriteOptionalString(searchParams)
 
 	var includedHeaders [][]string
 	for k, v := range req.Header {