bit-badger/BitBadger.Documents
1
0
Fork 0
Code Issues Pull Requests Projects Releases 11 Activity

v4.1 #11

Merged
danieljsummers merged 22 commits from v4point1 into main 2025-04-19 19:50:17 +00:00
Conversation 0 Commits 22 Files Changed 45 +814 -2
3 changed files with 814 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 5e5dbd3b80 - Show all commits

6
src/Postgres/WithProps.fs
View File

@ -771,8 +771,10 @@ module Json =
/// <param name="docId">The ID of the document to retrieve</param> /// <param name="docId">The ID of the document to retrieve</param>
/// <param name="sqlProps">The <c>SqlProps</c> to use to execute the query</param> /// <param name="sqlProps">The <c>SqlProps</c> to use to execute the query</param>
[<CompiledName "WriteById">] [<CompiledName "WriteById">]
let writeById<'TKey> tableName (writer: StreamWriter) (docId: 'TKey) sqlProps = let writeById<'TKey> tableName (writer: StreamWriter) (docId: 'TKey) sqlProps = backgroundTask {
byId tableName docId sqlProps |> writer.Write let! json = byId tableName docId sqlProps
do! writer.WriteAsync json
}
/// <summary>Retrieve JSON documents matching JSON field comparisons (<c>-&gt;&gt; =</c>, etc.)</summary> /// <summary>Retrieve JSON documents matching JSON field comparisons (<c>-&gt;&gt; =</c>, etc.)</summary>
/// <param name="tableName">The table from which documents should be retrieved (may include schema)</param> /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>

417
src/Tests.CSharp/PostgresCSharpTests.cs
View File

@ -1706,6 +1706,423 @@ public static class PostgresCSharpTests
[Field.Named("Sub.Bar DESC")]), [Field.Named("Sub.Bar DESC")]),
"four"); "four");
}) })
]),
TestList("WriteAll",
[
TestCase("succeeds when there is data", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteAll(PostgresDb.TableName, writer);
VerifyAllData(StreamText(stream));
}),
TestCase("succeeds when there is no data", async () =>
{
await using var db = PostgresDb.BuildDb();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteAll(PostgresDb.TableName, writer);
VerifyEmpty(StreamText(stream));
})
]),
TestList("WriteAllOrdered",
[
TestCase("succeeds when ordering numerically", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteAllOrdered(PostgresDb.TableName, writer, [Field.Named("n:NumValue")]);
VerifyExpectedOrder(StreamText(stream), "one", "three", "two", "four", "five");
}),
TestCase("succeeds when ordering numerically descending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteAllOrdered(PostgresDb.TableName, writer, [Field.Named("n:NumValue DESC")]);
VerifyExpectedOrder(StreamText(stream), "five", "four", "two", "three", "one");
}),
TestCase("succeeds when ordering alphabetically", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteAllOrdered(PostgresDb.TableName, writer, [Field.Named("Id DESC")]);
VerifyExpectedOrder(StreamText(stream), "two", "three", "one", "four", "five");
})
]),
TestList("WriteById",
[
TestCase("succeeds when a document is found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteById(PostgresDb.TableName, writer, "two");
var json = StreamText(stream);
Expect.stringStarts(json, """{"Id": "two",""", "An incorrect document was returned");
Expect.stringEnds(json, "}", "JSON should have ended with this document");
}),
TestCase("succeeds when a document is not found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteById(PostgresDb.TableName, writer, "three hundred eighty-seven");
VerifyNoDoc(StreamText(stream));
})
]),
TestList("WriteByFields",
[
TestCase("succeeds when documents are found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByFields(PostgresDb.TableName, writer, FieldMatch.All,
[Field.In("Value", ["purple", "blue"]), Field.Exists("Sub")]);
VerifySingleById(StreamText(stream), "four");
}),
TestCase("succeeds when documents are found using IN with numeric field", async() =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByFields(PostgresDb.TableName, writer, FieldMatch.All,
[Field.In("NumValue", [2, 4, 6, 8])]);
VerifySingleById(StreamText(stream), "three");
}),
TestCase("succeeds when documents are not found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByFields(PostgresDb.TableName, writer, FieldMatch.All,
[Field.Equal("Value", "mauve"), Field.NotEqual("NumValue", 40)]);
VerifyEmpty(StreamText(stream));
}),
TestCase("succeeds for InArray when matching documents exist", async () =>
{
await using var db = PostgresDb.BuildDb();
await Definition.EnsureTable(PostgresDb.TableName);
foreach (var doc in ArrayDocument.TestDocuments) await Document.Insert(PostgresDb.TableName, doc);
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByFields(PostgresDb.TableName, writer, FieldMatch.All,
[Field.InArray("Values", PostgresDb.TableName, ["c"])]);
var json = StreamText(stream);
VerifyBeginEnd(json);
VerifyDocById(json, "first");
VerifyDocById(json, "second");
}),
TestCase("succeeds for InArray when no matching documents exist", async () =>
{
await using var db = PostgresDb.BuildDb();
await Definition.EnsureTable(PostgresDb.TableName);
foreach (var doc in ArrayDocument.TestDocuments) await Document.Insert(PostgresDb.TableName, doc);
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByFields(PostgresDb.TableName, writer, FieldMatch.All,
[Field.InArray("Values", PostgresDb.TableName, ["j"])]);
VerifyEmpty(StreamText(stream));
})
]),
TestList("WriteByFieldsOrdered",
[
TestCase("succeeds when sorting ascending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByFieldsOrdered(PostgresDb.TableName, writer, FieldMatch.All,
[Field.Equal("Value", "purple")], [Field.Named("Id")]);
VerifyExpectedOrder(StreamText(stream), "five", "four");
}),
TestCase("succeeds when sorting descending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByFieldsOrdered(PostgresDb.TableName, writer, FieldMatch.All,
[Field.Equal("Value", "purple")], [Field.Named("Id DESC")]);
VerifyExpectedOrder(StreamText(stream), "four", "five");
})
]),
TestList("WriteByContains",
[
TestCase("succeeds when documents are found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByContains(PostgresDb.TableName, writer, new { Sub = new { Foo = "green" } });
var json = StreamText(stream);
VerifyBeginEnd(json);
VerifyDocById(json, "two");
VerifyDocById(json, "four");
}),
TestCase("succeeds when documents are not found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByContains(PostgresDb.TableName, writer, new { Value = "mauve" });
VerifyEmpty(StreamText(stream));
})
]),
TestList("WriteByContainsOrdered",
[
// Id = two, Sub.Bar = blue; Id = four, Sub.Bar = red
TestCase("succeeds when sorting ascending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByContainsOrdered(PostgresDb.TableName, writer, new { Sub = new { Foo = "green" } },
[Field.Named("Sub.Bar")]);
VerifyExpectedOrder(StreamText(stream), "two", "four");
}),
TestCase("succeeds when sorting descending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByContainsOrdered(PostgresDb.TableName, writer, new { Sub = new { Foo = "green" } },
[Field.Named("Sub.Bar DESC")]);
VerifyExpectedOrder(StreamText(stream), "four", "two");
})
]),
TestList("WriteByJsonPath",
[
TestCase("succeeds when documents are found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByJsonPath(PostgresDb.TableName, writer, "$.NumValue ? (@ < 15)");
var json = StreamText(stream);
VerifyBeginEnd(json);
VerifyDocById(json, "one");
VerifyDocById(json, "two");
VerifyDocById(json, "three");
}),
TestCase("succeeds when documents are not found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByJsonPath(PostgresDb.TableName, writer, "$.NumValue ? (@ < 0)");
VerifyEmpty(StreamText(stream));
})
]),
TestList("WriteByJsonPathOrdered",
[
// Id = one, NumValue = 0; Id = two, NumValue = 10; Id = three, NumValue = 4
TestCase("succeeds when sorting ascending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByJsonPathOrdered(PostgresDb.TableName, writer, "$.NumValue ? (@ < 15)",
[Field.Named("n:NumValue")]);
VerifyExpectedOrder(StreamText(stream), "one", "three", "two");
}),
TestCase("succeeds when sorting descending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteByJsonPathOrdered(PostgresDb.TableName, writer, "$.NumValue ? (@ < 15)",
[Field.Named("n:NumValue DESC")]);
VerifyExpectedOrder(StreamText(stream), "two", "three", "one");
})
]),
TestList("WriteFirstByFields",
[
TestCase("succeeds when a document is found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByFields(PostgresDb.TableName, writer, FieldMatch.Any,
[Field.Equal("Value", "another")]);
VerifyDocById(StreamText(stream), "two");
}),
TestCase("succeeds when multiple documents are found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByFields(PostgresDb.TableName, writer, FieldMatch.Any,
[Field.Equal("Value", "purple")]);
VerifyAnyById(StreamText(stream), ["five", "four"]);
}),
TestCase("succeeds when a document is not found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByFields(PostgresDb.TableName, writer, FieldMatch.Any,
[Field.Equal("Value", "absent")]);
VerifyNoDoc(StreamText(stream));
})
]),
TestList("WriteFirstByFieldsOrdered",
[
TestCase("succeeds when sorting ascending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByFieldsOrdered(PostgresDb.TableName, writer, FieldMatch.Any,
[Field.Equal("Value", "purple")], [Field.Named("Id")]);
VerifyDocById(StreamText(stream), "five");
}),
TestCase("succeeds when sorting descending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByFieldsOrdered(PostgresDb.TableName, writer, FieldMatch.Any,
[Field.Equal("Value", "purple")], [Field.Named("Id DESC")]);
VerifyDocById(StreamText(stream), "four");
})
]),
TestList("WriteFirstByContains",
[
TestCase("succeeds when a document is found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByContains(PostgresDb.TableName, writer, new { Value = "another" });
VerifyDocById(StreamText(stream), "two");
}),
TestCase("succeeds when multiple documents are found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByContains(PostgresDb.TableName, writer, new { Sub = new { Foo = "green" } });
VerifyAnyById(StreamText(stream), ["two", "four"]);
}),
TestCase("succeeds when a document is not found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByContains(PostgresDb.TableName, writer, new { Value = "absent" });
VerifyNoDoc(StreamText(stream));
})
]),
TestList("WriteFirstByContainsOrdered",
[
TestCase("succeeds when sorting ascending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByContainsOrdered(PostgresDb.TableName, writer,
new { Sub = new { Foo = "green" } }, [Field.Named("Value")]);
VerifyDocById(StreamText(stream), "two");
}),
TestCase("succeeds when sorting descending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByContainsOrdered(PostgresDb.TableName, writer,
new { Sub = new { Foo = "green" } }, [Field.Named("Value DESC")]);
VerifyDocById(StreamText(stream), "four");
})
]),
TestList("WriteFirstByJsonPath",
[
TestCase("succeeds when a document is found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByJsonPath(PostgresDb.TableName, writer, """$.Value ? (@ == "FIRST!")""");
VerifyDocById(StreamText(stream), "one");
}),
TestCase("succeeds when multiple documents are found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByJsonPath(PostgresDb.TableName, writer, """$.Sub.Foo ? (@ == "green")""");
VerifyAnyById(StreamText(stream), ["two", "four"]);
}),
TestCase("succeeds when a document is not found", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByJsonPath(PostgresDb.TableName, writer, """$.Id ? (@ == "nope")""");
VerifyNoDoc(StreamText(stream));
})
]),
TestList("WriteFirstByJsonPathOrdered",
[
TestCase("succeeds when sorting ascending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByJsonPathOrdered(PostgresDb.TableName, writer, """$.Sub.Foo ? (@ == "green")""",
[Field.Named("Sub.Bar")]);
VerifyDocById(StreamText(stream), "two");
}),
TestCase("succeeds when sorting descending", async () =>
{
await using var db = PostgresDb.BuildDb();
await LoadDocs();
await using MemoryStream stream = new();
await using var writer = WriteStream(stream);
await Json.WriteFirstByJsonPathOrdered(PostgresDb.TableName, writer, """$.Sub.Foo ? (@ == "green")""",
[Field.Named("Sub.Bar DESC")]);
VerifyDocById(StreamText(stream), "four");
})
]) ])
]); ]);

393
src/Tests/PostgresTests.fs
View File

@ -1451,6 +1451,399 @@ let jsonTests = testList "Json" [
verifyDocById json "four" verifyDocById json "four"
} }
] ]
testList "writeAll" [
testTask "succeeds when there is data" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeAll PostgresDb.TableName writer
verifyAllData (streamText stream)
}
testTask "succeeds when there is no data" {
use db = PostgresDb.BuildDb()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeAll PostgresDb.TableName writer
verifyEmpty (streamText stream)
}
]
testList "writeAllOrdered" [
testTask "succeeds when ordering numerically" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeAllOrdered PostgresDb.TableName writer [ Field.Named "n:NumValue" ]
verifyExpectedOrder (streamText stream) "one" "three" (Some "two") (Some "four") (Some "five")
}
testTask "succeeds when ordering numerically descending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeAllOrdered PostgresDb.TableName writer [ Field.Named "n:NumValue DESC" ]
verifyExpectedOrder (streamText stream) "five" "four" (Some "two") (Some "three") (Some "one")
}
testTask "succeeds when ordering alphabetically" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeAllOrdered PostgresDb.TableName writer [ Field.Named "Id DESC" ]
verifyExpectedOrder (streamText stream) "two" "three" (Some "one") (Some "four") (Some "five")
}
]
testList "writeById" [
testTask "succeeds when a document is found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeById PostgresDb.TableName writer "two"
let json = streamText stream
Expect.stringStarts json """{"Id": "two",""" "An incorrect document was returned"
Expect.stringEnds json "}" "JSON should have ended with this document"
}
testTask "succeeds when a document is not found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeById PostgresDb.TableName writer "three hundred eighty-seven"
verifyNoDoc (streamText stream)
}
]
testList "writeByFields" [
testTask "succeeds when documents are found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByFields
PostgresDb.TableName writer All [ Field.In "Value" [ "purple"; "blue" ]; Field.Exists "Sub" ]
verifySingleById (streamText stream) "four"
}
testTask "succeeds when documents are found using IN with numeric field" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByFields PostgresDb.TableName writer All [ Field.In "NumValue" [ 2; 4; 6; 8 ] ]
verifySingleById (streamText stream) "three"
}
testTask "succeeds when documents are not found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByFields
PostgresDb.TableName writer All [ Field.Equal "Value" "mauve"; Field.NotEqual "NumValue" 40 ]
verifyEmpty (streamText stream)
}
testTask "succeeds for InArray when matching documents exist" {
use db = PostgresDb.BuildDb()
do! Definition.ensureTable PostgresDb.TableName
for doc in ArrayDocument.TestDocuments do do! insert PostgresDb.TableName doc
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByFields
PostgresDb.TableName writer All [ Field.InArray "Values" PostgresDb.TableName [ "c" ] ]
let json = streamText stream
verifyBeginEnd json
verifyDocById json "first"
verifyDocById json "second"
}
testTask "succeeds for InArray when no matching documents exist" {
use db = PostgresDb.BuildDb()
do! Definition.ensureTable PostgresDb.TableName
for doc in ArrayDocument.TestDocuments do do! insert PostgresDb.TableName doc
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByFields
PostgresDb.TableName writer All [ Field.InArray "Values" PostgresDb.TableName [ "j" ] ]
verifyEmpty (streamText stream)
}
]
testList "writeByFieldsOrdered" [
testTask "succeeds when sorting ascending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByFieldsOrdered
PostgresDb.TableName writer All [ Field.Equal "Value" "purple" ] [ Field.Named "Id" ]
verifyExpectedOrder (streamText stream) "five" "four" None None None
}
testTask "succeeds when sorting descending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByFieldsOrdered
PostgresDb.TableName writer All [ Field.Equal "Value" "purple" ] [ Field.Named "Id DESC" ]
verifyExpectedOrder (streamText stream) "four" "five" None None None
}
]
testList "writeByContains" [
testTask "succeeds when documents are found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByContains PostgresDb.TableName writer {| Sub = {| Foo = "green" |} |}
let json = streamText stream
verifyBeginEnd json
verifyDocById json "two"
verifyDocById json "four"
}
testTask "succeeds when documents are not found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByContains PostgresDb.TableName writer {| Value = "mauve" |}
verifyEmpty (streamText stream)
}
]
testList "writeByContainsOrdered" [
// Id = two, Sub.Bar = blue; Id = four, Sub.Bar = red
testTask "succeeds when sorting ascending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByContainsOrdered
PostgresDb.TableName writer {| Sub = {| Foo = "green" |} |} [ Field.Named "Sub.Bar" ]
verifyExpectedOrder (streamText stream) "two" "four" None None None
}
testTask "succeeds when sorting descending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByContainsOrdered
PostgresDb.TableName writer {| Sub = {| Foo = "green" |} |} [ Field.Named "Sub.Bar DESC" ]
verifyExpectedOrder (streamText stream) "four" "two" None None None
}
]
testList "writeByJsonPath" [
testTask "succeeds when documents are found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByJsonPath PostgresDb.TableName writer "$.NumValue ? (@ < 15)"
let json = streamText stream
verifyBeginEnd json
verifyDocById json "one"
verifyDocById json "two"
verifyDocById json "three"
}
testTask "succeeds when documents are not found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByJsonPath PostgresDb.TableName writer "$.NumValue ? (@ < 0)"
verifyEmpty (streamText stream)
}
]
testList "writeByJsonPathOrdered" [
// Id = one, NumValue = 0; Id = two, NumValue = 10; Id = three, NumValue = 4
testTask "succeeds when sorting ascending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByJsonPathOrdered
PostgresDb.TableName writer "$.NumValue ? (@ < 15)" [ Field.Named "n:NumValue" ]
verifyExpectedOrder (streamText stream) "one" "three" (Some "two") None None
}
testTask "succeeds when sorting descending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeByJsonPathOrdered
PostgresDb.TableName writer "$.NumValue ? (@ < 15)" [ Field.Named "n:NumValue DESC" ]
verifyExpectedOrder (streamText stream) "two" "three" (Some "one") None None
}
]
testList "writeFirstByFields" [
testTask "succeeds when a document is found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByFields PostgresDb.TableName writer Any [ Field.Equal "Value" "another" ]
verifyDocById (streamText stream) "two"
}
testTask "succeeds when multiple documents are found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByFields PostgresDb.TableName writer Any [ Field.Equal "Value" "purple" ]
verifyAnyById (streamText stream) [ "five"; "four" ]
}
testTask "succeeds when a document is not found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByFields PostgresDb.TableName writer Any [ Field.Equal "Value" "absent" ]
verifyNoDoc (streamText stream)
}
]
testList "writeFirstByFieldsOrdered" [
testTask "succeeds when sorting ascending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByFieldsOrdered
PostgresDb.TableName writer Any [ Field.Equal "Value" "purple" ] [ Field.Named "Id" ]
verifyDocById (streamText stream) "five"
}
testTask "succeeds when sorting descending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByFieldsOrdered
PostgresDb.TableName writer Any [ Field.Equal "Value" "purple" ] [ Field.Named "Id DESC" ]
verifyDocById (streamText stream) "four"
}
]
testList "writeFirstByContains" [
testTask "succeeds when a document is found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByContains PostgresDb.TableName writer {| Value = "another" |}
verifyDocById (streamText stream) "two"
}
testTask "succeeds when multiple documents are found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByContains PostgresDb.TableName writer {| Sub = {| Foo = "green" |} |}
verifyAnyById (streamText stream) [ "two"; "four" ]
}
testTask "succeeds when a document is not found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByContains PostgresDb.TableName writer {| Value = "absent" |}
verifyNoDoc (streamText stream)
}
]
testList "writeFirstByContainsOrdered" [
testTask "succeeds when sorting ascending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByContainsOrdered
PostgresDb.TableName writer {| Sub = {| Foo = "green" |} |} [ Field.Named "Value" ]
verifyDocById (streamText stream) "two"
}
testTask "succeeds when sorting descending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByContainsOrdered
PostgresDb.TableName writer {| Sub = {| Foo = "green" |} |} [ Field.Named "Value DESC" ]
verifyDocById (streamText stream) "four"
}
]
testList "writeFirstByJsonPath" [
testTask "succeeds when a document is found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByJsonPath PostgresDb.TableName writer """$.Value ? (@ == "FIRST!")"""
verifyDocById (streamText stream) "one"
}
testTask "succeeds when multiple documents are found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByJsonPath PostgresDb.TableName writer """$.Sub.Foo ? (@ == "green")"""
verifyAnyById (streamText stream) [ "two"; "four" ]
}
testTask "succeeds when a document is not found" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByJsonPath PostgresDb.TableName writer """$.Id ? (@ == "nope")"""
verifyNoDoc (streamText stream)
}
]
testList "writeFirstByJsonPathOrdered" [
testTask "succeeds when sorting ascending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByJsonPathOrdered
PostgresDb.TableName writer """$.Sub.Foo ? (@ == "green")""" [ Field.Named "Sub.Bar" ]
verifyDocById (streamText stream) "two"
}
testTask "succeeds when sorting descending" {
use db = PostgresDb.BuildDb()
do! loadDocs ()
use stream = new MemoryStream()
use writer = writeStream stream
do! Json.writeFirstByJsonPathOrdered
PostgresDb.TableName writer """$.Sub.Foo ? (@ == "green")""" [ Field.Named "Sub.Bar DESC" ]
verifyDocById (streamText stream) "four"
}
]
] ]
/// Integration tests for the Update module of the PostgreSQL library /// Integration tests for the Update module of the PostgreSQL library