如何测试Go应用为不同HTTP请求调用正确的处理器

核心解决思路 #

直接把你实际应用里的http.ServeMux实例传给httptest.NewServer，而不是自定义单个HandlerFunc。这样测试服务器会完全复用你应用的路由规则，你就可以针对不同URL路径发起请求，验证对应的处理器是否被正确调用。

具体实现方法 #

1. 为测试准备可验证的处理器 #

你可以通过两种方式让处理器的调用状态可追踪：

• 让每个处理器返回唯一的响应内容，通过响应判断是否调用正确
• 使用Mock处理器，通过标记位或计数来确认调用情况

示例：返回唯一响应的处理器

func someHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "handler: someURLpath")
}

func someOtherHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "handler: someOtherURLpath")
}

示例：Mock处理器（适合复杂场景）

type MockHandler struct {
    Called bool
}

func (m *MockHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    m.Called = true
    // 可添加其他逻辑，比如记录请求参数
}

2. 编写测试用例 #

直接传入你的ServeMux到测试服务器，批量测试不同路径的路由映射：

import (
    "io"
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestMuxRouteMapping(t *testing.T) {
    // 初始化和应用一致的多路复用器与路由
    mux := http.NewServeMux()
    mux.Handle("/someURLpath", someHandler)
    mux.Handle("/someOtherURLpath", someOtherHandler)

    // 加入Mock处理器测试
    mockHandler := &MockHandler{}
    mux.Handle("/testMock", mockHandler)

    // 创建测试服务器，传入你的mux
    ts := httptest.NewServer(mux)
    defer ts.Close()

    // 定义测试用例集合：路径 → 预期响应内容
    testCases := []struct {
        path         string
        expectedBody string
    }{
        {"/someURLpath", "handler: someURLpath\n"},
        {"/someOtherURLpath", "handler: someOtherURLpath\n"},
    }

    // 遍历执行所有测试用例
    for _, tc := range testCases {
        t.Run(tc.path, func(t *testing.T) {
            // 发起GET请求
            resp, err := http.Get(ts.URL + tc.path)
            if err != nil {
                t.Fatalf("请求发送失败: %v", err)
            }
            defer resp.Body.Close()

            // 读取响应内容
            body, err := io.ReadAll(resp.Body)
            if err != nil {
                t.Fatalf("响应内容读取失败: %v", err)
            }

            // 验证响应是否符合预期
            if string(body) != tc.expectedBody {
                t.Errorf("预期响应: %q, 实际得到: %q", tc.expectedBody, string(body))
            }
        })
    }

    // 单独验证Mock处理器的调用状态
    t.Run("/testMock", func(t *testing.T) {
        _, err := http.Get(ts.URL + "/testMock")
        if err != nil {
            t.Fatalf("请求发送失败: %v", err)
        }

        if !mockHandler.Called {
            t.Error("/testMock 未触发对应的Mock处理器")
        }
    })
}

3. 轻量替代方案：直接调用ServeHTTP #

如果不想启动网络服务器，也可以直接构造请求和响应记录器，调用mux.ServeHTTP完成测试，适合单元测试场景：

func TestMuxDirectly(t *testing.T) {
    mux := http.NewServeMux()
    mock1 := &MockHandler{}
    mock2 := &MockHandler{}
    mux.Handle("/path1", mock1)
    mux.Handle("/path2", mock2)

    // 测试/path1路由
    req := httptest.NewRequest("GET", "/path1", nil)
    w := httptest.NewRecorder()
    mux.ServeHTTP(w, req)

    if !mock1.Called {
        t.Error("/path1 未触发mock1处理器")
    }
    if mock2.Called {
        t.Error("/path1 错误触发了mock2处理器")
    }

    // 重置Mock状态，测试/path2路由
    mock1.Called = false
    mock2.Called = false

    req = httptest.NewRequest("GET", "/path2", nil)
    w = httptest.NewRecorder()
    mux.ServeHTTP(w, req)

    if !mock2.Called {
        t.Error("/path2 未触发mock2处理器")
    }
    if mock1.Called {
        t.Error("/path2 错误触发了mock1处理器")
    }
}

内容的提问来源于stack exchange，提问作者vtm11