compare

Author: wxiaoguang

models/unittest/fixtures.go

@@ -15,23 +15,17 @@ import (
 	"xorm.io/xorm/schemas"
 )
 
-var defaultFixturesLoader *fixturesLoader
+type FixturesLoader interface {
+	Load() error
+}
+
+var fixturesLoader FixturesLoader
 
 // GetXORMEngine gets the XORM engine
 func GetXORMEngine() (x *xorm.Engine) {
 	return db.GetEngine(db.DefaultContext).(*xorm.Engine)
 }
 
-// InitFixtures initialize test fixtures for a test database
-func InitFixtures(opts FixturesOptions, engine ...*xorm.Engine) (err error) {
-	defaultFixturesLoader = &fixturesLoader{engine: util.IfZero(util.OptionalArg(engine), GetXORMEngine()), opts: opts}
-
-	// register the dummy hash algorithm function used in the test fixtures
-	_ = hash.Register("dummy", hash.NewDummyHasher)
-	setting.PasswordHashAlgo, _ = hash.SetDefaultPasswordHashAlgorithm("dummy")
-	return err
-}
-
 func loadFixtureResetSeqPgsql(e *xorm.Engine) error {
 	results, err := e.QueryString(`SELECT 'SELECT SETVAL(' ||
 		quote_literal(quote_ident(PGT.schemaname) || '.' || quote_ident(S.relname)) ||
@@ -63,14 +57,24 @@ func loadFixtureResetSeqPgsql(e *xorm.Engine) error {
 	return nil
 }
 
+// InitFixtures initialize test fixtures for a test database
+func InitFixtures(opts FixturesOptions, engine ...*xorm.Engine) (err error) {
+	fixturesLoader = newFixturesLoaderInternal(util.IfZero(util.OptionalArg(engine), GetXORMEngine()), opts)
+
+	// register the dummy hash algorithm function used in the test fixtures
+	_ = hash.Register("dummy", hash.NewDummyHasher)
+	setting.PasswordHashAlgo, _ = hash.SetDefaultPasswordHashAlgorithm("dummy")
+	return err
+}
+
 // LoadFixtures load fixtures for a test database
 func LoadFixtures() error {
-	if err := defaultFixturesLoader.Load(); err != nil {
+	if err := fixturesLoader.Load(); err != nil {
 		return err
 	}
 	// Now if we're running postgres we need to tell it to update the sequences
-	if defaultFixturesLoader.engine.Dialect().URI().DBType == schemas.POSTGRES {
-		if err := loadFixtureResetSeqPgsql(defaultFixturesLoader.engine); err != nil {
+	if GetXORMEngine().Dialect().URI().DBType == schemas.POSTGRES {
+		if err := loadFixtureResetSeqPgsql(GetXORMEngine()); err != nil {
 			return err
 		}
 	}

models/unittest/fixtures_loader.go renamed to models/unittest/fixtures_loader_internal.go

@@ -18,14 +18,14 @@ import (
 	"xorm.io/xorm/schemas"
 )
 
-type fixturesLoader struct {
+type fixturesLoaderInternal struct {
 	engine           *xorm.Engine
 	opts             FixturesOptions
 	quoteObject      func(string) string
 	paramPlaceholder func(idx int) string
 }
 
-func (f *fixturesLoader) prepareFieldValue(v any) any {
+func (f *fixturesLoaderInternal) prepareFieldValue(v any) any {
 	if s, ok := v.(string); ok {
 		if strings.HasPrefix(s, "0x") {
 			b, _ := hex.DecodeString(s[2:])
@@ -35,7 +35,7 @@ func (f *fixturesLoader) prepareFieldValue(v any) any {
 	return v
 }
 
-func (f *fixturesLoader) mssqlTableHasIdentityColumn(q *sql.Tx, tableName string) (bool, error) {
+func (f *fixturesLoaderInternal) mssqlTableHasIdentityColumn(q *sql.Tx, tableName string) (bool, error) {
 	row := q.QueryRow(`SELECT COUNT(*) FROM sys.identity_columns WHERE OBJECT_ID = OBJECT_ID(?)`, tableName)
 	var count int
 	if err := row.Scan(&count); err != nil {
@@ -44,7 +44,7 @@ func (f *fixturesLoader) mssqlTableHasIdentityColumn(q *sql.Tx, tableName string
 	return count > 0, nil
 }
 
-func (f *fixturesLoader) loadFixtures(tx *sql.Tx, file string) error {
+func (f *fixturesLoaderInternal) loadFixtures(tx *sql.Tx, file string) error {
 	data, err := os.ReadFile(file)
 	if err != nil {
 		return fmt.Errorf("failed to read file %q: %w", file, err)
@@ -105,7 +105,7 @@ func (f *fixturesLoader) loadFixtures(tx *sql.Tx, file string) error {
 	return nil
 }
 
-func (f *fixturesLoader) Load() error {
+func (f *fixturesLoaderInternal) Load() error {
 	goDB := f.engine.DB().DB
 
 	switch f.engine.Dialect().URI().DBType {
@@ -152,3 +152,7 @@ func (f *fixturesLoader) Load() error {
 	}
 	return tx.Commit()
 }
+
+func newFixturesLoaderInternal(x *xorm.Engine, opts FixturesOptions) *fixturesLoaderInternal {
+	return &fixturesLoaderInternal{engine: x, opts: opts}
+}

models/unittest/fixtures_loader_vendor.go

@@ -0,0 +1,58 @@
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package unittest
+
+import (
+	"code.gitea.io/gitea/modules/auth/password/hash"
+	"code.gitea.io/gitea/modules/setting"
+	"fmt"
+
+	"github.com/go-testfixtures/testfixtures/v3"
+	"xorm.io/xorm"
+	"xorm.io/xorm/schemas"
+)
+
+// InitFixtures initialize test fixtures for a test database
+func newFixturesLoaderVendor(e *xorm.Engine, opts FixturesOptions) *testfixtures.Loader {
+	var fixtureOptionFiles func(*testfixtures.Loader) error
+	if opts.Dir != "" {
+		fixtureOptionFiles = testfixtures.Directory(opts.Dir)
+	} else {
+		fixtureOptionFiles = testfixtures.Files(opts.Files...)
+	}
+	var dialect string
+	switch e.Dialect().URI().DBType {
+	case schemas.POSTGRES:
+		dialect = "postgres"
+	case schemas.MYSQL:
+		dialect = "mysql"
+	case schemas.MSSQL:
+		dialect = "mssql"
+	case schemas.SQLITE:
+		dialect = "sqlite3"
+	default:
+		panic(fmt.Errorf("unsupported RDBMS for integration tests: %q", e.Dialect().URI().DBType))
+	}
+	loaderOptions := []func(loader *testfixtures.Loader) error{
+		testfixtures.Database(e.DB().DB),
+		testfixtures.Dialect(dialect),
+		testfixtures.DangerousSkipTestDatabaseCheck(),
+		fixtureOptionFiles,
+	}
+
+	if e.Dialect().URI().DBType == schemas.POSTGRES {
+		loaderOptions = append(loaderOptions, testfixtures.SkipResetSequences())
+	}
+
+	// register the dummy hash algorithm function used in the test fixtures
+	_ = hash.Register("dummy", hash.NewDummyHasher)
+	setting.PasswordHashAlgo, _ = hash.SetDefaultPasswordHashAlgorithm("dummy")
+
+	loader, err := testfixtures.New(loaderOptions...)
+	if err != nil {
+		panic(fmt.Errorf("failed to create fixtures loader: %w", err))
+	}
+
+	return loader
+}