test-mocking-http-requests

Answer

Here's a comprehensive Go test suite demonstrating HTTP request mocking techniques:

// http_mock_test.go
package httptest

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/http/httptest"
    "strings"
    "sync"
    "testing"
)

// ---------------------------------------------------------------------------
// 1. Using httptest.Server for mocking
// ---------------------------------------------------------------------------

func TestWithHttptestServer(t *testing.T) {
    // Create a mock server that returns controlled responses
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Verify the request path
        if r.URL.Path != "/api/users" {
            t.Errorf("unexpected path: %s", r.URL.Path)
        }

        // Verify request method
        if r.Method != http.MethodGet {
            t.Errorf("unexpected method: %s", r.Method)
        }

        // Verify request headers
        if r.Header.Get("Authorization") != "Bearer test-token" {
            t.Errorf("unexpected auth header: %s", r.Header.Get("Authorization"))
        }

        // Return a JSON response
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusOK)
        fmt.Fprint(w, `{"users":[{"id":1,"name":"Alice"}]}`)
    }))
    defer server.Close()

    // Make a real HTTP request to the mock server
    req, err := http.NewRequest(http.MethodGet, server.URL+"/api/users", nil)
    if err != nil {
        t.Fatal(err)
    }
    req.Header.Set("Authorization", "Bearer test-token")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        t.Fatal(err)
    }
    defer resp.Body.Close()

    // Verify response
    if resp.StatusCode != http.StatusOK {
        t.Errorf("expected 200 OK, got %d", resp.StatusCode)
    }

    body, _ := io.ReadAll(resp.Body)
    if !strings.Contains(string(body), "Alice") {
        t.Errorf("unexpected body: %s", body)
    }
}

// ---------------------------------------------------------------------------
// 2. Custom RoundTripper for intercepting requests
// ---------------------------------------------------------------------------

// MockTransport intercepts all HTTP requests and returns canned responses.
type MockTransport struct {
    mu       sync.Mutex
    routes   map[string]RoundTripHandler // key: "METHOD URL"
    requests []*http.Request             // recorded requests for verification
}

// RoundTripHandler defines a canned response for a matched request.
type RoundTripHandler func(req *http.Request) (*http.Response, error)

// NewMockTransport creates a transport with no registered routes.
func NewMockTransport() *MockTransport {
    return &MockTransport{
        routes:   make(map[string]RoundTripHandler),
        requests: make([]*http.Request, 0),
    }
}

// RegisterRoute tells the transport what to respond when it sees method+url.
func (t *MockTransport) RegisterRoute(method, url string, handler RoundTripHandler) {
    t.mu.Lock()
    defer t.mu.Unlock()
    t.routes[method+" "+url] = handler
}

// RoundTrip implements http.RoundTripper.
func (t *MockTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    t.mu.Lock()
    // Clone the request so we can inspect it later (body is consumed).
    cloned := cloneRequest(req)
    t.requests = append(t.requests, cloned)
    key := req.Method + " " + req.URL.String()
    handler, ok := t.routes[key]
    t.mu.Unlock()

    if !ok {
        return nil, fmt.Errorf("no mock handler for %s %s", req.Method, req.URL)
    }
    return handler(req)
}

// Requests returns a copy of every request received (for assertion).
func (t *MockTransport) Requests() []*http.Request {
    t.mu.Lock()
    defer t.mu.Unlock()
    out := make([]*http.Request, len(t.requests))
    copy(out, t.requests)
    return out
}

// Reset clears recorded requests.
func (t *MockTransport) Reset() {
    t.mu.Lock()
    defer t.mu.Unlock()
    t.requests = nil
}

func cloneRequest(orig *http.Request) *http.Request {
    clone := new(http.Request)
    *clone = *orig
    if orig.Body != nil {
        b, _ := io.ReadAll(orig.Body)
        orig.Body.Close()
        orig.Body = io.NopCloser(bytes.NewReader(b))
        clone.Body = io.NopCloser(bytes.NewReader(b))
    }
    return clone
}

// helper to build canned responses
func cannedResponse(status int, headers map[string]string, body string) *http.Response {
    resp := &http.Response{
        StatusCode: status,
        Proto:      "HTTP/1.1",
        ProtoMajor: 1,
        ProtoMinor: 1,
        Header:     make(http.Header),
        Body:       io.NopCloser(strings.NewReader(body)),
    }
    for k, v := range headers {
        resp.Header.Set(k, v)
    }
    return resp
}

func TestCustomRoundTripper(t *testing.T) {
    transport := NewMockTransport()

    // Register a handler for GET /api/users
    transport.RegisterRoute("GET", "http://example.com/api/users", func(req *http.Request) (*http.Response, error) {
        return cannedResponse(http.StatusOK, map[string]string{"Content-Type": "application/json"}, `{"id":1,"name":"Alice"}`), nil
    })

    // Register a handler for POST /api/users (validates body + headers)
    transport.RegisterRoute("POST", "http://example.com/api/users", func(req *http.Request) (*http.Response, error) {
        // Verify request headers
        if req.Header.Get("Content-Type") != "application/json" {
            return cannedResponse(http.StatusBadRequest, nil, "bad content-type"), nil
        }

        // Read and verify body
        body, _ := io.ReadAll(req.Body)
        var payload struct {
            Name string `json:"name"`
        }
        if err := json.Unmarshal(body, &payload); err != nil {
            return cannedResponse(http.StatusBadRequest, nil, "bad body"), nil
        }
        if payload.Name != "Bob" {
            return cannedResponse(http.StatusBadRequest, nil, "unexpected name"), nil
        }

        return cannedResponse(http.StatusCreated, map[string]string{"Content-Type": "application/json"}, `{"id":2,"name":"Bob"}`), nil
    })

    // Create an HTTP client using our mock transport
    client := &http.Client{Transport: transport}

    // --- Test GET ---
    t.Run("GET /api/users", func(t *testing.T) {
        resp, err := client.Get("http://example.com/api/users")
        if err != nil {
            t.Fatal(err)
        }
        defer resp.Body.Close()

        if resp.StatusCode != http.StatusOK {
            t.Errorf("expected 200, got %d", resp.StatusCode)
        }
        body, _ := io.ReadAll(resp.Body)
        if !strings.Contains(string(body), "Alice") {
            t.Errorf("expected Alice in body, got %s", body)
        }
    })

    // --- Test POST with valid body ---
    t.Run("POST /api/users (valid)", func(t *testing.T) {
        payload := `{"name":"Bob"}`
        resp, err := client.Post("http://example.com/api/users", "application/json", strings.NewReader(payload))
        if err != nil {
            t.Fatal(err)
        }
        defer resp.Body.Close()

        if resp.StatusCode != http.StatusCreated {
            t.Errorf("expected 201, got %d", resp.StatusCode)
        }
    })

    // --- Verify that requests were recorded ---
    t.Run("verify recorded requests", func(t *testing.T) {
        requests := transport.Requests()
        if len(requests) != 2 {
            t.Fatalf("expected 2 requests, got %d", len(requests))
        }

        if requests[0].Method != http.MethodGet {
            t.Errorf("first request should be GET")
        }
        if requests[1].Method != http.MethodPost {
            t.Errorf("second request should be POST")
        }
    })
}

// ---------------------------------------------------------------------------
// 3. Record & Replay HTTP interactions
// ---------------------------------------------------------------------------

// RecordedInteraction stores a complete request/response pair.
type RecordedInteraction struct {
    Request  *http.Request
    Response *http.Response
}

// RecorderTransport wraps a round tripper and records every interaction.
type RecorderTransport struct {
    inner   http.RoundTripper
    mu      sync.Mutex
    tape    []RecordedInteraction
}

// NewRecorderTransport creates a recorder around a real transport.
func NewRecorderTransport(inner http.RoundTripper) *RecorderTransport {
    if inner == nil {
        inner = http.DefaultTransport
    }
    return &RecorderTransport{inner: inner, tape: make([]RecordedInteraction, 0)}
}

func (t *RecorderTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    resp, err := t.inner.RoundTrip(req)
    t.mu.Lock()
    defer t.mu.Unlock()

    clonedReq := cloneRequest(req)
    var clonedResp *http.Response
    if resp != nil {
        clonedResp = &http.Response{
            StatusCode: resp.StatusCode,
            Proto:      resp.Proto,
            ProtoMajor: resp.ProtoMajor,
            ProtoMinor: resp.ProtoMinor,
            Header:     resp.Header.Clone(),
        }
        if resp.Body != nil {
            b, _ := io.ReadAll(resp.Body)
            resp.Body.Close()
            resp.Body = io.NopCloser(bytes.NewReader(b))
            clonedResp.Body = io.NopCloser(bytes.NewReader(b))
        }
    }

    t.tape = append(t.tape, RecordedInteraction{
        Request:  clonedReq,
        Response: clonedResp,
    })
    return resp, err
}

// Tape returns all recorded interactions.
func (t *RecorderTransport) Tape() []RecordedInteraction {
    t.mu.Lock()
    defer t.mu.Unlock()
    out := make([]RecordedInteraction, len(t.tape))
    copy(out, t.tape)
    return out
}

// ReplayTransport replays previously recorded responses for matching requests.
type ReplayTransport struct {
    mu       sync.Mutex
    tape     []RecordedInteraction
    cursor   int
}

// NewReplayTransport creates a transport seeded with recorded interactions.
func NewReplayTransport(tape []RecordedInteraction) *ReplayTransport {
    return &ReplayTransport{tape: tape}
}

func (t *ReplayTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    t.mu.Lock()
    defer t.mu.Unlock()

    if t.cursor >= len(t.tape) {
        return nil, fmt.Errorf("replay: no more recorded responses (cursor=%d, tape=%d)", t.cursor, len(t.tape))
    }

    interaction := t.tape[t.cursor]
    t.cursor++

    // Clone the saved response so each caller gets a fresh body
    saved := interaction.Response
    resp := &http.Response{
        StatusCode: saved.StatusCode,
        Proto:      saved.Proto,
        ProtoMajor: saved.ProtoMajor,
        ProtoMinor: saved.ProtoMinor,
        Header:     saved.Header.Clone(),
    }
    if saved.Body != nil {
        b, _ := io.ReadAll(saved.Body)
        saved.Body.Close()
        saved.Body = io.NopCloser(bytes.NewReader(b))
        resp.Body = io.NopCloser(bytes.NewReader(b))
    }
    return resp, nil
}

// TestRecordAndReplay demonstrates the full record-then-replay cycle.
func TestRecordAndReplay(t *testing.T) {
    // ---- Record phase (against a real test server) ----
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(http.StatusOK)
        fmt.Fprint(w, `{"message":"hello from server"}`)
    }))
    defer server.Close()

    recorder := NewRecorderTransport(http.DefaultTransport)
    client := &http.Client{Transport: recorder}

    resp, err := client.Get(server.URL + "/api/test")
    if err != nil {
        t.Fatal(err)
    }
    resp.Body.Close()

    tape := recorder.Tape()
    if len(tape) != 1 {
        t.Fatalf("expected 1 recorded interaction, got %d", len(tape))
    }

    // ---- Replay phase (no server needed) ----
    replayer := NewReplayTransport(tape)
    replayClient := &http.Client{Transport: replayer}

    resp2, err := replayClient.Get("http://any-url-will-do/api/test")
    if err != nil {
        t.Fatal(err)
    }
    defer resp2.Body.Close()

    if resp2.StatusCode != http.StatusOK {
        t.Errorf("expected 200, got %d", resp2.StatusCode)
    }

    body, _ := io.ReadAll(resp2.Body)
    if !strings.Contains(string(body), "hello from server") {
        t.Errorf("expected replayed message, got %s", body)
    }
}

// ---------------------------------------------------------------------------
// 4. Verify request headers and body
// ---------------------------------------------------------------------------

// RequestValidator is an http.Handler that validates incoming requests.
type RequestValidator struct {
    ExpectedMethod   string
    ExpectedPath     string
    ExpectedHeaders  map[string]string
    ExpectedBody     string
    ResponseStatus   int
    ResponseBody     string
    ResponseHeaders  map[string]string
    t                *testing.T
}

func (v *RequestValidator) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    if v.ExpectedMethod != "" && r.Method != v.ExpectedMethod {
        v.t.Errorf("method: expected %s, got %s", v.ExpectedMethod, r.Method)
    }
    if v.ExpectedPath != "" && r.URL.Path != v.ExpectedPath {
        v.t.Errorf("path: expected %s, got %s", v.ExpectedPath, r.URL.Path)
    }
    for key, val := range v.ExpectedHeaders {
        if got := r.Header.Get(key); got != val {
            v.t.Errorf("header[%s]: expected %q, got %q", key, val, got)
        }
    }
    if v.ExpectedBody != "" {
        body, _ := io.ReadAll(r.Body)
        if string(bytes.TrimSpace(body)) != v.ExpectedBody {
            v.t.Errorf("body: expected %q, got %q", v.ExpectedBody, string(body))
        }
    }

    for key, val := range v.ResponseHeaders {
        w.Header().Set(key, val)
    }
    if v.ResponseStatus == 0 {
        w.WriteHeader(http.StatusOK)
    } else {
        w.WriteHeader(v.ResponseStatus)
    }
    fmt.Fprint(w, v.ResponseBody)
}

func TestRequestValidation(t *testing.T) {
    validator := &RequestValidator{
        ExpectedMethod:  http.MethodPost,
        ExpectedPath:    "/api/data",
        ExpectedHeaders: map[string]string{
            "Authorization": "Bearer secret",
            "Content-Type":  "application/json",
        },
        ExpectedBody:    `{"key":"value"}`,
        ResponseStatus:  http.StatusCreated,
        ResponseBody:    `{"status":"ok"}`,
        ResponseHeaders: map[string]string{"X-Request-Id": "abc-123"},
        t:              t,
    }

    server := httptest.NewServer(validator)
    defer server.Close()

    body := strings.NewReader(`{"key":"value"}`)
    req, err := http.NewRequest(http.MethodPost, server.URL+"/api/data", body)
    if err != nil {
        t.Fatal(err)
    }
    req.Header.Set("Authorization", "Bearer secret")
    req.Header.Set("Content-Type", "application/json")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        t.Fatal(err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusCreated {
        t.Errorf("status: expected 201, got %d", resp.StatusCode)
    }
    if resp.Header.Get("X-Request-Id") != "abc-123" {
        t.Errorf("response header X-Request-Id: expected abc-123, got %s", resp.Header.Get("X-Request-Id"))
    }
}