Go 单元测试之HTTP哀求与API测试

目次

• 一、httptest
  
  
  
  • 1.1 前置代码准备
    
  • 1.2 介绍
    
  • 1.3 根本用法
    
  
  
• 二、gock
  
  
  
  • 2.1介绍
    
  • 2.2 安装
    
  • 2.3 根本利用
    
  • 2.4 举个例子
    
    
    
    • 2.4.1 前置代码
      
    • 2.4.2 测试用例
      
    
    
  
  

一、httptest

1.1 前置代码准备

假设我们的业务逻辑是搭建一个http server端，对外提供HTTP服务。用来处理用户登录哀求，用户需要输入邮箱，密码。

1. package main
3. import (
4.         regexp "github.com/dlclark/regexp2"
5.         "github.com/gin-gonic/gin"
6.         "net/http"
7. )
9. type UserHandler struct {
10.         emailExp    *regexp.Regexp
11.         passwordExp *regexp.Regexp
12. }
14. func (u *UserHandler) RegisterRoutes(server *gin.Engine) {
15.         ug := server.Group("/user")
16.         ug.POST("/login", u.Login)
17. }
18. func NewUserHandler() *UserHandler {
19.         const (
20.                 emailRegexPattern    = "^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$"
21.                 passwordRegexPattern = `^(?=.*[A-Za-z])(?=.*\d)(?=.*[$@$!%*#?&])[A-Za-z\d$@$!%*#?&]{8,}$`
22.         )
23.         emailExp := regexp.MustCompile(emailRegexPattern, regexp.None)
24.         passwordExp := regexp.MustCompile(passwordRegexPattern, regexp.None)
25.         return &UserHandler{
26.                 emailExp:    emailExp,
27.                 passwordExp: passwordExp,
28.         }
29. }
31. type LoginRequest struct {
32.         Email string `json:"email"`
33.         Pwd   string `json:"pwd"`
34. }
36. func (u *UserHandler) Login(ctx *gin.Context) {
37.         var req LoginRequest
38.         if err := ctx.ShouldBindJSON(&req); err != nil {
39.                 ctx.JSON(http.StatusBadRequest, gin.H{"msg": "参数不正确!"})
40.                 return
41.         }
43.         // 校验邮箱和密码是否为空
44.         if req.Email == "" || req.Pwd == "" {
45.                 ctx.JSON(http.StatusBadRequest, gin.H{"msg": "邮箱或密码不能为空"})
46.                 return
47.         }
49.         // 正则校验邮箱
50.         ok, err := u.emailExp.MatchString(req.Email)
51.         if err != nil {
52.                 ctx.JSON(http.StatusInternalServerError, gin.H{"msg": "系统错误!"})
53.                 return
54.         }
55.         if !ok {
56.                 ctx.JSON(http.StatusBadRequest, gin.H{"msg": "邮箱格式不正确"})
57.                 return
58.         }
60.         // 校验密码格式
61.         ok, err = u.passwordExp.MatchString(req.Pwd)
62.         if err != nil {
63.                 ctx.JSON(http.StatusInternalServerError, gin.H{"msg": "系统错误!"})
64.                 return
65.         }
66.         if !ok {
67.                 ctx.JSON(http.StatusBadRequest, gin.H{"msg": "密码必须大于8位，包含数字、特殊字符"})
68.                 return
69.         }
71.         // 校验邮箱和密码是否匹配特定的值来确定登录成功与否
72.         if req.Email != "123@qq.com" || req.Pwd != "hello#world123" {
73.                 ctx.JSON(http.StatusBadRequest, gin.H{"msg": "邮箱或密码不匹配!"})
74.                 return
75.         }
77.         ctx.JSON(http.StatusOK, gin.H{"msg": "登录成功!"})
78. }
80. func InitWebServer(userHandler *UserHandler) *gin.Engine {
81.         server := gin.Default()
82.         userHandler.RegisterRoutes(server)
83.         return server
84. }
86. func main() {
87.         uh := &UserHandler{}
88.         server := InitWebServer(uh)
89.         server.Run(":8080") // 在8080端口启动服务器
90. }

复制代码

1.2 介绍

在 Web 开辟场景下，单元测试常常需要模拟 HTTP 哀求和响应。利用 httptest 可以让我们在测试代码中创建一个 HTTP 服务器实例，并界说特定的哀求和响应行为，从而模拟真实世界的网络交互，在Go语言中，一般都推荐利用Go尺度库 net/http/httptest 进行测试。
1.3 根本用法

利用 httptest 的根本步骤如下：

• 导入 net/http/httptest 包。
  
• 创建一个 httptest.Server 实例，并指定你想要的服务器行为。
  
• 在测试代码中利用 httptest.NewRequest 创建一个模拟的 HTTP 哀求，并将其发送到 httptest.Server。
  
• 检查响应内容或状态码是否符合预期。
  

以下是一个简单的 httptest 用法示例

1. package main
3. import (
4.         "bytes"
5.         "github.com/gin-gonic/gin"
6.         "github.com/stretchr/testify/assert"
7.         "net/http"
8.         "net/http/httptest"
9.         "testing"
10. )
12. func TestUserHandler_Login(t *testing.T) {
13.         // 定义测试用例
14.         testCases := []struct {
15.                 name     string
16.                 reqBody  string
17.                 wantCode int
18.                 wantBody string
19.         }{
20.                 {
21.                         name:     "登录成功",
22.                         reqBody:  `{"email": "123@qq.com", "pwd": "hello#world123"}`,
23.                         wantCode: http.StatusOK,
24.                         wantBody: `{"msg": "登录成功!"}`,
25.                 },
26.                 {
27.                         name:     "参数不正确",
28.                         reqBody:  `{"email": "123@qq.com", "pwd": "hello#world123",}`,
29.                         wantCode: http.StatusBadRequest,
30.                         wantBody: `{"msg": "参数不正确!"}`,
31.                 },
32.                 {
33.                         name:     "邮箱或密码为空",
34.                         reqBody:  `{"email": "", "pwd": ""}`,
35.                         wantCode: http.StatusBadRequest,
36.                         wantBody: `{"msg": "邮箱或密码不能为空"}`,
37.                 },
38.                 {
39.                         name:     "邮箱格式不正确",
40.                         reqBody:  `{"email": "invalidemail", "pwd": "hello#world123"}`,
41.                         wantCode: http.StatusBadRequest,
42.                         wantBody: `{"msg": "邮箱格式不正确"}`,
43.                 },
44.                 {
45.                         name:     "密码格式不正确",
46.                         reqBody:  `{"email": "123@qq.com", "pwd": "invalidpassword"}`,
47.                         wantCode: http.StatusBadRequest,
48.                         wantBody: `{"msg": "密码必须大于8位，包含数字、特殊字符"}`,
49.                 },
50.                 {
51.                         name:     "邮箱或密码不匹配",
52.                         reqBody:  `{"email": "123123@qq.com", "pwd": "hello#world123"}`,
53.                         wantCode: http.StatusBadRequest,
54.                         wantBody: `{"msg": "邮箱或密码不匹配!"}`,
55.                 },
56.         }
58.         for _, tc := range testCases {
59.                 t.Run(tc.name, func(t *testing.T) {
60.                         // 创建一个 gin 的上下文
61.                         server := gin.Default()
62.                         h := NewUserHandler()
63.                         h.RegisterRoutes(server)
64.                         // mock 创建一个 http 请求
65.                         req, err := http.NewRequest(
66.                                 http.MethodPost,                     // 请求方法
67.                                 "/user/login",                       // 请求路径
68.                                 bytes.NewBuffer([]byte(tc.reqBody)), // 请求体
69.                         )
70.                         // 断言没有错误
71.                         assert.NoError(t, err)
72.                         // 设置请求头
73.                         req.Header.Set("Content-Type", "application/json")
74.                         // 创建一个响应
75.                         resp := httptest.NewRecorder()
76.                         // 服务端处理请求
77.                         server.ServeHTTP(resp, req)
78.                         // 断言响应码和响应体
79.                         assert.Equal(t, tc.wantCode, resp.Code)
80.                         // 断言 JSON 字符串是否相等
81.                         assert.JSONEq(t, tc.wantBody, resp.Body.String())
82.                 })
83.         }
84. }

复制代码

在这个例子中，我们创建了一个简单的 HTTP 哀求，TestUserHandler_Login 函数界说了一个测试函数，用于测试用户登录功能的差别情况。

• testCases 列表界说了多个测试用例，每个测试用例包含了测试名称、哀求体、期望的 HTTP 状态码和期望的响应体内容。
  
• 利用 for 循环遍历测试用例列表，每次循环创建一个新的测试子函数，并在此中模拟 HTTP 哀求发送给登录接口。
  
• 在每个测试子函数中，先创建一个 Gin 的默认上下文和用户处理器 UserHandler，然后注册路由并创建一个模拟的 HTTP 哀求。
  
• 通过 httptest.NewRecorder() 创建一个响应记录器，利用 server.ServeHTTP(resp, req) 处理模拟哀求，得到响应结果。
  
• 末了利用断言来验证实际响应的 HTTP 状态码和响应体是否与测试用例中的期望一致。
  

末了,利用Goland 运行测试,结果如下:

二、gock

2.1介绍

gock 可以资助你在测试过程中模拟 HTTP 哀求和响应，这对于测试涉及外部 API 调用的应用程序非常有用。它可以让你轻松地界说模拟哀求，并验证你的应用程序是否精确处理了这些哀求。

GitHub 地点：github.com/h2non/gock

2.2 安装

你可以通过以下方式安装 gock：

1. go get -u github.com/h2non/gock

复制代码

导入 gock 包：

1. import "github.com/h2non/gock"

复制代码

2.3 根本利用

gock 的根本用法如下：

• 启动拦截器：在测试开始前，利用 gock.New 函数启动拦截器，并指定你想要拦截的域名和端口。
  
• 界说拦截规则：你可以利用 gock.Intercept 方法来界说拦截规则，比如拦截特定的 URL、方法、头部信息等。
  
• 设置响应：你可以利用 gock.NewJson、gock.NewText 等方法来设置拦截后的响应内容。
  
• 运行测试：在界说了拦截规则和响应后，你可以运行测试，gock 会拦截你的 HTTP 哀求，并返回你设置的响应。
  

2.4 举个例子

2.4.1 前置代码

如果我们是在代码中哀求外部API的场景（比如通过API调用其他服务获取返回值）又该怎么编写单元测试呢？
例如，我们有以下业务逻辑代码，依赖外部API：http://your-api.com/post提供的数据。

1. // ReqParam API请求参数
2. type ReqParam struct {
3.         X int `json:"x"`
4. }
6. // Result API返回结果
7. type Result struct {
8.         Value int `json:"value"`
9. }
11. func GetResultByAPI(x, y int) int {
12.         p := &ReqParam{X: x}
13.         b, _ := json.Marshal(p)
15.         // 调用其他服务的API
16.         resp, err := http.Post(
17.                 "http://your-api.com/post",
18.                 "application/json",
19.                 bytes.NewBuffer(b),
20.         )
21.         if err != nil {
22.                 return -1
23.         }
24.         body, _ := ioutil.ReadAll(resp.Body)
25.         var ret Result
26.         if err := json.Unmarshal(body, &ret); err != nil {
27.                 return -1
28.         }
29.         // 这里是对API返回的数据做一些逻辑处理
30.         return ret.Value + y
31. }

复制代码

在对类似上述这类业务代码编写单元测试的时间，如果不想在测试过程中真正去发送哀求或者依赖的外部接口还没有开辟完成时，我们可以在单元测试中对依赖的API进行mock。
2.4.2 测试用例

利用gock对外部API进行mock，即mock指定参数返回约定好的响应内容。 下面的代码中mock了两组数据，构成了两个测试用例。

1. package gock_demo
3. import (
4.         "testing"
6.         "github.com/stretchr/testify/assert"
7.         "gopkg.in/h2non/gock.v1"
8. )
10. func TestGetResultByAPI(t *testing.T) {
11.         defer gock.Off() // 测试执行后刷新挂起的mock
13.         // mock 请求外部api时传参x=1返回100
14.         gock.New("http://your-api.com").
15.                 Post("/post").
16.                 MatchType("json").
17.                 JSON(map[string]int{"x": 1}).
18.                 Reply(200).
19.                 JSON(map[string]int{"value": 100})
21.         // 调用我们的业务函数
22.         res := GetResultByAPI(1, 1)
23.         // 校验返回结果是否符合预期
24.         assert.Equal(t, res, 101)
26.         // mock 请求外部api时传参x=2返回200
27.         gock.New("http://your-api.com").
28.                 Post("/post").
29.                 MatchType("json").
30.                 JSON(map[string]int{"x": 2}).
31.                 Reply(200).
32.                 JSON(map[string]int{"value": 200})
34.         // 调用我们的业务函数
35.         res = GetResultByAPI(2, 2)
36.         // 校验返回结果是否符合预期
37.         assert.Equal(t, res, 202)
39.         assert.True(t, gock.IsDone()) // 断言mock被触发
40. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。