From 8f835eda799dc0cd750892c4d81d68fa8fe76922 Mon Sep 17 00:00:00 2001 From: Nuno Cruces Date: Mon, 5 Aug 2024 21:25:47 +0100 Subject: [PATCH] Use memdb for tests. (#131) --- driver/driver_test.go | 55 ++++++++++++++++++++------------- ext/array/array_test.go | 6 ++-- ext/fileio/fileio_test.go | 8 +++-- ext/fileio/fsdir_test.go | 5 ++- ext/fileio/write_test.go | 4 ++- ext/hash/hash_test.go | 4 ++- ext/lines/lines_test.go | 15 ++++++--- ext/regexp/regexp_test.go | 7 +++-- ext/uuid/uuid_test.go | 7 +++-- ext/zorder/zorder_test.go | 10 ++++-- gormlite/sqlite_test.go | 10 +++--- json_test.go | 3 +- tests/bradfitz/sql_test.go | 2 +- tests/conn_test.go | 7 ++++- tests/db_test.go | 3 +- tests/driver_test.go | 4 ++- tests/json_test.go | 4 ++- tests/parallel/parallel_test.go | 29 ++++++++--------- tests/time_test.go | 4 ++- tests/txn_test.go | 7 +++-- vfs/memdb/api.go | 30 ++++++++++++++++++ 21 files changed, 154 insertions(+), 70 deletions(-) diff --git a/driver/driver_test.go b/driver/driver_test.go index c7ea1c7..dba6b76 100644 --- a/driver/driver_test.go +++ b/driver/driver_test.go @@ -7,7 +7,6 @@ import ( "errors" "math" "net/url" - "path/filepath" "testing" "time" @@ -15,7 +14,7 @@ import ( _ "github.com/ncruces/go-sqlite3/embed" _ "github.com/ncruces/go-sqlite3/internal/testcfg" "github.com/ncruces/go-sqlite3/internal/util" - "github.com/ncruces/go-sqlite3/vfs" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func Test_Open_dir(t *testing.T) { @@ -38,8 +37,11 @@ func Test_Open_dir(t *testing.T) { func Test_Open_pragma(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t, url.Values{ + "_pragma": {"busy_timeout(1000)"}, + }) - db, err := sql.Open("sqlite3", "file::memory:?_pragma=busy_timeout(1000)") + db, err := sql.Open("sqlite3", tmp) if err != nil { t.Fatal(err) } @@ -57,8 +59,11 @@ func Test_Open_pragma(t *testing.T) { func Test_Open_pragma_invalid(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t, url.Values{ + "_pragma": {"busy_timeout 1000"}, + }) - db, err := sql.Open("sqlite3", "file::memory:?_pragma=busy_timeout+1000") + db, err := sql.Open("sqlite3", tmp) if err != nil { t.Fatal(err) } @@ -81,14 +86,13 @@ func Test_Open_pragma_invalid(t *testing.T) { } func Test_Open_txLock(t *testing.T) { - if !vfs.SupportsFileLocking { - t.Skip("skipping without locks") - } t.Parallel() + tmp := memdb.TestDB(t, url.Values{ + "_txlock": {"exclusive"}, + "_pragma": {"busy_timeout(1000)"}, + }) - db, err := sql.Open("sqlite3", "file:"+ - filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))+ - "?_txlock=exclusive&_pragma=busy_timeout(0)") + db, err := sql.Open("sqlite3", tmp) if err != nil { t.Fatal(err) } @@ -119,8 +123,11 @@ func Test_Open_txLock(t *testing.T) { func Test_Open_txLock_invalid(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t, url.Values{ + "_txlock": {"xclusive"}, + }) - _, err := sql.Open("sqlite3", "file::memory:?_txlock=xclusive") + _, err := sql.Open("sqlite3", tmp+"_txlock=xclusive") if err == nil { t.Fatal("want error") } @@ -130,17 +137,16 @@ func Test_Open_txLock_invalid(t *testing.T) { } func Test_BeginTx(t *testing.T) { - if !vfs.SupportsFileLocking { - t.Skip("skipping without locks") - } t.Parallel() + tmp := memdb.TestDB(t, url.Values{ + "_txlock": {"exclusive"}, + "_pragma": {"busy_timeout(0)"}, + }) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - db, err := sql.Open("sqlite3", "file:"+ - filepath.ToSlash(filepath.Join(t.TempDir(), "test.db"))+ - "?_txlock=exclusive&_pragma=busy_timeout(0)") + db, err := sql.Open("sqlite3", tmp) if err != nil { t.Fatal(err) } @@ -182,8 +188,9 @@ func Test_BeginTx(t *testing.T) { func Test_Prepare(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := sql.Open("sqlite3", ":memory:") + db, err := sql.Open("sqlite3", tmp) if err != nil { t.Fatal(err) } @@ -222,11 +229,12 @@ func Test_Prepare(t *testing.T) { func Test_QueryRow_named(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - db, err := sql.Open("sqlite3", ":memory:") + db, err := sql.Open("sqlite3", tmp) if err != nil { t.Fatal(err) } @@ -274,8 +282,9 @@ func Test_QueryRow_named(t *testing.T) { func Test_QueryRow_blob_null(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := sql.Open("sqlite3", ":memory:") + db, err := sql.Open("sqlite3", tmp) if err != nil { t.Fatal(err) } @@ -310,7 +319,11 @@ func Test_time(t *testing.T) { for _, fmt := range []string{"auto", "sqlite", "rfc3339", time.ANSIC} { t.Run(fmt, func(t *testing.T) { - db, err := sql.Open("sqlite3", "file::memory:?_timefmt="+url.QueryEscape(fmt)) + tmp := memdb.TestDB(t, url.Values{ + "_timefmt": {fmt}, + }) + + db, err := sql.Open("sqlite3", tmp) if err != nil { t.Fatal(err) } diff --git a/ext/array/array_test.go b/ext/array/array_test.go index 4b279ea..1c546ea 100644 --- a/ext/array/array_test.go +++ b/ext/array/array_test.go @@ -12,10 +12,11 @@ import ( _ "github.com/ncruces/go-sqlite3/embed" "github.com/ncruces/go-sqlite3/ext/array" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func Example_driver() { - db, err := driver.Open(":memory:", array.Register) + db, err := driver.Open("file:/test.db?vfs=memdb", array.Register) if err != nil { log.Fatal(err) } @@ -87,8 +88,9 @@ func Example() { func Test_cursor_Column(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", array.Register) + db, err := driver.Open(tmp, array.Register) if err != nil { t.Fatal(err) } diff --git a/ext/fileio/fileio_test.go b/ext/fileio/fileio_test.go index 9997137..30b8a20 100644 --- a/ext/fileio/fileio_test.go +++ b/ext/fileio/fileio_test.go @@ -12,12 +12,14 @@ import ( _ "github.com/ncruces/go-sqlite3/embed" "github.com/ncruces/go-sqlite3/ext/fileio" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func Test_lsmode(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", fileio.Register) + db, err := driver.Open(tmp, fileio.Register) if err != nil { t.Fatal(err) } @@ -51,7 +53,9 @@ func Test_readfile(t *testing.T) { for _, fsys := range []fs.FS{nil, os.DirFS(".")} { t.Run("", func(t *testing.T) { - db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error { + tmp := memdb.TestDB(t) + + db, err := driver.Open(tmp, func(c *sqlite3.Conn) error { fileio.RegisterFS(c, fsys) return nil }) diff --git a/ext/fileio/fsdir_test.go b/ext/fileio/fsdir_test.go index b9bedf3..127664c 100644 --- a/ext/fileio/fsdir_test.go +++ b/ext/fileio/fsdir_test.go @@ -13,6 +13,7 @@ import ( _ "github.com/ncruces/go-sqlite3/embed" "github.com/ncruces/go-sqlite3/ext/fileio" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func Test_fsdir(t *testing.T) { @@ -20,7 +21,9 @@ func Test_fsdir(t *testing.T) { for _, fsys := range []fs.FS{nil, os.DirFS(".")} { t.Run("", func(t *testing.T) { - db, err := driver.Open(":memory:", func(c *sqlite3.Conn) error { + tmp := memdb.TestDB(t) + + db, err := driver.Open(tmp, func(c *sqlite3.Conn) error { fileio.RegisterFS(c, fsys) return nil }) diff --git a/ext/fileio/write_test.go b/ext/fileio/write_test.go index d9ab80d..c5d74a4 100644 --- a/ext/fileio/write_test.go +++ b/ext/fileio/write_test.go @@ -10,12 +10,14 @@ import ( "github.com/ncruces/go-sqlite3/driver" _ "github.com/ncruces/go-sqlite3/embed" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func Test_writefile(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", Register) + db, err := driver.Open(tmp, Register) if err != nil { t.Fatal(err) } diff --git a/ext/hash/hash_test.go b/ext/hash/hash_test.go index 91aa756..cc274bb 100644 --- a/ext/hash/hash_test.go +++ b/ext/hash/hash_test.go @@ -10,6 +10,7 @@ import ( "github.com/ncruces/go-sqlite3/driver" _ "github.com/ncruces/go-sqlite3/embed" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" _ "golang.org/x/crypto/blake2b" _ "golang.org/x/crypto/blake2s" _ "golang.org/x/crypto/md4" @@ -19,6 +20,7 @@ import ( func TestRegister(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) tests := []struct { name string @@ -52,7 +54,7 @@ func TestRegister(t *testing.T) { {"blake2b('', 256)", "0E5751C026E543B2E8AB2EB06099DAA1D1E5DF47778F7787FAAB45CDF12FE3A8"}, } - db, err := driver.Open(":memory:", Register) + db, err := driver.Open(tmp, Register) if err != nil { t.Fatal(err) } diff --git a/ext/lines/lines_test.go b/ext/lines/lines_test.go index e99dc11..4cc42cf 100644 --- a/ext/lines/lines_test.go +++ b/ext/lines/lines_test.go @@ -15,10 +15,11 @@ import ( _ "github.com/ncruces/go-sqlite3/embed" "github.com/ncruces/go-sqlite3/ext/lines" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func Example() { - db, err := driver.Open(":memory:", lines.Register) + db, err := driver.Open("file:/test.db?vfs=memdb", lines.Register) if err != nil { log.Fatal(err) } @@ -66,8 +67,9 @@ func Example() { func Test_lines(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", lines.Register) + db, err := driver.Open(tmp, lines.Register) if err != nil { log.Fatal(err) } @@ -96,8 +98,9 @@ func Test_lines(t *testing.T) { func Test_lines_error(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", lines.Register) + db, err := driver.Open(tmp, lines.Register) if err != nil { log.Fatal(err) } @@ -120,8 +123,9 @@ func Test_lines_error(t *testing.T) { func Test_lines_read(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", lines.Register) + db, err := driver.Open(tmp, lines.Register) if err != nil { log.Fatal(err) } @@ -151,8 +155,9 @@ func Test_lines_read(t *testing.T) { func Test_lines_test(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", lines.Register) + db, err := driver.Open(tmp, lines.Register) if err != nil { log.Fatal(err) } diff --git a/ext/regexp/regexp_test.go b/ext/regexp/regexp_test.go index 3901458..1323205 100644 --- a/ext/regexp/regexp_test.go +++ b/ext/regexp/regexp_test.go @@ -6,12 +6,14 @@ import ( "github.com/ncruces/go-sqlite3/driver" _ "github.com/ncruces/go-sqlite3/embed" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func TestRegister(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", Register) + db, err := driver.Open(tmp, Register) if err != nil { t.Fatal(err) } @@ -45,8 +47,9 @@ func TestRegister(t *testing.T) { func TestRegister_errors(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", Register) + db, err := driver.Open(tmp, Register) if err != nil { t.Fatal(err) } diff --git a/ext/uuid/uuid_test.go b/ext/uuid/uuid_test.go index 4adcaa9..92e5e2a 100644 --- a/ext/uuid/uuid_test.go +++ b/ext/uuid/uuid_test.go @@ -7,12 +7,14 @@ import ( "github.com/ncruces/go-sqlite3/driver" _ "github.com/ncruces/go-sqlite3/embed" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func Test_generate(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", Register) + db, err := driver.Open(tmp, Register) if err != nil { t.Fatal(err) } @@ -130,8 +132,9 @@ func Test_generate(t *testing.T) { func Test_convert(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", Register) + db, err := driver.Open(tmp, Register) if err != nil { t.Fatal(err) } diff --git a/ext/zorder/zorder_test.go b/ext/zorder/zorder_test.go index 484ca4d..4dbad49 100644 --- a/ext/zorder/zorder_test.go +++ b/ext/zorder/zorder_test.go @@ -9,12 +9,14 @@ import ( _ "github.com/ncruces/go-sqlite3/embed" "github.com/ncruces/go-sqlite3/ext/zorder" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func TestRegister_zorder(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", zorder.Register) + db, err := driver.Open(tmp, zorder.Register) if err != nil { t.Fatal(err) } @@ -57,8 +59,9 @@ func TestRegister_zorder(t *testing.T) { func TestRegister_unzorder(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", zorder.Register) + db, err := driver.Open(tmp, zorder.Register) if err != nil { t.Fatal(err) } @@ -84,8 +87,9 @@ func TestRegister_unzorder(t *testing.T) { func TestRegister_error(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db, err := driver.Open(":memory:", zorder.Register) + db, err := driver.Open(tmp, zorder.Register) if err != nil { t.Fatal(err) } diff --git a/gormlite/sqlite_test.go b/gormlite/sqlite_test.go index db20292..b75466f 100644 --- a/gormlite/sqlite_test.go +++ b/gormlite/sqlite_test.go @@ -10,14 +10,14 @@ import ( "github.com/ncruces/go-sqlite3/driver" _ "github.com/ncruces/go-sqlite3/embed" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func TestDialector(t *testing.T) { - // This is the DSN of the in-memory SQLite database for these tests. - const InMemoryDSN = "file:testdatabase?mode=memory&cache=shared" + tmp := memdb.TestDB(t) // Custom connection with a custom function called "my_custom_function". - db, err := driver.Open(InMemoryDSN, func(conn *sqlite3.Conn) error { + db, err := driver.Open(tmp, func(conn *sqlite3.Conn) error { return conn.CreateFunction("my_custom_function", 0, sqlite3.DETERMINISTIC, func(ctx sqlite3.Context, arg ...sqlite3.Value) { ctx.ResultText("my-result") @@ -36,14 +36,14 @@ func TestDialector(t *testing.T) { }{ { description: "Default driver", - dialector: Open(InMemoryDSN), + dialector: Open(tmp), openSuccess: true, query: "SELECT 1", querySuccess: true, }, { description: "Custom function", - dialector: Open(InMemoryDSN), + dialector: Open(tmp), openSuccess: true, query: "SELECT my_custom_function()", querySuccess: false, diff --git a/json_test.go b/json_test.go index 8ff089c..094a210 100644 --- a/json_test.go +++ b/json_test.go @@ -6,11 +6,10 @@ import ( "github.com/ncruces/go-sqlite3" _ "github.com/ncruces/go-sqlite3/embed" - _ "github.com/ncruces/go-sqlite3/vfs/memdb" ) func Example_json() { - db, err := sqlite3.Open("file:/test.db?vfs=memdb") + db, err := sqlite3.Open(":memory:") if err != nil { log.Fatal(err) } diff --git a/tests/bradfitz/sql_test.go b/tests/bradfitz/sql_test.go index f700355..bc86b0f 100644 --- a/tests/bradfitz/sql_test.go +++ b/tests/bradfitz/sql_test.go @@ -45,7 +45,7 @@ func (t params) mustExec(sql string, args ...interface{}) sql.Result { func (sqliteDB) RunTest(t *testing.T, fn func(params)) { db, err := sql.Open("sqlite3", "file:"+ - filepath.Join(t.TempDir(), "foo.db")+ + filepath.ToSlash(filepath.Join(t.TempDir(), "foo.db"))+ "?_pragma=busy_timeout(10000)&_pragma=synchronous(off)") if err != nil { t.Fatalf("foo.db open fail: %v", err) diff --git a/tests/conn_test.go b/tests/conn_test.go index bf65829..d4e20bd 100644 --- a/tests/conn_test.go +++ b/tests/conn_test.go @@ -4,6 +4,7 @@ import ( "context" "errors" "math" + "net/url" "os" "path/filepath" "strings" @@ -13,6 +14,7 @@ import ( _ "github.com/ncruces/go-sqlite3/embed" _ "github.com/ncruces/go-sqlite3/internal/testcfg" "github.com/ncruces/go-sqlite3/vfs" + "github.com/ncruces/go-sqlite3/vfs/memdb" _ "github.com/ncruces/go-sqlite3/vfs/memdb" ) @@ -727,8 +729,11 @@ func TestConn_DBName(t *testing.T) { func TestConn_AutoVacuumPages(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t, url.Values{ + "_pragma": {"auto_vacuum(full)"}, + }) - db, err := sqlite3.Open("file:test.db?vfs=memdb&_pragma=auto_vacuum(full)") + db, err := sqlite3.Open(tmp) if err != nil { t.Fatal(err) } diff --git a/tests/db_test.go b/tests/db_test.go index 00fb3ad..00a0f93 100644 --- a/tests/db_test.go +++ b/tests/db_test.go @@ -12,6 +12,7 @@ import ( _ "github.com/ncruces/go-sqlite3/internal/testcfg" "github.com/ncruces/go-sqlite3/vfs" _ "github.com/ncruces/go-sqlite3/vfs/adiantum" + "github.com/ncruces/go-sqlite3/vfs/memdb" _ "github.com/ncruces/go-sqlite3/vfs/memdb" ) @@ -65,7 +66,7 @@ func TestDB_utf16(t *testing.T) { func TestDB_memdb(t *testing.T) { t.Parallel() - testDB(t, "file:test.db?vfs=memdb") + testDB(t, memdb.TestDB(t)) } func TestDB_adiantum(t *testing.T) { diff --git a/tests/driver_test.go b/tests/driver_test.go index f6a4f09..777159f 100644 --- a/tests/driver_test.go +++ b/tests/driver_test.go @@ -8,15 +8,17 @@ import ( "github.com/ncruces/go-sqlite3/driver" _ "github.com/ncruces/go-sqlite3/embed" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func TestDriver(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - db, err := driver.Open(":memory:", nil, func(c *sqlite3.Conn) error { + db, err := driver.Open(tmp, nil, func(c *sqlite3.Conn) error { return c.Exec(`PRAGMA optimize`) }) if err != nil { diff --git a/tests/json_test.go b/tests/json_test.go index d8328d7..d631905 100644 --- a/tests/json_test.go +++ b/tests/json_test.go @@ -11,16 +11,18 @@ import ( "github.com/ncruces/go-sqlite3/driver" _ "github.com/ncruces/go-sqlite3/embed" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" "github.com/ncruces/julianday" ) func TestJSON(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - db, err := driver.Open(":memory:") + db, err := driver.Open(tmp) if err != nil { t.Fatal(err) } diff --git a/tests/parallel/parallel_test.go b/tests/parallel/parallel_test.go index aa5aa32..d19565f 100644 --- a/tests/parallel/parallel_test.go +++ b/tests/parallel/parallel_test.go @@ -2,6 +2,7 @@ package tests import ( "io" + "net/url" "os" "os/exec" "path/filepath" @@ -31,7 +32,7 @@ func Test_parallel(t *testing.T) { } name := "file:" + - filepath.Join(t.TempDir(), "test.db") + + filepath.ToSlash(filepath.Join(t.TempDir(), "test.db")) + "?_pragma=busy_timeout(10000)" + "&_pragma=journal_mode(truncate)" + "&_pragma=synchronous(off)" @@ -45,7 +46,7 @@ func Test_wal(t *testing.T) { } name := "file:" + - filepath.Join(t.TempDir(), "test.db") + + filepath.ToSlash(filepath.Join(t.TempDir(), "test.db")) + "?_pragma=busy_timeout(10000)" + "&_pragma=journal_mode(wal)" + "&_pragma=synchronous(off)" @@ -61,8 +62,9 @@ func Test_memdb(t *testing.T) { iter = 5000 } - memdb.Create("test.db", nil) - name := "file:/test.db?vfs=memdb" + name := memdb.TestDB(t, url.Values{ + "_pragma": {"busy_timeout(10000)"}, + }) testParallel(t, name, iter) testIntegrity(t, name) } @@ -82,7 +84,10 @@ func Test_adiantum(t *testing.T) { name := "file:" + filepath.ToSlash(filepath.Join(t.TempDir(), "test.db")) + "?vfs=adiantum" + - "&_pragma=hexkey(e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855)" + "&_pragma=hexkey(e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855)" + + "&_pragma=busy_timeout(10000)" + + "&_pragma=journal_mode(truncate)" + + "&_pragma=synchronous(off)" testParallel(t, name, iter) testIntegrity(t, name) } @@ -98,7 +103,7 @@ func TestMultiProcess(t *testing.T) { file := filepath.Join(t.TempDir(), "test.db") t.Setenv("TestMultiProcess_dbfile", file) - name := "file:" + file + + name := "file:" + filepath.ToSlash(file) + "?_pragma=busy_timeout(10000)" + "&_pragma=journal_mode(truncate)" + "&_pragma=synchronous(off)" @@ -133,7 +138,7 @@ func TestChildProcess(t *testing.T) { t.SkipNow() } - name := "file:" + file + + name := "file:" + filepath.ToSlash(file) + "?_pragma=busy_timeout(10000)" + "&_pragma=journal_mode(truncate)" + "&_pragma=synchronous(off)" @@ -177,8 +182,9 @@ func Benchmark_memdb(b *testing.B) { sqlite3.Initialize() b.ResetTimer() - memdb.Create("test.db", nil) - name := "file:/test.db?vfs=memdb" + name := memdb.TestDB(b, url.Values{ + "_pragma": {"busy_timeout(10000)"}, + }) testParallel(b, name, b.N) } @@ -218,11 +224,6 @@ func testParallel(t testing.TB, name string, n int) { } defer db.Close() - err = db.BusyTimeout(10 * time.Second) - if err != nil { - return err - } - stmt, _, err := db.Prepare(`SELECT id, name FROM users`) if err != nil { return err diff --git a/tests/time_test.go b/tests/time_test.go index 529355a..2482ec6 100644 --- a/tests/time_test.go +++ b/tests/time_test.go @@ -11,6 +11,7 @@ import ( "github.com/ncruces/go-sqlite3/driver" _ "github.com/ncruces/go-sqlite3/embed" _ "github.com/ncruces/go-sqlite3/internal/testcfg" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func TestTimeFormat_Encode(t *testing.T) { @@ -132,11 +133,12 @@ func TestTimeFormat_Decode(t *testing.T) { func TestTimeFormat_Scanner(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) ctx, cancel := context.WithCancel(context.Background()) defer cancel() - db, err := driver.Open(":memory:") + db, err := driver.Open(tmp) if err != nil { t.Fatal(err) } diff --git a/tests/txn_test.go b/tests/txn_test.go index a56abe1..7728724 100644 --- a/tests/txn_test.go +++ b/tests/txn_test.go @@ -8,7 +8,7 @@ import ( "github.com/ncruces/go-sqlite3" _ "github.com/ncruces/go-sqlite3/embed" _ "github.com/ncruces/go-sqlite3/internal/testcfg" - _ "github.com/ncruces/go-sqlite3/vfs/memdb" + "github.com/ncruces/go-sqlite3/vfs/memdb" ) func TestConn_Transaction_exec(t *testing.T) { @@ -254,14 +254,15 @@ func TestConn_Transaction_interrupted(t *testing.T) { func TestConn_Transaction_busy(t *testing.T) { t.Parallel() + tmp := memdb.TestDB(t) - db1, err := sqlite3.Open("file:/test.db?vfs=memdb") + db1, err := sqlite3.Open(tmp) if err != nil { t.Fatal(err) } defer db1.Close() - db2, err := sqlite3.Open("file:/test.db?vfs=memdb&_pragma=busy_timeout(10000)") + db2, err := sqlite3.Open(tmp + "&_pragma=busy_timeout(10000)") if err != nil { t.Fatal(err) } diff --git a/vfs/memdb/api.go b/vfs/memdb/api.go index 5a2b84c..78fc351 100644 --- a/vfs/memdb/api.go +++ b/vfs/memdb/api.go @@ -10,7 +10,10 @@ package memdb import ( + "fmt" + "net/url" "sync" + "testing" "github.com/ncruces/go-sqlite3/vfs" ) @@ -66,3 +69,30 @@ func Delete(name string) { defer memoryMtx.Unlock() delete(memoryDBs, name) } + +// TestDB creates an empty shared memory database for the test to use. +// The database is automatically deleted when the test and all its subtests complete. +// Each subsequent call to TestDB returns a unique database. +func TestDB(tb testing.TB, params ...url.Values) string { + tb.Helper() + + name := fmt.Sprintf("%s_%p", tb.Name(), tb) + tb.Cleanup(func() { Delete(name) }) + Create(name, nil) + + p := url.Values{"vfs": {"memdb"}} + for _, v := range params { + for k, v := range v { + for _, v := range v { + p.Add(k, v) + } + } + } + + return (&url.URL{ + Scheme: "file", + OmitHost: true, + Path: "/" + name, + RawQuery: p.Encode(), + }).String() +}