Daniel J. Summers
2c24e2e912
Changes in this version: - **BREAKING CHANGE**: All `*byField`/`*ByField` functions are now `*byFields`/`*ByFields`, and take a `FieldMatch` case before the list of fields. The `Compat` namespace in both libraries will assist in this transition. In support of this change, the `Field` parameter name is optional; the library will generate parameter names for it if they are not specified. - **BREAKING CHANGE**: The `Query` namespaces have had some significant work, particularly from the full-query perspective. Most have been broken up into the base query and modifiers `by*` that will combine the base query with the `WHERE` clause needed to satisfy the criteria. - **FEATURE / BREAKING CHANGE**: PostgreSQL document fields will now be cast to numeric if the parameter value passed to the query is numeric. This drove the `Query` breaking changes, as the fields need to have their intended value for the library to generate the appropriate SQL. Additionally, if code assumes the library can be given something like `8` and transform it to `"8"`, this is no longer the case. - **FEATURE**: All `Find` queries (except `byId`/`ById`) now have a version with the `Ordered` suffix. These take a list of fields by which the query should be ordered. A new `Field` method called `Named` can assist with creating these fields. Prefixing the field name with `n:` will cast the field to numeric in PostgreSQL (and will be ignored by SQLite); adding " DESC" to the field name will sort it descending (Z-A, high to low) instead of ascending (A-Z, low to high). - **BREAKING CHANGE** (PostgreSQL only): `fieldNameParam`/`Parameters.FieldName` are now plural. The function still only generates one parameter, but the name is now the same between PostgreSQL and SQLite. The goal of this library is to abstract the differences away as much as practical, and this furthers that end. There are functions with these names in the `Compat` namespace. - **FEATURE**: In the F# v3 library, lists of parameters were expected to be F#'s `List` type, and the C# version took either `List<T>` or `IEnumerable<T>`. In this version, these all expect `seq`/`IEnumerable<T>`. F#'s `List` satisfies the `seq` constraints, so this should not be a breaking change. - **FEATURE**: `Field`s now may have qualifiers; this allows tables to be aliased when joining multiple tables (as all have the same `data` column). F# users can use `with` to specify this at creation, and both F# and C# can use the `WithQualifier` method to create a field with the qualifier specified. Parameter names for fields may be specified in a similar way, substituting `ParameterName` for `Qualifier`. Reviewed-on: #6
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:"))
|
|
]);
|
|
}
|