1. 项目概述：为什么我们需要模拟HTTP请求？

在软件开发，尤其是后端服务、微服务架构和自动化测试领域，我们每天都在和HTTP请求打交道。无论是调用第三方API、服务间通信，还是编写单元测试，你的代码总免不了要向外“伸手”。但问题来了：你写了一个调用天气API的功能，难道每次跑测试都要真的去请求一次外部服务吗？如果这个服务收费、有调用频率限制，或者干脆在测试环境里不稳定，你的测试就会变得异常脆弱，甚至根本无法进行。

这就是 gock 这类HTTP模拟库大显身手的地方。简单来说， gock 是一个用于Go语言的HTTP模拟库，它允许你在不启动真实服务器、不依赖外部网络的情况下，精确地模拟HTTP请求和响应。你可以把它想象成一个“流量拦截器”和“剧本导演”的结合体。当你的代码试图发起一个HTTP请求时， gock 会把它截住，然后根据你预先写好的“剧本”（即模拟规则），返回一个你设定好的响应。整个过程完全在内存中进行，速度快、零依赖、可预测性极强。

我最初接触 gock 是在为一个金融支付系统编写集成测试时。系统需要调用多个银行和第三方支付网关的API，这些外部服务要么没有稳定的测试环境，要么调用一次就要产生真实的交易记录，这显然是不可行的。用 gock 之后，我们为每一个外部接口都编写了对应的模拟规则，测试用例瞬间从“看天吃饭”变成了“精准可控”，开发效率和测试可靠性得到了质的提升。今天，我就结合自己多年的实战经验，带你从零开始，彻底掌握 gock ，让你在面对HTTP依赖时也能游刃有余。

2. gock核心设计与工作原理拆解

2.1 拦截机制：它是如何“骗过”你的HTTP客户端的？

要理解 gock ，首先要明白Go标准库 net/http 的工作机制。当你使用 http.Client 发起请求时，底层会通过一个名为 Transport 的接口来实际处理网络通信。默认的 http.DefaultTransport 会使用系统的网络栈进行真实的TCP/HTTP通信。

gock 的核心魔法就在于它实现了自己的 Transport ，并临时替换掉了HTTP客户端默认的 Transport 。这个替换过程是动态且线程安全的。具体流程如下：

  1. 启用拦截 ：当你调用 gock.InterceptClient(client) 时， gock 会检查传入的 http.Client 。如果该客户端尚未被拦截， gock 会创建一个自己的 gock.Transport 实例。
  2. 替换Transport ： gock 将这个自有的 Transport 设置为该客户端的 Transport 属性。此时，所有通过这个客户端发起的请求，都会首先流经 gock.Transport 。
  3. 规则匹配 ： gock.Transport 内部维护着一个模拟规则（ gock.Request ）的列表。当一个请求到来时，它会遍历这个列表，将请求的URL、方法、头信息、正文等与每一条规则进行匹配。
  4. 响应返回或放行 ：
    • 匹配成功 ：如果找到匹配的模拟规则， gock 会立即根据该规则构造一个模拟的 http.Response ，并返回给你的代码。你的程序会认为这个响应来自“真实的”服务器。
    • 匹配失败 ：如果没有找到任何匹配的规则， gock 可以选择将请求“放行”，让其通过原来的、真实的 Transport （比如系统的 http.DefaultTransport ）发送到真实的网络。你也可以通过配置禁止放行，让未匹配的请求直接失败，这在测试中非常有用，可以确保所有外部调用都被显式模拟。

这种设计非常巧妙，它不需要你修改任何业务代码。你只需要在测试初始化阶段“动一下手脚”，之后所有的HTTP通信就都在你的掌控之中了。

2.2 规则链与匹配优先级

gock 的模拟规则是通过链式调用的DSL（领域特定语言）来定义的，读起来就像在描述一个预期的请求。例如： 

gock.New("https://api.example.com").
    Get("/user").
    MatchParam("id", "123").
    Reply(200).
    JSON(map[string]string{"name": "John"})

这条规则定义了一个对 https://api.example.com/user?id=123 的GET请求，并返回一个状态码为200、JSON格式的响应。

gock 支持非常丰富的匹配器（Matchers）：

  • URL与路径 ： New(url) , Get(path) , Post(path)
  • 查询参数 ： MatchParam(key, value) , MatchParams(map[string]string)
  • 请求头 ： MatchHeader(key, value)
  • 请求体 ：
    • MatchType("json") ：匹配Content-Type。
    • JSON(data) ：不仅设置响应体为JSON，也可以用于匹配请求体（需配合 BodyMatcher ）。
    • Body(bodyString) ：直接匹配字符串形式的请求体。
    • File(path) ：从文件加载请求体进行匹配。
  • 自定义匹配 ：你可以使用 AddMatcher(func(*http.Request, *gock.Request) (bool, error)) 来实现任何复杂的匹配逻辑，比如根据请求体中的某个字段值来决定是否匹配。

一个重要细节是匹配优先级 ： gock 内部按规则添加的顺序进行匹配， 最先添加的规则优先级最高 。一旦某个请求匹配了一条规则，就会立即返回该规则的响应，并停止后续匹配。这意味着你需要精心安排规则的添加顺序，将最具体、限制条件最多的规则放在前面，将较通用或“兜底”的规则（如匹配所有到某个域名的请求）放在后面，避免特定规则被通用规则意外“吃掉”。

2.3 与同类库的对比与选型思考

Go生态中还有其他HTTP模拟工具，比如 httpmock 。为什么我最终更倾向于 gock ？

  • 表达力与灵活性 ： gock 的链式API设计得非常流畅，表达复杂匹配条件（如特定Header+特定JSON Body）的代码写起来很直观。 httpmock 的API相对更函数式一些，在复杂场景下代码可能略显繁琐。
  • 拦截机制 ： gock 的 InterceptClient 机制非常干净，它只影响你显式传入的那个客户端实例。这意味着你可以在同一个测试中，让一部分客户端走模拟，另一部分（比如用于测试内部服务通信的客户端）走真实网络，互不干扰。而有些库是通过修改全局 http.DefaultTransport 来实现的，影响范围是全局的，容易造成测试间的意外污染。
  • “未匹配请求”的处理策略 ： gock 对未匹配请求的处理策略非常明确且可配置。你可以通过 gock.DisableNetworking() 来禁止所有网络访问，强制要求所有请求都必须被模拟，这对于编写严格的单元测试至关重要，能有效防止测试因漏模拟而意外访问生产环境。 gock 在这方面的设计哲学更偏向于测试的确定性和安全性。

当然， httpmock 也是一个非常优秀且流行的库，社区活跃，文档齐全。选择哪个很大程度上取决于个人或团队的编码风格偏好。但对于需要精细控制、复杂匹配和严格测试隔离的场景， gock 的优势更为明显。

3. 从零开始：gock环境搭建与基础用法

3.1 安装与初始化

首先，使用Go Modules来管理依赖： 

go mod init your-project
go get -u github.com/h2non/gock

在你的测试文件中，导入 gock 包。一个最佳实践是，在每个测试用例的开始和结束时，分别清理之前的模拟规则，避免跨测试污染。 

import (
    "testing"
    "github.com/h2non/gock"
)

func TestMyFunction(t *testing.T) {
    // 测试开始时，激活gock并确保测试结束后清理
    defer gock.Off() // 关键！确保测试结束后清除所有模拟规则
    // ... 你的测试逻辑，包括定义gock规则
}

defer gock.Off() 这行代码至关重要。它会在这个测试函数执行完毕后，无论成功还是失败，都清理掉当前激活的所有 gock 规则。如果不这样做，规则可能会残留并影响后续的测试，导致一些难以调试的、时好时坏的“灵异”测试失败。

3.2 第一个模拟：模拟一个简单的GET请求

假设我们要测试一个函数 FetchUser ，它会调用 https://api.example.com/users/123 。 

func TestFetchUser_Success(t *testing.T) {
    defer gock.Off() // 清理

    // 1. 定义模拟规则
    gock.New("https://api.example.com").
        Get("/users/123").
        Reply(200).
        JSON(map[string]interface{}{
            "id":   123,
            "name": "Alice",
        })

    // 2. 创建被拦截的HTTP客户端
    client := &http.Client{}
    gock.InterceptClient(client) // 关键：让这个client的请求被gock拦截

    // 3. 执行被测函数（这里简化为直接调用）
    req, _ := http.NewRequest("GET", "https://api.example.com/users/123", nil)
    resp, err := client.Do(req)

    // 4. 断言
    if err != nil {
        t.Fatalf("请求失败: %v", err)
    }
    defer resp.Body.Close()
    if resp.StatusCode != 200 {
        t.Errorf("期望状态码200，得到%d", resp.StatusCode)
    }
    // ... 进一步解析resp.Body并断言内容
}

关键点解析 ：

  • gock.New 指定了要模拟的基准URL。
  • Get 指定了路径和方法。注意，这里定义的路径是 /users/123 ，它会和基准URL拼接。
  • Reply 设置了期望返回的HTTP状态码。
  • JSON 是一个便捷方法，它做了两件事：1) 将提供的Go数据结构序列化为JSON字符串作为响应体；2) 自动为响应头设置 Content-Type: application/json 。
  • gock.InterceptClient(client) 是建立拦截的关键。只有被拦截的客户端发出的请求才会被 gock 处理。

3.3 模拟复杂的请求与响应

现实世界的API远比简单的GET复杂。我们来看如何模拟带请求体、查询参数和自定义Header的交互。

模拟一个创建用户的POST请求： 

func TestCreateUser(t *testing.T) {
    defer gock.Off()

    // 模拟请求：匹配特定的JSON请求体
    gock.New("https://api.example.com").
        Post("/users").
        MatchHeader("Authorization", "Bearer secret-token"). // 匹配授权头
        MatchHeader("Content-Type", "application/json").
        JSON(map[string]interface{}{ // 匹配请求体为特定JSON
            "email": "alice@example.com",
            "age":   30,
        }).
        Reply(201). // 创建成功通常返回201
        JSON(map[string]interface{}{
            "id":    456,
            "email": "alice@example.com",
        })

    client := &http.Client{}
    gock.InterceptClient(client)

    // 构建一个符合模拟规则的请求
    body := `{"email": "alice@example.com", "age": 30}`
    req, _ := http.NewRequest("POST", "https://api.example.com/users", strings.NewReader(body))
    req.Header.Set("Authorization", "Bearer secret-token")
    req.Header.Set("Content-Type", "application/json")

    resp, _ := client.Do(req)
    // ... 断言
}

模拟错误响应和网络异常： 测试不仅要覆盖成功路径，失败路径同样重要。 gock 可以轻松模拟服务器错误、超时等。 

// 模拟服务器内部错误
gock.New("https://api.example.com").
    Get("/users/999").
    Reply(500).
    BodyString(`{"error": "Internal Server Error"}`)

// 模拟连接超时（模拟网络层错误）
gock.New("https://unreachable.example.com").
    Get("/").
    ReplyError(errors.New("dial tcp: i/o timeout"))

使用 ReplyError 可以模拟在HTTP请求发出之前就发生的网络错误（如DNS解析失败、连接超时），这对于测试你代码中的错误处理逻辑非常有用。

4. 高级特性与实战技巧

4.1 持久化Mock与Fixture文件

当响应体很大或者很复杂时，把JSON直接写在测试代码里会显得臃肿且难以维护。一个好的做法是将预期的响应体保存在独立的Fixture文件中。

假设我们在 testdata/fixtures/user_123.json 文件中保存了用户数据。 

{
  "id": 123,
  "name": "Alice",
  "email": "alice@example.com",
  "address": {
    "city": "Shanghai"
  }
}

在测试中，我们可以这样使用： 

func TestFetchUser_WithFixture(t *testing.T) {
    defer gock.Off()

    // 读取fixture文件
    data, err := os.ReadFile("testdata/fixtures/user_123.json")
    if err != nil {
        t.Fatal(err)
    }

    gock.New("https://api.example.com").
        Get("/users/123").
        Reply(200).
        BodyString(string(data)). // 使用文件内容作为响应体
        SetHeader("Content-Type", "application/json") // 需要手动设置Header

    // ... 后续测试逻辑
}

为了更优雅，可以写一个辅助函数来加载Fixture。更进一步，可以利用 gock 的 ReplyFunc ，动态地从文件系统或内存中生成响应。

4.2 动态响应与ReplyFunc

有些场景下，响应的内容需要根据请求的参数动态生成。 ReplyFunc 允许你提供一个回调函数来动态生成响应。 

func TestFetchUser_DynamicResponse(t *testing.T) {
    defer gock.Off()

    gock.New("https://api.example.com").
        Get("/users/(\\d+)").
        ReplyFunc(func(r *http.Request, g *gock.Request) (*http.Response, error) {
            // 从请求路径中提取用户ID
            re := regexp.MustCompile(`/users/(\d+)`)
            matches := re.FindStringSubmatch(r.URL.Path)
            userId := matches[1]

            // 动态构建响应
            responseBody := fmt.Sprintf(`{"id": %s, "name": "User-%s"}`, userId, userId)
            response := gock.NewResponse().
                SetStatus(200).
                SetBody(responseBody).
                SetHeader("Content-Type", "application/json")
            return response, nil
        })

    client := &http.Client{}
    gock.InterceptClient(client)

    // 测试不同的ID会得到不同的动态响应
    req1, _ := http.NewRequest("GET", "https://api.example.com/users/100", nil)
    resp1, _ := client.Do(req1)
    // resp1.Body 会是 {"id": 100, "name": "User-100"}
}

ReplyFunc 提供了极大的灵活性，可以用于模拟分页接口（根据 page 参数返回不同数据）、搜索接口等复杂逻辑。

4.3 验证请求是否被发送（Assertions）

模拟并返回响应只是故事的一半。在单元测试中，我们经常还需要断言“我们的代码是否以正确的参数发起了请求”。 gock 提供了 IsDone() 和 IsPending() 方法来验证期望的请求是否全部发生。 

func TestUpdateUser_SendsCorrectRequest(t *testing.T) {
    defer gock.Off()

    // 定义我们期望的请求
    mockRequest := gock.New("https://api.example.com").
        Put("/users/123").
        MatchHeader("Content-Type", "application/json").
        JSON(map[string]interface{}{"name": "NewName"}).
        Reply(200)

    client := &http.Client{}
    gock.InterceptClient(client)

    // 执行被测代码，该代码应发起一个PUT请求
    CallUpdateUser(client, 123, "NewName") // 假设这是你的业务函数

    // 关键断言：验证我们定义的模拟请求是否真的被调用过
    if !mockRequest.Done() {
        t.Error("期望的PUT请求未被发送")
    }
    // 或者，更常用的方式是检查是否所有预期的请求都已完成
    if !gock.IsDone() {
        t.Error("还有未完成的预期请求:", gock.GetUnmatchedRequests())
    }
}

gock.GetUnmatchedRequests() 可以帮你列出所有已定义但未被触发的模拟规则，这在调试“为什么我的模拟没生效”时非常有用。

4.4 隔离测试：管理多个HTTP客户端

在一个复杂的应用中，你可能使用多个配置不同的 http.Client 实例。 gock 可以精确地控制拦截哪一个。 

func TestMultipleClients(t *testing.T) {
    defer gock.Off()

    // Client A 用于调用外部API，需要被模拟
    clientA := &http.Client{Timeout: 5 * time.Second}
    gock.InterceptClient(clientA)
    gock.New("https://external.api.com").Get("/data").Reply(200).BodyString("from mock")

    // Client B 用于调用内部服务，不需要模拟，走真实网络（或另一个测试服务器）
    clientB := &http.Client{Timeout: 2 * time.Second}
    // 注意：我们没有对clientB调用InterceptClient

    // 使用clientA的请求会被拦截并返回模拟数据
    respA, _ := clientA.Get("https://external.api.com/data")
    // respA.Body 会是 "from mock"

    // 使用clientB的请求会正常发出网络请求（假设测试环境有对应服务）
    // respB, _ := clientB.Get("http://internal-service/test")
}

这种精细化的控制能力，使得你可以为测试的不同部分构建不同的上下文，非常适合微服务架构下的集成测试。

5. 集成测试实战：模拟第三方API依赖

让我们看一个更贴近现实的例子：一个简单的天气查询服务，它依赖一个外部的天气API。

业务代码 ( weather.go ): 

package weather

import (
    "encoding/json"
    "fmt"
    "net/http"
)

type WeatherClient struct {
    APIKey string
    Client *http.Client
    BaseURL string
}

type WeatherResponse struct {
    Main struct {
        Temp float64 `json:"temp"`
    } `json:"main"`
    Name string `json:"name"`
}

func (w *WeatherClient) GetTemperature(city string) (float64, error) {
    url := fmt.Sprintf("%s/data/2.5/weather?q=%s&appid=%s&units=metric", w.BaseURL, city, w.APIKey)
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return 0, err
    }

    resp, err := w.Client.Do(req)
    if err != nil {
        return 0, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return 0, fmt.Errorf("天气API返回错误状态码: %d", resp.StatusCode)
    }

    var result WeatherResponse
    if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
        return 0, err
    }
    return result.Main.Temp, nil
}

对应的单元测试 ( weather_test.go ): 

package weather

import (
    "net/http"
    "testing"
    "github.com/h2non/gock"
)

func TestWeatherClient_GetTemperature_Success(t *testing.T) {
    defer gock.Off()

    // 1. 定义对外部API的模拟
    expectedCity := "London"
    expectedTemp := 15.5
    gock.New("https://api.openweathermap.org").
        Get("/data/2.5/weather").
        MatchParam("q", expectedCity).
        MatchParam("appid", "test-api-key").
        MatchParam("units", "metric").
        Reply(200).
        JSON(map[string]interface{}{
            "main": map[string]interface{}{"temp": expectedTemp},
            "name": expectedCity,
        })

    // 2. 创建被测试的客户端，并注入被拦截的http.Client
    client := &http.Client{}
    gock.InterceptClient(client) // 拦截这个client

    weatherClient := &WeatherClient{
        APIKey:  "test-api-key",
        Client:  client, // 使用被拦截的client
        BaseURL: "https://api.openweathermap.org",
    }

    // 3. 执行
    temp, err := weatherClient.GetTemperature(expectedCity)

    // 4. 断言
    if err != nil {
        t.Fatalf("预期无错误，但得到: %v", err)
    }
    if temp != expectedTemp {
        t.Errorf("预期温度 %.1f，但得到 %.1f", expectedTemp, temp)
    }
    // 可选：验证请求确实按预期发送了
    if !gock.IsDone() {
        t.Error("还有未匹配的预期请求")
    }
}

func TestWeatherClient_GetTemperature_APIError(t *testing.T) {
    defer gock.Off()

    // 模拟API返回404（城市未找到）
    gock.New("https://api.openweathermap.org").
        Get("/data/2.5/weather").
        Reply(404).
        BodyString(`{"cod": "404", "message": "city not found"}`)

    client := &http.Client{}
    gock.InterceptClient(client)

    weatherClient := &WeatherClient{
        APIKey:  "test-api-key",
        Client:  client,
        BaseURL: "https://api.openweathermap.org",
    }

    _, err := weatherClient.GetTemperature("InvalidCity")
    if err == nil {
        t.Error("预期一个错误，但得到了nil")
    }
    // 可以进一步断言错误信息中是否包含 "404" 或 "city not found"
}

通过这个例子，你可以看到如何将 gock 无缝集成到业务代码的单元测试中。测试完全控制了外部依赖的行为，使得测试用例快速、稳定且可重复。

6. 常见陷阱、调试技巧与最佳实践

6.1 为什么我的模拟没有生效？

这是新手最常见的问题。请按以下清单排查：

  1. 忘记调用 gock.InterceptClient(client) ：这是最可能的原因。你必须显式地告诉 gock 去拦截哪个客户端。如果你使用的是全局的 http.DefaultClient ，需要用 gock.Intercept() 。
  2. 规则匹配失败 ：仔细检查你的模拟规则（URL、方法、参数、Header、Body）是否与代码实际发出的请求 完全一致 。一个多余的斜杠、大小写不一致、参数顺序不同都可能导致匹配失败。使用 gock.GetUnmatchedRequests() 来查看哪些规则没被触发。
  3. 请求被放行到真实网络 ：如果你没有调用 gock.DisableNetworking() ，且请求没有匹配任何规则， gock 默认会放行它。这会导致测试去请求真实的URL，可能成功也可能失败，造成测试行为不稳定。在严格的单元测试中，建议始终禁用网络。
  4. 测试间污染 ：忘记在测试开头使用 defer gock.Off() 。上一个测试定义的规则残留了下来，干扰了当前测试。 务必在每个测试开始时清理 。
  5. 客户端被重用 ：如果你在多个测试中复用了同一个 http.Client 实例，并且只在第一个测试中调用了 InterceptClient ，那么后续测试中这个客户端可能处于一个奇怪的状态。更安全的做法是为每个测试创建新的客户端。

6.2 性能考量与测试优化

  • 避免过度匹配 ： gock 在匹配请求时需要遍历所有已注册的规则。如果你在测试中定义了海量规则（比如上千条），可能会对测试速度有轻微影响。尽量让规则保持精确，减少不必要的泛化匹配。
  • 复用HTTP客户端 ：虽然建议每个测试创建独立的模拟上下文，但 http.Client 本身（尤其是配置了连接池的）是可以安全复用的。你可以在测试套件初始化时创建一个客户端，在每个测试用例中单独调用 gock.InterceptClient 并定义自己的规则。
  • 并行测试 ： gock 通过为每个 http.Client 单独维护拦截状态来支持并行测试。只要确保每个并发的goroutine使用自己独立的客户端和规则集，就不会有问题。不要在不同的goroutine中共享同一个被拦截的客户端实例。

6.3 组织测试代码的最佳实践

  1. 使用测试辅助函数 ：对于复杂的模拟设置，将其封装成辅助函数。 
    func mockWeatherAPI(city string, temp float64) {
    gock.New("https://api.openweathermap.org").
        Get("/data/2.5/weather").
        MatchParam("q", city).
        Reply(200).
        JSON(map[string]interface{}{"main": map[string]interface{}{"temp": temp}})
}

func TestSomething(t *testing.T) {
    defer gock.Off()
    mockWeatherAPI("London", 15.5)
    // ... 测试逻辑
}
  2. Table-Driven Tests ：结合表驱动测试，可以清晰地测试多种输入输出组合。 
    func TestGetTemperature_TableDriven(t *testing.T) {
    tests := []struct {
        name     string
        city     string
        mockTemp float64
        wantTemp float64
        wantErr  bool
    }{
        {"London", "London", 15.5, 15.5, false},
        {"API Error", "InvalidCity", 0, 0, true},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            defer gock.Off()
            if !tt.wantErr {
                mockWeatherAPI(tt.city, tt.mockTemp)
            } else {
                gock.New("https://api.openweathermap.org").Get("/data/2.5/weather").Reply(500)
            }
            // ... 执行和断言
        })
    }
}
  3. 清理与重置 ：除了 defer gock.Off() ，在复杂的测试设置中，如果中途需要清除所有规则重新开始，可以调用 gock.Flush() 。 gock.Off() 会禁用拦截并清除规则，而 gock.Flush() 只清除规则，拦截状态保持不变。

6.4 处理HTTPS请求

默认情况下， gock 也能处理HTTPS请求，其原理和HTTP一样，都是通过拦截 Transport 层。你不需要做任何特殊配置。但是，如果你的代码使用了自定义的TLS配置（如自签名证书），你需要确保用于测试的 http.Client 也使用了相同的配置，或者使用 gock.New() 时指定一个能匹配你自定义配置的规则。

7. 总结与延伸思考

经过上面这些步骤，你应该已经能够熟练运用 gock 来为你的Go项目构建可靠的、不依赖外部环境的HTTP层测试了。它的价值远不止于“让测试通过”，更在于它迫使你去思考代码的边界——哪些是内部逻辑，哪些是外部依赖，并让你能对这些依赖的行为进行精确的断言和模拟。

我个人在大型项目中推行 gock 时，最大的体会是它显著提升了团队对测试的信心。以前，一个“第三方API限流”的告警就能让整个测试套件变红，现在这种不确定性被彻底消除了。开发者在本地和CI环境中都能获得一致的、快速的测试反馈。

最后分享一个进阶技巧：你可以将常用的第三方API模拟规则打包成一个独立的Go包，作为团队的共享测试工具。例如，创建一个 internal/testmock 包，里面为所有依赖的外部服务（支付、短信、邮件、身份验证等）提供预置的、符合契约的模拟函数。这样，所有团队成员的测试都能基于一套统一、可靠的模拟数据，进一步保证测试的一致性和效率。 gock 不仅仅是一个测试工具，当用得深入时，它也能成为你架构设计和团队工程实践的一个有力支点。

Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区