Keep each test database when the pool replaces its connection (closes #209)

SQLite deletes a shared in-memory database when its last connection
closes. A query cancelled while it runs makes the pool close its
connection, so a test could lose all its tables and rows at random.

NewTestDatabaseURL in internal/db returns the URL of a new in-memory
database with a random name. It holds one connection to it open until
the test ends. The db, handlers, ircserver, server and service tests
now take their database URL from it.

A new test cancels a query on such a database, checks with a TEMP
table that the connection was replaced, and checks that a row is
still there.

Model: opus-5-5

internal/db/db_test.go

@@ -155,6 +155,52 @@ func TestForeignKeysOnAfterCancelledQuery(t *testing.T) {
 	}
 }
 
+// TestNewTestDatabaseURLKeepsDataAfterCancelledQuery cancels a query
+// on a test database while it runs, which makes the pool close its
+// only connection and open a new one. A TEMP table lasts only as long
+// as its connection, so its absence shows the connection was replaced.
+// The database must still have its tables and rows.
+func TestNewTestDatabaseURLKeepsDataAfterCancelledQuery(t *testing.T) {
+	t.Parallel()
+
+	database, err := startDatabase(t, db.NewTestDatabaseURL(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = database.GetOrCreateChannel(t.Context(), "#test")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = database.GetDB().ExecContext(
+		t.Context(), "CREATE TEMP TABLE first_connection (x)",
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, cancel := context.WithTimeout(t.Context(), endlessQueryTimeout)
+	defer cancel()
+
+	_, err = database.GetDB().ExecContext(ctx, endlessQuery)
+	if !errors.Is(err, context.DeadlineExceeded) {
+		t.Fatalf("endless query: err = %v", err)
+	}
+
+	tempTables := queryInt(
+		t, database, "SELECT COUNT(*) FROM sqlite_temp_schema",
+	)
+	if tempTables != 0 {
+		t.Fatal("the pool kept its first connection")
+	}
+
+	channels := queryInt(t, database, "SELECT COUNT(*) FROM channels")
+	if channels != 1 {
+		t.Errorf("channels = %d, want 1", channels)
+	}
+}
+
 // TestDBURLSettingForeignKeysFailsStartup checks that the database
 // refuses to start when DBURL sets foreign_keys itself, however it
 // is spelled.

internal/db/export_test.go

@@ -5,21 +5,14 @@ import (
 	"database/sql"
 	"fmt"
 	"log/slog"
-	"sync/atomic"
+	"testing"
 )
 
-//nolint:gochecknoglobals // test counter
-var testDBCounter atomic.Int64
-
 // NewTestDatabase creates an in-memory database for testing.
-func NewTestDatabase() (*Database, error) {
+func NewTestDatabase(tb testing.TB) (*Database, error) {
-	counter := testDBCounter.Add(1)
+	tb.Helper()
 
-	dsn := fmt.Sprintf(
+	dsn := NewTestDatabaseURL(tb) + "&_pragma=foreign_keys(1)"
-		"file:testdb%d?mode=memory"+
-			"&cache=shared&_pragma=foreign_keys(1)",
-		counter,
-	)
 
 	conn, err := sql.Open("sqlite", dsn)
 	if err != nil {

internal/db/queries_test.go

@@ -13,7 +13,7 @@ import (
 func setupTestDB(t *testing.T) *db.Database {
 	t.Helper()
 
-	database, err := db.NewTestDatabase()
+	database, err := db.NewTestDatabase(t)
 	if err != nil {
 		t.Fatal(err)
 	}

internal/db/testing.go

@@ -2,10 +2,40 @@ package db
 
 import (
 	"context"
+	"crypto/rand"
 	"database/sql"
 	"log/slog"
+	"testing"
 )
 
+// NewTestDatabaseURL returns the URL of a new, empty in-memory
+// database for one test. SQLite deletes an in-memory database when
+// its last connection closes. A pool closes a connection when a query
+// on it is cancelled while it runs. So this function holds a
+// connection of its own open until the test ends.
+func NewTestDatabaseURL(tb testing.TB) string {
+	tb.Helper()
+
+	// A random name, so that no other test can share the database.
+	dbURL := "file:" + rand.Text() + "?mode=memory&cache=shared"
+
+	pool, err := sql.Open("sqlite", dbURL)
+	if err != nil {
+		tb.Fatalf("open test database: %v", err)
+	}
+
+	tb.Cleanup(func() { _ = pool.Close() })
+
+	conn, err := pool.Conn(tb.Context())
+	if err != nil {
+		tb.Fatalf("connect to test database: %v", err)
+	}
+
+	tb.Cleanup(func() { _ = conn.Close() })
+
+	return dbURL
+}
+
 // NewTestDatabaseFromConn creates a Database wrapping an
 // existing *sql.DB connection.  Intended for integration
 // tests in other packages.

internal/handlers/api_test.go

@@ -3,7 +3,6 @@ package handlers_test
 import (
 	"bytes"
 	"context"
-	"crypto/rand"
 	"database/sql"
 	"encoding/json"
 	"errors"
@@ -164,13 +163,7 @@ func newTestServerWith(
 	viperMu.Lock()
 	defer viperMu.Unlock()
 
-	// A random name, so that no other test can share it, not
+	dbURL := db.NewTestDatabaseURL(t)
-	// even one that has finished but still holds its database
-	// open.
-	dbURL := fmt.Sprintf(
-		"file:%s?mode=memory&cache=shared",
-		rand.Text(),
-	)
 	copyTemplateDB(t, dbURL)
 
 	var (

internal/ircserver/server_test.go

@@ -3,7 +3,6 @@ package ircserver_test
 import (
 	"bufio"
 	"context"
-	"crypto/rand"
 	"database/sql"
 	"errors"
 	"fmt"
@@ -107,14 +106,7 @@ func newTestEnvWithResolver(
 ) *testEnv {
 	t.Helper()
 
-	// A random name, so that no other test environment, not
+	conn, err := sql.Open("sqlite", db.NewTestDatabaseURL(t))
-	// even an earlier run of the same test, can share it.
-	dsn := fmt.Sprintf(
-		"file:%s?mode=memory&cache=shared",
-		rand.Text(),
-	)
-
-	conn, err := sql.Open("sqlite", dsn)
 	if err != nil {
 		t.Fatalf("open db: %v", err)
 	}

internal/server/server_test.go

@@ -5,7 +5,6 @@
 package server_test
 
 import (
-	"crypto/rand"
 	"fmt"
 	"net"
 	"net/http"
@@ -241,10 +240,7 @@ func newApp(
 			stats.New,
 		),
 		fx.Decorate(func(cfg *config.Config) *config.Config {
-			// A random name, so that no other test can share it.
+			cfg.DBURL = db.NewTestDatabaseURL(t)
-			cfg.DBURL = fmt.Sprintf(
-				"file:%s?mode=memory&cache=shared", rand.Text(),
-			)
 			cfg.Port = port
 
 			return cfg

internal/service/service_test.go

@@ -6,7 +6,6 @@ package service_test
 
 import (
 	"context"
-	"crypto/rand"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -46,13 +45,7 @@ type testEnv struct {
 func newTestEnv(t *testing.T) *testEnv {
 	t.Helper()
 
-	// A random name, so that no other test can share it, not
+	dbURL := db.NewTestDatabaseURL(t)
-	// even one that has finished but still holds its database
-	// open.
-	dbURL := fmt.Sprintf(
-		"file:%s?mode=memory&cache=shared",
-		rand.Text(),
-	)
 
 	var (
 		database *db.Database