103. Go单测系列3---mockey与convey综合实战

最新推荐文章于 2024-05-10 10:31:53 发布

百里守约学编程

最新推荐文章于 2024-05-10 10:31:53 发布

阅读量1.8k

点赞数 49

分类专栏： go 文章标签： golang

本文链接：https://blog.csdn.net/YouMing_Li/article/details/136634452

版权

go 专栏收录该内容

123 篇文章 8 订阅

订阅专栏

文章目录

前言
断言
mock
F&Q
- 1. 如何禁用内联和编译优化

前言

工作中，随着业务的快速发展，代码量级和复杂度也会随之快速增长，面临的稳定性挑战越来越大。单测作为稳定性保障的重要一环越来越受到重视，编写单元测试应该成为程序员的基本素养。

之前写单元测试都是基于go自己的test方式，基本就是在线下跑通流程，遇到下游的接口无法访问时，只会束手无策。后来了解到一些单测工具，市面上已有很多成熟的单测工具，本文不会比较各种工具的优劣，而是结合自身经验介绍本人在工作时常用的工具。

我们在撰写单元测试的过程中其实关注的主要是两部分内容：mock（使用mockey包）和断言（使用convey包）。

断言

断言(assertion)是一种在程序中的一阶逻辑(如：一个结果为真或假的逻辑判断式)，目的为了表示与验证软件开发者预期的结果——当程序执行到断言的位置时，对应的断言应该为真。若断言不为真时，程序会中止执行，并给出错误信息。

断言就是判断某个结果是否符合预期，工作中最常用的是goconvey

比如针对以下方法，我们可以编写相关的单元测试用例如下

func Add(a, b int) int {
    return a + b
}

import (
    "testing"
    
	"github.com/bytedance/mockey"
    "github.com/smartystreets/goconvey/convey"
)

func TestAdd(t *testing.T) {
    mockey.PatchConvey("test Add", t, func() {
        mockey.PatchConvey("test 2+3=5", func() {
            sum := Add(2, 3)
            convey.So(sum, ShouldEqual, 5)
        })

        mockey.PatchConvey("test 1+1 != 3", func() {
            sum := Add(1, 1)
            convey.So(sum, ShouldNotEqual, 3)
        })
    })
}

从上述例子中我们可以看到，mockey提供了PatchConvey方法帮助我们进行测试用例的组织和编排，他能支持多级嵌套，方便我们进行case管理。而convey提供了断言方法So。

注：作为最外层的PatchConvey要加参数t，而内层的PatchConvey不用加

运行单元测试后，我们可以看到相关代码的覆盖率，这样可进一步帮助我们判断单测覆盖情况，查漏补缺。

mock

在单元测试中，模拟对象可以模拟复杂的、真实的（非模拟）对象的行为，如果真实的对象无法放入单元测试中，使用模拟对象就很有帮助。

当我们的代码依赖较多，由于多种因素导致我们可能无法准确的控制这些依赖的返回值，比如你在线下环境测试，依赖的某些服务并没有部署线下环境，此时你的代码根本无法执行通过；如果直接在预览环境测试有可能导致线上风险，因此这时候我们就需要对这些下游服务的返回结果进行mock（关于mock工具比较推荐字节的mockey），使其按照我们预期的结果进行返回。

此处的下游不一定就是外部的服务(rpc接口），也可能是自身的方法或者函数。根据工作中实际场景，将mock分为如下几类：

整体使用方式：

MockerBuilder 方法介绍

开始mock
API：Mock(target interface{}) *MockBuilder
参数：target 需要mock的函数
返回：*MockBuilder
参考实例：

func Fun(a string) string {
   fmt.Println(a)
   return a
}

type Class struct {
}

func (*Class) FunA(a string) string {
   fmt.Println(a)
   return a
}
func TestMock(t *testing.T) {
    Mock(Fun)                //对于普通函数使用这种
    Mock((*Class).FunA)      //对于class(struct)使用这种方式
}

条件设置（可选）
API：When(when interface{}) *MockBuilder
参数：when 函数指针。表示在何种条件下调用mock函数返回mock结果。
函数原型： when(args…) bool
args：与Mock 函数参数一致，一般通过args来判断是否需要执行 mock，注意类成员函数需要增加self作为第一个参数（目前已经兼容了不传入receiver，当不需要使用的时候可以忽略）
返回值： bool ，是true的时候执行 mock
返回： *MockBuilder
参考实例

 func TestMock(t *testing.T) {
    //对于普通函数使用这种
    Mock(Fun).When(func(p string) bool { return p == "a" })                
    //对于class使用这种方式
    Mock((*Class).FunA).When(func(self *Class, p string) bool { return p == "a" })     
}

结果设置
API：Return(results …interface{}) *MockBuilder
参数: results 参数列表需要完全等同于需要mock的函数返回值列表,（mockey v1.2.4+新增sequence支持，可以设置多个连续的返回值）
返回： *MockBuilder
参考实例：

Mock(Fun).Return("c")

// mockey v1.2.4+ 支持
Mock(Fun).Return(Sequence("Alice").Times(3).Then("Bob").Then("Tom").Times(2))

使用mock函数
API：To(hook interface{}) *MockBuilder
参数: hook 参数与返回值需要与mock函数完全一致，注意类成员函数需要增加self作为第一个参数（目前已经兼容了不传入receiver，当不需要使用的时候可以忽略）
返回： mockBuilder
参考实例：原调用Fun函数的地方替换为调用mock函数，注意mock函数与Fun函数定义要一致（即入参，返回值一致）

func Fun(a string) string {
   fmt.Println(a)
   return a
}

mock := func(p string) string {
   fmt.Println("b")
   return "b"
}
Mock(Fun).To(mock).Build()

创建
API：Build()
参数: 无
**返回值：**Mocker
参考实例：

 mock := Mock(Fun).Return("c").Build()

具体示例

mock结构体方法

type Animal struct {}

func (t*Animal)Run() string {
    return "animal run"
}

func AnimalRun() string {
    animal := &Animal{}
    return animal.Run()
}

func TestAnimalRun(t *testing.T) {
    PatchConvey("test animal run", t, func() {
        Mock((*Animal).Run).Return("animal jump").Build()
        So(AnimalRun(), ShouldEqual, "animal jump")
    })
}

我们通过Mock方法修改了Animal.Run函数的返回值恒定为"animal jump"。

注意：Return()方法中参数的数量要与被mock函数的返回值数量及其顺序保持一致。

mock普通函数

func Add(a, b int) int {
    return a + b
}

func TwoSum(a, b int) int {
    return Add(a, b)
}

import (
    "testing"

    . "github.com/bytedance/mockey"
    . "github.com/smartystreets/goconvey/convey"
)

func TestTwoSum(t *testing.T) {
    PatchConvey("test two sum", t, func() {
        Mock(Add).Return(10).Build()
        So(TwoSum(1, 2), ShouldEqual, 10)
    })
}

我们通过Mock方法修改了Add函数的返回值恒定为10。

序列化mock

在实际工作中会有这样一种场景，我们会会在一次请求处理中对某个方法调用多次，我们希望每次调用都可以返回不同的结果，这种该如何实现呢？别担心，mockey提供了序列化方式，可以指定mock函数在多次执行中每次执行的结果，我们看下如何示例：

type Event struct {
    Extra string `json:"extra"` // map
}

func parseEvent(value string) (map[string]interface{},error) {
    event := &Event{}
    if err := json.Unmarshal([]byte(value), &event); err != nil {
        return nil, errors.New("unmarshal_event_failed")
    }

    ret := make(map[string]interface{})
    if err := json.Unmarshal([]byte(event.Extra), &ret); err != nil {
        return nil, errors.New("unmarshal_extra_failed")
    }

    return ret, nil
}

比如我们希望第一次unmarshal成功，第二次也成功，我们可以撰写如下单测

func TestParseEvent(t *testing.T) {
    PatchConvey("test parse event", t, func() {
        PatchConvey("test success", func() {
            Mock(json.Unmarshal).Return(nil).Build() // 一次mock后续所有执行全部都是这个结果
            ret, err := ParseEvent("")
            So(ret, ShouldNotBeNil)
            So(err, ShouldBeNil)
        })
    })
}

但是如果我希望第一次成功，第二次失败呢，使用上述方式就行不通了，我们可以这样写

func TestParseEvent(t *testing.T) {
    PatchConvey("test parse event", t, func() {
        PatchConvey("test unmarshal extra failed", func() {
            Mock(json.Unmarshal).Return(Sequence(nil).Then(errors.New("unmarshal failed"))).Build()
            ret, err := ParseEvent("")
            So(ret, ShouldBeNil)
            So(err.Error(), ShouldEqual, "unmarshal_extra_failed")
        })
    })
}

你可能会问，那我连续mock两次json.unmarshal是否可以的，答案当然是no，连续mock会导致异常，如：

func TestParseEvent(t *testing.T) {
    PatchConvey("test parse event", t, func() {
        PatchConvey("test unmarshal extra failed", func() {
            // Mock(json.Unmarshal).Return(Sequence(nil).Then(errors.New("unmarshal failed"))).Build()
            Mock(json.Unmarshal).Return(nil).Build()
            Mock(json.Unmarshal).Return(errors.New("unmarshal failed")).Build()
            ret, err := ParseEvent("")
            So(ret, ShouldBeNil)
            So(err.Error(), ShouldEqual, "unmarshal_extra_failed")
        })
    })
}

运行结果如下：会提示re-mock
 Line 51: - re-mock <func([]uint8, interface {}) error Value>, previous mock at: /Users/bytedance/go/src/code.byted.org/namespace/test/unittest/exemple_test.go:50 
  goroutine 6 [running]:

MySQL和Redis单测

在开发中会经常用到各种数据库，比如常见的MySQL和Redis等。本部分就分别举例来演示如何在编写单元测试的时候对MySQL和Redis进行mock。

go-sqlmock

sqlmock 是一个实现 sql/driver 的mock库。它不需要建立真正的数据库连接就可以在测试中模拟任何 sql 驱动程序的行为。使用它可以很方便的在编写单元测试的时候mock sql语句的执行结果。

安装

go get github.com/DATA-DOG/go-sqlmock

使用示例

这里使用的是go-sqlmock官方文档中提供的基础示例代码。在下面的代码中，我们实现了一个recordStats函数用来记录用户浏览商品时产生的相关数据。具体实现的功能是在一个事务中进行以下两次SQL操作：

在products表中将当前商品的浏览次数+1
在product_viewers表中记录浏览当前商品的用户id

package main

import "database/sql"

// recordStats 记录用户浏览产品信息
func recordStats(db *sql.DB, userID, productID int64) (err error) {
	// 开启事务
	// 操作views和product_viewers两张表
	tx, err := db.Begin()
	if err != nil {
		return
	}

	defer func() {
		switch err {
		case nil:
			err = tx.Commit()
		default:
			tx.Rollback()
		}
	}()

	// 更新products表
	if _, err = tx.Exec("UPDATE products SET views = views + 1"); err != nil {
		return
	}
	// product_viewers表中插入一条数据
	if _, err = tx.Exec(
		"INSERT INTO product_viewers (user_id, product_id) VALUES (?, ?)",
		userID, productID); err != nil {
		return
	}
	return
}

func main() {
	// 注意：测试的过程中并不需要真正的连接
	db, err := sql.Open("mysql", "root@/blog")
	if err != nil {
		panic(err)
	}
	defer db.Close()
	// userID为1的用户浏览了productID为5的产品
	if err = recordStats(db, 1 /*some user id*/, 5 /*some product id*/); err != nil {
		panic(err)
	}
}

现在我们需要为代码中的recordStats函数编写单元测试，但是又不想在测试过程中连接真实的数据库进行测试。这个时候我们就可以像下面示例代码中那样使用sqlmock工具去mock数据库操作。

package main

import (
	"fmt"
	"testing"

	"github.com/DATA-DOG/go-sqlmock"
)

// TestShouldUpdateStats sql执行成功的测试用例
func TestShouldUpdateStats(t *testing.T) {
	// mock一个*sql.DB对象，不需要连接真实的数据库
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	// mock执行指定SQL语句时的返回结果
	mock.ExpectBegin()
	mock.ExpectExec("UPDATE products").WillReturnResult(sqlmock.NewResult(1, 1))
	mock.ExpectExec("INSERT INTO product_viewers").WithArgs(2, 3).WillReturnResult(sqlmock.NewResult(1, 1))
	mock.ExpectCommit()

	// 将mock的DB对象传入我们的函数中
	if err = recordStats(db, 2, 3); err != nil {
		t.Errorf("error was not expected while updating stats: %s", err)
	}

	// 确保期望的结果都满足
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Errorf("there were unfulfilled expectations: %s", err)
	}
}

// TestShouldRollbackStatUpdatesOnFailure sql执行失败回滚的测试用例
func TestShouldRollbackStatUpdatesOnFailure(t *testing.T) {
	db, mock, err := sqlmock.New()
	if err != nil {
		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
	}
	defer db.Close()

	mock.ExpectBegin()
	mock.ExpectExec("UPDATE products").WillReturnResult(sqlmock.NewResult(1, 1))
	mock.ExpectExec("INSERT INTO product_viewers").
		WithArgs(2, 3).
		// 注意：此处返回了错误
		WillReturnError(fmt.Errorf("some error"))
	mock.ExpectRollback()

	// now we execute our method
	if err = recordStats(db, 2, 3); err == nil {
		t.Errorf("was expecting an error, but there was none")
	}

	// we make sure that all expectations were met
	if err := mock.ExpectationsWereMet(); err != nil {
		t.Errorf("there were unfulfilled expectations: %s", err)
	}
}

上面的代码中，定义了一个执行成功的测试用例和一个执行失败回滚的测试用例，确保我们代码中的每个逻辑分支都能被测试到，提高单元测试覆盖率的同时也保证了代码的健壮性。

执行单元测试，看一下最终的测试结果。

➜  demo_ut_go go test -v -run=TestShould
=== RUN   TestShouldUpdateStats
--- PASS: TestShouldUpdateStats (0.00s)
=== RUN   TestShouldRollbackStatUpdatesOnFailure
--- PASS: TestShouldRollbackStatUpdatesOnFailure (0.00s)
PASS

可以看到两个测试用例的结果都符合预期，单元测试通过。

在很多使用ORM工具的场景下，也可以使用go-sqlmock库mock数据库操作进行测试。

miniredis

除了经常用到MySQL外，Redis在日常开发中也会经常用到。接下来我们将一起学习如何在单元测试中mock Redis的相关操作。

miniredis是一个纯go实现的用于单元测试的redis server。它是一个简单易用的、基于内存的redis替代品，它具有真正的TCP接口，你可以把它当成是redis版本的net/http/httptest。

当我们为一些包含Redis操作的代码编写单元测试时就可以使用它来mock Redis操作。

安装
这里以github.com/go-redis/redis库为例，编写了一个包含若干Redis操作的DoSomethingWithRedis函数。

go get github.com/alicebob/miniredis/v2

package main

import (
	"context"
	"strings"
	"time"

	"github.com/go-redis/redis/v8" // 注意导入版本
)

const (
	KeyValidWebsite = "app:valid:website:list"
)

func DoSomethingWithRedis(rdb *redis.Client, key string) bool {
	// 这里可以是对redis操作的一些逻辑
	ctx := context.TODO()
	if !rdb.SIsMember(ctx, KeyValidWebsite, key).Val() {
		return false
	}
	val, err := rdb.Get(ctx, key).Result()
	if err != nil {
		return false
	}
	if !strings.HasPrefix(val, "https://") {
		val = "https://" + val
	}
	// 设置 blog key 五秒过期
	if err := rdb.Set(ctx, "blog", val, 5*time.Second).Err(); err != nil {
		return false
	}
	return true
}

下面的代码是使用miniredis库为DoSomethingWithRedis函数编写的单元测试代码，其中miniredis不仅支持mock常用的Redis操作，还提供了很多实用的帮助函数，例如检查key的值是否与预期相等的s.CheckGet()和帮助检查key过期时间的s.FastForward()。

package main

import (
	"testing"
	"time"

	"github.com/alicebob/miniredis/v2"
	"github.com/go-redis/redis/v8"
)

func TestDoSomethingWithRedis(t *testing.T) {
	// mock一个redis server
	s, err := miniredis.Run()
	if err != nil {
		panic(err)
	}
	defer s.Close()

	// 准备数据
	s.Set("lym", "lym.com")
	s.SAdd(KeyValidWebsite, "lym")

	// 连接mock的redis server
	rdb := redis.NewClient(&redis.Options{
		Addr: s.Addr(), // mock redis server的地址
	})

	// 调用函数
	ok := DoSomethingWithRedis(rdb, "lym")
	if !ok {
		t.Fatal()
	}

	// 可以手动检查redis中的值是否复合预期
	if got, err := s.Get("blog"); err != nil || got != "https://lym.com" {
		t.Fatalf("'blog' has the wrong value")
	}
	// 也可以使用帮助工具检查
	s.CheckGet(t, "blog", "https://lym.com")

	// 过期检查
	s.FastForward(5 * time.Second) // 快进5秒
	if s.Exists("blog") {
		t.Fatal("'blog' should not have existed anymore")
	}
}

执行执行测试，查看单元测试结果：

➜  demo_ut_go go test -v -run=TestDoSomethingWithRedis
=== RUN   TestDoSomethingWithRedis
--- PASS: TestDoSomethingWithRedis (0.00s)
PASS

miniredis基本上支持绝大多数的Redis命令，大家可以通过查看文档了解更多用法。

当然除了使用miniredis搭建本地redis server这种方法外，还可以使用各种打桩工具对具体方法进行打桩。在编写单元测试时具体使用哪种mock方式还是要根据实际情况来决定。

F&Q

官方文档

执行单测时需要关闭内联优化，这样可以保证mock成功!!!

1. 如何禁用内联和编译优化

命令行跑单测可以采用：

go test -gcflags="all=-l -N" -v ./...

goland 图形界面可以采用：

Debug 模式下跑单个测试时会自动带上该参数，Run 模式下跑单个测试或者跑一个包的测试则需要手动带上该参数

在这里插入图片描述

百里守约学编程

关注

49
点赞
踩
26

收藏

觉得还不错? 一键收藏
1
评论
103. Go单测系列3---mockey与convey综合实战

工作中，随着业务的快速发展，代码量级和复杂度也会随之快速增长，面临的稳定性挑战越来越大。单测作为稳定性保障的重要一环越来越受到重视，编写单元测试应该成为程序员的基本素养。之前写单元测试都是基于go自己的test方式，基本就是在线下跑通流程，遇到下游的接口无法访问时，只会束手无策。后来了解到一些单测工具，市面上已有很多成熟的单测工具，本文不会比较各种工具的优劣，而是结合自身经验介绍本人在工作时常用的工具。
复制链接

扫一扫

专栏目录