如何在Go中Mock *http.Client的Post方法实现HTTP单元测试？

Go是静态类型语言，你的MockPost和*http.Client属于完全不同的类型，因此无法直接传入待测试函数。下面提供两种常用的解决方案：

方案一：抽象HTTP客户端接口（推荐，符合依赖倒置） #

通过定义接口将待测试函数与具体的*http.Client解耦，这样Mock对象就能实现接口并传入测试。

1. 修改生产代码（http.go） #

新增一个与http.Client的Post方法签名一致的接口，并修改待测试函数的参数类型：

import (
    "bytes"
    "fmt"
    "io"
    "net/http"
)

// 定义HTTP客户端接口，匹配http.Client的Post方法签名
type HTTPClient interface {
    Post(url string, contentType string, body io.Reader) (*http.Response, error)
}

func makePost(apiString string, body []byte, client HTTPClient) error {
    resp, err := client.Post(apiString, "application/json", bytes.NewBuffer(body))
    if err != nil {
        return err
    }
    defer resp.Body.Close() // 新增defer关闭响应体，避免资源泄漏

    if resp.StatusCode != 201 {
        bodyBytes, err := io.ReadAll(resp.Body)
        if err != nil {
            return err
        }
        return fmt.Errorf("请求失败: %s", bodyBytes)
    }
    return nil
}

2. 修改测试代码（http_test.go） #

你的MockPost已经天然实现了HTTPClient接口，只需调整测试逻辑：

import (
    "io"
    "net/http"
    "strings"
    "testing"

    "github.com/stretchr/testify/mock"
)

type MockPost struct {
    mock.Mock
}

func (m *MockPost) Post(url string, contentType string, body io.Reader) (*http.Response, error) {
    args := m.Called(url, contentType, body)
    return args.Get(0).(*http.Response), args.Error(1)
}

func TestFunc(t *testing.T) {
    mockPost := &MockPost{}
    // 注意匹配makePost中实际传入的Content-Type值
    mockPost.On("Post", "apistring", "application/json", mock.Anything).Return(
        &http.Response{
            StatusCode: 201,
            Body:       io.NopCloser(strings.NewReader("")),
        }, nil)

    err := makePost("apistring", nil, mockPost)
    if err != nil {
        t.Fatal(err)
    }
    mockPost.AssertExpectations(t)
}

方案二：替换http.Client的Transport（无需修改生产代码） #

http.Client的Post方法最终依赖Transport字段处理请求，我们可以自定义RoundTripper来Mock响应：

测试代码示例（http_test.go） #

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

// 自定义MockTransport，实现http.RoundTripper接口
type MockTransport struct {
    RoundTripFunc func(req *http.Request) (*http.Response, error)
}

func (m *MockTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    return m.RoundTripFunc(req)
}

func TestFunc(t *testing.T) {
    // 创建带MockTransport的http.Client
    client := &http.Client{
        Transport: &MockTransport{
            RoundTripFunc: func(req *http.Request) (*http.Response, error) {
                // 验证请求参数是否符合预期
                if req.URL.String() != "apistring" {
                    t.Errorf("期望URL: 'apistring'，实际得到: '%s'", req.URL.String())
                }
                if req.Header.Get("Content-Type") != "application/json" {
                    t.Errorf("期望Content-Type: 'application/json'，实际得到: '%s'", req.Header.Get("Content-Type"))
                }
                // 返回预设的成功响应
                return &http.Response{
                    StatusCode: 201,
                    Body:       io.NopCloser(strings.NewReader("")),
                    Header:     make(http.Header),
                }, nil
            },
        },
    }

    err := makePost("apistring", nil, client)
    if err != nil {
        t.Fatal(err)
    }
}

两种方案对比 #

• 方案一：侵入性稍大，但符合依赖倒置原则，代码扩展性更强，后续更换HTTP客户端实现更方便。
• 方案二：无需修改生产代码，侵入性小，但需要手动验证请求参数，适合不想改动原有代码的场景。

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