tests/golite.go: Remove global `tdb` and make tests under `TestSuite` independent

1 files changed, 111 insertions, 98 deletions

diff --git a/tests/golite.go b/tests/golite.go
index 2815432..48d3cb0 100644
--- a/tests/golite.go
+++ b/tests/golite.go
@@ -19,6 +19,8 @@ import (
 	"testing"
 	"testing/internal/testdeps"
 	"time"
+
+	g "gobang"
 )
 
 
@@ -3290,46 +3292,11 @@ var customFunctionOnce sync.Once
 
 func TestSuite(t *testing.T) {
 	// FIXME: too slow
-	initializeTestDB(t)
-	defer freeTestDB()
-
 	for _, test := range tests {
 		t.Run(test.Name, test.F)
 	}
 }
 
-// DB provide context for the tests
-type TestDB struct {
-	testing.TB
-	*sql.DB
-	once         sync.Once
-	tempFilename string
-}
-
-var tdb *TestDB
-
-func initializeTestDB(t testing.TB) {
-	tempFilename := TempFilename(t)
-	d, err := sql.Open(DriverName, tempFilename+"?mode=memory&cache=shared")
-	if err != nil {
-		os.Remove(tempFilename)
-		t.Fatal(err)
-	}
-
-	tdb = &TestDB{t, d, sync.Once{}, tempFilename}
-}
-
-func freeTestDB() {
-	err := tdb.DB.Close()
-	if err != nil {
-		panic(err)
-	}
-	err = os.Remove(tdb.tempFilename)
-	if err != nil {
-		panic(err)
-	}
-}
-
 // the following tables will be created and dropped during the test
 var testTables = []string{"foo"}
 
@@ -3344,35 +3311,32 @@ var tests = []testing.InternalTest{
 	{Name: "TestExecEmptyQuery", F: testExecEmptyQuery},
 }
 
-func (db *TestDB) mustExec(sql string, args ...any) sql.Result {
-	res, err := db.Exec(sql, args...)
-	if err != nil {
-		db.Fatalf("Error running %q: %v", sql, err)
-	}
-	return res
-}
-
-func (db *TestDB) tearDown() {
-	for _, tbl := range testTables {
-		db.mustExec("drop table if exists " + tbl)
-	}
-}
-
-// testResult is test for result
 func testResult(t *testing.T) {
-	tdb.tearDown()
-	tdb.mustExec("create temporary table test (id integer primary key autoincrement, name varchar(10))")
+	db, err := sql.Open(DriverName, InMemory)
+	g.TErrorIf(err)
+	defer db.Close()
+
+	_, err = db.Exec(`create temporary table test (
+		id integer primary key autoincrement,
+		name varchar(10)
+	);`)
+	g.TErrorIf(err)
 
 	for i := 1; i < 3; i++ {
-		r := tdb.mustExec("insert into test (name) values (?)", fmt.Sprintf("row %d", i))
-		n, err := r.RowsAffected()
+		res, err := db.Exec(
+			"insert into test (name) values (?)",
+			fmt.Sprintf("row %d", i),
+		)
+		g.TErrorIf(err)
+
+		n, err := res.RowsAffected()
 		if err != nil {
 			t.Fatal(err)
 		}
 		if n != 1 {
 			t.Errorf("got %v, want %v", n, 1)
 		}
-		n, err = r.LastInsertId()
+		n, err = res.LastInsertId()
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -3380,22 +3344,31 @@ func testResult(t *testing.T) {
 			t.Errorf("got %v, want %v", n, i)
 		}
 	}
-	if _, err := tdb.Exec("error!"); err == nil {
+	if _, err := db.Exec("error!"); err == nil {
 		t.Fatalf("expected error")
 	}
 }
 
 // testBlobs is test for blobs
 func testBlobs(t *testing.T) {
-	tdb.tearDown()
+	db, err := sql.Open(DriverName, InMemory)
+	g.TErrorIf(err)
+	defer db.Close()
+
 	var blob = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
-	tdb.mustExec("create table foo (id integer primary key, bar blob[16])")
-	tdb.mustExec("insert into foo (id, bar) values(?,?)", 0, blob)
+
+	_, err = db.Exec(
+		"create table foo (id integer primary key, bar blob[16])",
+	)
+	g.TErrorIf(err)
+
+	_, err = db.Exec("insert into foo (id, bar) values(?,?)", 0, blob)
+	g.TErrorIf(err)
 
 	want := fmt.Sprintf("%x", blob)
 
 	b := make([]byte, 16)
-	err := tdb.QueryRow("select bar from foo where id = ?", 0).Scan(&b)
+	err = db.QueryRow("select bar from foo where id = ?", 0).Scan(&b)
 	got := fmt.Sprintf("%x", b)
 	if err != nil {
 		t.Errorf("[]byte scan: %v", err)
@@ -3403,7 +3376,7 @@ func testBlobs(t *testing.T) {
 		t.Errorf("for []byte, got %q; want %q", got, want)
 	}
 
-	err = tdb.QueryRow("select bar from foo where id = ?", 0).Scan(&got)
+	err = db.QueryRow("select bar from foo where id = ?", 0).Scan(&got)
 	want = string(blob)
 	if err != nil {
 		t.Errorf("string scan: %v", err)
@@ -3413,20 +3386,31 @@ func testBlobs(t *testing.T) {
 }
 
 func testMultiBlobs(t *testing.T) {
-	tdb.tearDown()
-	tdb.mustExec("create table foo (id integer primary key, bar blob[16])")
+	db, err := sql.Open(DriverName, InMemory)
+	g.TErrorIf(err)
+	defer db.Close()
+
+	_, err = db.Exec(
+		"create table foo (id integer primary key, bar blob[16])",
+	)
+	g.TErrorIf(err)
+
 	var blob0 = []byte{0, 1, 2, 3, 4, 5, 6, 7}
-	tdb.mustExec("insert into foo (id, bar) values(?,?)", 0, blob0)
+	_, err = db.Exec("insert into foo (id, bar) values(?,?)", 0, blob0)
+	g.TErrorIf(err)
+
 	var blob1 = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
-	tdb.mustExec("insert into foo (id, bar) values(?,?)", 1, blob1)
+	_, err = db.Exec("insert into foo (id, bar) values(?,?)", 1, blob1)
+	g.TErrorIf(err)
 
-	r, err := tdb.Query("select bar from foo order by id")
+	rows, err := db.Query("select bar from foo order by id")
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer r.Close()
-	if !r.Next() {
-		if r.Err() != nil {
+	defer rows.Close()
+
+	if !rows.Next() {
+		if rows.Err() != nil {
 			t.Fatal(err)
 		}
 		t.Fatal("expected one rows")
@@ -3434,14 +3418,14 @@ func testMultiBlobs(t *testing.T) {
 
 	want0 := fmt.Sprintf("%x", blob0)
 	b0 := make([]byte, 8)
-	err = r.Scan(&b0)
+	err = rows.Scan(&b0)
 	if err != nil {
 		t.Fatal(err)
 	}
 	got0 := fmt.Sprintf("%x", b0)
 
-	if !r.Next() {
-		if r.Err() != nil {
+	if !rows.Next() {
+		if rows.Err() != nil {
 			t.Fatal(err)
 		}
 		t.Fatal("expected one rows")
@@ -3449,7 +3433,7 @@ func testMultiBlobs(t *testing.T) {
 
 	want1 := fmt.Sprintf("%x", blob1)
 	b1 := make([]byte, 16)
-	err = r.Scan(&b1)
+	err = rows.Scan(&b1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -3464,14 +3448,23 @@ func testMultiBlobs(t *testing.T) {
 
 // testBlobs tests that we distinguish between null and zero-length blobs
 func testNullZeroLengthBlobs(t *testing.T) {
-	tdb.tearDown()
-	tdb.mustExec("create table foo (id integer primary key, bar blob[16])")
-	tdb.mustExec("insert into foo (id, bar) values(?,?)", 0, nil)
-	tdb.mustExec("insert into foo (id, bar) values(?,?)", 1, []byte{})
+	db, err := sql.Open(DriverName, InMemory)
+	g.TErrorIf(err)
+	defer db.Close()
+
+	_, err = db.Exec(
+		"create table foo (id integer primary key, bar blob[16])",
+	)
+	g.TErrorIf(err)
+
+	_, err = db.Exec("insert into foo (id, bar) values(?,?)", 0, nil)
+	g.TErrorIf(err)
+
+	_, err = db.Exec("insert into foo (id, bar) values(?,?)", 1, []byte{})
+	g.TErrorIf(err)
 
-	r0 := tdb.QueryRow("select bar from foo where id=0")
 	var b0 []byte
-	err := r0.Scan(&b0)
+	err = db.QueryRow("select bar from foo where id=0").Scan(&b0)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -3479,9 +3472,8 @@ func testNullZeroLengthBlobs(t *testing.T) {
 		t.Errorf("for id=0, got %x; want nil", b0)
 	}
 
-	r1 := tdb.QueryRow("select bar from foo where id=1")
 	var b1 []byte
-	err = r1.Scan(&b1)
+	err = db.QueryRow("select bar from foo where id=1").Scan(&b1)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -3494,12 +3486,23 @@ func testNullZeroLengthBlobs(t *testing.T) {
 
 func testManyQueryRow(t *testing.T) {
 	// FIXME: too slow
-	tdb.tearDown()
-	tdb.mustExec("create table foo (id integer primary key, name varchar(50))")
-	tdb.mustExec("insert into foo (id, name) values(?,?)", 1, "bob")
+	db, err := sql.Open(DriverName, InMemory)
+	g.TErrorIf(err)
+	defer db.Close()
+
+	_, err = db.Exec(
+		"create table foo (id integer primary key, name varchar(50))",
+	)
+	g.TErrorIf(err)
+
+	_, err = db.Exec("insert into foo (id, name) values(?,?)", 1, "bob")
+	g.TErrorIf(err)
+
 	var name string
 	for i := 0; i < 10000; i++ {
-		err := tdb.QueryRow("select name from foo where id = ?", 1).Scan(&name)
+		err := db.QueryRow("select name from foo where id = ?", 1).Scan(
+			&name,
+		)
 		if err != nil || name != "bob" {
 			t.Fatalf("on query %d: err=%v, name=%q", i, err, name)
 		}
@@ -3507,8 +3510,11 @@ func testManyQueryRow(t *testing.T) {
 }
 
 func testTxQuery(t *testing.T) {
-	tdb.tearDown()
-	tx, err := tdb.Begin()
+	db, err := sql.Open(DriverName, InMemory)
+	g.TErrorIf(err)
+	defer db.Close()
+
+	tx, err := db.Begin()
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -3524,21 +3530,21 @@ func testTxQuery(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	r, err := tx.Query("select name from foo where id = ?", 1)
+	rows, err := tx.Query("select name from foo where id = ?", 1)
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer r.Close()
+	defer rows.Close()
 
-	if !r.Next() {
-		if r.Err() != nil {
+	if !rows.Next() {
+		if rows.Err() != nil {
 			t.Fatal(err)
 		}
 		t.Fatal("expected one rows")
 	}
 
 	var name string
-	err = r.Scan(&name)
+	err = rows.Scan(&name)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -3546,16 +3552,20 @@ func testTxQuery(t *testing.T) {
 
 func testPreparedStmt(t *testing.T) {
 	// FIXME: too slow
-	tdb.tearDown()
-	tdb.mustExec("CREATE TABLE t (count INT)")
+	db, err := sql.Open(DriverName, InMemory)
+	g.TErrorIf(err)
+	defer db.Close()
+
+	_, err = db.Exec("CREATE TABLE t (count INT)")
+	g.TErrorIf(err)
 
-	sel, err := tdb.Prepare("SELECT count FROM t ORDER BY count DESC")
+	sel, err := db.Prepare("SELECT count FROM t ORDER BY count DESC")
 	if err != nil {
 		t.Fatalf("prepare 1: %v", err)
 	}
 	defer sel.Close()
 
-	ins, err := tdb.Prepare("INSERT INTO t (count) VALUES (?)")
+	ins, err := db.Prepare("INSERT INTO t (count) VALUES (?)")
 	if err != nil {
 		t.Fatalf("prepare 2: %v", err)
 	}
@@ -3594,8 +3604,11 @@ func testPreparedStmt(t *testing.T) {
 
 // testEmptyQuery is test for validating the API in case of empty query
 func testExecEmptyQuery(t *testing.T) {
-	tdb.tearDown()
-	res, err := tdb.Exec(" -- this is just a comment ")
+	db, err := sql.Open(DriverName, InMemory)
+	g.TErrorIf(err)
+	defer db.Close()
+
+	res, err := db.Exec(" -- this is just a comment ")
 	if err != nil {
 		t.Fatalf("empty query err: %v", err)
 	}