Golang 单元测试 - 接口层

上次我们已经搞定了逻辑层的单元测试，这次我们来康康接口层的单元测试。接口层主要负责的就是请求的处理，最常见的就是 HTTP 请求的处理。

但针对 接口层 的单元测试其实是可以五花八门的。它并不像逻辑层和数据层一样的通用，对于它的测试往往有很多路可以走。

由于使用的 HTTP 框架不同，单元测试的实现方式则不同。既可以通过程序来模拟 HTTP 请求，也可以通过真实的 HTTP 请求来测试，通过借助外部的一些测试工具来实现。

所以本文只能给出一种思路，具体的实现方式还是要根据实际的框架来实现。

环境

本文以常用的 gin 框架为例，使用一种个人比较喜欢也非常简单的方式来实现单元测试。特点主要有：

不需要启动路由服务
复用已有的项目内的请求结构

代码

由于之前已经贴过，所以 service 层的代码这里就不赘述了

base case

package controller

import (
	"context"

	"github.com/gin-gonic/gin"
	"go-demo/m/unit-test/entity"
)

//go:generate mockgen -source=./user.go -destination=../mock/user_service_mock.go -package=mock
type UserService interface {
	AddUser(ctx context.Context, username string) (err error)
	GetUser(ctx context.Context, userID int) (user *entity.User, err error)
}

type AddUserRequest struct {
	Username string `json:"username" binding:"required"`
}

type GetUserRequest struct {
	UserID int `form:"user_id" binding:"required"`
}

type GetUserResponse struct {
	Username string `json:"username"`
}

type UserController struct {
	UserService UserService
}

func NewUserController(userService UserService) *UserController {
	return &UserController{UserService: userService}
}

func (uc *UserController) AddUser(ctx *gin.Context) {
	req := &AddUserRequest{}
	if err := ctx.BindJSON(req); err != nil {
		return
	}
	if err := uc.UserService.AddUser(ctx, req.Username); err != nil {
		ctx.JSON(400, gin.H{"error": err.Error()})
		return
	}
	ctx.JSON(200, gin.H{"message": "success"})
}

func (uc *UserController) GetUser(ctx *gin.Context) {
	req := &GetUserRequest{}
	if err := ctx.BindQuery(req); err != nil {
		return
	}
	user, err := uc.UserService.GetUser(ctx, req.UserID)
	if err != nil {
		ctx.JSON(400, gin.H{"error": err.Error()})
		return
	}
	ctx.JSON(200, &GetUserResponse{Username: user.Username})
}

既然之前我们 service 的单元测试已经通过，这次我们就需要 mock 的是 service 层的接口 mockgen -source=./user.go -destination=../mock/user_service_mock.go -package=mock
这里我将请求和返回的结构如：GetUserRequest、GetUserResponse 放在了这里仅仅是为了方便展示代码

单元测试

基础代码非常简单，就是我们常见的，最重要的让我们来看看单元测试应该怎么写

工具方法

在编写实际单元测试之前，我们需要一些工具方法来帮助我们构建一些请求。

func createGetReqCtx(req interface{}, handlerFunc gin.HandlerFunc) (isSuccess bool, resp string) {
	w := httptest.NewRecorder()
	c, _ := gin.CreateTestContext(w)
	encode := structToURLValues(req).Encode()
	c.Request, _ = http.NewRequest("GET", "/?"+encode, nil)
	handlerFunc(c)
	return w.Code == http.StatusOK, w.Body.String()
}

func createPostReqCtx(req interface{}, handlerFunc gin.HandlerFunc) (isSuccess bool, resp string) {
	responseRecorder := httptest.NewRecorder()
	ctx, _ := gin.CreateTestContext(responseRecorder)
	body, _ := json.Marshal(req)
	ctx.Request, _ = http.NewRequest("POST", "/", bytes.NewBuffer(body))
	ctx.Request.Header.Set("Content-Type", "application/json")

	handlerFunc(ctx)
	return responseRecorder.Code == http.StatusOK, responseRecorder.Body.String()
}

// 将结构体转换为 URL 参数
func structToURLValues(s interface{}) url.Values {
	v := reflect.ValueOf(s)
	if v.Kind() == reflect.Ptr {
		v = v.Elem()
	}
	t := v.Type()

	values := url.Values{}
	for i := 0; i < t.NumField(); i++ {
		field := t.Field(i)
		tag := field.Tag.Get("form")
		if tag == "" {
			continue
		}

		value := v.Field(i).Interface()
		values.Set(tag, valueToString(value))
	}

	return values
}

// 由于 get 请求常常参数并不会特别复杂，通常的几种类型就应该可以包括，有需要可以继续添加
func valueToString(v interface{}) string {
	switch v := v.(type) {
	case int:
		return strconv.Itoa(v)
	case string:
		return v
	default:
		return ""
	}
}

既然我们不想启动路由，其实最关键的问题就在如何构建一个 gin.Context 来模拟正常的请求。

通过 gin.CreateTestContext 创建一个我们需要模拟的 context
通过 http.NewRequest 来创建我们需要的请求结构

单元测试

有了我们的工具方法，那么编写单元测试的时候就非常方便了，mock 方法和之前类似，剩下要调用对应的方法就可以了。并且这里可以复用我们已经在原有程序中使用的请求结构如 GetUserRequest 这样就可以不需要重新劳动了。

package controller

import (
	"fmt"
	"testing"

	"github.com/golang/mock/gomock"
	"github.com/stretchr/testify/assert"
	"go-demo/m/unit-test/entity"
	"go-demo/m/unit-test/mock"
)

func TestUserController_AddUser(t *testing.T) {
	ctl := gomock.NewController(t)
	defer ctl.Finish()

	req := &AddUserRequest{Username: "LinkinStar"}
	mockUserService := mock.NewMockUserService(ctl)
	mockUserService.EXPECT().AddUser(gomock.Any(), gomock.Any()).Return(nil)

	userController := NewUserController(mockUserService)

	success, resp := createPostReqCtx(req, userController.AddUser)
	assert.True(t, success)
	fmt.Println(resp)
}

func TestUserController_GetUser(t *testing.T) {
	ctl := gomock.NewController(t)
	defer ctl.Finish()

	req := &GetUserRequest{UserID: 1}
	user := &entity.User{Username: "LinkinStar"}
	mockUserService := mock.NewMockUserService(ctl)
	mockUserService.EXPECT().GetUser(gomock.Any(), gomock.Any()).Return(user, nil)

	userController := NewUserController(mockUserService)

	success, resp := createGetReqCtx(req, userController.GetUser)
	assert.True(t, success)
	fmt.Println(resp)
}