682 lines
33 KiB
C#
682 lines
33 KiB
C#
using Expecto.CSharp;
|
|
using Expecto;
|
|
using BitBadger.Documents.Sqlite;
|
|
|
|
namespace BitBadger.Documents.Tests.CSharp;
|
|
|
|
using static Runner;
|
|
|
|
/// <summary>
|
|
/// C# tests for the extensions on the <tt>SqliteConnection</tt> class
|
|
/// </summary>
|
|
public static class SqliteCSharpExtensionTests
|
|
{
|
|
private static Task LoadDocs() => SqliteCSharpTests.LoadDocs();
|
|
|
|
/// <summary>
|
|
/// Integration tests for the SQLite extension methods
|
|
/// </summary>
|
|
[Tests]
|
|
public static readonly Test Integration = TestList("Sqlite.C#.Extensions",
|
|
[
|
|
TestList("CustomSingle",
|
|
[
|
|
TestCase("succeeds when a row is found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var doc = await conn.CustomSingle($"SELECT data FROM {SqliteDb.TableName} WHERE data ->> 'Id' = @id",
|
|
[Parameters.Id("one")], Results.FromData<JsonDocument>);
|
|
Expect.isNotNull(doc, "There should have been a document returned");
|
|
Expect.equal(doc!.Id, "one", "The incorrect document was returned");
|
|
}),
|
|
TestCase("succeeds when a row is not found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var doc = await conn.CustomSingle($"SELECT data FROM {SqliteDb.TableName} WHERE data ->> 'Id' = @id",
|
|
[Parameters.Id("eighty")], Results.FromData<JsonDocument>);
|
|
Expect.isNull(doc, "There should not have been a document returned");
|
|
})
|
|
]),
|
|
TestList("CustomList",
|
|
[
|
|
TestCase("succeeds when data is found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var docs = await conn.CustomList(Query.Find(SqliteDb.TableName), Parameters.None,
|
|
Results.FromData<JsonDocument>);
|
|
Expect.equal(docs.Count, 5, "There should have been 5 documents returned");
|
|
}),
|
|
TestCase("succeeds when data is not found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var docs = await conn.CustomList(
|
|
$"SELECT data FROM {SqliteDb.TableName} WHERE data ->> 'NumValue' > @value", [new("@value", 100)],
|
|
Results.FromData<JsonDocument>);
|
|
Expect.isEmpty(docs, "There should have been no documents returned");
|
|
})
|
|
]),
|
|
TestList("CustomNonQuery",
|
|
[
|
|
TestCase("succeeds when operating on data", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
await conn.CustomNonQuery($"DELETE FROM {SqliteDb.TableName}", Parameters.None);
|
|
|
|
var remaining = await conn.CountAll(SqliteDb.TableName);
|
|
Expect.equal(remaining, 0L, "There should be no documents remaining in the table");
|
|
}),
|
|
TestCase("succeeds when no data matches where clause", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
await conn.CustomNonQuery($"DELETE FROM {SqliteDb.TableName} WHERE data ->> 'NumValue' > @value",
|
|
[new("@value", 100)]);
|
|
|
|
var remaining = await conn.CountAll(SqliteDb.TableName);
|
|
Expect.equal(remaining, 5L, "There should be 5 documents remaining in the table");
|
|
})
|
|
]),
|
|
TestCase("CustomScalar succeeds", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
|
|
var nbr = await conn.CustomScalar("SELECT 5 AS test_value", Parameters.None, rdr => rdr.GetInt32(0));
|
|
Expect.equal(nbr, 5, "The query should have returned the number 5");
|
|
}),
|
|
TestCase("EnsureTable succeeds", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
|
|
var exists = await ItExists("ensured");
|
|
var alsoExists = await ItExists("idx_ensured_key");
|
|
Expect.isFalse(exists, "The table should not exist already");
|
|
Expect.isFalse(alsoExists, "The key index should not exist already");
|
|
|
|
await conn.EnsureTable("ensured");
|
|
|
|
exists = await ItExists("ensured");
|
|
alsoExists = await ItExists("idx_ensured_key");
|
|
Expect.isTrue(exists, "The table should now exist");
|
|
Expect.isTrue(alsoExists, "The key index should now exist");
|
|
return;
|
|
|
|
Task<bool> ItExists(string name) =>
|
|
conn.CustomScalar($"SELECT EXISTS (SELECT 1 FROM {SqliteDb.Catalog} WHERE name = @name) AS it",
|
|
[new("@name", name)], Results.ToExists);
|
|
}),
|
|
TestCase("EnsureFieldIndex succeeds", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
|
|
var exists = await IndexExists();
|
|
Expect.isFalse(exists, "The index should not exist already");
|
|
|
|
await conn.EnsureTable("ensured");
|
|
await conn.EnsureFieldIndex("ensured", "test", ["Id", "Category"]);
|
|
exists = await IndexExists();
|
|
Expect.isTrue(exists, "The index should now exist");
|
|
return;
|
|
|
|
Task<bool> IndexExists() =>
|
|
conn.CustomScalar(
|
|
$"SELECT EXISTS (SELECT 1 FROM {SqliteDb.Catalog} WHERE name = 'idx_ensured_test') AS it",
|
|
Parameters.None, Results.ToExists);
|
|
}),
|
|
TestList("Insert",
|
|
[
|
|
TestCase("succeeds", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
var before = await conn.FindAll<SubDocument>(SqliteDb.TableName);
|
|
Expect.isEmpty(before, "There should be no documents in the table");
|
|
await conn.Insert(SqliteDb.TableName,
|
|
new JsonDocument { Id = "turkey", Sub = new() { Foo = "gobble", Bar = "gobble" } });
|
|
var after = await conn.FindAll<JsonDocument>(SqliteDb.TableName);
|
|
Expect.equal(after.Count, 1, "There should have been one document inserted");
|
|
}),
|
|
TestCase("fails for duplicate key", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await conn.Insert(SqliteDb.TableName, new JsonDocument { Id = "test" });
|
|
try
|
|
{
|
|
await Document.Insert(SqliteDb.TableName, new JsonDocument { Id = "test" });
|
|
Expect.isTrue(false, "An exception should have been raised for duplicate document ID insert");
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// This is what is supposed to happen
|
|
}
|
|
})
|
|
]),
|
|
TestList("Save",
|
|
[
|
|
TestCase("succeeds when a document is inserted", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
var before = await conn.FindAll<JsonDocument>(SqliteDb.TableName);
|
|
Expect.isEmpty(before, "There should be no documents in the table");
|
|
|
|
await conn.Save(SqliteDb.TableName,
|
|
new JsonDocument { Id = "test", Sub = new() { Foo = "a", Bar = "b" } });
|
|
var after = await conn.FindAll<JsonDocument>(SqliteDb.TableName);
|
|
Expect.equal(after.Count, 1, "There should have been one document inserted");
|
|
}),
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await conn.Insert(SqliteDb.TableName,
|
|
new JsonDocument { Id = "test", Sub = new() { Foo = "a", Bar = "b" } });
|
|
|
|
var before = await conn.FindById<string, JsonDocument>(SqliteDb.TableName, "test");
|
|
Expect.isNotNull(before, "There should have been a document returned");
|
|
Expect.equal(before!.Id, "test", "The document is not correct");
|
|
Expect.isNotNull(before.Sub, "There should have been a sub-document");
|
|
Expect.equal(before.Sub!.Foo, "a", "The document is not correct");
|
|
Expect.equal(before.Sub.Bar, "b", "The document is not correct");
|
|
|
|
await conn.Save(SqliteDb.TableName, new JsonDocument { Id = "test" });
|
|
var after = await conn.FindById<string, JsonDocument>(SqliteDb.TableName, "test");
|
|
Expect.isNotNull(after, "There should have been a document returned post-update");
|
|
Expect.equal(after!.Id, "test", "The updated document is not correct");
|
|
Expect.isNull(after.Sub, "There should not have been a sub-document in the updated document");
|
|
})
|
|
]),
|
|
TestCase("CountAll succeeds", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var theCount = await conn.CountAll(SqliteDb.TableName);
|
|
Expect.equal(theCount, 5L, "There should have been 5 matching documents");
|
|
}),
|
|
TestCase("CountByField succeeds", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var theCount = await conn.CountByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Value", "purple")]);
|
|
Expect.equal(theCount, 2L, "There should have been 2 matching documents");
|
|
}),
|
|
TestList("ExistsById",
|
|
[
|
|
TestCase("succeeds when a document exists", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var exists = await conn.ExistsById(SqliteDb.TableName, "three");
|
|
Expect.isTrue(exists, "There should have been an existing document");
|
|
}),
|
|
TestCase("succeeds when a document does not exist", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var exists = await conn.ExistsById(SqliteDb.TableName, "seven");
|
|
Expect.isFalse(exists, "There should not have been an existing document");
|
|
})
|
|
]),
|
|
TestList("ExistsByFields",
|
|
[
|
|
TestCase("succeeds when documents exist", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var exists = await conn.ExistsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.GE("NumValue", 10)]);
|
|
Expect.isTrue(exists, "There should have been existing documents");
|
|
}),
|
|
TestCase("succeeds when no matching documents exist", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var exists =
|
|
await conn.ExistsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Nothing", "none")]);
|
|
Expect.isFalse(exists, "There should not have been any existing documents");
|
|
})
|
|
]),
|
|
TestList("FindAll",
|
|
[
|
|
TestCase("succeeds when there is data", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
|
|
await conn.Insert(SqliteDb.TableName, new JsonDocument { Id = "one", Value = "two" });
|
|
await conn.Insert(SqliteDb.TableName, new JsonDocument { Id = "three", Value = "four" });
|
|
await conn.Insert(SqliteDb.TableName, new JsonDocument { Id = "five", Value = "six" });
|
|
|
|
var results = await conn.FindAll<JsonDocument>(SqliteDb.TableName);
|
|
Expect.equal(results.Count, 3, "There should have been 3 documents returned");
|
|
}),
|
|
TestCase("succeeds when there is no data", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
var results = await conn.FindAll<JsonDocument>(SqliteDb.TableName);
|
|
Expect.isEmpty(results, "There should have been no documents returned");
|
|
})
|
|
]),
|
|
TestList("FindAllOrdered",
|
|
[
|
|
TestCase("succeeds when ordering numerically", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var results = await conn.FindAllOrdered<JsonDocument>(SqliteDb.TableName, [Field.Named("n:NumValue")]);
|
|
Expect.hasLength(results, 5, "There should have been 5 documents returned");
|
|
Expect.equal(string.Join('|', results.Select(x => x.Id)), "one|three|two|four|five",
|
|
"The documents were not ordered correctly");
|
|
}),
|
|
TestCase("succeeds when ordering numerically descending", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var results =
|
|
await conn.FindAllOrdered<JsonDocument>(SqliteDb.TableName, [Field.Named("n:NumValue DESC")]);
|
|
Expect.hasLength(results, 5, "There should have been 5 documents returned");
|
|
Expect.equal(string.Join('|', results.Select(x => x.Id)), "five|four|two|three|one",
|
|
"The documents were not ordered correctly");
|
|
}),
|
|
TestCase("succeeds when ordering alphabetically", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var results = await conn.FindAllOrdered<JsonDocument>(SqliteDb.TableName, [Field.Named("Id DESC")]);
|
|
Expect.hasLength(results, 5, "There should have been 5 documents returned");
|
|
Expect.equal(string.Join('|', results.Select(x => x.Id)), "two|three|one|four|five",
|
|
"The documents were not ordered correctly");
|
|
})
|
|
]),
|
|
TestList("FindById",
|
|
[
|
|
TestCase("succeeds when a document is found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var doc = await conn.FindById<string, JsonDocument>(SqliteDb.TableName, "two");
|
|
Expect.isNotNull(doc, "There should have been a document returned");
|
|
Expect.equal(doc!.Id, "two", "The incorrect document was returned");
|
|
}),
|
|
TestCase("succeeds when a document is not found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var doc = await conn.FindById<string, JsonDocument>(SqliteDb.TableName, "eighty-seven");
|
|
Expect.isNull(doc, "There should not have been a document returned");
|
|
})
|
|
]),
|
|
TestList("FindByFields",
|
|
[
|
|
TestCase("succeeds when documents are found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var docs = await conn.FindByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
|
|
[Field.GT("NumValue", 15)]);
|
|
Expect.equal(docs.Count, 2, "There should have been two documents returned");
|
|
}),
|
|
TestCase("succeeds when documents are not found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var docs = await conn.FindByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
|
|
[Field.EQ("Value", "mauve")]);
|
|
Expect.isEmpty(docs, "There should have been no documents returned");
|
|
})
|
|
]),
|
|
TestList("ByFieldsOrdered",
|
|
[
|
|
TestCase("succeeds when documents are found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var docs = await conn.FindByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
|
|
[Field.GT("NumValue", 15)], [Field.Named("Id")]);
|
|
Expect.equal(string.Join('|', docs.Select(x => x.Id)), "five|four",
|
|
"There should have been two documents returned");
|
|
}),
|
|
TestCase("succeeds when documents are not found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var docs = await conn.FindByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
|
|
[Field.GT("NumValue", 15)], [Field.Named("Id DESC")]);
|
|
Expect.equal(string.Join('|', docs.Select(x => x.Id)), "four|five",
|
|
"There should have been two documents returned");
|
|
})
|
|
]),
|
|
TestList("FindFirstByFields",
|
|
[
|
|
TestCase("succeeds when a document is found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var doc = await conn.FindFirstByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
|
|
[Field.EQ("Value", "another")]);
|
|
Expect.isNotNull(doc, "There should have been a document returned");
|
|
Expect.equal(doc!.Id, "two", "The incorrect document was returned");
|
|
}),
|
|
TestCase("succeeds when multiple documents are found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var doc = await conn.FindFirstByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
|
|
[Field.EQ("Sub.Foo", "green")]);
|
|
Expect.isNotNull(doc, "There should have been a document returned");
|
|
Expect.contains(["two", "four"], doc!.Id, "An incorrect document was returned");
|
|
}),
|
|
TestCase("succeeds when a document is not found", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var doc = await conn.FindFirstByFields<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
|
|
[Field.EQ("Value", "absent")]);
|
|
Expect.isNull(doc, "There should not have been a document returned");
|
|
})
|
|
]),
|
|
TestList("FindFirstByFieldsOrdered",
|
|
[
|
|
TestCase("succeeds when sorting ascending", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var doc = await conn.FindFirstByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
|
|
[Field.EQ("Sub.Foo", "green")], [Field.Named("Sub.Bar")]);
|
|
Expect.isNotNull(doc, "There should have been a document returned");
|
|
Expect.equal("two", doc!.Id, "An incorrect document was returned");
|
|
}),
|
|
TestCase("succeeds when sorting descending", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var doc = await conn.FindFirstByFieldsOrdered<JsonDocument>(SqliteDb.TableName, FieldMatch.Any,
|
|
[Field.EQ("Sub.Foo", "green")], [Field.Named("Sub.Bar DESC")]);
|
|
Expect.isNotNull(doc, "There should have been a document returned");
|
|
Expect.equal("four", doc!.Id, "An incorrect document was returned");
|
|
})
|
|
]),
|
|
TestList("UpdateById",
|
|
[
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
var testDoc = new JsonDocument { Id = "one", Sub = new() { Foo = "blue", Bar = "red" } };
|
|
await conn.UpdateById(SqliteDb.TableName, "one", testDoc);
|
|
var after = await conn.FindById<string, JsonDocument>(SqliteDb.TableName, "one");
|
|
Expect.isNotNull(after, "There should have been a document returned post-update");
|
|
Expect.equal(after.Id, "one", "The updated document is not correct");
|
|
Expect.isNotNull(after.Sub, "The updated document should have had a sub-document");
|
|
Expect.equal(after.Sub!.Foo, "blue", "The updated sub-document is not correct");
|
|
Expect.equal(after.Sub.Bar, "red", "The updated sub-document is not correct");
|
|
}),
|
|
TestCase("succeeds when no document is updated", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
var before = await conn.FindAll<JsonDocument>(SqliteDb.TableName);
|
|
Expect.isEmpty(before, "There should have been no documents returned");
|
|
|
|
// This not raising an exception is the test
|
|
await conn.UpdateById(SqliteDb.TableName, "test",
|
|
new JsonDocument { Id = "x", Sub = new() { Foo = "blue", Bar = "red" } });
|
|
})
|
|
]),
|
|
TestList("UpdateByFunc",
|
|
[
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
await conn.UpdateByFunc(SqliteDb.TableName, doc => doc.Id,
|
|
new JsonDocument { Id = "one", Value = "le un", NumValue = 1 });
|
|
var after = await conn.FindById<string, JsonDocument>(SqliteDb.TableName, "one");
|
|
Expect.isNotNull(after, "There should have been a document returned post-update");
|
|
Expect.equal(after.Id, "one", "The updated document is incorrect");
|
|
Expect.equal(after.Value, "le un", "The updated document is incorrect");
|
|
Expect.equal(after.NumValue, 1, "The updated document is incorrect");
|
|
Expect.isNull(after.Sub, "The updated document should not have a sub-document");
|
|
}),
|
|
TestCase("succeeds when no document is updated", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
var before = await conn.FindAll<JsonDocument>(SqliteDb.TableName);
|
|
Expect.isEmpty(before, "There should have been no documents returned");
|
|
|
|
// This not raising an exception is the test
|
|
await conn.UpdateByFunc(SqliteDb.TableName, doc => doc.Id,
|
|
new JsonDocument { Id = "one", Value = "le un", NumValue = 1 });
|
|
})
|
|
]),
|
|
TestList("PatchById",
|
|
[
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
await conn.PatchById(SqliteDb.TableName, "one", new { NumValue = 44 });
|
|
var after = await conn.FindById<string, JsonDocument>(SqliteDb.TableName, "one");
|
|
Expect.isNotNull(after, "There should have been a document returned post-update");
|
|
Expect.equal(after.Id, "one", "The updated document is not correct");
|
|
Expect.equal(after.NumValue, 44, "The updated document is not correct");
|
|
}),
|
|
TestCase("succeeds when no document is updated", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
var before = await conn.FindAll<JsonDocument>(SqliteDb.TableName);
|
|
Expect.isEmpty(before, "There should have been no documents returned");
|
|
|
|
// This not raising an exception is the test
|
|
await conn.PatchById(SqliteDb.TableName, "test", new { Foo = "green" });
|
|
})
|
|
]),
|
|
TestList("PatchByFields",
|
|
[
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
await conn.PatchByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Value", "purple")],
|
|
new { NumValue = 77 });
|
|
var after = await conn.CountByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", 77)]);
|
|
Expect.equal(after, 2L, "There should have been 2 documents returned");
|
|
}),
|
|
TestCase("succeeds when no document is updated", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
var before = await conn.FindAll<JsonDocument>(SqliteDb.TableName);
|
|
Expect.isEmpty(before, "There should have been no documents returned");
|
|
|
|
// This not raising an exception is the test
|
|
await conn.PatchByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Value", "burgundy")],
|
|
new { Foo = "green" });
|
|
})
|
|
]),
|
|
TestList("RemoveFieldsById",
|
|
[
|
|
TestCase("succeeds when fields are removed", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
await conn.RemoveFieldsById(SqliteDb.TableName, "two", ["Sub", "Value"]);
|
|
var updated = await Find.ById<string, JsonDocument>(SqliteDb.TableName, "two");
|
|
Expect.isNotNull(updated, "The updated document should have been retrieved");
|
|
Expect.equal(updated.Value, "", "The string value should have been removed");
|
|
Expect.isNull(updated.Sub, "The sub-document should have been removed");
|
|
}),
|
|
TestCase("succeeds when a field is not removed", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
// This not raising an exception is the test
|
|
await conn.RemoveFieldsById(SqliteDb.TableName, "two", ["AFieldThatIsNotThere"]);
|
|
}),
|
|
TestCase("succeeds when no document is matched", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
|
|
// This not raising an exception is the test
|
|
await conn.RemoveFieldsById(SqliteDb.TableName, "two", ["Value"]);
|
|
})
|
|
]),
|
|
TestList("RemoveFieldsByFields",
|
|
[
|
|
TestCase("succeeds when a field is removed", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
await conn.RemoveFieldsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", 17)],
|
|
["Sub"]);
|
|
var updated = await Find.ById<string, JsonDocument>(SqliteDb.TableName, "four");
|
|
Expect.isNotNull(updated, "The updated document should have been retrieved");
|
|
Expect.isNull(updated.Sub, "The sub-document should have been removed");
|
|
}),
|
|
TestCase("succeeds when a field is not removed", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
// This not raising an exception is the test
|
|
await conn.RemoveFieldsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("NumValue", 17)],
|
|
["Nothing"]);
|
|
}),
|
|
TestCase("succeeds when no document is matched", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
|
|
// This not raising an exception is the test
|
|
await conn.RemoveFieldsByFields(SqliteDb.TableName, FieldMatch.Any, [Field.NE("Abracadabra", "apple")],
|
|
["Value"]);
|
|
})
|
|
]),
|
|
TestList("DeleteById",
|
|
[
|
|
TestCase("succeeds when a document is deleted", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
await conn.DeleteById(SqliteDb.TableName, "four");
|
|
var remaining = await conn.CountAll(SqliteDb.TableName);
|
|
Expect.equal(remaining, 4L, "There should have been 4 documents remaining");
|
|
}),
|
|
TestCase("succeeds when a document is not deleted", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
await conn.DeleteById(SqliteDb.TableName, "thirty");
|
|
var remaining = await conn.CountAll(SqliteDb.TableName);
|
|
Expect.equal(remaining, 5L, "There should have been 5 documents remaining");
|
|
})
|
|
]),
|
|
TestList("DeleteByFields",
|
|
[
|
|
TestCase("succeeds when documents are deleted", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
await conn.DeleteByFields(SqliteDb.TableName, FieldMatch.Any, [Field.NE("Value", "purple")]);
|
|
var remaining = await conn.CountAll(SqliteDb.TableName);
|
|
Expect.equal(remaining, 2L, "There should have been 2 documents remaining");
|
|
}),
|
|
TestCase("succeeds when documents are not deleted", async () =>
|
|
{
|
|
await using var db = await SqliteDb.BuildDb();
|
|
await using var conn = Sqlite.Configuration.DbConn();
|
|
await LoadDocs();
|
|
|
|
await conn.DeleteByFields(SqliteDb.TableName, FieldMatch.Any, [Field.EQ("Value", "crimson")]);
|
|
var remaining = await conn.CountAll(SqliteDb.TableName);
|
|
Expect.equal(remaining, 5L, "There should have been 5 documents remaining");
|
|
})
|
|
]),
|
|
TestCase("Clean up database", () => Sqlite.Configuration.UseConnectionString("data source=:memory:"))
|
|
]);
|
|
}
|