Mastering Go Unit Testing: Mock Strategies, CI Integration, and Best Practices

Background

Testing is an effective way to ensure code quality, and unit testing provides the smallest verification unit for program modules. Compared with manual testing, unit tests are automated, repeatable, and more efficient, allowing daily pushes and test runs to gauge code quality through success rates and coverage.

Unit Test Principles

A (Automatic) : Tests should run fully automatically without interaction.

I (Independent) : Test cases must not call each other or depend on execution order.

R (Repeatable) : Tests should be repeatable in CI pipelines, shielding external dependencies via mocks.

Good unit tests are concise, focused on a single purpose, simple to set up and clean, fast to execute, and follow a strict structure (setup, action, verification).

Common Pitfalls

Missing assertions – a test without assertions has no value.

Not integrated into CI – tests should run on every merge and deployment.

Too large granularity – keep tests small, focusing only on input, output, and assertions.

Complex dependencies often discourage developers from writing tests; isolation techniques such as mocking can address this.

Mock Strategies

Strategy 1: Mock downstream dependencies via configuration (not recommended)

Configure local storage (e.g., SQLite, Redis) so downstream services are called directly without mocks.

var db *gorm.DB
func getMetricsRepo() *model.MetricsRepo {
    repo := model.MetricsRepo{ProjectID: 2, RepoPath: "/", FileCount: 5, CodeLineCount: 76, OwnerWorkNo: "999999"}
    return &repo
}
func getTeam() *model.Teams { return &model.Teams{WorkNo: "999999"} }
func init() {
    db, err := gorm.Open("sqlite3", "test.db")
    if err != nil { os.Exit(-1) }
    db.Debug()
    db.DropTableIfExists(model.MetricsRepo{})
    db.DropTableIfExists(model.Teams{})
    db.CreateTable(model.MetricsRepo{})
    db.CreateTable(model.Teams{})
    db.FirstOrCreate(getMetricsRepo())
    db.FirstOrCreate(getTeam())
}

Strategy 2: Interface‑based mocking with gomock (recommended)

Define interfaces for dependencies and generate mocks using gomock and mockgen.

type Foo interface { Bar(x int) int }
func SUT(f Foo) { /* ... */ }
ctrl := gomock.NewController(t)
defer ctrl.Finish()
m := NewMockFoo(ctrl)
m.EXPECT().Bar(gomock.Eq(99)).Return(101)
SUT(m)

Apply this to the controller by injecting a CrCtxInterface implementation.

type RepoCrCRController struct { c *gin.Context; crCtx code_review.CrCtxInterface }
func NewRepoCrCRController(ctx *gin.Context, cr code_review.CrCtxInterface) *RepoCrCRController {
    return &RepoCrCRController{c: ctx, crCtx: cr}
}
func (ctrl *RepoCrCRController) ListRepoCrAggregateMetrics(c *gin.Context) {
    workNo := c.Query("work_no")
    if workNo == "" { c.JSON(http.StatusOK, errors.BuildRsp(errors.ErrorWarpper(errors.ErrParamError.ErrorCode, "员工工号信息错误"), nil)); return }
    rsp, err := ctrl.crCtx.ListRepoCrAggregateMetrics(workNo)
    if err != nil { c.JSON(http.StatusOK, errors.BuildRsp(errors.ErrorWarpper(errors.ErrDbQueryError.ErrorCode, err.Error()), rsp)); return }
    c.JSON(http.StatusOK, errors.BuildRsp(errors.ErrSuccess, rsp))
}

func TestListRepoCrAggregateMetrics(t *testing.T) {
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()
    m := mock.NewMockCrCtxInterface(ctrl)
    resp := &code_review.RepoCrMetricsRsp{}
    m.EXPECT().ListRepoCrAggregateMetrics("999999").Return(resp, nil)
    w := httptest.NewRecorder()
    ctx, engine := gin.CreateTestContext(w)
    repoCtrl := NewRepoCrCRController(ctx, m)
    engine.GET("/api/test/code_review/repo", repoCtrl.ListRepoCrAggregateMetrics)
    req, _ := http.NewRequest("GET", "/api/test/code_review/repo?work_no=999999", nil)
    engine.ServeHTTP(w, req)
    assert.Equal(t, w.Code, 200)
    var got gin.H
    json.NewDecoder(w.Body).Decode(&got)
    assert.EqualValues(t, got["errorCode"], 0)
}

Strategy 3: Monkey‑patching instance methods (recommended for non‑interface code)

Use the monkey package to replace instance methods at runtime.

func TestListRepoCrAggregateMetrics(t *testing.T) {
    w := httptest.NewRecorder()
    _, engine := gin.CreateTestContext(w)
    engine.GET("/api/test/code_review/repo", ListRepoCrAggregateMetrics)
    var crCtx *code_review.CrCtx
    repoRet := code_review.RepoCrMetricsRsp{}
    monkey.PatchInstanceMethod(reflect.TypeOf(crCtx), "ListRepoCrAggregateMetrics",
        func(ctx *code_review.CrCtx, workNo string) (*code_review.RepoCrMetricsRsp, error) {
            if workNo == "999999" { repoRet.Total = 0; repoRet.RepoCodeReview = []*code_review.RepoCodeReview{} }
            return &repoRet, nil
        })
    req, _ := http.NewRequest("GET", "/api/test/code_review/repo?work_no=999999", nil)
    engine.ServeHTTP(w, req)
    assert.Equal(t, w.Code, 200)
    var v map[string]code_review.RepoCrMetricsRsp
    json.Unmarshal(w.Body.Bytes(), &v)
    assert.EqualValues(t, 0, v["data"].Total)
    assert.Len(t, v["data"].RepoCodeReview, 0)
}

Storage Layer Mocking

Use go-sqlmock to mock the database/sql/driver interface, enabling table‑driven tests without a real database.

package store
import (
    "database/sql/driver"
    "github.com/DATA-DOG/go-sqlmock"
    "github.com/gin-gonic/gin"
    "github.com/jinzhu/gorm"
    "github.com/stretchr/testify/assert"
    "net/http/httptest"
    "testing"
)
// ... test cases using sqlmock to set expectations and verify results ...

Continuous Integration

Alibaba's internal Aone platform provides CI similar to Travis CI. Tests can be run as dedicated unit‑test tasks or via the lab environment. Example command to execute tests and generate coverage:

mkdir -p $sourcepath/cover
RDSC_CONF=$sourcepath/config/config.yaml go test -v -cover=true -coverprofile=$sourcepath/cover/cover.cover ./...
ret=$?
if [[ $ret -ne 0 && $ret -ne 1 ]]; then exit $ret; fi

Coverage reports can be converted to XML with gocov and compared using diff‑cover to produce incremental coverage reports.

References: [1] https://thomasvilhena.com/2020/04/on-the-architecture-for-unit-testing [2] https://github.com/golang/mock [3] https://godoc.org/database/sql/driver [4] https://github.com/golang/go/wiki/TableDrivenTests [5] https://travis-ci.org/ [6] https://help.aliyun.com/document_detail/64021.html