Golang中如何模拟结构体方法进行测试

在Golang中模拟结构体方法进行测试，通常使用接口和依赖注入。以下是针对你的代码示例的解决方案：

首先，定义接口来抽象HTTP客户端：

type HTTPClient interface {
    Do(req *http.Request) (*http.Response, error)
}

type Graph struct {
    ClientID     string
    ClientSecret string
    Client       HTTPClient  // 使用接口类型
}

修改GetJSON方法使用注入的客户端：

func (g *Graph) GetJSON(method string, url string) ([]byte, error) {
    g.RefreshToken()
    request, err := http.NewRequest(method, url, nil)
    if err != nil {
        return nil, err
    }
    
    response, err := g.Client.Do(request)  // 使用注入的客户端
    if err != nil {
        return nil, err
    }

    defer response.Body.Close()
    body, err := ioutil.ReadAll(response.Body)
    if err != nil {
        return body, err
    }
    return body, nil
}

创建模拟HTTP客户端进行测试：

type MockHTTPClient struct {
    DoFunc func(req *http.Request) (*http.Response, error)
}

func (m *MockHTTPClient) Do(req *http.Request) (*http.Response, error) {
    if m.DoFunc != nil {
        return m.DoFunc(req)
    }
    return nil, nil
}

func TestGetUsers(t *testing.T) {
    mockClient := &MockHTTPClient{
        DoFunc: func(req *http.Request) (*http.Response, error) {
            // 验证请求参数
            if req.URL.String() != "https://example.com/users" {
                t.Errorf("期望URL: https://example.com/users, 实际: %s", req.URL.String())
            }
            
            // 返回模拟响应
            body := `{"users": [{"id": 1, "name": "test"}]}`
            return &http.Response{
                StatusCode: 200,
                Body:       ioutil.NopCloser(strings.NewReader(body)),
            }, nil
        },
    }
    
    graph := &Graph{
        ClientID:     "test-id",
        ClientSecret: "test-secret",
        Client:       mockClient,
    }
    
    users, err := graph.GetUsers()
    if err != nil {
        t.Errorf("GetUsers失败: %v", err)
    }
    
    // 验证结果
    if users == nil {
        t.Error("期望返回用户数据")
    }
}

对于RefreshToken方法的模拟，可以使用类似的方法：

type TokenRefresher interface {
    RefreshToken() error
}

type MockGraph struct {
    Graph
    RefreshTokenFunc func() error
}

func (m *MockGraph) RefreshToken() error {
    if m.RefreshTokenFunc != nil {
        return m.RefreshTokenFunc()
    }
    return nil
}

func TestGetJSON_WithMockRefresh(t *testing.T) {
    refreshCalled := false
    mockGraph := &MockGraph{
        RefreshTokenFunc: func() error {
            refreshCalled = true
            return nil
        },
    }
    
    // 设置模拟HTTP客户端
    mockGraph.Client = &MockHTTPClient{
        DoFunc: func(req *http.Request) (*http.Response, error) {
            return &http.Response{
                StatusCode: 200,
                Body:       ioutil.NopCloser(strings.NewReader(`{}`)),
            }, nil
        },
    }
    
    _, err := mockGraph.GetJSON("GET", "https://example.com/test")
    if err != nil {
        t.Errorf("GetJSON失败: %v", err)
    }
    
    if !refreshCalled {
        t.Error("RefreshToken方法未被调用")
    }
}

在生产代码中初始化Graph：

// main.go
func main() {
    client := &Graph{
        ClientID:     "clientId",
        ClientSecret: "clientsecret",
        Client:       &http.Client{},  // 使用真实的HTTP客户端
    }
    
    users, err := client.GetUsers()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(users)
}

这种方法通过接口实现了依赖注入，使得在测试时可以轻松替换真实的HTTP客户端和RefreshToken方法，避免了对外部服务的真实调用。