Added further CrudTests. Ensuring read connection is closed, clearing db connection from pool.

Author: Chriztiaan

PowerSync/PowerSync.Common/DB/Crud/CrudEntry.cs

@@ -30,7 +30,7 @@ public class CrudEntryJSON
 public class CrudEntryDataJSON
 {
     [JsonProperty("data")]
-    public Dictionary<string, object> Data { get; set; } = new();
+    public Dictionary<string, object>? Data { get; set; }
 
     [JsonProperty("op")]
     public UpdateType Op { get; set; }
@@ -87,8 +87,6 @@ public static CrudEntry FromRow(CrudEntryJSON dbRow)
         );
     }
 
-
-
     public override bool Equals(object? obj)
     {
         if (obj is not CrudEntry other) return false;

PowerSync/PowerSync.Common/MDSQLite/MDSQLiteAdapter.cs

@@ -32,8 +32,8 @@ public class MDSQLiteAdapter : EventStream<DBAdapterEvent>, IDBAdapter
     protected RequiredMDSQLiteOptions resolvedMDSQLiteOptions;
     private CancellationTokenSource? tablesUpdatedCts;
 
-    private static readonly AsyncLock writeMutex = new();
-    private static readonly AsyncLock readMutex = new();
+    private readonly AsyncLock writeMutex = new();
+    private readonly AsyncLock readMutex = new();
 
     public MDSQLiteAdapter(MDSQLiteAdapterOptions options)
     {
@@ -143,6 +143,7 @@ private void LoadExtension(SqliteConnection db)
         tablesUpdatedCts?.Cancel();
         base.Close();
         writeConnection?.Close();
+        readConnection?.Close();
     }
 
     public async Task<NonQueryResult> Execute(string query, object[]? parameters = null)

PowerSync/PowerSync.Common/MDSQLite/MDSQLiteConnection.cs

@@ -213,6 +213,8 @@ public async Task<T> Get<T>(string sql, object[]? parameters = null)
     {
         base.Close();
         Db.Close();
+        // https://stackoverflow.com/questions/8511901/system-data-sqlite-close-not-releasing-database-file
+        SqliteConnection.ClearPool(Db);
     }
 
     public async Task RefreshSchema()

Tests/PowerSync/PowerSync.Common.Tests/Client/Sync/CRUDTests.cs

@@ -1,20 +1,25 @@
-namespace PowerSync.Common.Tests.Client;
+namespace PowerSync.Common.Tests.Client.Sync;
+
+using Microsoft.Data.Sqlite;
 
-using System.Diagnostics;
 using Newtonsoft.Json;
+
 using PowerSync.Common.Client;
-using PowerSync.Common.Client.Sync.Bucket;
 using PowerSync.Common.DB.Crud;
+using PowerSync.Common.DB.Schema;
+using PowerSync.Common.Tests.Utils;
 
 public class CRUDTests : IAsyncLifetime
 {
     private PowerSyncDatabase db = default!;
+    private readonly string testId = Guid.NewGuid().ToString();
+    private readonly string dbName = "crud-test.db";
 
     public async Task InitializeAsync()
     {
         db = new PowerSyncDatabase(new PowerSyncDatabaseOptions
         {
-            Database = new SQLOpenOptions { DbFilename = "crudtest12xas.db" },
+            Database = new SQLOpenOptions { DbFilename = dbName },
             Schema = TestSchema.appSchema,
         });
         await db.Init();
@@ -24,13 +29,12 @@ public async Task DisposeAsync()
     {
         await db.DisconnectAndClear();
         await db.Close();
+        DatabaseUtils.CleanDb(dbName);
     }
 
-    [Fact(Skip = "Need to delete db file")]
-    public async Task Insert_ShouldRecordCrudEntry()
+    [Fact]
+    public async Task Insert_RecordCrudEntryTest()
     {
-        string testId = Guid.NewGuid().ToString();
-
         var initialRows = await db.GetAll<object>("SELECT * FROM ps_crud");
         Assert.Empty(initialRows);
 
@@ -59,5 +63,280 @@ public async Task Insert_ShouldRecordCrudEntry()
         Assert.True(tx.Crud.First().Equals(expectedCrudEntry));
     }
 
+    private record CountResult(int count);
+
+    [Fact]
+    public async Task InsertOrReplaceTest()
+    {
+        await db.Execute("INSERT INTO assets(id, description) VALUES(?, ?)", [testId, "test"]);
+        await db.Execute("DELETE FROM ps_crud WHERE 1");
+
+        // Replace existing entry
+        await db.Execute("INSERT OR REPLACE INTO assets(id, description) VALUES(?, ?)", [testId, "test2"]);
+
+        var crudEntry = await db.Get<CrudEntryJSON>("SELECT data FROM ps_crud ORDER BY id");
+
+        Assert.Equal(
+            JsonConvert.SerializeObject(new
+            {
+                op = "PUT",
+                type = "assets",
+                id = testId,
+                data = new { description = "test2" }
+            }),
+            crudEntry.Data
+        );
+
+        var assetCount = await db.Get<CountResult>("SELECT count(*) as count FROM assets");
+        Assert.Equal(1, assetCount.count);
+
+        // Test uniqueness constraint
+        var ex = await Assert.ThrowsAsync<SqliteException>(() =>
+            db.Execute("INSERT INTO assets(id, description) VALUES(?, ?)", [testId, "test3"])
+        );
+
+        Assert.Contains("UNIQUE constraint failed", ex.Message);
+    }
+
+    [Fact]
+    public async Task UpdateTest()
+    {
+        await db.Execute("INSERT INTO assets(id, description, make) VALUES(?, ?, ?)", [testId, "test", "test"]);
+        await db.Execute("DELETE FROM ps_crud WHERE 1");
+
+        await db.Execute("UPDATE assets SET description = ? WHERE id = ?", ["test2", testId]);
+
+        var crudEntry = await db.Get<CrudEntryJSON>("SELECT data FROM ps_crud ORDER BY id");
+
+        Assert.Equal(
+            JsonConvert.SerializeObject(new
+            {
+                op = "PATCH",
+                type = "assets",
+                id = testId,
+                data = new { description = "test2" }
+            }),
+            crudEntry.Data
+        );
+
+        var tx = await db.GetNextCrudTransaction();
+        Assert.Equal(2, tx!.TransactionId);
+
+        var expectedCrudEntry = new CrudEntry(2, UpdateType.PATCH, "assets", testId, 2, new Dictionary<string, object>
+        {
+            { "description", "test2" }
+        });
+
+        Assert.True(tx.Crud.First().Equals(expectedCrudEntry));
+    }
+
+    [Fact]
+    public async Task DeleteTest()
+    {
+        await db.Execute("INSERT INTO assets(id, description, make) VALUES(?, ?, ?)", [testId, "test", "test"]);
+        await db.Execute("DELETE FROM ps_crud WHERE 1");
+
+        await db.Execute("DELETE FROM assets WHERE id = ?", [testId]);
+
+        var crudEntry = await db.Get<CrudEntryJSON>("SELECT data FROM ps_crud ORDER BY id");
+
+        Assert.Equal(
+            JsonConvert.SerializeObject(new
+            {
+                op = "DELETE",
+                type = "assets",
+                id = testId
+            }),
+            crudEntry.Data
+        );
+
+        var tx = await db.GetNextCrudTransaction();
+        Assert.Equal(2, tx!.TransactionId);
+
+        var expectedCrudEntry = new CrudEntry(2, UpdateType.DELETE, "assets", testId, 2);
+        Assert.Equal(expectedCrudEntry, tx.Crud.First());
+    }
+
+    [Fact]
+    public async Task InsertOnlyTablesTest()
+    {
+        var logs = new Table(new Dictionary<string, ColumnType>
+        {
+            { "level", ColumnType.TEXT },
+            { "content", ColumnType.TEXT },
+        }, new TableOptions
+        {
+            InsertOnly = true
+        });
+
+        Schema insertOnlySchema = new Schema(new Dictionary<string, Table>
+        {
+            { "logs", logs },
+        });
+
+        var uniqueDbName = $"test-{Guid.NewGuid()}.db";
+
+        var insertOnlyDb = new PowerSyncDatabase(new PowerSyncDatabaseOptions
+        {
+            Database = new SQLOpenOptions { DbFilename = uniqueDbName },
+            Schema = insertOnlySchema,
+        });
+
+        await insertOnlyDb.Init();
+
+        var initialCrudRows = await insertOnlyDb.GetAll<object>("SELECT * FROM ps_crud");
+        Assert.Empty(initialCrudRows);
+
+        await insertOnlyDb.Execute("INSERT INTO logs(id, level, content) VALUES(?, ?, ?)", [testId, "INFO", "test log"]);
+
+        var crudEntry = await insertOnlyDb.Get<CrudEntryJSON>("SELECT data FROM ps_crud ORDER BY id");
+
+        Assert.Equal(
+            JsonConvert.SerializeObject(new
+            {
+                op = "PUT",
+                type = "logs",
+                id = testId,
+                data = new { content = "test log", level = "INFO" }
+            }),
+            crudEntry.Data
+        );
+
+        var logRows = await insertOnlyDb.GetAll<object>("SELECT * FROM logs");
+        Assert.Empty(logRows);
+
+        var tx = await insertOnlyDb.GetNextCrudTransaction();
+        Assert.Equal(1, tx!.TransactionId);
+
+        var expectedCrudEntry = new CrudEntry(1, UpdateType.PUT, "logs", testId, 1, new Dictionary<string, object>
+        {
+            { "content", "test log" },
+            { "level", "INFO" }
+        });
+
+        Assert.True(tx.Crud.First().Equals(expectedCrudEntry));
+    }
+
+
+    private record QuantityResult(long quantity);
+
+    [Fact]
+    public async Task BigNumbersIntegerTest()
+    {
+        long bigNumber = 1L << 62;
+        await db.Execute("INSERT INTO assets(id, quantity) VALUES(?, ?)", [testId, bigNumber]);
+
+        var result = await db.Get<QuantityResult>("SELECT quantity FROM assets WHERE id = ?", [testId]);
+        Assert.Equal(bigNumber, result.quantity);
 
+        var crudEntry = await db.Get<CrudEntryJSON>("SELECT data FROM ps_crud ORDER BY id");
+
+        Assert.Equal(
+            JsonConvert.SerializeObject(new
+            {
+                op = "PUT",
+                type = "assets",
+                id = testId,
+                data = new { quantity = bigNumber }
+            }),
+            crudEntry.Data
+        );
+
+        var tx = await db.GetNextCrudTransaction();
+        Assert.Equal(1, tx!.TransactionId);
+
+        var expectedCrudEntry = new CrudEntry(1, UpdateType.PUT, "assets", testId, 1, new Dictionary<string, object>
+        {
+            { "quantity", bigNumber }
+        });
+
+        Assert.True(tx.Crud.First().Equals(expectedCrudEntry));
+    }
+
+    [Fact]
+    public async Task BigNumbersTextTest()
+    {
+        long bigNumber = 1L << 62;
+        await db.Execute("INSERT INTO assets(id, quantity) VALUES(?, ?)", [testId, bigNumber.ToString()]);
+
+        var result = await db.Get<QuantityResult>("SELECT quantity FROM assets WHERE id = ?", [testId]);
+        Assert.Equal(bigNumber, result.quantity);
+
+        var crudEntry = await db.Get<CrudEntryJSON>("SELECT data FROM ps_crud ORDER BY id");
+
+        Assert.Equal(
+            JsonConvert.SerializeObject(new
+            {
+                op = "PUT",
+                type = "assets",
+                id = testId,
+                data = new { quantity = bigNumber.ToString() }
+            }),
+            crudEntry.Data
+        );
+
+        await db.Execute("DELETE FROM ps_crud WHERE 1");
+
+        await db.Execute("UPDATE assets SET description = ?, quantity = CAST(quantity AS INTEGER) + 1 WHERE id = ?", [
+            "updated",
+        testId
+        ]);
+
+        crudEntry = await db.Get<CrudEntryJSON>("SELECT data FROM ps_crud ORDER BY id");
+
+        Assert.Equal(
+            JsonConvert.SerializeObject(new
+            {
+                op = "PATCH",
+                type = "assets",
+                id = testId,
+                data = new { description = "updated", quantity = bigNumber + 1 }
+            }),
+            crudEntry.Data
+        );
+    }
+
+    [Fact]
+    public async Task TransactionGroupingTest()
+    {
+        var initialCrudRows = await db.GetAll<object>("SELECT * FROM ps_crud");
+        Assert.Empty(initialCrudRows);
+
+        await db.WriteTransaction(async (tx) =>
+        {
+            await tx.Execute("INSERT INTO assets(id, description) VALUES(?, ?)", [testId, "test1"]);
+            await tx.Execute("INSERT INTO assets(id, description) VALUES(?, ?)", ["test2", "test2"]);
+        });
+
+        await db.WriteTransaction(async (tx) =>
+        {
+            await tx.Execute("UPDATE assets SET description = ? WHERE id = ?", ["updated", testId]);
+        });
+
+        var tx1 = await db.GetNextCrudTransaction();
+        Assert.Equal(1, tx1!.TransactionId);
+
+        var expectedCrudEntries = new[]
+        {
+            new CrudEntry(1, UpdateType.PUT, "assets", testId, 1, new Dictionary<string, object> { { "description", "test1" } }),
+            new CrudEntry(2, UpdateType.PUT, "assets", "test2", 1, new Dictionary<string, object> { { "description", "test2" } })
+        };
+
+        Assert.True(tx1.Crud.Select((entry, index) => entry.Equals(expectedCrudEntries[index])).All(result => result));
+        await tx1.Complete();
+
+        var tx2 = await db.GetNextCrudTransaction();
+        Assert.Equal(2, tx2!.TransactionId);
+
+        var expectedCrudEntry2 = new CrudEntry(3, UpdateType.PATCH, "assets", testId, 2, new Dictionary<string, object>
+        {
+            { "description", "updated" }
+        });
+
+        Assert.True(tx2.Crud.First().Equals(expectedCrudEntry2));
+        await tx2.Complete();
+
+        var nextTx = await db.GetNextCrudTransaction();
+        Assert.Null(nextTx);
+    }
 }