package db import ( "context" "errors" "path/filepath" "testing" "time" "github.com/jmoiron/sqlx" ) func newTaskLockTestDB(t *testing.T) *sqlx.DB { t.Helper() conn, err := OpenSQLite(filepath.Join(t.TempDir(), "tasklock.db")) if err != nil { t.Fatalf("open sqlite: %v", err) } sqlxDB := sqlx.NewDb(conn, "sqlite3") t.Cleanup(func() { _ = sqlxDB.Close() }) if _, err := sqlxDB.Exec(`CREATE TABLE tasks (id TEXT PRIMARY KEY, updated_at TIMESTAMP)`); err != nil { t.Fatalf("create tasks table: %v", err) } return sqlxDB } func TestLockTaskRowInTx_SQLiteNoOpSucceedsRegardlessOfExistence(t *testing.T) { sqlxDB := newTaskLockTestDB(t) ctx := context.Background() tx, err := sqlxDB.BeginTxx(ctx, nil) if err != nil { t.Fatalf("begin tx: %v", err) } defer func() { _ = tx.Rollback() }() // SQLite branch is a deliberate no-op: it must not fail even for a task // row that does not exist, because the guarantee it provides on SQLite // comes from the single-connection writer pool, not from this query. if err := LockTaskRowInTx(ctx, tx, "sqlite3", "does-not-exist"); err != nil { t.Fatalf("LockTaskRowInTx (sqlite no-op) = %v, want nil", err) } } func TestLockTaskRowInTx_SQLiteSerializesViaSingleWriterConnection(t *testing.T) { sqlxDB := newTaskLockTestDB(t) ctx := context.Background() if _, err := sqlxDB.Exec(`INSERT INTO tasks (id, updated_at) VALUES ('task-1', ?)`, time.Now().UTC()); err != nil { t.Fatalf("seed task: %v", err) } tx1, err := sqlxDB.BeginTxx(ctx, nil) if err != nil { t.Fatalf("begin tx1: %v", err) } if err := LockTaskRowInTx(ctx, tx1, "sqlite3", "task-1"); err != nil { t.Fatalf("LockTaskRowInTx tx1: %v", err) } // A second writer attempt against the same (MaxOpenConns=1) handle must // block until tx1 releases the single connection — proving the // serialization the design doc attributes to the writer pool rather // than to this function's SQLite branch. done := make(chan error, 1) go func() { _, execErr := sqlxDB.ExecContext(ctx, `UPDATE tasks SET updated_at = ? WHERE id = 'task-1'`, time.Now().UTC()) done <- execErr }() select { case <-done: t.Fatal("second writer completed before the first transaction committed") case <-time.After(100 * time.Millisecond): // Expected: still blocked on the single connection. } if err := tx1.Commit(); err != nil { t.Fatalf("commit tx1: %v", err) } select { case execErr := <-done: if execErr != nil { t.Fatalf("second writer error = %v, want nil", execErr) } case <-time.After(2 * time.Second): t.Fatal("second writer never completed after tx1 committed") } } func TestLockTaskRowInTx_PostgresBranchQueriesForUpdate(t *testing.T) { // The Postgres branch is exercised end-to-end by the environment-gated // Postgres suites in task/repository/sqlite (e.g. // TestTaskCleanupBarrierPostgres_*), which share this helper via // lockTaskRowInTx. This unit test only pins that a non-Postgres driver // name takes the no-op path and a Postgres driver name does not, // without requiring a live Postgres connection. sqlxDB := newTaskLockTestDB(t) ctx := context.Background() tx, err := sqlxDB.BeginTxx(ctx, nil) if err != nil { t.Fatalf("begin tx: %v", err) } defer func() { _ = tx.Rollback() }() // Against a SQLite connection there is no "tasks" table shaped for a // pgx driver name to match query syntax, so asserting the pgx branch // is attempted (and fails, since this isn't really Postgres) is enough // to prove the dialect branch is live rather than silently skipped. err = LockTaskRowInTx(ctx, tx, "pgx", "task-1") if err == nil { t.Fatal("LockTaskRowInTx with pgx driver name against a non-Postgres connection = nil error, want a query error (FOR UPDATE is not valid SQLite syntax)") } if errors.Is(err, ErrTaskRowNotFound) { t.Fatalf("error = %v, want a syntax/execution error, not ErrTaskRowNotFound", err) } }