gin单元测试真香实践

lsekfe

1、单元测试常识
-单元测试文件名必须为xxx_test.go(其中xxx为业务逻辑程序)
　　-分为基础测试、基准测试、案例测试
　　-基础测试的函数名必须为Testxxx(xxx可用来识别业务逻辑函数)
　　-基准测试必须以BenchmarkXXX函数名出现
　　-案例测试必须要已ExampleXXX函数名出线
　　-单元测试函数参数必须为t *testing.T(测试框架强要求)
　　-测试程序和被测试程序文件在一个包package中(可以不放，我自己会单独放一个tests目录)
　　-测试用例文件不会参与正常源码编译，不会被包含到可执行文件中
　　-必须import testing这个包

　　常见命令有很多人说了，我就提供个文档吧
　　2、为什么要写单元测试
　　保证代码的质量，保证每个函数是可运行，运行结果是正确的，保证写出来的代码性能是好的、同时使用单元测试很直观的可以提高开发效率，你不需要每次编译你的代码， 然后在去postman模拟参数测试、单元可以可以模拟http请求，并且可以帮助你进行性能测试以及代码覆盖率，导出测试报告等等
　　3、在gin框架中单元测试该如何写
　　TestMain
　　在写测试时，有时需要在测试之前或之后进行额外的设置（setup）或拆卸（teardown）；有时，测试还需要控制在主线程上运行的代码。为了支持这些需求，testing 包提供了 TestMain 函数 :

1. package tests
   
2. 
   
3. import (
   
4. 
   
5.    "testing"
   
6.     "fmt"
   
7.     "os"
   
8.    
   
9.     "github.com/gin-gonic/gin"
   
10.    
    
11.     "go-api/config"
    
12. )
    
13. func setup() {
    
14.     gin.SetMode(gin.TestMode)
    
15.     fmt.Println(config.AppSetting.JwtSecret);
    
16.     fmt.Println("Before all tests")
    
17. }
    
18. func teardown() {
    
19.     fmt.Println("After all tests")
    
20. }
    
21. func TestMain(m *testing.M)  {
    
22.     setup()
    
23.     fmt.Println("Test begins....")
    
24.     code := m.Run() // 如果不加这句，只会执行Main
    
25.     teardown()
    
26.     os.Exit(code)
    
27. }

复制代码

gin 单元测试案例

1. 　package main
   
2. 
   
3. funcsetupRouter() *gin.Engine{
   
4.     r := gin.Default()
   
5.     r.GET("/ping", func(c *gin.Context) {
   
6.         c.String(200,"pong")
   
7.     })
   
8.     return r
   
9. }
   
10. 
    
11. func main() {
    
12.     r := setupRouter()
    
13.     r.Run(":8080")
    
14. }
    
15. 
    
16. package main
    
17. 
    
18. import (
    
19.    "net/http"
    
20.     "net/http/httptest"
    
21.     "testing"
    
22. 
    
23.     "github.com/stretchr/testify/assert"
    
24. )
    
25. 
    
26. funcTestPingRoute(t *testing.T) {
    
27.     router := setupRouter()
    
28. 
    
29.     w := httptest.NewRecorder()
    
30.     req, _ := http.NewRequest("GET","/ping", nil)
    
31.     router.ServeHTTP(w, req)
    
32. 
    
33.     assert.Equal(t, 200, w.Code)
    
34.     assert.Equal(t,"pong", w.Body.String())
    
35. }

复制代码

4、gin该如何优雅的写单元测试
　　使用Table-Driven Test

1. func TestFib(t *testing.T) {
   
2.     var fibTests = []struct {
   
3.         in       int // input
   
4.         expected int // expected result
   
5.     }{
   
6.         {1, 1},
   
7.         {2, 1},
   
8.         {3, 2},
   
9.         {4, 3},
   
10.         {5, 5},
    
11.         {6, 8},
    
12.         {7, 13},
    
13.     }
    
14. 
    
15.     for _, tt := range fibTests {
    
16.         actual := Fib(tt.in)
    
17.         if actual != tt.expected {
    
18.             t.Errorf("Fib(%d) = %d; expected %d", tt.in, actual, tt.expected)
    
19.         }
    
20.     }
    
21. }

复制代码

　封装一些test helper

1. package tests
   
2. 
   
3. import (
   
4.     "io"
   
5.     "net/http"
   
6.     "net/http/httptest"
   
7. 
   
8.     "bytes"
   
9.     "fmt"
   
10.     "testing"
    
11. 
    
12.     "github.com/gin-gonic/gin"
    
13.     "github.com/stretchr/testify/assert"
    
14. 
    
15.     "go-api/routes"
    
16.     "go-api/tool"
    
17. )
    
18. 
    
19. type TestCase struct {
    
20.     code         int         //状态码
    
21.     param        string      //参数
    
22.     method       string      //请求类型
    
23.     desc         string      //描述
    
24.     showBody     bool        //是否展示返回
    
25.     errMsg       string      //错误信息
    
26.     url          string      //链接
    
27.     content_type string      //
    
28.     ext1         interface{} //自定义1
    
29.     ext2         interface{} //自定义2
    
30. }
    
31. 
    
32. func NewBufferString(body string) io.Reader {
    
33.     return bytes.NewBufferString(body)
    
34. }
    
35. 
    
36. func PerformRequest(mothod, url, content_type string, body string) (c *gin.Context, r *http.Request, w *httptest.ResponseRecorder) {
    
37.     router := routes.InitRouter()
    
38.     w = httptest.NewRecorder()
    
39.     c, _ = gin.CreateTestContext(w)
    
40.     r = httptest.NewRequest(mothod, url, NewBufferString(body))
    
41.     c.Request = r
    
42.     c.Request.Header.Set("Content-Type", content_type)
    
43.     router.ServeHTTP(w, r)
    
44.     return
    
45. }
    
46. 
    
47. 
    
48. func call(t *testing.T,testcase []TestCase){
    
49.     for k, v := range testcase {
    
50.         _, _, w := PerformRequest(v.method, v.url, v.content_type, v.param)
    
51.         //assert.Contains(t, w.Body.String(),fmt.Sprintf("\"error_code\":%d",v.code))
    
52.         fmt.Println()
    
53.         fmt.Printf("第%d个测试用例：%s", k+1, v.desc)
    
54.         if v.showBody {
    
55.             fmt.Printf("接口返回%s", w.Body.String())
    
56.             fmt.Println()
    
57.         }
    
58. 
    
59.         s := struct {
    
60.             Error_code int         `json:"error_code"`
    
61.             Msg        string      `json:"msg"`
    
62.             Data       interface{} `json:"data"`
    
63.         }{}
    
64.         err := tool.JsonToStruct([]byte(w.Body.String()), &s)
    
65.         assert.NoError(t, err)
    
66.         assert.Equal(t, v.errMsg, s.Msg, "错误信息不一致")
    
67.         assert.Equal(t, v.code, s.Error_code, "错误码不一致")
    
68.     }
    
69. }
    

复制代码

　使用子测试（subtests）
　　来控制嵌套测试和执行顺序、解决测试套件依赖性

1. func TestFoo(t *testing.T) {
   
2.     // <setup code>
   
3.     t.Run("A=1", func(t *testing.T) { ... })
   
4.     t.Run("A=2", func(t *testing.T) { ... })
   
5.     t.Run("B=1", func(t *testing.T) { ... })
   
6.     // <tear-down code>
   
7. }

复制代码