137 lines
3.4 KiB
Go
137 lines
3.4 KiB
Go
package sqlite
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"fmt"
|
|
"os"
|
|
"runtime"
|
|
"testing"
|
|
|
|
"github.com/Gleipnir-Technology/jet/internal/utils/throw"
|
|
"github.com/Gleipnir-Technology/jet/qrm"
|
|
"github.com/Gleipnir-Technology/jet/sqlite"
|
|
"github.com/Gleipnir-Technology/jet/stmtcache"
|
|
"github.com/Gleipnir-Technology/jet/tests/dbconfig"
|
|
"github.com/pkg/profile"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
_ "github.com/mattn/go-sqlite3"
|
|
)
|
|
|
|
var db *stmtcache.DB
|
|
var sampleDB *stmtcache.DB
|
|
|
|
var withStatementCaching bool
|
|
|
|
func init() {
|
|
withStatementCaching = os.Getenv("JET_TESTS_WITH_STMT_CACHE") == "true"
|
|
}
|
|
|
|
func TestMain(m *testing.M) {
|
|
defer profile.Start().Stop()
|
|
|
|
func() {
|
|
fmt.Printf("\nRunning sqlite tests caching enabled: %t \n", withStatementCaching)
|
|
|
|
sqlDB, err := sql.Open("sqlite3", "file:"+dbconfig.SakilaDBPath)
|
|
throw.OnError(err)
|
|
db = stmtcache.New(sqlDB).SetCaching(withStatementCaching)
|
|
defer db.Close()
|
|
|
|
_, err = db.Exec(fmt.Sprintf("ATTACH DATABASE '%s' as 'chinook';", dbconfig.ChinookDBPath))
|
|
throw.OnError(err)
|
|
|
|
sqlSampleDB, err := sql.Open("sqlite3", dbconfig.TestSampleDBPath)
|
|
throw.OnError(err)
|
|
sampleDB = stmtcache.New(sqlSampleDB).SetCaching(withStatementCaching)
|
|
defer sampleDB.Close()
|
|
|
|
for i := 0; i < runCount(withStatementCaching); i++ {
|
|
ret := m.Run()
|
|
if ret != 0 {
|
|
fmt.Printf("\nFAIL: Running sqlite tests failed, caching enabled: %t \n", withStatementCaching)
|
|
os.Exit(ret)
|
|
}
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
func allowUnmappedFields(f func()) {
|
|
previous := qrm.GlobalConfig.StrictFieldMapping
|
|
defer func() { qrm.GlobalConfig.StrictFieldMapping = previous }()
|
|
qrm.GlobalConfig.StrictFieldMapping = false
|
|
f()
|
|
}
|
|
|
|
func requireStrictFieldMapping(f func()) {
|
|
previous := qrm.GlobalConfig.StrictFieldMapping
|
|
defer func() { qrm.GlobalConfig.StrictFieldMapping = previous }()
|
|
qrm.GlobalConfig.StrictFieldMapping = true
|
|
f()
|
|
}
|
|
|
|
func runCount(stmtCaching bool) int {
|
|
if stmtCaching {
|
|
return 4
|
|
}
|
|
|
|
return 1
|
|
}
|
|
|
|
var loggedSQL string
|
|
var loggedSQLArgs []interface{}
|
|
var loggedDebugSQL string
|
|
|
|
var queryInfo sqlite.QueryInfo
|
|
var callerFile string
|
|
var callerLine int
|
|
var callerFunction string
|
|
|
|
func init() {
|
|
sqlite.SetLogger(func(ctx context.Context, statement sqlite.PrintableStatement) {
|
|
loggedSQL, loggedSQLArgs = statement.Sql()
|
|
loggedDebugSQL = statement.DebugSql()
|
|
})
|
|
|
|
sqlite.SetQueryLogger(func(ctx context.Context, info sqlite.QueryInfo) {
|
|
queryInfo = info
|
|
callerFile, callerLine, callerFunction = info.Caller()
|
|
})
|
|
}
|
|
|
|
func requireQueryLogged(t *testing.T, statement sqlite.Statement, rowsProcessed int64) {
|
|
query, args := statement.Sql()
|
|
queryLogged, argsLogged := queryInfo.Statement.Sql()
|
|
|
|
require.Equal(t, query, queryLogged)
|
|
require.Equal(t, args, argsLogged)
|
|
require.Equal(t, queryInfo.RowsProcessed, rowsProcessed)
|
|
|
|
pc, file, _, _ := runtime.Caller(1)
|
|
funcDetails := runtime.FuncForPC(pc)
|
|
require.Equal(t, file, callerFile)
|
|
require.NotEmpty(t, callerLine)
|
|
require.Equal(t, funcDetails.Name(), callerFunction)
|
|
}
|
|
|
|
func requireLogged(t *testing.T, statement sqlite.Statement) {
|
|
query, args := statement.Sql()
|
|
require.Equal(t, loggedSQL, query)
|
|
require.Equal(t, loggedSQLArgs, args)
|
|
require.Equal(t, loggedDebugSQL, statement.DebugSql())
|
|
}
|
|
|
|
func beginSampleDBTx(t *testing.T) *stmtcache.Tx {
|
|
tx, err := sampleDB.BeginTx(context.Background(), nil)
|
|
require.NoError(t, err)
|
|
return tx
|
|
}
|
|
|
|
func beginDBTx(t *testing.T) *stmtcache.Tx {
|
|
tx, err := db.Begin()
|
|
require.NoError(t, err)
|
|
return tx
|
|
}
|