1507 lines
75 KiB
C#
1507 lines
75 KiB
C#
using Expecto.CSharp;
|
|
using Expecto;
|
|
using BitBadger.Documents.Postgres;
|
|
using ThrowawayDb.Postgres;
|
|
|
|
namespace BitBadger.Documents.Tests.CSharp;
|
|
|
|
using static CommonExtensionsAndTypesForNpgsqlFSharp;
|
|
using static Runner;
|
|
|
|
/// <summary>
|
|
/// C# tests for the PostgreSQL implementation of <tt>BitBadger.Documents</tt>
|
|
/// </summary>
|
|
public static class PostgresCSharpTests
|
|
{
|
|
/// <summary>
|
|
/// Tests which do not hit the database
|
|
/// </summary>
|
|
private static readonly Test Unit = TestList("Unit",
|
|
[
|
|
TestList("Parameters",
|
|
[
|
|
TestCase("Id succeeds", () =>
|
|
{
|
|
var it = Parameters.Id(88);
|
|
Expect.equal(it.Item1, "@id", "ID parameter not constructed correctly");
|
|
Expect.equal(it.Item2, Sql.@string("88"), "ID parameter value incorrect");
|
|
}),
|
|
TestCase("Json succeeds", () =>
|
|
{
|
|
var it = Parameters.Json("@test", new { Something = "good" });
|
|
Expect.equal(it.Item1, "@test", "JSON parameter not constructed correctly");
|
|
Expect.equal(it.Item2, Sql.jsonb("{\"Something\":\"good\"}"), "JSON parameter value incorrect");
|
|
}),
|
|
TestList("AddFields",
|
|
[
|
|
TestCase("succeeds when a parameter is added", () =>
|
|
{
|
|
var paramList = Parameters.AddFields([Field.EQ("it", "242")], []).ToList();
|
|
Expect.hasLength(paramList, 1, "There should have been a parameter added");
|
|
var (name, value) = paramList[0];
|
|
Expect.equal(name, "@field0", "Field parameter name not correct");
|
|
if (!value.IsParameter)
|
|
{
|
|
Expect.isTrue(false, "The parameter was not a Parameter type");
|
|
}
|
|
}),
|
|
TestCase("succeeds when multiple independent parameters are added", () =>
|
|
{
|
|
var paramList = Parameters.AddFields([Field.EQ("me", "you"), Field.GT("us", "them")],
|
|
[Parameters.Id(14)]).ToList();
|
|
Expect.hasLength(paramList, 3, "There should have been 2 parameters added");
|
|
var (name, value) = paramList[0];
|
|
Expect.equal(name, "@id", "First field parameter name not correct");
|
|
if (!value.IsString)
|
|
{
|
|
Expect.isTrue(false, "First parameter was not a String type");
|
|
}
|
|
(name, value) = paramList[1];
|
|
Expect.equal(name, "@field0", "Second field parameter name not correct");
|
|
if (!value.IsParameter)
|
|
{
|
|
Expect.isTrue(false, "Second parameter was not a Parameter type");
|
|
}
|
|
(name, value) = paramList[2];
|
|
Expect.equal(name, "@field1", "Third parameter name not correct");
|
|
if (!value.IsParameter)
|
|
{
|
|
Expect.isTrue(false, "Third parameter was not a Parameter type");
|
|
}
|
|
}),
|
|
TestCase("succeeds when a parameter is not added", () =>
|
|
{
|
|
var paramList = Parameters.AddFields([Field.EX("tacos")], []).ToList();
|
|
Expect.isEmpty(paramList, "There should not have been any parameters added");
|
|
}),
|
|
TestCase("succeeds when two parameters are added for one field", () =>
|
|
{
|
|
var paramList =
|
|
Parameters.AddFields([Field.BT("that", "eh", "zed").WithParameterName("@test")], []).ToList();
|
|
Expect.hasLength(paramList, 2, "There should have been 2 parameters added");
|
|
var (name, value) = paramList[0];
|
|
Expect.equal(name, "@testmin", "Minimum field name not correct");
|
|
if (!value.IsParameter)
|
|
{
|
|
Expect.isTrue(false, "Minimum parameter was not a Parameter type");
|
|
}
|
|
(name, value) = paramList[1];
|
|
Expect.equal(name, "@testmax", "Maximum field name not correct");
|
|
if (!value.IsParameter)
|
|
{
|
|
Expect.isTrue(false, "Maximum parameter was not a Parameter type");
|
|
}
|
|
})
|
|
]),
|
|
#pragma warning disable CS0618
|
|
TestList("AddField",
|
|
[
|
|
TestCase("succeeds when a parameter is added", () =>
|
|
{
|
|
var it = Parameters.AddField("@field", Field.EQ("it", "242"), []).ToList();
|
|
Expect.hasLength(it, 1, "There should have been a parameter added");
|
|
Expect.equal(it[0].Item1, "@field", "Field parameter not constructed correctly");
|
|
Expect.isTrue(it[0].Item2.IsParameter, "Field parameter value incorrect");
|
|
}),
|
|
TestCase("succeeds when a parameter is not added", () =>
|
|
{
|
|
var it = Parameters.AddField("@it", Field.EX("It"), []);
|
|
Expect.isEmpty(it, "There should not have been any parameters added");
|
|
}),
|
|
TestCase("succeeds when two parameters are added", () =>
|
|
{
|
|
var it = Parameters.AddField("@field", Field.BT("that", "eh", "zed"), []).ToList();
|
|
Expect.hasLength(it, 2, "There should have been 2 parameters added");
|
|
Expect.equal(it[0].Item1, "@fieldmin", "Minimum field name not correct");
|
|
Expect.isTrue(it[0].Item2.IsParameter, "Minimum field parameter value incorrect");
|
|
Expect.equal(it[1].Item1, "@fieldmax", "Maximum field name not correct");
|
|
Expect.isTrue(it[1].Item2.IsParameter, "Maximum field parameter value incorrect");
|
|
})
|
|
]),
|
|
#pragma warning restore CS0618
|
|
TestList("FieldNames",
|
|
[
|
|
TestCase("succeeds for one name", () =>
|
|
{
|
|
var (name, value) = Parameters.FieldNames(["bob"]);
|
|
Expect.equal(name, "@name", "The parameter name was incorrect");
|
|
if (!value.IsString)
|
|
{
|
|
Expect.isTrue(false, "The parameter was not a String type");
|
|
}
|
|
}),
|
|
TestCase("succeeds for multiple names", () =>
|
|
{
|
|
var (name, value) = Parameters.FieldNames(["bob", "tom", "mike"]);
|
|
Expect.equal(name, "@name", "The parameter name was incorrect");
|
|
if (!value.IsStringArray)
|
|
{
|
|
Expect.isTrue(false, "The parameter was not a StringArray type");
|
|
}
|
|
})
|
|
]),
|
|
#pragma warning disable CS0618
|
|
TestList("FieldName",
|
|
[
|
|
TestCase("succeeds for one name", () =>
|
|
{
|
|
var (name, value) = Parameters.FieldName(["bob"]);
|
|
Expect.equal(name, "@name", "The parameter name was incorrect");
|
|
if (!value.IsString)
|
|
{
|
|
Expect.isTrue(false, "The parameter was not a String type");
|
|
}
|
|
}),
|
|
TestCase("succeeds for multiple names", () =>
|
|
{
|
|
var (name, value) = Parameters.FieldName(["bob", "tom", "mike"]);
|
|
Expect.equal(name, "@name", "The parameter name was incorrect");
|
|
if (!value.IsStringArray)
|
|
{
|
|
Expect.isTrue(false, "The parameter was not a StringArray type");
|
|
}
|
|
})
|
|
])
|
|
#pragma warning restore CS0618
|
|
]),
|
|
TestList("Query",
|
|
[
|
|
TestList("WhereByFields",
|
|
[
|
|
TestCase("succeeds for a single field when a logical operator is passed", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.WhereByFields(FieldMatch.Any,
|
|
[Field.GT("theField", 0).WithParameterName("@test")]),
|
|
"data->>'theField' > @test", "WHERE clause not correct");
|
|
}),
|
|
TestCase("succeeds for a single field when an existence operator is passed", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.WhereByFields(FieldMatch.Any, [Field.NEX("thatField")]),
|
|
"data->>'thatField' IS NULL", "WHERE clause not correct");
|
|
}),
|
|
TestCase("succeeds for a single field when a between operator is passed with numeric values", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.WhereByFields(FieldMatch.All,
|
|
[Field.BT("aField", 50, 99).WithParameterName("@range")]),
|
|
"(data->>'aField')::numeric BETWEEN @rangemin AND @rangemax", "WHERE clause not correct");
|
|
}),
|
|
TestCase("succeeds for a single field when a between operator is passed with non-numeric values", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.WhereByFields(FieldMatch.Any,
|
|
[Field.BT("field0", "a", "b").WithParameterName("@alpha")]),
|
|
"data->>'field0' BETWEEN @alphamin AND @alphamax", "WHERE clause not correct");
|
|
}),
|
|
TestCase("succeeds for all multiple fields with logical operators", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.WhereByFields(FieldMatch.All,
|
|
[Field.EQ("theFirst", "1"), Field.EQ("numberTwo", "2")]),
|
|
"data->>'theFirst' = @field0 AND data->>'numberTwo' = @field1", "WHERE clause not correct");
|
|
}),
|
|
TestCase("succeeds for any multiple fields with an existence operator", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.WhereByFields(FieldMatch.Any,
|
|
[Field.NEX("thatField"), Field.GE("thisField", 18)]),
|
|
"data->>'thatField' IS NULL OR data->>'thisField' >= @field0", "WHERE clause not correct");
|
|
}),
|
|
TestCase("succeeds for all multiple fields with between operators", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.WhereByFields(FieldMatch.All,
|
|
[Field.BT("aField", 50, 99), Field.BT("anotherField", "a", "b")]),
|
|
"(data->>'aField')::numeric BETWEEN @field0min AND @field0max AND data->>'anotherField' BETWEEN @field1min AND @field1max",
|
|
"WHERE clause not correct");
|
|
})
|
|
]),
|
|
#pragma warning disable CS0618
|
|
TestList("WhereByField",
|
|
[
|
|
TestCase("succeeds when a logical operator is passed", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.WhereByField(Field.GT("theField", 0), "@test"),
|
|
"data->>'theField' > @test", "WHERE clause not correct");
|
|
}),
|
|
TestCase("succeeds when an existence operator is passed", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.WhereByField(Field.NEX("thatField"), ""), "data->>'thatField' IS NULL",
|
|
"WHERE clause not correct");
|
|
}),
|
|
TestCase("succeeds when a between operator is passed with numeric values", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.WhereByField(Field.BT("aField", 50, 99), "@range"),
|
|
"(data->>'aField')::numeric BETWEEN @rangemin AND @rangemax", "WHERE clause not correct");
|
|
}),
|
|
TestCase("succeeds when a between operator is passed with non-numeric values", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.WhereByField(Field.BT("field0", "a", "b"), "@alpha"),
|
|
"data->>'field0' BETWEEN @alphamin AND @alphamax", "WHERE clause not correct");
|
|
})
|
|
]),
|
|
#pragma warning restore CS0618
|
|
TestCase("WhereById succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.WhereById("@id"), "data->>'Id' = @id", "WHERE clause not correct");
|
|
}),
|
|
TestList("Definition",
|
|
[
|
|
TestCase("EnsureTable succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Definition.EnsureTable(PostgresDb.TableName),
|
|
$"CREATE TABLE IF NOT EXISTS {PostgresDb.TableName} (data JSONB NOT NULL)",
|
|
"CREATE TABLE statement not constructed correctly");
|
|
}),
|
|
TestCase("EnsureDocumentIndex succeeds for full index", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Definition.EnsureDocumentIndex("schema.tbl", DocumentIndex.Full),
|
|
"CREATE INDEX IF NOT EXISTS idx_tbl_document ON schema.tbl USING GIN (data)",
|
|
"CREATE INDEX statement not constructed correctly");
|
|
}),
|
|
TestCase("EnsureDocumentIndex succeeds for JSONB Path Ops index", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.Definition.EnsureDocumentIndex(PostgresDb.TableName, DocumentIndex.Optimized),
|
|
string.Format(
|
|
"CREATE INDEX IF NOT EXISTS idx_{0}_document ON {0} USING GIN (data jsonb_path_ops)",
|
|
PostgresDb.TableName),
|
|
"CREATE INDEX statement not constructed correctly");
|
|
})
|
|
]),
|
|
TestCase("Update succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Update("tbl"), "UPDATE tbl SET data = @data WHERE data->>'Id' = @id",
|
|
"UPDATE full statement not correct");
|
|
}),
|
|
TestCase("WhereDataContains succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.WhereDataContains("@test"), "data @> @test",
|
|
"WHERE clause not correct");
|
|
}),
|
|
TestCase("WhereJsonPathMatches succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.WhereJsonPathMatches("@path"), "data @? @path::jsonpath",
|
|
"WHERE clause not correct");
|
|
}),
|
|
TestList("Count",
|
|
[
|
|
TestCase("All succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Count.All(PostgresDb.TableName),
|
|
$"SELECT COUNT(*) AS it FROM {PostgresDb.TableName}", "Count query not correct");
|
|
}),
|
|
TestCase("ByFields succeeds", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.Count.ByFields("x", FieldMatch.All,
|
|
[Field.EQ("thatField", 0), Field.EQ("anotherField", 8)]),
|
|
$"SELECT COUNT(*) AS it FROM x WHERE data->>'thatField' = @field0 AND data->>'anotherField' = @field1",
|
|
"JSON field text comparison count query not correct");
|
|
}),
|
|
#pragma warning disable CS0618
|
|
TestCase("ByField succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Count.ByField(PostgresDb.TableName, Field.EQ("thatField", 0)),
|
|
$"SELECT COUNT(*) AS it FROM {PostgresDb.TableName} WHERE data->>'thatField' = @field0",
|
|
"JSON field text comparison count query not correct");
|
|
}),
|
|
#pragma warning restore CS0618
|
|
TestCase("ByContains succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Count.ByContains(PostgresDb.TableName),
|
|
$"SELECT COUNT(*) AS it FROM {PostgresDb.TableName} WHERE data @> @criteria",
|
|
"JSON containment count query not correct");
|
|
}),
|
|
TestCase("ByJsonPath succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Count.ByJsonPath(PostgresDb.TableName),
|
|
$"SELECT COUNT(*) AS it FROM {PostgresDb.TableName} WHERE data @? @path::jsonpath",
|
|
"JSON Path match count query not correct");
|
|
})
|
|
]),
|
|
TestList("Exists",
|
|
[
|
|
TestCase("ById succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Exists.ById(PostgresDb.TableName),
|
|
$"SELECT EXISTS (SELECT 1 FROM {PostgresDb.TableName} WHERE data->>'Id' = @id) AS it",
|
|
"ID existence query not correct");
|
|
}),
|
|
TestCase("ByFields succeeds", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.Exists.ByFields("q", FieldMatch.Any,
|
|
[Field.LT("Test", 0).WithParameterName("@a"), Field.LT("Unit", "x").WithParameterName("@b")]),
|
|
$"SELECT EXISTS (SELECT 1 FROM q WHERE data->>'Test' < @a OR data->>'Unit' < @b) AS it",
|
|
"JSON field text comparison exists query not correct");
|
|
}),
|
|
#pragma warning disable CS0618
|
|
TestCase("ByField succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Exists.ByField(PostgresDb.TableName, Field.LT("Test", 0)),
|
|
$"SELECT EXISTS (SELECT 1 FROM {PostgresDb.TableName} WHERE data->>'Test' < @field0) AS it",
|
|
"JSON field text comparison exists query not correct");
|
|
}),
|
|
#pragma warning restore CS0618
|
|
TestCase("ByContains succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Exists.ByContains(PostgresDb.TableName),
|
|
$"SELECT EXISTS (SELECT 1 FROM {PostgresDb.TableName} WHERE data @> @criteria) AS it",
|
|
"JSON containment exists query not correct");
|
|
}),
|
|
TestCase("byJsonPath succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Exists.ByJsonPath(PostgresDb.TableName),
|
|
$"SELECT EXISTS (SELECT 1 FROM {PostgresDb.TableName} WHERE data @? @path::jsonpath) AS it",
|
|
"JSON Path match existence query not correct");
|
|
})
|
|
]),
|
|
TestList("Find",
|
|
[
|
|
TestCase("ById succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Find.ById(PostgresDb.TableName),
|
|
$"SELECT data FROM {PostgresDb.TableName} WHERE data->>'Id' = @id",
|
|
"SELECT by ID query not correct");
|
|
}),
|
|
TestCase("ByFields succeeds", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.Find.ByFields("x", FieldMatch.Any, [Field.GE("Golf", 0), Field.LE("Flog", 1)]),
|
|
$"SELECT data FROM x WHERE data->>'Golf' >= @field0 OR data->>'Flog' <= @field1",
|
|
"SELECT by JSON comparison query not correct");
|
|
}),
|
|
#pragma warning disable CS0618
|
|
TestCase("ByField succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Find.ByField(PostgresDb.TableName, Field.GE("Golf", 0)),
|
|
$"SELECT data FROM {PostgresDb.TableName} WHERE data->>'Golf' >= @field0",
|
|
"SELECT by JSON comparison query not correct");
|
|
}),
|
|
#pragma warning restore CS0618
|
|
TestCase("byContains succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Find.ByContains(PostgresDb.TableName),
|
|
$"SELECT data FROM {PostgresDb.TableName} WHERE data @> @criteria",
|
|
"SELECT by JSON containment query not correct");
|
|
}),
|
|
TestCase("byJsonPath succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Find.ByJsonPath(PostgresDb.TableName),
|
|
$"SELECT data FROM {PostgresDb.TableName} WHERE data @? @path::jsonpath",
|
|
"SELECT by JSON Path match query not correct");
|
|
})
|
|
]),
|
|
TestList("Patch",
|
|
[
|
|
TestCase("ById succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Patch.ById(PostgresDb.TableName),
|
|
$"UPDATE {PostgresDb.TableName} SET data = data || @data WHERE data->>'Id' = @id",
|
|
"UPDATE partial by ID statement not correct");
|
|
}),
|
|
TestCase("ByFields succeeds", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.Patch.ByFields("x", FieldMatch.All,
|
|
[Field.LT("Snail", 0), Field.BT("Slug", 8, 14)]),
|
|
$"UPDATE x SET data = data || @data WHERE data->>'Snail' < @field0 AND (data->>'Slug')::numeric BETWEEN @field1min AND @field1max",
|
|
"UPDATE partial by ID statement not correct");
|
|
}),
|
|
#pragma warning disable CS0618
|
|
TestCase("ByField succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Patch.ByField(PostgresDb.TableName, Field.LT("Snail", 0)),
|
|
$"UPDATE {PostgresDb.TableName} SET data = data || @data WHERE data->>'Snail' < @field0",
|
|
"UPDATE partial by ID statement not correct");
|
|
}),
|
|
#pragma warning restore CS0618
|
|
TestCase("ByContains succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Patch.ByContains(PostgresDb.TableName),
|
|
$"UPDATE {PostgresDb.TableName} SET data = data || @data WHERE data @> @criteria",
|
|
"UPDATE partial by JSON containment statement not correct");
|
|
}),
|
|
TestCase("ByJsonPath succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Patch.ByJsonPath(PostgresDb.TableName),
|
|
$"UPDATE {PostgresDb.TableName} SET data = data || @data WHERE data @? @path::jsonpath",
|
|
"UPDATE partial by JSON Path statement not correct");
|
|
})
|
|
]),
|
|
TestList("RemoveFields",
|
|
[
|
|
TestCase("ById succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.RemoveFields.ById(PostgresDb.TableName),
|
|
$"UPDATE {PostgresDb.TableName} SET data = data - @name WHERE data->>'Id' = @id",
|
|
"Remove field by ID query not correct");
|
|
}),
|
|
TestCase("ByFields succeeds", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.RemoveFields.ByFields("x", FieldMatch.Any,
|
|
[Field.LT("Fly", 0), Field.LT("Ant", 2)]),
|
|
$"UPDATE x SET data = data - @name WHERE data->>'Fly' < @field0 OR data->>'Ant' < @field1",
|
|
"Remove field by field query not correct");
|
|
}),
|
|
#pragma warning disable CS0618
|
|
TestCase("ByField succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.RemoveFields.ByField(PostgresDb.TableName, Field.LT("Fly", 0)),
|
|
$"UPDATE {PostgresDb.TableName} SET data = data - @name WHERE data->>'Fly' < @field0",
|
|
"Remove field by field query not correct");
|
|
}),
|
|
#pragma warning restore CS0618
|
|
TestCase("ByContains succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.RemoveFields.ByContains(PostgresDb.TableName),
|
|
$"UPDATE {PostgresDb.TableName} SET data = data - @name WHERE data @> @criteria",
|
|
"Remove field by contains query not correct");
|
|
}),
|
|
TestCase("ByJsonPath succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.RemoveFields.ByJsonPath(PostgresDb.TableName),
|
|
$"UPDATE {PostgresDb.TableName} SET data = data - @name WHERE data @? @path::jsonpath",
|
|
"Remove field by JSON path query not correct");
|
|
})
|
|
]),
|
|
TestList("Delete",
|
|
[
|
|
TestCase("ById succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Delete.ById(PostgresDb.TableName),
|
|
$"DELETE FROM {PostgresDb.TableName} WHERE data->>'Id' = @id",
|
|
"DELETE by ID query not correct");
|
|
}),
|
|
TestCase("ByFields succeeds", () =>
|
|
{
|
|
Expect.equal(
|
|
Postgres.Query.Delete.ByFields("tbl", FieldMatch.All, [Field.NEX("gone"), Field.EX("here")]),
|
|
$"DELETE FROM tbl WHERE data->>'gone' IS NULL AND data->>'here' IS NOT NULL",
|
|
"DELETE by JSON comparison query not correct");
|
|
}),
|
|
#pragma warning disable CS0618
|
|
TestCase("ByField succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Delete.ByField(PostgresDb.TableName, Field.NEX("gone")),
|
|
$"DELETE FROM {PostgresDb.TableName} WHERE data->>'gone' IS NULL",
|
|
"DELETE by JSON comparison query not correct");
|
|
}),
|
|
#pragma warning restore CS0618
|
|
TestCase("byContains succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Delete.ByContains(PostgresDb.TableName),
|
|
$"DELETE FROM {PostgresDb.TableName} WHERE data @> @criteria",
|
|
"DELETE by JSON containment query not correct");
|
|
}),
|
|
TestCase("byJsonPath succeeds", () =>
|
|
{
|
|
Expect.equal(Postgres.Query.Delete.ByJsonPath(PostgresDb.TableName),
|
|
$"DELETE FROM {PostgresDb.TableName} WHERE data @? @path::jsonpath",
|
|
"DELETE by JSON Path match query not correct");
|
|
})
|
|
])
|
|
])
|
|
]);
|
|
|
|
private static readonly List<JsonDocument> TestDocuments =
|
|
[
|
|
new() { Id = "one", Value = "FIRST!", NumValue = 0 },
|
|
new() { Id = "two", Value = "another", NumValue = 10, Sub = new() { Foo = "green", Bar = "blue" } },
|
|
new() { Id = "three", Value = "", NumValue = 4 },
|
|
new() { Id = "four", Value = "purple", NumValue = 17, Sub = new() { Foo = "green", Bar = "red" } },
|
|
new() { Id = "five", Value = "purple", NumValue = 18 }
|
|
];
|
|
|
|
/// <summary>
|
|
/// Add the test documents to the database
|
|
/// </summary>
|
|
internal static async Task LoadDocs()
|
|
{
|
|
foreach (var doc in TestDocuments) await Document.Insert(SqliteDb.TableName, doc);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Integration tests for the PostgreSQL library
|
|
/// </summary>
|
|
private static readonly Test Integration = TestList("Integration",
|
|
[
|
|
TestList("Configuration",
|
|
[
|
|
TestCase("UseDataSource disposes existing source", () =>
|
|
{
|
|
using var db1 = ThrowawayDatabase.Create(PostgresDb.ConnStr.Value);
|
|
var source = PostgresDb.MkDataSource(db1.ConnectionString);
|
|
Postgres.Configuration.UseDataSource(source);
|
|
|
|
using var db2 = ThrowawayDatabase.Create(PostgresDb.ConnStr.Value);
|
|
Postgres.Configuration.UseDataSource(PostgresDb.MkDataSource(db2.ConnectionString));
|
|
try
|
|
{
|
|
_ = source.OpenConnection();
|
|
Expect.isTrue(false, "Data source should have been disposed");
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// This is what should have happened
|
|
}
|
|
}),
|
|
TestCase("DataSource returns configured data source", () =>
|
|
{
|
|
using var db = ThrowawayDatabase.Create(PostgresDb.ConnStr.Value);
|
|
var source = PostgresDb.MkDataSource(db.ConnectionString);
|
|
Postgres.Configuration.UseDataSource(source);
|
|
|
|
Expect.isTrue(ReferenceEquals(source, Postgres.Configuration.DataSource()),
|
|
"Data source should have been the same");
|
|
})
|
|
]),
|
|
TestList("Custom",
|
|
[
|
|
TestList("List",
|
|
[
|
|
TestCase("succeeds when data is found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var docs = await Custom.List(Query.SelectFromTable(PostgresDb.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 = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var docs = await Custom.List(
|
|
$"SELECT data FROM {PostgresDb.TableName} WHERE data @? @path::jsonpath",
|
|
new[] { Tuple.Create("@path", Sql.@string("$.NumValue ? (@ > 100)")) },
|
|
Results.FromData<JsonDocument>);
|
|
Expect.isEmpty(docs, "There should have been no documents returned");
|
|
})
|
|
]),
|
|
TestList("Single",
|
|
[
|
|
TestCase("succeeds when a row is found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Custom.Single($"SELECT data FROM {PostgresDb.TableName} WHERE data ->> 'Id' = @id",
|
|
new[] { Tuple.Create("@id", Sql.@string("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 = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Custom.Single($"SELECT data FROM {PostgresDb.TableName} WHERE data ->> 'Id' = @id",
|
|
new[] { Tuple.Create("@id", Sql.@string("eighty")) }, Results.FromData<JsonDocument>);
|
|
Expect.isNull(doc, "There should not have been a document returned");
|
|
})
|
|
]),
|
|
TestList("NonQuery",
|
|
[
|
|
TestCase("succeeds when operating on data", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Custom.NonQuery($"DELETE FROM {PostgresDb.TableName}", Parameters.None);
|
|
|
|
var remaining = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(remaining, 0, "There should be no documents remaining in the table");
|
|
}),
|
|
TestCase("succeeds when no data matches where clause", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Custom.NonQuery($"DELETE FROM {PostgresDb.TableName} WHERE data @? @path::jsonpath",
|
|
new[] { Tuple.Create("@path", Sql.@string("$.NumValue ? (@ > 100)")) });
|
|
|
|
var remaining = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(remaining, 5, "There should be 5 documents remaining in the table");
|
|
})
|
|
]),
|
|
TestCase("Scalar succeeds", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
var nbr = await Custom.Scalar("SELECT 5 AS test_value", Parameters.None, row => row.@int("test_value"));
|
|
Expect.equal(nbr, 5, "The query should have returned the number 5");
|
|
})
|
|
]),
|
|
TestList("Definition",
|
|
[
|
|
TestCase("EnsureTable succeeds", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
var exists = await TableExists();
|
|
var alsoExists = await KeyExists();
|
|
Expect.isFalse(exists, "The table should not exist already");
|
|
Expect.isFalse(alsoExists, "The key index should not exist already");
|
|
|
|
await Definition.EnsureTable("ensured");
|
|
exists = await TableExists();
|
|
alsoExists = await KeyExists();
|
|
Expect.isTrue(exists, "The table should now exist");
|
|
Expect.isTrue(alsoExists, "The key index should now exist");
|
|
return;
|
|
|
|
Task<bool> TableExists() => Custom.Scalar(
|
|
"SELECT EXISTS (SELECT 1 FROM pg_class WHERE relname = 'ensured') AS it", Parameters.None,
|
|
Results.ToExists);
|
|
Task<bool> KeyExists() => Custom.Scalar(
|
|
"SELECT EXISTS (SELECT 1 FROM pg_class WHERE relname = 'idx_ensured_key') AS it", Parameters.None,
|
|
Results.ToExists);
|
|
}),
|
|
TestCase("EnsureDocumentIndex succeeds", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
var exists = await IndexExists();
|
|
Expect.isFalse(exists, "The index should not exist already");
|
|
|
|
await Definition.EnsureTable("ensured");
|
|
await Definition.EnsureDocumentIndex("ensured", DocumentIndex.Optimized);
|
|
exists = await IndexExists();
|
|
Expect.isTrue(exists, "The index should now exist");
|
|
return;
|
|
|
|
Task<bool> IndexExists() => Custom.Scalar(
|
|
"SELECT EXISTS (SELECT 1 FROM pg_class WHERE relname = 'idx_ensured_document') AS it",
|
|
Parameters.None, Results.ToExists);
|
|
}),
|
|
TestCase("EnsureFieldIndex succeeds", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
var exists = await IndexExists();
|
|
Expect.isFalse(exists, "The index should not exist already");
|
|
|
|
await Definition.EnsureTable("ensured");
|
|
await Definition.EnsureFieldIndex("ensured", "test", new[] { "Id", "Category" });
|
|
exists = await IndexExists();
|
|
Expect.isTrue(exists, "The index should now exist");
|
|
return;
|
|
|
|
Task<bool> IndexExists() => Custom.Scalar(
|
|
"SELECT EXISTS (SELECT 1 FROM pg_class WHERE relname = 'idx_ensured_test') AS it", Parameters.None,
|
|
Results.ToExists);
|
|
})
|
|
]),
|
|
TestList("Document",
|
|
[
|
|
TestList("Insert",
|
|
[
|
|
TestCase("succeeds", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
var before = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(before, 0, "There should be no documents in the table");
|
|
|
|
await Document.Insert(PostgresDb.TableName,
|
|
new JsonDocument { Id = "turkey", Sub = new() { Foo = "gobble", Bar = "gobble" } });
|
|
var after = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(after, 1, "There should have been one document inserted");
|
|
}),
|
|
TestCase("fails for duplicate key", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await Document.Insert(PostgresDb.TableName, new JsonDocument { Id = "test" });
|
|
try
|
|
{
|
|
await Document.Insert(PostgresDb.TableName, new JsonDocument { Id = "test" });
|
|
Expect.isTrue(false, "An exception should have been raised for duplicate document ID insert");
|
|
}
|
|
catch (Exception)
|
|
{
|
|
// This is what should have happened
|
|
}
|
|
})
|
|
]),
|
|
TestList("Save",
|
|
[
|
|
TestCase("succeeds when a document is inserted", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
var before = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(before, 0, "There should be no documents in the table");
|
|
|
|
await Document.Save(PostgresDb.TableName,
|
|
new JsonDocument { Id = "test", Sub = new() { Foo = "a", Bar = "b" } });
|
|
var after = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(after, 1, "There should have been one document inserted");
|
|
}),
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await Document.Insert(PostgresDb.TableName,
|
|
new JsonDocument { Id = "test", Sub = new() { Foo = "a", Bar = "b" } });
|
|
|
|
var before = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "test");
|
|
Expect.isNotNull(before, "There should have been a document returned");
|
|
Expect.equal(before.Id, "test", "The document is not correct");
|
|
|
|
before.Sub = new() { Foo = "c", Bar = "d" };
|
|
await Document.Save(PostgresDb.TableName, before);
|
|
var after = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "test");
|
|
Expect.isNotNull(after, "There should have been a document returned post-update");
|
|
Expect.equal(after.Id, "test", "The document is not correct");
|
|
Expect.equal(after.Sub!.Foo, "c", "The updated document is not correct");
|
|
})
|
|
])
|
|
]),
|
|
TestList("Count",
|
|
[
|
|
TestCase("All succeeds", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var theCount = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(theCount, 5, "There should have been 5 matching documents");
|
|
}),
|
|
#pragma warning disable CS0618
|
|
TestCase("ByField succeeds for numeric range", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var theCount = await Count.ByField(PostgresDb.TableName, Field.BT("NumValue", 10, 20));
|
|
Expect.equal(theCount, 3, "There should have been 3 matching documents");
|
|
}),
|
|
TestCase("ByField succeeds for non-numeric range", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var theCount = await Count.ByField(PostgresDb.TableName, Field.BT("Value", "aardvark", "apple"));
|
|
Expect.equal(theCount, 1, "There should have been 1 matching document");
|
|
}),
|
|
#pragma warning restore CS0618
|
|
TestCase("ByContains succeeds", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var theCount = await Count.ByContains(PostgresDb.TableName, new { Value = "purple" });
|
|
Expect.equal(theCount, 2, "There should have been 2 matching documents");
|
|
}),
|
|
TestCase("ByJsonPath succeeds", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var theCount = await Count.ByJsonPath(PostgresDb.TableName, "$.NumValue ? (@ > 5)");
|
|
Expect.equal(theCount, 3, "There should have been 3 matching documents");
|
|
})
|
|
]),
|
|
TestList("Exists",
|
|
[
|
|
TestList("ById",
|
|
[
|
|
TestCase("succeeds when a document exists", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var exists = await Exists.ById(PostgresDb.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 = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var exists = await Exists.ById(PostgresDb.TableName, "seven");
|
|
Expect.isFalse(exists, "There should not have been an existing document");
|
|
})
|
|
]),
|
|
#pragma warning disable CS0618
|
|
TestList("ByField",
|
|
[
|
|
TestCase("succeeds when documents exist", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var exists = await Exists.ByField(PostgresDb.TableName, Field.NEX("Sub"));
|
|
Expect.isTrue(exists, "There should have been existing documents");
|
|
}),
|
|
TestCase("succeeds when documents do not exist", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var exists = await Exists.ByField(PostgresDb.TableName, Field.EQ("NumValue", "six"));
|
|
Expect.isFalse(exists, "There should not have been existing documents");
|
|
})
|
|
]),
|
|
#pragma warning restore CS0618
|
|
TestList("ByContains",
|
|
[
|
|
TestCase("succeeds when documents exist", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var exists = await Exists.ByContains(PostgresDb.TableName, new { NumValue = 10 });
|
|
Expect.isTrue(exists, "There should have been existing documents");
|
|
}),
|
|
TestCase("succeeds when no matching documents exist", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var exists = await Exists.ByContains(PostgresDb.TableName, new { Nothing = "none" });
|
|
Expect.isFalse(exists, "There should not have been any existing documents");
|
|
})
|
|
]),
|
|
TestList("ByJsonPath",
|
|
[
|
|
TestCase("succeeds when documents exist", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var exists = await Exists.ByJsonPath(PostgresDb.TableName, "$.Sub.Foo ? (@ == \"green\")");
|
|
Expect.isTrue(exists, "There should have been existing documents");
|
|
}),
|
|
TestCase("succeeds when no matching documents exist", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var exists = await Exists.ByJsonPath(PostgresDb.TableName, "$.NumValue ? (@ > 1000)");
|
|
Expect.isFalse(exists, "There should not have been any existing documents");
|
|
})
|
|
])
|
|
]),
|
|
TestList("Find",
|
|
[
|
|
TestList("All",
|
|
[
|
|
TestCase("succeeds when there is data", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
await Document.Insert(PostgresDb.TableName, new SubDocument { Foo = "one", Bar = "two" });
|
|
await Document.Insert(PostgresDb.TableName, new SubDocument { Foo = "three", Bar = "four" });
|
|
await Document.Insert(PostgresDb.TableName, new SubDocument { Foo = "five", Bar = "six" });
|
|
|
|
var results = await Find.All<SubDocument>(PostgresDb.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 = PostgresDb.BuildDb();
|
|
var results = await Find.All<SubDocument>(PostgresDb.TableName);
|
|
Expect.isEmpty(results, "There should have been no documents returned");
|
|
})
|
|
]),
|
|
TestList("ById",
|
|
[
|
|
TestCase("succeeds when a document is found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Find.ById<string, JsonDocument>(PostgresDb.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 = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "three hundred eighty-seven");
|
|
Expect.isNull(doc, "There should not have been a document returned");
|
|
})
|
|
]),
|
|
#pragma warning disable CS0618
|
|
TestList("ByField",
|
|
[
|
|
TestCase("succeeds when documents are found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var docs = await Find.ByField<JsonDocument>(PostgresDb.TableName, Field.EQ("Value", "another"));
|
|
Expect.equal(docs.Count, 1, "There should have been one document returned");
|
|
}),
|
|
TestCase("succeeds when documents are not found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var docs = await Find.ByField<JsonDocument>(PostgresDb.TableName, Field.EQ("Value", "mauve"));
|
|
Expect.isEmpty(docs, "There should have been no documents returned");
|
|
})
|
|
]),
|
|
#pragma warning restore CS0618
|
|
TestList("ByContains",
|
|
[
|
|
TestCase("succeeds when documents are found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var docs = await Find.ByContains<JsonDocument>(PostgresDb.TableName,
|
|
new { Sub = new { Foo = "green" } });
|
|
Expect.equal(docs.Count, 2, "There should have been two documents returned");
|
|
}),
|
|
TestCase("succeeds when documents are not found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var docs = await Find.ByContains<JsonDocument>(PostgresDb.TableName, new { Value = "mauve" });
|
|
Expect.isEmpty(docs, "There should have been no documents returned");
|
|
})
|
|
]),
|
|
TestList("ByJsonPath",
|
|
[
|
|
TestCase("succeeds when documents are found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var docs = await Find.ByJsonPath<JsonDocument>(PostgresDb.TableName, "$.NumValue ? (@ < 15)");
|
|
Expect.equal(docs.Count, 3, "There should have been 3 documents returned");
|
|
}),
|
|
TestCase("succeeds when documents are not found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var docs = await Find.ByJsonPath<JsonDocument>(PostgresDb.TableName, "$.NumValue ? (@ < 0)");
|
|
Expect.isEmpty(docs, "There should have been no documents returned");
|
|
})
|
|
]),
|
|
#pragma warning disable CS0618
|
|
TestList("FirstByField",
|
|
[
|
|
TestCase("succeeds when a document is found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Find.FirstByField<JsonDocument>(PostgresDb.TableName, 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 = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Find.FirstByField<JsonDocument>(PostgresDb.TableName, Field.EQ("Value", "purple"));
|
|
Expect.isNotNull(doc, "There should have been a document returned");
|
|
Expect.contains(new[] { "five", "four" }, doc.Id, "An incorrect document was returned");
|
|
}),
|
|
TestCase("succeeds when a document is not found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Find.FirstByField<JsonDocument>(PostgresDb.TableName, Field.EQ("Value", "absent"));
|
|
Expect.isNull(doc, "There should not have been a document returned");
|
|
})
|
|
]),
|
|
#pragma warning restore CS0618
|
|
TestList("FirstByContains",
|
|
[
|
|
TestCase("succeeds when a document is found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Find.FirstByContains<JsonDocument>(PostgresDb.TableName, new { 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 = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Find.FirstByContains<JsonDocument>(PostgresDb.TableName,
|
|
new { Sub = new { Foo = "green" } });
|
|
Expect.isNotNull(doc, "There should have been a document returned");
|
|
Expect.contains(new[] { "two", "four" }, doc.Id, "An incorrect document was returned");
|
|
}),
|
|
TestCase("succeeds when a document is not found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Find.FirstByContains<JsonDocument>(PostgresDb.TableName, new { Value = "absent" });
|
|
Expect.isNull(doc, "There should not have been a document returned");
|
|
})
|
|
]),
|
|
TestList("FirstByJsonPath",
|
|
[
|
|
TestCase("succeeds when a document is found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Find.FirstByJsonPath<JsonDocument>(PostgresDb.TableName,
|
|
"$.Value ? (@ == \"FIRST!\")");
|
|
Expect.isNotNull(doc, "There should have been a document returned");
|
|
Expect.equal(doc.Id, "one", "The incorrect document was returned");
|
|
}),
|
|
TestCase("succeeds when multiple documents are found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Find.FirstByJsonPath<JsonDocument>(PostgresDb.TableName,
|
|
"$.Sub.Foo ? (@ == \"green\")");
|
|
Expect.isNotNull(doc, "There should have been a document returned");
|
|
Expect.contains(new[] { "two", "four" }, doc.Id, "An incorrect document was returned");
|
|
}),
|
|
TestCase("succeeds when a document is not found", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
var doc = await Find.FirstByJsonPath<JsonDocument>(PostgresDb.TableName, "$.Id ? (@ == \"nope\")");
|
|
Expect.isNull(doc, "There should not have been a document returned");
|
|
})
|
|
])
|
|
]),
|
|
TestList("Update",
|
|
[
|
|
TestList("ById",
|
|
[
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Update.ById(PostgresDb.TableName, "one",
|
|
new JsonDocument { Id = "one", Sub = new() { Foo = "blue", Bar = "red" } });
|
|
var after = await Find.ById<string, JsonDocument>(PostgresDb.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 (ID)");
|
|
Expect.equal(after.Value, "", "The updated document is not correct (Value)");
|
|
Expect.equal(after.NumValue, 0, "The updated document is not correct (NumValue)");
|
|
Expect.isNotNull(after.Sub, "The updated document should have had a sub-document");
|
|
Expect.equal(after.Sub!.Foo, "blue", "The updated document is not correct (Sub.Foo)");
|
|
Expect.equal(after.Sub.Bar, "red", "The updated document is not correct (Sub.Bar)");
|
|
}),
|
|
TestCase("succeeds when no document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
var before = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(before, 0, "There should have been no documents returned");
|
|
|
|
// This not raising an exception is the test
|
|
await Update.ById(PostgresDb.TableName, "test",
|
|
new JsonDocument { Id = "x", Sub = new() { Foo = "blue", Bar = "red" } });
|
|
})
|
|
]),
|
|
TestList("ByFunc",
|
|
[
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Update.ByFunc(PostgresDb.TableName, doc => doc.Id,
|
|
new JsonDocument { Id = "one", Value = "le un", NumValue = 1 });
|
|
var after = await Find.ById<string, JsonDocument>(PostgresDb.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 (ID)");
|
|
Expect.equal(after.Value, "le un", "The updated document is not correct (Value)");
|
|
Expect.equal(after.NumValue, 1, "The updated document is not correct (NumValue)");
|
|
Expect.isNull(after.Sub, "The updated document should not have had a sub-document");
|
|
}),
|
|
TestCase("succeeds when no document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
var before = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(before, 0, "There should have been no documents returned");
|
|
|
|
// This not raising an exception is the test
|
|
await Update.ByFunc(PostgresDb.TableName, doc => doc.Id,
|
|
new JsonDocument { Id = "one", Value = "le un", NumValue = 1 });
|
|
})
|
|
])
|
|
]),
|
|
TestList("Patch",
|
|
[
|
|
TestList("ById",
|
|
[
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Patch.ById(PostgresDb.TableName, "one", new { NumValue = 44 });
|
|
var after = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "one");
|
|
Expect.isNotNull(after, "There should have been a document returned post-update");
|
|
Expect.equal(after.NumValue, 44, "The updated document is not correct");
|
|
}),
|
|
TestCase("succeeds when no document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
var before = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(before, 0, "There should have been no documents returned");
|
|
|
|
// This not raising an exception is the test
|
|
await Patch.ById(PostgresDb.TableName, "test", new { Foo = "green" });
|
|
})
|
|
]),
|
|
#pragma warning disable CS0618
|
|
TestList("ByField",
|
|
[
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Patch.ByField(PostgresDb.TableName, Field.EQ("Value", "purple"), new { NumValue = 77 });
|
|
var after = await Count.ByField(PostgresDb.TableName, Field.EQ("NumValue", "77"));
|
|
Expect.equal(after, 2, "There should have been 2 documents returned");
|
|
}),
|
|
TestCase("succeeds when no document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
var before = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(before, 0, "There should have been no documents returned");
|
|
|
|
// This not raising an exception is the test
|
|
await Patch.ByField(PostgresDb.TableName, Field.EQ("Value", "burgundy"), new { Foo = "green" });
|
|
})
|
|
]),
|
|
#pragma warning restore CS0618
|
|
TestList("ByContains",
|
|
[
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Patch.ByContains(PostgresDb.TableName, new { Value = "purple" }, new { NumValue = 77 });
|
|
var after = await Count.ByContains(PostgresDb.TableName, new { NumValue = 77 });
|
|
Expect.equal(after, 2, "There should have been 2 documents returned");
|
|
}),
|
|
TestCase("succeeds when no document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
var before = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(before, 0, "There should have been no documents returned");
|
|
|
|
// This not raising an exception is the test
|
|
await Patch.ByContains(PostgresDb.TableName, new { Value = "burgundy" }, new { Foo = "green" });
|
|
})
|
|
]),
|
|
TestList("ByJsonPath",
|
|
[
|
|
TestCase("succeeds when a document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Patch.ByJsonPath(PostgresDb.TableName, "$.NumValue ? (@ > 10)", new { NumValue = 1000 });
|
|
var after = await Count.ByJsonPath(PostgresDb.TableName, "$.NumValue ? (@ > 999)");
|
|
Expect.equal(after, 2, "There should have been 2 documents returned");
|
|
}),
|
|
TestCase("succeeds when no document is updated", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
var before = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(before, 0, "There should have been no documents returned");
|
|
|
|
// This not raising an exception is the test
|
|
await Patch.ByJsonPath(PostgresDb.TableName, "$.NumValue ? (@ < 0)", new { Foo = "green" });
|
|
})
|
|
])
|
|
]),
|
|
TestList("RemoveFields",
|
|
[
|
|
TestList("ById",
|
|
[
|
|
TestCase("succeeds when multiple fields are removed", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await RemoveFields.ById(PostgresDb.TableName, "two", new[] { "Sub", "Value" });
|
|
var updated = await Find.ById<string, JsonDocument>(PostgresDb.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 single field is removed", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await RemoveFields.ById(PostgresDb.TableName, "two", new[] { "Sub" });
|
|
var updated = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "two");
|
|
Expect.isNotNull(updated, "The updated document should have been retrieved");
|
|
Expect.notEqual(updated.Value, "", "The string value should not 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 = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
// This not raising an exception is the test
|
|
await RemoveFields.ById(PostgresDb.TableName, "two", new[] { "AFieldThatIsNotThere" });
|
|
}),
|
|
TestCase("succeeds when no document is matched", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
// This not raising an exception is the test
|
|
await RemoveFields.ById(PostgresDb.TableName, "two", new[] { "Value" });
|
|
})
|
|
]),
|
|
#pragma warning disable CS0618
|
|
TestList("ByField",
|
|
[
|
|
TestCase("succeeds when multiple fields are removed", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await RemoveFields.ByField(PostgresDb.TableName, Field.EQ("NumValue", "17"),
|
|
new[] { "Sub", "Value" });
|
|
var updated = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "four");
|
|
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 single field is removed", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await RemoveFields.ByField(PostgresDb.TableName, Field.EQ("NumValue", "17"), new[] { "Sub" });
|
|
var updated = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "four");
|
|
Expect.isNotNull(updated, "The updated document should have been retrieved");
|
|
Expect.notEqual(updated.Value, "", "The string value should not 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 = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
// This not raising an exception is the test
|
|
await RemoveFields.ByField(PostgresDb.TableName, Field.EQ("NumValue", "17"), new[] { "Nothing" });
|
|
}),
|
|
TestCase("succeeds when no document is matched", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
// This not raising an exception is the test
|
|
await RemoveFields.ByField(PostgresDb.TableName, Field.NE("Abracadabra", "apple"),
|
|
new[] { "Value" });
|
|
})
|
|
]),
|
|
#pragma warning restore CS0618
|
|
TestList("ByContains",
|
|
[
|
|
TestCase("succeeds when multiple fields are removed", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await RemoveFields.ByContains(PostgresDb.TableName, new { NumValue = 17 },
|
|
new[] { "Sub", "Value" });
|
|
var updated = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "four");
|
|
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 single field is removed", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await RemoveFields.ByContains(PostgresDb.TableName, new { NumValue = 17 }, new[] { "Sub" });
|
|
var updated = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "four");
|
|
Expect.isNotNull(updated, "The updated document should have been retrieved");
|
|
Expect.notEqual(updated.Value, "", "The string value should not 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 = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
// This not raising an exception is the test
|
|
await RemoveFields.ByContains(PostgresDb.TableName, new { NumValue = 17 }, new[] { "Nothing" });
|
|
}),
|
|
TestCase("succeeds when no document is matched", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
// This not raising an exception is the test
|
|
await RemoveFields.ByContains(PostgresDb.TableName, new { Abracadabra = "apple" },
|
|
new[] { "Value" });
|
|
})
|
|
]),
|
|
TestList("ByJsonPath",
|
|
[
|
|
TestCase("succeeds when multiple fields are removed", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await RemoveFields.ByJsonPath(PostgresDb.TableName, "$.NumValue ? (@ == 17)",
|
|
new[] { "Sub", "Value" });
|
|
var updated = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "four");
|
|
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 single field is removed", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await RemoveFields.ByJsonPath(PostgresDb.TableName, "$.NumValue ? (@ == 17)", new[] { "Sub" });
|
|
var updated = await Find.ById<string, JsonDocument>(PostgresDb.TableName, "four");
|
|
Expect.isNotNull(updated, "The updated document should have been retrieved");
|
|
Expect.notEqual(updated.Value, "", "The string value should not 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 = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
// This not raising an exception is the test
|
|
await RemoveFields.ByJsonPath(PostgresDb.TableName, "$.NumValue ? (@ == 17)", new[] { "Nothing" });
|
|
}),
|
|
TestCase("succeeds when no document is matched", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
|
|
// This not raising an exception is the test
|
|
await RemoveFields.ByJsonPath(PostgresDb.TableName, "$.Abracadabra ? (@ == \"apple\")",
|
|
new[] { "Value" });
|
|
})
|
|
])
|
|
]),
|
|
TestList("Delete",
|
|
[
|
|
TestList("ById",
|
|
[
|
|
TestCase("succeeds when a document is deleted", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Delete.ById(PostgresDb.TableName, "four");
|
|
var remaining = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(remaining, 4, "There should have been 4 documents remaining");
|
|
}),
|
|
TestCase("succeeds when a document is not deleted", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Delete.ById(PostgresDb.TableName, "thirty");
|
|
var remaining = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(remaining, 5, "There should have been 5 documents remaining");
|
|
})
|
|
]),
|
|
#pragma warning disable CS0618
|
|
TestList("ByField",
|
|
[
|
|
TestCase("succeeds when documents are deleted", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Delete.ByField(PostgresDb.TableName, Field.EQ("Value", "purple"));
|
|
var remaining = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(remaining, 3, "There should have been 3 documents remaining");
|
|
}),
|
|
TestCase("succeeds when documents are not deleted", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Delete.ByField(PostgresDb.TableName, Field.EQ("Value", "crimson"));
|
|
var remaining = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(remaining, 5, "There should have been 5 documents remaining");
|
|
})
|
|
]),
|
|
#pragma warning restore CS0618
|
|
TestList("ByContains",
|
|
[
|
|
TestCase("succeeds when documents are deleted", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Delete.ByContains(PostgresDb.TableName, new { Value = "purple" });
|
|
var remaining = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(remaining, 3, "There should have been 3 documents remaining");
|
|
}),
|
|
TestCase("succeeds when documents are not deleted", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Delete.ByContains(PostgresDb.TableName, new { Value = "crimson" });
|
|
var remaining = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(remaining, 5, "There should have been 5 documents remaining");
|
|
})
|
|
]),
|
|
TestList("ByJsonPath",
|
|
[
|
|
TestCase("succeeds when documents are deleted", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Delete.ByJsonPath(PostgresDb.TableName, "$.Sub.Foo ? (@ == \"green\")");
|
|
var remaining = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(remaining, 3, "There should have been 3 documents remaining");
|
|
}),
|
|
TestCase("succeeds when documents are not deleted", async () =>
|
|
{
|
|
await using var db = PostgresDb.BuildDb();
|
|
await LoadDocs();
|
|
|
|
await Delete.ByJsonPath(PostgresDb.TableName, "$.NumValue ? (@ > 100)");
|
|
var remaining = await Count.All(PostgresDb.TableName);
|
|
Expect.equal(remaining, 5, "There should have been 5 documents remaining");
|
|
})
|
|
])
|
|
])
|
|
]);
|
|
|
|
/// <summary>
|
|
/// All Postgres C# tests
|
|
/// </summary>
|
|
[Tests]
|
|
public static readonly Test All = TestList("Postgres.C#", [Unit, TestSequenced(Integration)]);
|
|
}
|