Golang轻松实现HTTP接口模拟测试的插件库gock的使用

gock是一个功能强大的Go语言HTTP模拟测试库，它可以轻松地模拟任何基于net/http标准库实现的HTTP请求。

特性

• 简单、表达力强的流式API
• 支持JSON/XML模拟的内置助手
• 支持持久性和临时TTL限制的模拟
• 完整的正则表达式HTTP请求匹配能力
• 支持通过方法、URL参数、headers和body匹配请求
• 可扩展和可插拔的HTTP匹配规则
• 能够在模拟和真实网络模式之间切换
• 兼容任何net/http兼容的客户端

安装

go get -u github.com/h2non/gock

基本使用示例

简单测试模拟

package test

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

  "github.com/nbio/st"
  "github.com/h2non/gock"
)

func TestSimple(t *testing.T) {
  defer gock.Off() // 测试执行后清除挂起的模拟

  gock.New("http://server.com").
    Get("/bar").
    Reply(200).
    JSON(map[string]string{"foo": "bar"})

  res, err := http.Get("http://server.com/bar")
  st.Expect(t, err, nil)
  st.Expect(t, res.StatusCode, 200)

  body, _ := ioutil.ReadAll(res.Body)
  st.Expect(t, string(body)[:13], `{"foo":"bar"}`)

  // 验证没有挂起的模拟
  st.Expect(t, gock.IsDone(), true)
}

请求头匹配

package test

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

  "github.com/nbio/st"
  "github.com/h2non/gock"
)

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

  gock.New("http://foo.com").
    MatchHeader("Authorization", "^foo bar$").
    MatchHeader("API", "1.[0-9]+").
    HeaderPresent("Accept").
    Reply(200).
    BodyString("foo foo")

  req, err := http.NewRequest("GET", "http://foo.com", nil)
  req.Header.Set("Authorization", "foo bar")
  req.Header.Set("API", "1.0")
  req.Header.Set("Accept", "text/plain")

  res, err := (&http.Client{}).Do(req)
  st.Expect(t, err, nil)
  st.Expect(t, res.StatusCode, 200)
  body, _ := ioutil.ReadAll(res.Body)
  st.Expect(t, string(body), "foo foo")

  // 验证没有挂起的模拟
  st.Expect(t, gock.IsDone(), true)
}

请求参数匹配

package test

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

  "github.com/nbio/st"
  "github.com/h2non/gock"
)

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

  gock.New("http://foo.com").
    MatchParam("page", "1").
    MatchParam("per_page", "10").
    Reply(200).
    BodyString("foo foo")

  req, err := http.NewRequest("GET", "http://foo.com?page=1&per_page=10", nil)

  res, err := (&http.Client{}).Do(req)
  st.Expect(t, err, nil)
  st.Expect(t, res.StatusCode, 200)
  body, _ := ioutil.ReadAll(res.Body)
  st.Expect(t, string(body), "foo foo")

  // 验证没有挂起的模拟
  st.Expect(t, gock.IsDone(), true)
}

JSON body匹配和响应

package test

import (
  "bytes"
  "io/ioutil"
  "net/http"
  "testing"
  
  "github.com/nbio/st"
  "github.com/h2non/gock"
)

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

  gock.New("http://foo.com").
    Post("/bar").
    MatchType("json").
    JSON(map[string]string{"foo": "bar"}).
    Reply(201).
    JSON(map[string]string{"bar": "foo"})

  body := bytes.NewBuffer([]byte(`{"foo":"bar"}`))
  res, err := http.Post("http://foo.com/bar", "application/json", body)
  st.Expect(t, err, nil)
  st.Expect(t, res.StatusCode, 201)

  resBody, _ := ioutil.ReadAll(res.Body)
  st.Expect(t, string(resBody)[:13], `{"bar":"foo"}`)

  // 验证没有挂起的模拟
  st.Expect(t, gock.IsDone(), true)
}

模拟自定义http.Client和http.RoundTripper

package test

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

  "github.com/nbio/st"
  "github.com/h2non/gock"
)

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

  gock.New("http://foo.com").
    Reply(200).
    BodyString("foo foo")

  req, err := http.NewRequest("GET", "http://foo.com", nil)
  client := &http.Client{Transport: &http.Transport{}}
  gock.InterceptClient(client)

  res, err := client.Do(req)
  st.Expect(t, err, nil)
  st.Expect(t, res.StatusCode, 200)
  body, _ := ioutil.ReadAll(res.Body)
  st.Expect(t, string(body), "foo foo")

  // 验证没有挂起的模拟
  st.Expect(t, gock.IsDone(), true)
}

启用真实网络

package main

import (
  "fmt"
  "io/ioutil"
  "net/http"

  "github.com/h2non/gock"
)

func main() {
  defer gock.Off()
  defer gock.DisableNetworking()

  gock.EnableNetworking()
  gock.New("http://httpbin.org").
    Get("/get").
    Reply(201).
    SetHeader("Server", "gock")

  res, err := http.Get("http://httpbin.org/get")
  if err != nil {
    fmt.Errorf("Error: %s", err)
  }

  // 响应状态来自模拟
  fmt.Printf("Status: %d\n", res.StatusCode)
  // 服务器头也来自模拟
  fmt.Printf("Server header: %s\n", res.Header.Get("Server"))
  // 响应体是原始的
  body, _ := ioutil.ReadAll(res.Body)
  fmt.Printf("Body: %s", string(body))
}

调试拦截的HTTP请求

package main

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

func main() {
  defer gock.Off()
  gock.Observe(gock.DumpRequest)

  gock.New("http://foo.com").
    Post("/bar").
    MatchType("json").
    JSON(map[string]string{"foo": "bar"}).
    Reply(200)

  body := bytes.NewBuffer([]byte(`{"foo":"bar"}`))
  http.Post("http://foo.com/bar", "application/json", body)
}

使用技巧

1. 在测试开始时声明模拟
2. 使用defer gock.Off()确保测试完成后清理模拟
3. 对于并发代码，确保先声明模拟以避免竞态条件
4. 先定义更复杂的模拟，再定义通用的
5. 拦截自定义http.Client只需一次
6. 拦截后恢复http.Client

许可证

MIT - Tomas Aparicio