Golang中测试HTTP处理程序：使用服务器还是不使用服务器？

在Golang中测试HTTP处理程序时，是否使用服务器取决于测试目标。以下是两种方法的详细对比：

1. 直接测试处理程序（不使用服务器）

这种方法直接调用处理函数，适合单元测试：

func TestSlowHandlerDirect(t *testing.T) {
    t.Run("handler returns 200 without timeout", func(t *testing.T) {
        w := httptest.NewRecorder()
        r := httptest.NewRequest(http.MethodGet, "/slow", nil)
        
        // 创建带取消的context来模拟超时
        ctx, cancel := context.WithTimeout(r.Context(), 100*time.Millisecond)
        defer cancel()
        r = r.WithContext(ctx)
        
        slowHandler(w, r)
        
        if w.Code != http.StatusOK {
            t.Errorf("expected 200, got %d", w.Code)
        }
    })
}

优点：

• 测试隔离性好，只测试处理程序逻辑
• 执行速度快
• 可以精确控制输入参数

缺点：

• 无法测试中间件（如TimeoutHandler）
• 无法测试路由配置
• 无法测试服务器级别的行为

2. 通过服务器测试（使用httptest.Server或自定义服务器）

使用httptest.Server：

func TestSlowHandlerWithTestServer(t *testing.T) {
    // 创建测试服务器
    mux := http.NewServeMux()
    mux.Handle("/slow", http.TimeoutHandler(
        http.HandlerFunc(slowHandler), 
        maxTimeout, 
        "timeout",
    ))
    
    ts := httptest.NewServer(mux)
    defer ts.Close()
    
    t.Run("request times out with 503", func(t *testing.T) {
        client := ts.Client()
        client.Timeout = maxTimeout
        
        resp, err := client.Get(ts.URL + "/slow")
        if err != nil {
            t.Fatal(err)
        }
        defer resp.Body.Close()
        
        if resp.StatusCode != http.StatusServiceUnavailable {
            t.Errorf("expected 503, got %d", resp.StatusCode)
        }
    })
}

使用自定义服务器（如你的示例）：

func TestSlowHandlerWithCustomServer(t *testing.T) {
    t.Run("test timeout through server handler chain", func(t *testing.T) {
        server := setUpServer()
        w := httptest.NewRecorder()
        r := httptest.NewRequest(http.MethodGet, "/slow", nil)
        
        // 通过完整的处理链执行
        server.Handler.ServeHTTP(w, r)
        
        if w.Code != http.StatusServiceUnavailable {
            t.Errorf("expected 503, got %d", w.Code)
        }
    })
    
    t.Run("test other endpoints", func(t *testing.T) {
        server := setUpServer()
        w := httptest.NewRecorder()
        r := httptest.NewRequest(http.MethodGet, "/health", nil)
        
        // 测试其他路由
        server.Handler.ServeHTTP(w, r)
        
        // 验证响应
    })
}

优点：

• 测试完整的请求处理链（中间件、路由等）
• 更接近生产环境行为
• 可以测试服务器配置（如超时设置）

缺点：

• 执行速度较慢
• 测试可能依赖外部配置
• 测试失败时难以定位问题根源

3. 混合测试策略示例

在实际项目中，通常结合两种方法：

// 单元测试：测试处理程序核心逻辑
func TestSlowHandlerLogic(t *testing.T) {
    tests := []struct {
        name     string
        ctx      context.Context
        wantCode int
    }{
        {
            name:     "normal context",
            ctx:      context.Background(),
            wantCode: http.StatusOK,
        },
        {
            name:     "cancelled context",
            ctx:      func() context.Context {
                ctx, cancel := context.WithCancel(context.Background())
                cancel()
                return ctx
            }(),
            wantCode: http.StatusInternalServerError,
        },
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            w := httptest.NewRecorder()
            r := httptest.NewRequest(http.MethodGet, "/slow", nil)
            r = r.WithContext(tt.ctx)
            
            slowHandler(w, r)
            
            if w.Code != tt.wantCode {
                t.Errorf("got status %d, want %d", w.Code, tt.wantCode)
            }
        })
    }
}

// 集成测试：测试完整服务器行为
func TestServerIntegration(t *testing.T) {
    server := setUpServer()
    
    tests := []struct {
        name     string
        path     string
        method   string
        wantCode int
    }{
        {
            name:     "slow endpoint with timeout",
            path:     "/slow",
            method:   http.MethodGet,
            wantCode: http.StatusServiceUnavailable,
        },
        {
            name:     "non-existent endpoint",
            path:     "/not-found",
            method:   http.MethodGet,
            wantCode: http.StatusNotFound,
        },
    }
    
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            w := httptest.NewRecorder()
            r := httptest.NewRequest(tt.method, tt.path, nil)
            
            server.Handler.ServeHTTP(w, r)
            
            if w.Code != tt.wantCode {
                t.Errorf("%s: got status %d, want %d", tt.name, w.Code, tt.wantCode)
            }
        })
    }
}

结论

在你的具体案例中，第二个测试失败是因为直接调用slowHandler绕过了TimeoutHandler中间件。处理程序本身没有设置503状态码，这个状态码是由超时中间件设置的。

建议：

• 对处理程序的核心业务逻辑进行单元测试（不使用服务器）
• 对包含中间件和路由的完整处理链进行集成测试（使用服务器）
• 使用httptest.NewServer进行端到端测试，模拟真实HTTP请求

两种方法各有适用场景，通常在实际项目中会同时使用，以确保代码质量和测试覆盖率。