Files
Chronos/tests/Titano.Data.Tests/Sqlite/SqliteBindingTests.cs
T
Claude 304ddf643d fix(data): never block the caller's thread and never lose a SQLite cancel
SQLite steps ran synchronously on the calling thread, so a repository
awaited on the WPF UI thread would freeze the window for the length of
the query. Blocking calls now continue on the thread pool.

A cancel that landed before sqlite3_step started the statement was lost
(SQLite clears the interrupt when no statement is running) and the query
ran to completion. Each connection now has a cancel flag polled by a
progress handler; it is cleared outside every interruptible operation so
a stale cancel cannot stop a later statement.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-02 11:04:21 +00:00

199 lines
9.7 KiB
C#

using Titano.Data.Sqlite;
using Titano.Data.Tests.Infrastructure;
using Titano.Testing;
namespace Titano.Data.Tests.Sqlite;
public sealed class SqliteBindingTests(TestContext context) : DatabaseTest(context)
{
protected override Backend Backend => Backend.SqliteFile;
[Test]
public void SystemLibraryIsRecentEnough()
{
var parts = SqliteDatabase.LibraryVersion.Split('.').Select(int.Parse).ToArray();
Assert.True(parts[0] > 3 || (parts[0] == 3 && parts[1] >= 31), $"SQLite {SqliteDatabase.LibraryVersion}");
}
[Test]
public async Task ConnectionsUseTheBriefPragmas()
{
await using var session = await (await OpenDatabaseAsync()).OpenAsync(Ct);
Assert.Equal("wal", await session.ScalarAsync<string>("PRAGMA journal_mode", [], Ct));
Assert.Equal(1L, await session.ScalarAsync<long>("PRAGMA synchronous", [], Ct));
Assert.Equal(1L, await session.ScalarAsync<long>("PRAGMA foreign_keys", [], Ct));
Assert.Equal(2L, await session.ScalarAsync<long>("PRAGMA temp_store", [], Ct));
Assert.Equal(-65536L, await session.ScalarAsync<long>("PRAGMA cache_size", [], Ct));
Assert.Equal(268435456L, await session.ScalarAsync<long>("PRAGMA mmap_size", [], Ct));
}
[Test]
public async Task CallsFromAUiThreadReturnBeforeTheStatementRuns()
{
await using var session = await (await OpenDatabaseAsync()).OpenAsync(Ct);
using var cts = CancellationTokenSource.CreateLinkedTokenSource(Ct);
Task? query = null;
var ui = new Thread(() =>
{
// A UI thread: has a synchronization context and is not a pool thread.
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
query = session.ExecuteAsync(
"WITH RECURSIVE r(n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM r WHERE n < 2000000000) SELECT count(*) FROM r", [], cts.Token);
});
ui.Start();
Assert.True(ui.Join(TimeSpan.FromSeconds(5)), "the calling thread was blocked by the statement");
Assert.False(query!.IsCompleted);
await cts.CancelAsync();
await Assert.ThrowsAsync<OperationCanceledException>(() => query);
}
[Test]
public async Task RejectsScriptsAndWrongParameterCounts()
{
await using var session = await (await OpenDatabaseAsync()).OpenAsync(Ct);
await Assert.ThrowsAsync<ArgumentException>(() => session.ExecuteAsync("SELECT 1; SELECT 2", [], Ct));
await Assert.ThrowsAsync<ArgumentException>(() => session.ExecuteAsync("SELECT $1, $2", [1], Ct));
Assert.Equal(1, await session.ScalarAsync<int>("SELECT 1 -- trailing comment", [], Ct));
var error = await Assert.ThrowsAsync<SqliteException>(() => session.ExecuteAsync("SELEC 1", [], Ct));
Assert.Equal(1, error.ResultCode);
}
[Test]
public async Task WritersFromManySessionsAreSerialised()
{
var database = await OpenDatabaseAsync(multiConnection: true);
await using (var setup = await database.OpenAsync(Ct))
await setup.ExecuteScriptAsync("CREATE TABLE counter (id INTEGER PRIMARY KEY, n INTEGER NOT NULL); INSERT INTO counter VALUES (1, 0)", Ct);
await Task.WhenAll(Enumerable.Range(0, 8).Select(_ => Task.Run(async () =>
{
for (var i = 0; i < 25; i++)
{
await using var session = await database.OpenAsync(Ct);
await using var tx = await session.BeginAsync(Ct);
var n = await session.ScalarAsync<long>("SELECT n FROM counter WHERE id = 1", [], Ct);
await session.ExecuteAsync("UPDATE counter SET n = $1 WHERE id = 1", [n + 1], Ct);
await tx.CommitAsync(Ct);
}
})));
await using var check = await database.OpenAsync(Ct);
Assert.Equal(200L, await check.ScalarAsync<long>("SELECT n FROM counter", [], Ct));
}
[Test]
public async Task ReadersSeeTheLastCommitWhileAWriterIsOpen()
{
var database = await OpenDatabaseAsync(multiConnection: true);
await using var writer = await database.OpenAsync(Ct);
await writer.ExecuteScriptAsync("CREATE TABLE r (id INTEGER PRIMARY KEY); INSERT INTO r VALUES (1)", Ct);
await using var tx = await writer.BeginAsync(Ct);
await writer.ExecuteAsync("INSERT INTO r VALUES ($1)", [2], Ct);
await using var reader = await database.OpenAsync(Ct);
Assert.Equal(1L, await reader.ScalarAsync<long>("SELECT count(*) FROM r", [], Ct));
await tx.CommitAsync(Ct);
Assert.Equal(2L, await reader.ScalarAsync<long>("SELECT count(*) FROM r", [], Ct));
}
[Test]
public async Task SameStatementCanRunNestedOnOneSession()
{
await using var session = await (await OpenDatabaseAsync()).OpenAsync(Ct);
await session.ExecuteScriptAsync("CREATE TABLE r (id INTEGER PRIMARY KEY); INSERT INTO r VALUES (1); INSERT INTO r VALUES (2)", Ct);
var pairs = 0;
await foreach (var outer in session.QueryAsync("SELECT id FROM r ORDER BY id", [], Ct))
{
await foreach (var inner in session.QueryAsync("SELECT id FROM r ORDER BY id", [], Ct))
{
pairs++;
Assert.True(inner.GetInt32(0) is 1 or 2 && outer.GetInt32(0) is 1 or 2);
}
}
Assert.Equal(4, pairs);
}
[Test]
public async Task BackupKeepsTheThreeNewestAndRestoreBringsDataBack()
{
var path = Path.Combine(Context.CreateTempDirectory(), "titano.db");
var backups = Context.CreateTempDirectory();
var database = (SqliteDatabase)Own(DatabaseFactory.Open(DatabaseOptions.Sqlite(path)));
await using (var session = await database.OpenAsync(Ct))
await session.ExecuteScriptAsync("CREATE TABLE b (id INTEGER PRIMARY KEY, v TEXT); INSERT INTO b VALUES (1, 'original')", Ct);
var first = await database.BackupAsync(backups, cancellationToken: Ct);
Assert.FileExists(first);
for (var i = 0; i < 4; i++) await database.BackupAsync(backups, cancellationToken: Ct);
var kept = Directory.GetFiles(backups).OrderBy(f => f, StringComparer.Ordinal).ToList();
Assert.Equal(3, kept.Count);
Assert.DoesNotContain(first, kept);
await using (var session = await database.OpenAsync(Ct))
await session.ExecuteAsync("UPDATE b SET v = $1", ["changed"], Ct);
await database.RestoreAsync(kept[^1], Ct);
await using (var session = await database.OpenAsync(Ct))
Assert.Equal("original", await session.ScalarAsync<string>("SELECT v FROM b WHERE id = 1", [], Ct));
}
[Test]
public async Task RestoreWaitsForSessionsThatStillWrite()
{
var path = Path.Combine(Context.CreateTempDirectory(), "titano.db");
var database = (SqliteDatabase)Own(DatabaseFactory.Open(DatabaseOptions.Sqlite(path)));
await using (var setup = await database.OpenAsync(Ct))
await setup.ExecuteScriptAsync("CREATE TABLE b (id INTEGER PRIMARY KEY)", Ct);
var backup = await database.BackupAsync(Context.CreateTempDirectory(), cancellationToken: Ct);
var session = await database.OpenAsync(Ct);
var restore = database.RestoreAsync(backup, Ct);
await Task.Delay(100, Ct);
Assert.False(restore.IsCompleted, "restore must wait for the open session");
// The session can still take the write lock while the restore waits for its pool slot.
await session.ExecuteAsync("INSERT INTO b VALUES ($1)", [1], Ct);
await using (var tx = await session.BeginAsync(Ct)) await tx.CommitAsync(Ct);
await session.DisposeAsync();
await restore.WaitAsync(TimeSpan.FromSeconds(10), Ct);
await using var check = await database.OpenAsync(Ct);
Assert.Equal(0L, await check.ScalarAsync<long>("SELECT count(*) FROM b", [], Ct));
}
[Test]
public async Task RestoreRefusesAFileThatIsNotADatabase()
{
var database = (SqliteDatabase)await OpenDatabaseAsync();
var bogus = Path.Combine(Context.CreateTempDirectory(), "bogus.db");
await File.WriteAllTextAsync(bogus, "not a database, just text that is long enough to have a header", Ct);
await Assert.ThrowsAsync<InvalidDataException>(() => database.RestoreAsync(bogus, Ct));
await using var session = await database.OpenAsync(Ct);
Assert.Equal(1, await session.ScalarAsync<int>("SELECT 1", [], Ct));
}
[Test]
public async Task InMemoryDatabasesAreIsolated()
{
var a = Own(DatabaseFactory.Open(DatabaseOptions.SqliteInMemory()));
var b = Own(DatabaseFactory.Open(DatabaseOptions.SqliteInMemory()));
await using (var s = await a.OpenAsync(Ct)) await s.ExecuteScriptAsync("CREATE TABLE only_a (id INTEGER)", Ct);
await using var sb = await b.OpenAsync(Ct);
Assert.Equal(0L, await sb.ScalarAsync<long>("SELECT count(*) FROM sqlite_master WHERE name = 'only_a'", [], Ct));
await Assert.ThrowsAsync<NotSupportedException>(() => ((SqliteDatabase)a).RestoreAsync("x.db", Ct));
}
}
public sealed class SqliteSqlTextTests
{
[Theory]
[Case("SELECT $1", "SELECT ?1")]
[Case("SELECT $2, $1, $12", "SELECT ?2, ?1, ?12")]
[Case("SELECT '$1', \"$2\", [$3], `$4` FROM t WHERE a = $5", "SELECT '$1', \"$2\", [$3], `$4` FROM t WHERE a = ?5")]
[Case("SELECT 'it''s $1' || $1", "SELECT 'it''s $1' || ?1")]
[Case("SELECT $1 -- $2\n, $3 /* $4 */", "SELECT ?1 -- $2\n, ?3 /* $4 */")]
[Case("SELECT a$1 FROM t", "SELECT a$1 FROM t")]
[Case("SELECT 'unterminated $1", "SELECT 'unterminated $1")]
public void TranslatesPlaceholdersOutsideLiterals(string sql, string expected) =>
Assert.Equal(expected, SqliteSqlText.TranslatePlaceholders(sql));
}