test: server client mock (#2571)

Author: ldez

go.mod

@@ -35,6 +35,7 @@ require (
 	github.com/exoscale/egoscale/v3 v3.1.13
 	github.com/go-jose/go-jose/v4 v4.0.5
 	github.com/go-viper/mapstructure/v2 v2.2.1
+	github.com/google/go-cmp v0.7.0
 	github.com/google/go-querystring v1.1.0
 	github.com/gophercloud/gophercloud v1.14.1
 	github.com/gophercloud/utils v0.0.0-20231010081019-80377eca5d56

platform/tester/servermock/builder.go

@@ -0,0 +1,72 @@
+package servermock
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"slices"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// Link represents a middleware interface, enabling middleware chaining.
+type Link interface {
+	Bind(next http.Handler) http.Handler
+}
+
+// LinkFunc defines a function type [Link].
+type LinkFunc func(next http.Handler) http.Handler
+
+func (f LinkFunc) Bind(next http.Handler) http.Handler {
+	return f(next)
+}
+
+// ClientBuilder defines a function type for creating a client of type T based on a httptest.Server instance.
+type ClientBuilder[T any] func(server *httptest.Server) (T, error)
+
+// Builder is a type that facilitates the construction of testable HTTP clients and server.
+// It allows defining routes, attaching middleware, and creating custom HTTP clients.
+type Builder[T any] struct {
+	mux   *http.ServeMux
+	chain []Link
+
+	clientBuilder ClientBuilder[T]
+}
+
+func NewBuilder[T any](clientBuilder ClientBuilder[T], chain ...Link) *Builder[T] {
+	return &Builder[T]{
+		mux:           http.NewServeMux(),
+		chain:         chain,
+		clientBuilder: clientBuilder,
+	}
+}
+
+func (b *Builder[T]) Route(pattern string, handler http.Handler, chain ...Link) *Builder[T] {
+	if handler == nil {
+		handler = Noop()
+	}
+
+	for _, link := range slices.Backward(b.chain) {
+		handler = link.Bind(handler)
+	}
+
+	for _, link := range slices.Backward(chain) {
+		handler = link.Bind(handler)
+	}
+
+	b.mux.Handle(pattern, handler)
+
+	return b
+}
+
+func (b *Builder[T]) Build(t *testing.T) T {
+	t.Helper()
+
+	server := httptest.NewServer(b.mux)
+	t.Cleanup(server.Close)
+
+	client, err := b.clientBuilder(server)
+	require.NoError(t, err)
+
+	return client
+}

platform/tester/servermock/handler_dump.go

@@ -0,0 +1,20 @@
+package servermock
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httputil"
+)
+
+// DumpRequest logs the full HTTP request to the console, including the body if present.
+func DumpRequest() http.HandlerFunc {
+	return func(rw http.ResponseWriter, req *http.Request) {
+		dump, err := httputil.DumpRequest(req, true)
+		if err != nil {
+			http.Error(rw, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		fmt.Println(string(dump))
+	}
+}

platform/tester/servermock/handler_file.go

@@ -0,0 +1,77 @@
+package servermock
+
+import (
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"slices"
+)
+
+// ResponseFromFileHandler handles HTTP responses using the content of a file.
+type ResponseFromFileHandler struct {
+	statusCode int
+	headers    http.Header
+	filename   string
+}
+
+func ResponseFromFile(filename string) *ResponseFromFileHandler {
+	return &ResponseFromFileHandler{
+		statusCode: http.StatusOK,
+		headers:    http.Header{},
+		filename:   filename,
+	}
+}
+
+func ResponseFromFixture(filename string) *ResponseFromFileHandler {
+	return ResponseFromFile(filepath.Join("fixtures", filename))
+}
+
+func (h *ResponseFromFileHandler) ServeHTTP(rw http.ResponseWriter, _ *http.Request) {
+	for k, values := range h.headers {
+		for _, v := range values {
+			rw.Header().Add(k, v)
+		}
+	}
+
+	if h.filename == "" {
+		rw.WriteHeader(h.statusCode)
+		return
+	}
+
+	if filepath.Ext(h.filename) == ".json" {
+		rw.Header().Set(contentTypeHeader, applicationJSONMimeType)
+	}
+
+	file, err := os.Open(h.filename)
+	if err != nil {
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	defer func() { _ = file.Close() }()
+
+	rw.WriteHeader(h.statusCode)
+
+	_, err = io.Copy(rw, file)
+	if err != nil {
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func (h *ResponseFromFileHandler) WithStatusCode(status int) *ResponseFromFileHandler {
+	if h.statusCode >= http.StatusContinue {
+		h.statusCode = status
+	}
+
+	return h
+}
+
+func (h *ResponseFromFileHandler) WithHeader(name, value string, values ...string) *ResponseFromFileHandler {
+	for _, v := range slices.Concat([]string{value}, values) {
+		h.headers.Add(name, v)
+	}
+
+	return h
+}

platform/tester/servermock/handler_json.go

@@ -0,0 +1,39 @@
+package servermock
+
+import (
+	"encoding/json"
+	"net/http"
+)
+
+// JSONEncodeHandler is a handler that encodes data into JSON and writes it to an HTTP response.
+type JSONEncodeHandler struct {
+	data       any
+	statusCode int
+}
+
+func JSONEncode(data any) *JSONEncodeHandler {
+	return &JSONEncodeHandler{
+		data:       data,
+		statusCode: http.StatusOK,
+	}
+}
+
+func (h *JSONEncodeHandler) ServeHTTP(rw http.ResponseWriter, _ *http.Request) {
+	rw.Header().Set(contentTypeHeader, applicationJSONMimeType)
+
+	rw.WriteHeader(h.statusCode)
+
+	err := json.NewEncoder(rw).Encode(h.data)
+	if err != nil {
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func (h *JSONEncodeHandler) WithStatusCode(status int) *JSONEncodeHandler {
+	if h.statusCode >= http.StatusContinue {
+		h.statusCode = status
+	}
+
+	return h
+}

platform/tester/servermock/handler_noop.go

@@ -0,0 +1,45 @@
+package servermock
+
+import (
+	"net/http"
+	"slices"
+)
+
+// NoopHandler is a simple HTTP handler that responds without processing requests.
+type NoopHandler struct {
+	statusCode int
+	headers    http.Header
+}
+
+func Noop() *NoopHandler {
+	return &NoopHandler{
+		statusCode: http.StatusOK,
+		headers:    http.Header{},
+	}
+}
+
+func (h *NoopHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
+	for k, values := range h.headers {
+		for _, v := range values {
+			rw.Header().Add(k, v)
+		}
+	}
+
+	rw.WriteHeader(h.statusCode)
+}
+
+func (h *NoopHandler) WithStatusCode(status int) *NoopHandler {
+	if h.statusCode >= http.StatusContinue {
+		h.statusCode = status
+	}
+
+	return h
+}
+
+func (h *NoopHandler) WithHeader(name, value string, values ...string) *NoopHandler {
+	for _, v := range slices.Concat([]string{value}, values) {
+		h.headers.Add(name, v)
+	}
+
+	return h
+}

platform/tester/servermock/handler_raw.go

@@ -0,0 +1,61 @@
+package servermock
+
+import (
+	"net/http"
+	"slices"
+)
+
+// RawResponseHandler is a custom HTTP handler that serves raw response data.
+type RawResponseHandler struct {
+	statusCode int
+	headers    http.Header
+	data       []byte
+}
+
+func RawResponse(data []byte) *RawResponseHandler {
+	return &RawResponseHandler{
+		statusCode: http.StatusOK,
+		headers:    http.Header{},
+		data:       data,
+	}
+}
+
+func RawStringResponse(data string) *RawResponseHandler {
+	return RawResponse([]byte(data))
+}
+
+func (h *RawResponseHandler) ServeHTTP(rw http.ResponseWriter, _ *http.Request) {
+	for k, values := range h.headers {
+		for _, v := range values {
+			rw.Header().Add(k, v)
+		}
+	}
+
+	rw.WriteHeader(h.statusCode)
+
+	if len(h.data) == 0 {
+		return
+	}
+
+	_, err := rw.Write(h.data)
+	if err != nil {
+		http.Error(rw, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func (h *RawResponseHandler) WithStatusCode(status int) *RawResponseHandler {
+	if h.statusCode >= http.StatusContinue {
+		h.statusCode = status
+	}
+
+	return h
+}
+
+func (h *RawResponseHandler) WithHeader(name, value string, values ...string) *RawResponseHandler {
+	for _, v := range slices.Concat([]string{value}, values) {
+		h.headers.Add(name, v)
+	}
+
+	return h
+}