本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《使用模拟编写单元测试》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~
问题内容我在里面写了一个rest api。现在我想通过隔离不同的组件来对其进行单元测试。
项目结构如下所示，有两个主要包
├── main.go
├── routes
│ ├── routes.go
│ └── routes_test.go
├── db
│ └── db.gomain.go：项目的主要入口点
routes/routes.go：http 路由处理程序包
db/db.go：数据库处理程序包
现在，当我测试 http 路由时，我只想测试请求是否路由到正确的处理函数，然后它们会做出相应的响应。在实际应用程序中，处理程序函数实际上会插入/更新数据库，但我不想在测试时这样做。因此，如果我可以模拟一个数据库对象并使我的处理程序函数对其进行连接/读取/写入，但我不知道该怎么做。
当谈到测试数据库处理程序包 db.go 时，我认为我不能模拟它，我必须设置一个测试数据库来进行查询。
这就是我的文件的样子。
路线/routes.go
package routes
import (
"cfengine-service/db"
"encoding/json"
"net/http"
"strings"
log "github.com/sirupsen/logrus"
"github.com/gorilla/mux"
)
// route - struct modal for routes
type route struct {
name string
endpoint string
methods []string
handlerfunc http.handlerfunc
}
var dbhandler = &db.mongo{}
// setuprouter - returns the mux router
func setuprouter() *mux.router {
err := dbhandler.connect()
if err != nil {
log.fatal(err)
}
router := mux.newrouter()
for _, route := range setuproutes() {
router.handlefunc(route.endpoint, route.handlerfunc).methods(route.methods...)
}
return router
}
func setuproutes() []route {
return []route{
{
"host config management",
"/configs/group",
[]string{"get", "post"},
groupconfig,
},
}
func groupconfig(w http.responsewriter, r *http.request) {
reqmethod := r.method
if reqmethod == "get" {
getgroupconfig(w, r)
} else if reqmethod == "post" {
newgroupconfig(w, r)
}
}
func getgroupconfig(w http.responsewriter, r *http.request) {
w.header().set("content-type", "application/json")
// g := r.url.query().get("groupname")
g := r.formvalue("groupname")
if g == "" {
if data, err := dbhandler.readallgroups(); statuswriter(w, err) {
_ = json.newencoder(w).encode(data)
}
} else {
if data, err := dbhandler.readonegroup(g); statuswriter(w, err) {
_ = json.newencoder(w).encode(data)
}
}
}
// newgroupconfig - end point for creating new config group
func newgroupconfig(w http.responsewriter, r *http.request) {
w.header().set("content-type", "application/json")
var group db.groupconfig
err := json.newdecoder(r.body).decode(&group)
statuswriter(w, err)
err = dbhandler.creategroupconfig(&group)
statuswriter(w, err)
}db/db.go
package db
import (
"cfengine-service/config"
"cfengine-service/helpers"
"context"
"fmt"
"time"
log "github.com/sirupsen/logrus"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
type hostconfig struct {
hostname string `bson:"_id" json:"hostname"`
type string `bson:"type" json:"type"`
groups []string `bson:"groups" json:"groups"`
overrides map[string]string `bson:"overrides" json:"overrides"`
excludes []string `bson:"excludes" json:"excludes"`
data map[string]string `bson:"data" json:"data"`
}
// mongo collection
type mongo struct {
collection *mongo.collection
}
// storage is interface for db operations
type storage interface {
connect() error
readall() ([]hostconfig, error)
readone() (*hostconfig, error)
createhostconfig(h *hostconfig) error
creategroupconfig(g *groupconfig) error
deletehostconfig(h *hostconfig) error
updatehostgrops(h string, g string, opr string) error
validategroup(ctx context.context, val string) error
}
func (m *mongo) connect() error {
ctx, cancel := context.withtimeout(context.background(), 10*time.second)
defer cancel()
//client, err := mongo.newclient(config.config.mongouri)
client, err := mongo.connect(ctx, options.client().applyuri(config.config.mongouri))
if err != nil {
return err
}
log.info("connected to mongodb.....")
m.collection = client.database(config.config.mongodbname).collection(config.config.mongocollectionname)
return nil
}
func (m *mongo) creategroupconfig(g *groupconfig) error {
ctx, cancel := context.withtimeout(context.background(), 10*time.second)
defer cancel()
data, err := bson.marshal(g)
if err != nil {
log.error(err.error())
return err
}
_, err = m.collection.insertone(ctx, data)
if err != nil {
return err
}
return nil
}
func (m *mongo) readonegroup(g string) (groupconfig, error) {
ctx, cancel := context.withtimeout(context.background(), time.second*10)
defer cancel()
var group groupconfig
err := m.collection.findone(ctx, bson.m{"_id": g}).decode(&group)
if err != nil {
return groupconfig{}, err
}
return group, nil
}
func (m *mongo) readallgroups() ([]groupconfig, error) {
var configs []groupconfig
ctx, cancel := context.withtimeout(context.background(), 10*time.second)
defer cancel()
cur, err := m.collection.find(ctx, bson.m{"type": "group"})
if err != nil {
return nil, err
}
defer cur.close(ctx)
for cur.next(ctx) {
var record groupconfig
if err = cur.decode(&record); err != nil {
return nil, err
}
configs = append(configs, record)
}
return configs, nil
}因此，使用 mockgen 包，我在 storage 接口中生成了 db.go 的模拟，但我不确定如何开始使用它。这是mock_db.go 的外观。
mock_db.go
type MockStorage struct {
ctrl *gomock.Controller
recorder *MockStorageMockRecorder
}
// MockStorageMockRecorder is the mock recorder for MockStorage
type MockStorageMockRecorder struct {
mock *MockStorage
}
// NewMockStorage creates a new mock instance
func NewMockStorage(ctrl *gomock.Controller) *MockStorage {
mock := &MockStorage{ctrl: ctrl}
mock.recorder = &MockStorageMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use
func (m *MockStorage) EXPECT() *MockStorageMockRecorder {
return m.recorder
}
// Connect mocks base method
func (m *MockStorage) Connect() error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "Connect")
ret0, _ := ret[0].(error)
return ret0
}
// Connect indicates an expected call of Connect
func (mr *MockStorageMockRecorder) Connect() *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Connect", reflect.TypeOf((*MockStorage)(nil).Connect))
}
func (m *MockStorage) CreateGroupConfig(arg0 *db.GroupConfig) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "CreateGroupConfig", arg0)
ret0, _ := ret[0].(error)
return ret0
}
// CreateGroupConfig indicates an expected call of CreateGroupConfig
func (mr *MockStorageMockRecorder) CreateGroupConfig(arg0 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroupConfig", reflect.TypeOf((*MockStorage)(nil).CreateGroupConfig), arg0)
}那么任何人都可以在这里指导我或给我一些提示以朝着正确的方向前进。
解决方案
您在测试处理程序时犯的错误是，您正在 setuprouter 函数内创建所谓的“单例对象”新对象，因为应用程序所需的所有依赖项都应在 main.go 中实例化，并将它们作为接口，其中你需要它们。还要定义小接口 - 理想的接口大小是 1 或 2 个方法。
// storage是一个你已有的接口，这样你可以在单元测试时传递你的mock对象，router也应该是一个接口。
func SetupRouter(db Storage, router Router) *mux.Router {
err := db.Connect()
if err != nil {
log.Fatal(err)
}
//router := mux.NewRouter() - you do not need to do this now
// then perform whateven actions you want to do with router
}所以上面的代码片段只是一个示例，说明如何模拟案例数据库中的依赖项，但正如 @adrian 在评论中所说，如果此代码是生产代码，则需要大量重构。
文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《使用模拟编写单元测试》文章吧，也可关注编程网公众号了解相关技术文章。
