单元测试

1    1、文件名必须以xx_test.go命名
2    2、方法必须是Test[^a-z]开头,否则go test 会直接跳过测试不执行
3    3、方法参数必须 t *testing.T
4    4、使用go test执行单元测试

1 go test -v  -timeout 30s pages_test.go -run ^TestAllPages
2 go test --bench=. 0016atomicvsrwmutex_test.go  
3 go test ./tests -v -count=1  //测试会有缓存，清楚缓存
4  		Go 为了提高测试的性能，会对包的编译后的测试代码进行缓存。
5  		一般常见的，也是官方推荐的清除缓存的方式是使用 -count 参数。
6  		此参数一般用以设置测试运行的次数，如果设置为 2 的话就会运行测试两次。

1func TestName(t *testing.T){
2    // ...
3}

1func TestAdd(t *testing.T){ ... }
2func TestSum(t *testing.T){ ... }
3func TestLog(t *testing.T){ ... }

 1func (c *T) Error(args ...interface{}) // 等价 Log(args ...interface{}) +  Fail()   
 2func (c *T) Errorf(format string, args ...interface{}) //等价Logf(format string, args ...interface{}) +    Fail()   
 3func (c *T) Fail()   //标记测试函数为失败，然后继续执行(剩下的测试)。
 4func (c *T) FailNow() //标记测试函数为失败并中止执行;文件中别的测试也被略过，继续执行下一个文件。
 5func (c *T) Failed() bool
 6func (c *T) Fatal(args ...interface{}) //先执行Log() 再执行 FailNow()
 7func (c *T) Fatalf(format string, args ...interface{})
 8func (c *T) Log(args ...interface{}) //args 被用默认的格式格式化并打印到错误日志中。
 9func (c *T) Logf(format string, args ...interface{})
10func (c *T) Name() string
11func (t *T) Parallel()
12func (t *T) Run(name string, f func(t *T)) bool
13func (c *T) Skip(args ...interface{})
14func (c *T) SkipNow() // 必须写在函数第一行，跳过这个测试
15func (c *T) Skipf(format string, args ...interface{})
16func (c *T) Skipped() bool
17
18// 获取测试名称
19method (*T) Name() string
20// 打印日志
21method (*T) Log(args ...interface{})
22// 打印日志，支持 Printf 格式化打印
23method (*T) Logf(format string, args ...interface{})
24// 反馈测试失败，但不退出测试，继续执行
25method (*T) Fail()
26// 反馈测试失败，立刻退出测试
27method (*T) FailNow()
28// 反馈测试失败，打印错误
29method (*T) Error(args ...interface{})
30// 反馈测试失败，打印错误，支持 Printf 的格式化规则
31method (*T) Errorf(format string, args ...interface{})
32// 检测是否已经发生过错误
33method (*T) Failed() bool
34// 相当于 Error + FailNow，表示这是非常严重的错误，打印信息结束需立刻退出。
35method (*T) Fatal(args ...interface{})
36// 相当于 Errorf + FailNow，与 Fatal 类似，区别在于支持 Printf 格式化打印信息；
37method (*T) Fatalf(format string, args ...interface{})
38// 跳出测试，从调用 SkipNow 退出，如果之前有错误依然提示测试报错
39method (*T) SkipNow()
40// 相当于 Log 和 SkipNow 的组合
41method (*T) Skip(args ...interface{})
42// 与Skip，相当于 Logf 和 SkipNow 的组合，区别在于支持 Printf 格式化打印
43method (*T) Skipf(format string, args ...interface{})
44// 用于标记调用函数为 helper 函数，打印文件信息或日志，不会追溯该函数。
45method (*T) Helper()
46// 标记测试函数可并行执行，这个并行执行仅仅指的是与其他测试函数并行，相同测试不会并行。
47method (*T) Parallel()
48// 可用于执行子测试
49method (*T) Run(name string, f func(t *T)) bool

 1package test
 2import (
 3		"testing"
 4  	"fmt"
 5)
 6func TestPrint(t *test.T){
 7  t.Run("a1",func(t *testing.T){fmt.Println("a1")})
 8  t.Run("a2",func(t *testing.T){fmt.Println("a2")})
 9  t.Run("a3",func(t *testing.T){fmt.Println("a3")})
10}

1➜  tmp git:(master) ✗ ls
2tmp.go      tmp_test.go

1cd tmp 
2go test -v tmp_test.go tmp.go

 1package tmp
 2
 3import (
 4	"fmt"
 5	"testing"
 6)
 7
 8func testPrint1(t *testing.T) {
 9	//t.SkipNow()
10	t.Log("testprint1 begin")
11	res := Print()
12	if res != 1 {
13		t.Errorf("testprint1 return error")
14	}
15	t.Log("testprint1 end")
16}
17func testPrint2(t *testing.T) {
18	//t.SkipNow()
19	t.Log("testprint2 begin")
20	res := Print()
21	if res != 1 {
22		t.Errorf("testprint2 return error")
23	}
24	t.Log("testprint2 end")
25}
26
27//第二执行
28func TestAll(t *testing.T) {
29	//第三执行
30	t.Run("print1", testPrint1)
31	//第四执行
32	t.Run("print2", testPrint2)
33}
34
35//最先执行
36func TestMain(m *testing.M) {
37	fmt.Println("test begins")
38	m.Run()
39}

1package tmp
2
3import "fmt"
4
5func Print() int {
6	fmt.Println("tmp")
7	return 1
8}

1go test -bench=. 
2如果其他test函数没有错误，只会跑带Benchmark的case
3benchmark函数还是受到 TestMain的m.Run()控制

1func BenchmarkFibonacci(b *testing.B){
2	n :=10
3	b.ReportAllocs() //开启内存统计
4	b.ResetTimer() // 重制计时器
5	for i:=0;i<b.N;i++{
6	     Fibonacci(n)	
7    }
8}

1func BenchmarkFibonacciRunParallel(b *testing.B){
2	 n :=10
3	 b.RunParaller(func(pb *testing.PB){
4	     for pb.Next(){
5            Fibonacci(n)
6     }	 
7    })
8}

 1package print
 2
 3import "strings"
 4
 5func Print() int {
 6	var age int
 7	age = 20
 8	return age
 9}
10
11
12
13func Split(s, sep string) (result []string) {
14	i := strings.Index(s, sep)
15
16	for i > -1 {
17		result = append(result, s[:i])
18		s = s[i+len(sep):] // 这里使用len(sep)获取sep的长度
19		i = strings.Index(s, sep)
20	}
21	result = append(result, s)
22	return
23}

 1package test
 2
 3import (
 4	"fmt"
 5	"go-im/print"
 6	"testing"
 7)
 8
 9func BenchmarkPrint(b *testing.B) {
10	fmt.Println("begin")
11	for i := 0; i < b.N; i++ {
12		print.Split("枯藤老树昏鸦", "老")
13	}
14}

1# go test -bench=Print
2
3BenchmarkPrint-8         8189996               146 ns/op
4PASS
5ok      go-im/test      1.368s

1#go test -bench=Print -benchmem
2
3goos: darwin
4goarch: amd64
5pkg: go-im/test
6BenchmarkPrint-8         8023243               146 ns/op              48 B/op          2 allocs/op
7PASS
8ok      go-im/test      1.353s

1$ go test puzzlers/article20/q2
2ok   puzzlers/article20/q2 (cached)

1$ go test -bench=. -run=^$ puzzlers/article20/q3
2goos: darwin
3goarch: amd64
4pkg: puzzlers/article20/q3
5BenchmarkGetPrimes-8      500000       2314 ns/op
6PASS
7ok   puzzlers/article20/q3 1.192s

1for i := 0; i < b.N; i++ {
2 GetPrimes(1000)
3}

 1package mock
 2import "context"
 3/*
 4gomock 测试
 5
 6*/
 7type User struct {
 8	Mobile   string
 9	Password string
10	NickName string
11}
12type UserServer struct {
13	Db UserData
14}
15func (us *UserServer) GetUserByMobile(ctx context.Context, mobile string) (User, error) {
16	user, err := us.Db.GetUserByMobile(ctx, mobile)
17	if err != nil {
18		return User{}, err
19	}
20	if user.NickName == "bobby18" {
21		user.NickName = "bobby17"
22	}
23	return user, nil
24}
25type UserData interface {
26	GetUserByMobile(ctx context.Context, mobile string) (User, error)
27}

 1// Code generated by MockGen. DO NOT EDIT.
 2// Source: mock/user.go
 3
 4// Package mock is a generated GoMock package.
 5package mock
 6
 7import (
 8	context "context"
 9	main "gotool/mock"
10	reflect "reflect"
11
12	gomock "github.com/golang/mock/gomock"
13)
14
15// MockUserData is a mock of UserData interface.
16type MockUserData struct {
17	ctrl     *gomock.Controller
18	recorder *MockUserDataMockRecorder
19}
20
21// MockUserDataMockRecorder is the mock recorder for MockUserData.
22type MockUserDataMockRecorder struct {
23	mock *MockUserData
24}
25
26// NewMockUserData creates a new mock instance.
27func NewMockUserData(ctrl *gomock.Controller) *MockUserData {
28	mock := &MockUserData{ctrl: ctrl}
29	mock.recorder = &MockUserDataMockRecorder{mock}
30	return mock
31}
32
33// EXPECT returns an object that allows the caller to indicate expected use.
34func (m *MockUserData) EXPECT() *MockUserDataMockRecorder {
35	return m.recorder
36}
37
38// GetUserByMobile mocks base method.
39func (m *MockUserData) GetUserByMobile(ctx context.Context, mobile string) (main.User, error) {
40	m.ctrl.T.Helper()
41	ret := m.ctrl.Call(m, "GetUserByMobile", ctx, mobile)
42	ret0, _ := ret[0].(main.User)
43	ret1, _ := ret[1].(error)
44	return ret0, ret1
45}
46
47// GetUserByMobile indicates an expected call of GetUserByMobile.
48func (mr *MockUserDataMockRecorder) GetUserByMobile(ctx, mobile interface{}) *gomock.Call {
49	mr.mock.ctrl.T.Helper()
50	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByMobile", reflect.TypeOf((*MockUserData)(nil).GetUserByMobile), ctx, mobile)
51}

 1package mock
 2
 3import (
 4	"context"
 5	"fmt"
 6	"github.com/golang/mock/gomock"
 7	"gotool/mock"
 8	"testing"
 9)
10
11func TestGetUserByMobile(t *testing.T) {
12	//mock 准备工作
13	ctrl := gomock.NewController(t)
14	defer ctrl.Finish()
15
16	mockUserData := NewMockUserData(ctrl)
17	//mock数据， expect()期望 返回的值  档mobile=18的时候 返回nickname是crmao1的user,  mock 的是 service中的db。 
18	mockUserData.EXPECT().GetUserByMobile(gomock.Any(), "18").Return(mock.User{
19		NickName: "crmao1",
20	}, nil)
21
22	//实际调用过程
23	userServer := mock.UserServer{
24		Db: mockUserData, //  mockUserData 就是mock了 db 调用 GetUserByMobile的过程。
25	}
26	user, err := userServer.GetUserByMobile(context.Background(), "18")
27
28	//判断正确与否
29	if err != nil {
30		t.Errorf("error: %v", err)
31	}
32	fmt.Println(user)
33	if user.NickName != "crmao2" {
34		t.Errorf("error: %v", err)
35	}
36}

 1package mock
 2
 3import "context"
 4
 5/*
 6gomock 测试
 7安装：
 8	go get -u github.com/golang/mock/gomock
 9
10	go install github.com/golang/mock/mockgen
11*/
12
13type User struct {
14	Mobile   string
15	Password string
16	NickName string
17}
18
19type UserServer struct {
20	Db UserData
21}
22
23func (us *UserServer) GetUserByMobile(ctx context.Context, mobile string) (User, error) {
24	//返回crmao1 ,mock结果是crmao1
25	user, err := us.Db.GetUserByMobile(ctx, mobile)
26	if err != nil {
27		return User{}, err
28	}
29	if user.NickName == "crmao1" {
30		//最终是crmao2
31		user.NickName = "crmao2"
32	}
33	return user, nil
34}
35
36type UserData interface {
37	GetUserByMobile(ctx context.Context, mobile string) (User, error)
38}

 1package mysql
 2
 3import (
 4	"context"
 5
 6	"gorm.io/gorm"
 7	"gotool/mock"
 8)
 9
10type user struct {
11	db *gorm.DB
12}
13
14func NewUser(db *gorm.DB) *user {
15	return &user{db: db}
16}
17
18func (u *user) GetUserByMobile(ctx context.Context, mobile string) (mock.User, error) {
19	var user mock.User
20	_ = u.db.Where(&mock.User{Mobile: mobile}).First(&user)
21	return user, nil
22}
23
24var _ mock.UserData = &user{}

 1package mysql
 2
 3import (
 4	"context"
 5	"regexp"
 6
 7	"database/sql"
 8	"gorm.io/driver/mysql"
 9	"gorm.io/gorm"
10	"testing"
11
12	"github.com/DATA-DOG/go-sqlmock"
13	"github.com/stretchr/testify/assert"
14	umock "gotool/mock"
15)
16
17func TestGetUserByMobile(t *testing.T) {
18	//注入,模拟出一个db。
19	db, mock, err := sqlmock.New()
20	if err != nil {
21		t.Fatalf("init sqlmock: %v", err)
22	}
23
24	defer func(db *sql.DB) {
25		err := db.Close()
26		if err != nil {
27			t.Fatalf("close sqlmock: %v", err)
28		}
29	}(db)
30	gormDB, err := gorm.Open(mysql.New(mysql.Config{
31		SkipInitializeWithVersion: true,
32		Conn:                      db,
33	}), &gorm.Config{})
34	if err != nil {
35		t.Fatalf("open gorm: %v", err)
36	}
37	mobile := "18"
38	//期望, 执行这个sql语句的时候， 参数是 mobile 返回字段切片， 如果是一行，他会只取一行
39	mock.ExpectQuery(regexp.QuoteMeta("SELECT * FROM `users` WHERE `users`.`mobile` = ? ORDER BY `users`.`mobile` LIMIT 1")).
40		WithArgs(mobile).WillReturnRows(
41		sqlmock.NewRows([]string{"mobile", "password", "nick_name"}).AddRow("18758327777", "123456", "crmao"))
42	//也要进行关闭 
43	mock.ExpectClose()
44	//调用
45	userData := NewUser(gormDB)
46	user, err := userData.GetUserByMobile(context.Background(), mobile)
47	assert.Nil(t, err)
48
49	expUser := umock.User{
50		Mobile:   "18758327777",
51		Password: "123456",
52		NickName: "crmao",
53	}
54	assert.Equal(t, expUser, user)
55	/*
56		fake 测试
57		grpc 服务， rocketmq， kafka，
58	*/
59}

1# 三个命令都行
2go test
3go test -fuzz=Fuzz
4go test -run fuzz_test.go 

 1package fuzz
 2
 3import (
 4   "fmt"
 5   "github.com/stretchr/testify/assert"
 6   "testing"
 7   "unicode/utf8"
 8)
 9
10/*
11模糊测试，单元测试有局限性， 每个测试输入必须由开发者添加到单元测试用例， 更进一步
12还是一个人工的check过程
13fuzzing优点 就是可以基于开发者代码中指定的测试输入作为基础数据，进一步自动生成随机测试数据，用来发现指定测试输入没有覆盖到的边界情况
14*/
15
16func Reverse(s string) (string, error) {
17   //没有考虑到非法的unicode编码
18   //q 代表该值对应的单引号括起来的go语法字符字面值
19   if !utf8.ValidString(s) {
20   	return "", fmt.Errorf("invalid utf8: %q", s)
21   }
22   b := []rune(s)
23   for i, j := 0, len(b)-1; i < len(b)/2; i, j = i+1, j-1 {
24   	b[i], b[j] = b[j], b[i]
25   }
26   return string(b), nil
27}
28
29//TDD
30/*
31当涉及业务相关的单元测试, 此时
32
33用例复杂, 输入可能是多层嵌套的struct, 某一层的某个变量的值影响输出
34用例数量多, 某个函数可能有5个以上的用例
35由于table-driven的表达能力有限:
36
37如何复用输入结构体? (当前情况开发会复制粘贴过去改)
38name过于简单不被重视, 导致单元测试失败时难以快速阅读
39
40最终带来的问题是:
41
42单个用例构造复杂, 可能是十几行甚至是几十行;
43用例和用例之间没有复用, 基本基于复制粘贴;
44难以区分用例之间的差异
45用例过多导致难以维护, 不能明确知道每个用例的目的, 用例和用例之间的差别;
46单个测试集过大, 可能有几百行测试代码;
47BDD
48goconvey ginkgo
49*/
50
51func TestReverse(t *testing.T) {
52   testcases := []struct {
53   	in, want string
54   }{
55   	{"hello", "olleh"}, //基本
56   	{"a", "a"},         //边界
57   	{" ", " "},         //特殊
58   }
59   for _, c := range testcases {
60   	rev, _ := Reverse(c.in)
61   	assert.Equal(t, c.want, rev)
62   }
63}
64
65func FuzzReverse(f *testing.F) {
66   testcases := []string{"Hello", "a", " ", "!#j"}
67   for _, c := range testcases {
68   	f.Add(c) //提供种子语料库
69   }
70   f.Fuzz(func(t *testing.T, orig string) {
71   	rev, err := Reverse(orig)
72   	if err != nil {
73   		return
74   	}
75   	//没有输入的，也有无法预期的输出， 模糊测试的缺点非常明显，就是几乎无法通过equal去判断， 只能通过比较字符串的长度来判断
76   	//如果要基于种子语料库生成随机测试数据用于模糊测试，需要给go test命令加上 -fuzz=Fuzz
77   	assert.Equal(t, len(orig), len(rev))
78   	double, err := Reverse(rev)
79   	if err != nil {
80   		return
81   	}
82   	assert.Equal(t, orig, double) //技巧
83
84   	//另一种技巧，这个技巧说实话没有什么说服力
85   	if utf8.ValidString(orig) && !utf8.ValidString(rev) {
86   		t.Errorf("invalid utf8: %q", rev)
87   	}
88   })
89}
90
91//不要把单元和模糊测试做对比，他们是互补的，某些核心函数我们可以同时将单元测试和模糊加上保证代码的正确性
92//testdata目录go的一种惯例， 如果我们的测试用例有外部输入数据，我们就将数据放到testdata，这个目录会被go test命令扫描到， 这样我们就不用关心路径问题

 1package monkey
 2
 3import (
 4	"github.com/agiledragon/gomonkey/v2"
 5	"reflect"
 6	"testing"
 7)
 8
 9// mock 一个函数, mock 范围更广， 而且不需要事先生成代码， 可以结合自己的需求使用。
10func TestCompute(t *testing.T) {
11	//动态的补丁技术, 让networkCompute 这个函数 返回一个值， 现在是给他固定2，那么算是mock好了一个函数了。
12	patches := gomonkey.ApplyFunc(networkCompute, func(a, b int) (int, error) {
13		return 2, nil
14	})
15	defer patches.Reset()
16	// Compute-》调用 networkCompute会是上面mock 的函数。
17	sum, err := Compute(1, 2)
18	if err != nil {
19		t.Error(err)
20	}
21	if sum != 4 {
22		t.Errorf("sum is %d, want 3", sum)
23	}
24}
25
26func TestCompute2(t *testing.T) {
27	//动态的补丁技术
28	var c *Computer
29	patches := gomonkey.ApplyMethod(reflect.TypeOf(c), "NetworkCompute", func(_ *Computer, a, b int) (int, error) {
30		return 2, nil
31	})
32	defer patches.Reset()
33
34	c = &Computer{}
35	sum, err := c.Compute(1, 2)
36	if err != nil {
37		t.Error(err)
38	}
39	if sum != 3 {
40		t.Errorf("sum is %d, want 3", sum)
41	}
42}
43
44var num = 10
45
46func TestGlobalVar(t *testing.T) {
47
48	patches := gomonkey.ApplyGlobalVar(&num, 12)
49	defer patches.Reset()
50
51	if num != 10 {
52		t.Errorf("expected %v, got: %v", 10, num)
53	}
54}

 1package monkey
 2
 3type Computer struct {
 4}
 5
 6func (c *Computer) NetworkCompute(a, b int) (int, error) {
 7	sum := a + b
 8	return sum, nil
 9}
10
11func (c *Computer) Compute(a, b int) (int, error) {
12	sum, err := c.NetworkCompute(a, b)
13	/*
14		业务逻辑
15	*/
16	return sum, err
17}
18
19func networkCompute(a, b int) (int, error) {
20	c := a + b
21	return c, nil
22}
23
24func Compute(a, b int) (int, error) {
25	sum, err := networkCompute(a, b)
26	/*
27		业务逻辑
28	*/
29	return sum, err
30}

 1package ginkgo
 2
 3import (
 4	"github.com/agiledragon/gomonkey/v2"
 5	"github.com/golang/mock/gomock"
 6	. "github.com/onsi/ginkgo"
 7	. "github.com/onsi/gomega"
 8	"github.com/stretchr/testify/assert"
 9	"testing"
10)
11
12func TestBooks(t *testing.T) {
13	RegisterFailHandler(Fail)
14	RunSpecs(t, "Books Suite")
15}
16
17// 并不一定需要每个测试用例都这么写， 对于核心的函数或者核心的业务逻辑我们建议设计好的测试用例
18var _ = Describe("Books", func() {
19	var (
20		longBook  string
21		shortBook string
22
23		pathches *gomonkey.Patches
24		ctl      *gomock.Controller
25	)
26	BeforeEach(func() {
27		longBook = "long"
28		shortBook = "short"
29
30		ctl = gomock.NewController(GinkgoT())
31	})
32
33	AfterEach(func() {
34		longBook = ""
35		shortBook = ""
36
37		ctl.Finish()
38		pathches.Reset()
39	})
40
41	Describe("Add Books", func() {
42		It("should be able to add a book", func() {
43			//调用AddBook方法，并传入参数，期望返回的结果为true
44			assert.Equal(GinkgoT(), "long", longBook)
45		})
46		It("should not be able to add a book", func() {
47			//调用AddBook方法，并传入参数，期望返回的结果为true
48			assert.Equal(GinkgoT(), "short", shortBook)
49		})
50	})
51
52	Describe("Delete Books", func() {
53
54	})
55})