use unit test bridge instead of unit test api

Author: wxiaoguang

integrations/integration_test.go

@@ -34,8 +34,6 @@ import (
 	"code.gitea.io/gitea/modules/queue"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/storage"
-	"code.gitea.io/gitea/modules/unittestapi"
-	"code.gitea.io/gitea/modules/unittestassert"
 	"code.gitea.io/gitea/modules/util"
 	"code.gitea.io/gitea/modules/web"
 	"code.gitea.io/gitea/routers"
@@ -86,7 +84,7 @@ func NewNilResponseHashSumRecorder() *NilResponseHashSumRecorder {
 func TestMain(m *testing.M) {
 	defer log.Close()
 
-	unittestapi.SetNewAsserterFunc(unittestassert.NewTestifyAsserter)
+	unittest.InitUnitTestBridge()
 	managerCtx, cancel := context.WithCancel(context.Background())
 	graceful.InitManager(managerCtx)
 	defer cancel()

models/consistency.go

@@ -9,14 +9,14 @@ import (
 	"strings"
 
 	"code.gitea.io/gitea/models/db"
-	"code.gitea.io/gitea/modules/unittestapi"
+	"code.gitea.io/gitea/modules/unittestbridge"
 
 	"xorm.io/builder"
 )
 
 // CheckConsistencyFor test that all matching database entries are consistent
-func CheckConsistencyFor(t unittestapi.Tester, beansToCheck ...interface{}) {
-	ta := unittestapi.NewAsserter(t)
+func CheckConsistencyFor(t unittestbridge.Tester, beansToCheck ...interface{}) {
+	ta := unittestbridge.NewAsserter(t)
 	for _, bean := range beansToCheck {
 		sliceType := reflect.SliceOf(reflect.TypeOf(bean))
 		sliceValue := reflect.MakeSlice(sliceType, 0, 10)
@@ -34,7 +34,7 @@ func CheckConsistencyFor(t unittestapi.Tester, beansToCheck ...interface{}) {
 	}
 }
 
-func checkForConsistency(ta unittestapi.Asserter, bean interface{}) {
+func checkForConsistency(ta unittestbridge.Asserter, bean interface{}) {
 	switch b := bean.(type) {
 	case *User:
 		checkForUserConsistency(b, ta)
@@ -58,19 +58,19 @@ func checkForConsistency(ta unittestapi.Asserter, bean interface{}) {
 }
 
 // getCount get the count of database entries matching bean
-func getCount(ta unittestapi.Asserter, e db.Engine, bean interface{}) int64 {
+func getCount(ta unittestbridge.Asserter, e db.Engine, bean interface{}) int64 {
 	count, err := e.Count(bean)
 	ta.NoError(err)
 	return count
 }
 
 // assertCount test the count of database entries matching bean
-func assertCount(ta unittestapi.Asserter, bean interface{}, expected int) {
+func assertCount(ta unittestbridge.Asserter, bean interface{}, expected int) {
 	ta.EqualValues(expected, getCount(ta, db.GetEngine(db.DefaultContext), bean),
 		"Failed consistency test, the counted bean (of type %T) was %+v", bean, bean)
 }
 
-func checkForUserConsistency(user *User, ta unittestapi.Asserter) {
+func checkForUserConsistency(user *User, ta unittestbridge.Asserter) {
 	assertCount(ta, &Repository{OwnerID: user.ID}, user.NumRepos)
 	assertCount(ta, &Star{UID: user.ID}, user.NumStars)
 	assertCount(ta, &OrgUser{OrgID: user.ID}, user.NumMembers)
@@ -83,7 +83,7 @@ func checkForUserConsistency(user *User, ta unittestapi.Asserter) {
 	}
 }
 
-func checkForRepoConsistency(repo *Repository, ta unittestapi.Asserter) {
+func checkForRepoConsistency(repo *Repository, ta unittestbridge.Asserter) {
 	ta.Equal(repo.LowerName, strings.ToLower(repo.Name), "repo: %+v", repo)
 	assertCount(ta, &Star{RepoID: repo.ID}, repo.NumStars)
 	assertCount(ta, &Milestone{RepoID: repo.ID}, repo.NumMilestones)
@@ -117,7 +117,7 @@ func checkForRepoConsistency(repo *Repository, ta unittestapi.Asserter) {
 		"Unexpected number of closed milestones for repo %+v", repo)
 }
 
-func checkForIssueConsistency(issue *Issue, ta unittestapi.Asserter) {
+func checkForIssueConsistency(issue *Issue, ta unittestbridge.Asserter) {
 	actual := getCount(ta, db.GetEngine(db.DefaultContext).Where("type=?", CommentTypeComment), &Comment{IssueID: issue.ID})
 	ta.EqualValues(issue.NumComments, actual,
 		"Unexpected number of comments for issue %+v", issue)
@@ -127,13 +127,13 @@ func checkForIssueConsistency(issue *Issue, ta unittestapi.Asserter) {
 	}
 }
 
-func checkForPullRequestConsistency(pr *PullRequest, ta unittestapi.Asserter) {
+func checkForPullRequestConsistency(pr *PullRequest, ta unittestbridge.Asserter) {
 	issue := db.AssertExistsAndLoadBean(ta, &Issue{ID: pr.IssueID}).(*Issue)
 	ta.True(issue.IsPull)
 	ta.EqualValues(issue.Index, pr.Index)
 }
 
-func checkForMilestoneConsistency(milestone *Milestone, ta unittestapi.Asserter) {
+func checkForMilestoneConsistency(milestone *Milestone, ta unittestbridge.Asserter) {
 	assertCount(ta, &Issue{MilestoneID: milestone.ID}, milestone.NumIssues)
 
 	actual := getCount(ta, db.GetEngine(db.DefaultContext).Where("is_closed=?", true), &Issue{MilestoneID: milestone.ID})
@@ -147,7 +147,7 @@ func checkForMilestoneConsistency(milestone *Milestone, ta unittestapi.Asserter)
 	ta.Equal(completeness, milestone.Completeness)
 }
 
-func checkForLabelConsistency(label *Label, ta unittestapi.Asserter) {
+func checkForLabelConsistency(label *Label, ta unittestbridge.Asserter) {
 	issueLabels := make([]*IssueLabel, 0, 10)
 	ta.NoError(db.GetEngine(db.DefaultContext).Find(&issueLabels, &IssueLabel{LabelID: label.ID}))
 	ta.EqualValues(label.NumIssues, len(issueLabels),
@@ -166,12 +166,12 @@ func checkForLabelConsistency(label *Label, ta unittestapi.Asserter) {
 		"Unexpected number of closed issues for label %+v", label)
 }
 
-func checkForTeamConsistency(team *Team, ta unittestapi.Asserter) {
+func checkForTeamConsistency(team *Team, ta unittestbridge.Asserter) {
 	assertCount(ta, &TeamUser{TeamID: team.ID}, team.NumMembers)
 	assertCount(ta, &TeamRepo{TeamID: team.ID}, team.NumRepos)
 }
 
-func checkForActionConsistency(action *Action, ta unittestapi.Asserter) {
+func checkForActionConsistency(action *Action, ta unittestbridge.Asserter) {
 	repo := db.AssertExistsAndLoadBean(ta, &Repository{ID: action.RepoID}).(*Repository)
 	ta.Equal(repo.IsPrivate, action.IsPrivate, "action: %+v", action)
 }

models/db/unit_tests.go

@@ -8,7 +8,7 @@ import (
 	"context"
 	"math"
 
-	"code.gitea.io/gitea/modules/unittestapi"
+	"code.gitea.io/gitea/modules/unittestbridge"
 
 	"xorm.io/xorm"
 )
@@ -58,16 +58,16 @@ func LoadBeanIfExists(bean interface{}, conditions ...interface{}) (bool, error)
 }
 
 // BeanExists for testing, check if a bean exists
-func BeanExists(t unittestapi.Tester, bean interface{}, conditions ...interface{}) bool {
-	ta := unittestapi.NewAsserter(t)
+func BeanExists(t unittestbridge.Tester, bean interface{}, conditions ...interface{}) bool {
+	ta := unittestbridge.NewAsserter(t)
 	exists, err := LoadBeanIfExists(bean, conditions...)
 	ta.NoError(err)
 	return exists
 }
 
 // AssertExistsAndLoadBean assert that a bean exists and load it from the test database
-func AssertExistsAndLoadBean(t unittestapi.Tester, bean interface{}, conditions ...interface{}) interface{} {
-	ta := unittestapi.NewAsserter(t)
+func AssertExistsAndLoadBean(t unittestbridge.Tester, bean interface{}, conditions ...interface{}) interface{} {
+	ta := unittestbridge.NewAsserter(t)
 	exists, err := LoadBeanIfExists(bean, conditions...)
 	ta.NoError(err)
 	ta.True(exists,
@@ -77,8 +77,8 @@ func AssertExistsAndLoadBean(t unittestapi.Tester, bean interface{}, conditions
 }
 
 // GetCount get the count of a bean
-func GetCount(t unittestapi.Tester, bean interface{}, conditions ...interface{}) int {
-	ta := unittestapi.NewAsserter(t)
+func GetCount(t unittestbridge.Tester, bean interface{}, conditions ...interface{}) int {
+	ta := unittestbridge.NewAsserter(t)
 	sess := x.NewSession()
 	defer sess.Close()
 	whereConditions(sess, conditions)
@@ -88,38 +88,38 @@ func GetCount(t unittestapi.Tester, bean interface{}, conditions ...interface{})
 }
 
 // AssertNotExistsBean assert that a bean does not exist in the test database
-func AssertNotExistsBean(t unittestapi.Tester, bean interface{}, conditions ...interface{}) {
-	ta := unittestapi.NewAsserter(t)
+func AssertNotExistsBean(t unittestbridge.Tester, bean interface{}, conditions ...interface{}) {
+	ta := unittestbridge.NewAsserter(t)
 	exists, err := LoadBeanIfExists(bean, conditions...)
 	ta.NoError(err)
 	ta.False(exists)
 }
 
 // AssertExistsIf asserts that a bean exists or does not exist, depending on
 // what is expected.
-func AssertExistsIf(t unittestapi.Tester, expected bool, bean interface{}, conditions ...interface{}) {
-	ta := unittestapi.NewAsserter(t)
+func AssertExistsIf(t unittestbridge.Tester, expected bool, bean interface{}, conditions ...interface{}) {
+	ta := unittestbridge.NewAsserter(t)
 	exists, err := LoadBeanIfExists(bean, conditions...)
 	ta.NoError(err)
 	ta.Equal(expected, exists)
 }
 
 // AssertSuccessfulInsert assert that beans is successfully inserted
-func AssertSuccessfulInsert(t unittestapi.Tester, beans ...interface{}) {
-	ta := unittestapi.NewAsserter(t)
+func AssertSuccessfulInsert(t unittestbridge.Tester, beans ...interface{}) {
+	ta := unittestbridge.NewAsserter(t)
 	_, err := x.Insert(beans...)
 	ta.NoError(err)
 }
 
 // AssertCount assert the count of a bean
-func AssertCount(t unittestapi.Tester, bean, expected interface{}) {
-	ta := unittestapi.NewAsserter(t)
+func AssertCount(t unittestbridge.Tester, bean, expected interface{}) {
+	ta := unittestbridge.NewAsserter(t)
 	ta.EqualValues(expected, GetCount(ta, bean))
 }
 
 // AssertInt64InRange assert value is in range [low, high]
-func AssertInt64InRange(t unittestapi.Tester, low, high, value int64) {
-	ta := unittestapi.NewAsserter(t)
+func AssertInt64InRange(t unittestbridge.Tester, low, high, value int64) {
+	ta := unittestbridge.NewAsserter(t)
 	ta.True(value >= low && value <= high,
 		"Expected value in range [%d, %d], found %d", low, high, value)
 }

modules/unittestassert/testassert.go renamed to models/unittest/bridge.go

@@ -2,49 +2,53 @@
 // Use of this source code is governed by a MIT-style
 // license that can be found in the LICENSE file.
 
-package unittestassert
+package unittest
 
 import (
-	"code.gitea.io/gitea/modules/unittestapi"
+	"code.gitea.io/gitea/modules/unittestbridge"
 	"github.com/stretchr/testify/assert"
 )
 
+// For legacy code only, please refer to the `unittestbridge` package.
+
 // TestifyAsserter uses "stretchr/testify/assert" to do assert
 type TestifyAsserter struct {
-	t unittestapi.Tester
+	t unittestbridge.Tester
 }
 
-//Errorf Errorf
+// Errorf assert Errorf
 func (ta TestifyAsserter) Errorf(format string, args ...interface{}) {
 	ta.t.Errorf(format, args)
 }
 
-//NoError NoError
+// NoError assert NoError
 func (ta TestifyAsserter) NoError(err error, msgAndArgs ...interface{}) bool {
 	return assert.NoError(ta, err, msgAndArgs...)
 }
 
-//EqualValues EqualValues
+// EqualValues assert EqualValues
 func (ta TestifyAsserter) EqualValues(expected, actual interface{}, msgAndArgs ...interface{}) bool {
 	return assert.EqualValues(ta, expected, actual, msgAndArgs...)
 }
 
-//Equal Equal
+// Equal assert Equal
 func (ta TestifyAsserter) Equal(expected, actual interface{}, msgAndArgs ...interface{}) bool {
 	return assert.Equal(ta, expected, actual, msgAndArgs...)
 }
 
-//True True
+// True assert True
 func (ta TestifyAsserter) True(value bool, msgAndArgs ...interface{}) bool {
 	return assert.True(ta, value, msgAndArgs...)
 }
 
-//False False
+// False assert False
 func (ta TestifyAsserter) False(value bool, msgAndArgs ...interface{}) bool {
 	return assert.False(ta, value, msgAndArgs...)
 }
 
-//NewTestifyAsserter returns a new asserter
-func NewTestifyAsserter(t unittestapi.Tester) unittestapi.Asserter {
-	return &TestifyAsserter{t: t}
+// InitUnitTestBridge init the unit test bridge. eg: models.CheckConsistencyFor can use testing and assert frameworks
+func InitUnitTestBridge() {
+	unittestbridge.SetNewAsserterFunc(func(t unittestbridge.Tester) unittestbridge.Asserter {
+		return &TestifyAsserter{t: t}
+	})
 }

models/unittest/testdb.go

@@ -15,8 +15,6 @@ import (
 	"code.gitea.io/gitea/modules/base"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/storage"
-	"code.gitea.io/gitea/modules/unittestapi"
-	"code.gitea.io/gitea/modules/unittestassert"
 	"code.gitea.io/gitea/modules/util"
 
 	"github.com/stretchr/testify/assert"
@@ -45,7 +43,7 @@ func fatalTestError(fmtStr string, args ...interface{}) {
 // test database. Creates the test database, and sets necessary settings.
 func MainTest(m *testing.M, pathToGiteaRoot string, fixtureFiles ...string) {
 	var err error
-	unittestapi.SetNewAsserterFunc(unittestassert.NewTestifyAsserter)
+	InitUnitTestBridge()
 	giteaRoot = pathToGiteaRoot
 	fixturesDir = filepath.Join(pathToGiteaRoot, "models", "fixtures")
 

modules/unittestapi/unittestapi.go

@@ -0,0 +1,46 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package unittestbridge
+
+// Usage: generally, non-unit-test code shouldn't depend on unit test code.
+// However, we have some code like models.CheckConsistencyFor, which need to do some unit test works.
+// Now we can not decouple models.CheckConsistencyFor from unit test code easily (cycle-import reasons).
+// So we introduce this `unit test bridge`:
+// * When a release binary is built, no testing/assert framework would be compiled into the binary, and CheckConsistencyFor won't run unit test related code
+// * When a unit test binary is built, the unit test code will init this bridge, then CheckConsistencyFor can run unit test related code
+//
+// Tester/Assert are intermediate interfaces, they should NOT be used in new code.
+// One day, if CheckConsistencyFor is clean enough, we can remove these intermediate interfaces.
+
+// Tester is the same as TestingT in "stretchr/testify/assert"
+// Tester can be used in non-unit-test code (ex: models.CheckConsistencyFor), it is used to isolate dependencies
+type Tester interface {
+	Errorf(format string, args ...interface{})
+}
+
+// Asserter can be used in non-unit-test code (ex: models.CheckConsistencyFor), it is used to isolate dependencies
+type Asserter interface {
+	Tester
+	NoError(err error, msgAndArgs ...interface{}) bool
+	EqualValues(expected, actual interface{}, msgAndArgs ...interface{}) bool
+	Equal(expected, actual interface{}, msgAndArgs ...interface{}) bool
+	True(value bool, msgAndArgs ...interface{}) bool
+	False(value bool, msgAndArgs ...interface{}) bool
+}
+
+var newAsserterFunc func(t Tester) Asserter
+
+// NewAsserter returns a new asserter, only works in unit test
+func NewAsserter(t Tester) Asserter {
+	if newAsserterFunc == nil {
+		panic("the newAsserterFunc is not set. you can only use assert in unit test.")
+	}
+	return newAsserterFunc(t)
+}
+
+// SetNewAsserterFunc in unit test, the asserter must be set first
+func SetNewAsserterFunc(f func(t Tester) Asserter) {
+	newAsserterFunc = f
+}