module SqliteTests

open System.Text.Json
open BitBadger.Documents
open BitBadger.Documents.Sqlite
open BitBadger.Documents.Tests
open Expecto
open Microsoft.Data.Sqlite
open Types

#nowarn "0044"

(** UNIT TESTS **)

/// Unit tests for the Query module of the SQLite library
let queryTests = testList "Query" [
    testList "whereByFields" [
        test "succeeds for a single field when a logical operator is passed" {
            Expect.equal
                (Query.whereByFields Any [ { Field.GT "theField" 0 with ParameterName = Some "@test" } ])
                "data->>'theField' > @test"
                "WHERE clause not correct"
        }
        test "succeeds for a single field when an existence operator is passed" {
            Expect.equal
                (Query.whereByFields Any [ Field.NEX "thatField" ])
                "data->>'thatField' IS NULL"
                "WHERE clause not correct"
        }
        test "succeeds for a single field when a between operator is passed" {
            Expect.equal
                (Query.whereByFields All [ { Field.BT "aField" 50 99 with ParameterName = Some "@range" } ])
                "data->>'aField' BETWEEN @rangemin AND @rangemax"
                "WHERE clause not correct"
        }
        test "succeeds for all multiple fields with logical operators" {
            Expect.equal
                (Query.whereByFields All [ Field.EQ "theFirst" "1"; Field.EQ "numberTwo" "2" ])
                "data->>'theFirst' = @field0 AND data->>'numberTwo' = @field1"
                "WHERE clause not correct"
        }
        test "succeeds for any multiple fields with an existence operator" {
            Expect.equal
                (Query.whereByFields Any [ Field.NEX "thatField"; Field.GE "thisField" 18 ])
                "data->>'thatField' IS NULL OR data->>'thisField' >= @field0"
                "WHERE clause not correct"
        }
        test "succeeds for all multiple fields with between operators" {
            Expect.equal
                (Query.whereByFields All [ Field.BT "aField" 50 99; Field.BT "anotherField" "a" "b" ])
                "data->>'aField' BETWEEN @field0min AND @field0max AND data->>'anotherField' BETWEEN @field1min AND @field1max"
                "WHERE clause not correct"
        }
    ]
    test "whereById succeeds" {
        Expect.equal (Query.whereById "@id") "data->>'Id' = @id" "WHERE clause not correct"
    }
    test "patch succeeds" {
        Expect.equal
            (Query.patch SqliteDb.TableName)
            $"UPDATE {SqliteDb.TableName} SET data = json_patch(data, json(@data))"
            "Patch query not correct"
    }
    test "removeFields succeeds" {
        Expect.equal
            (Query.removeFields SqliteDb.TableName [ SqliteParameter("@a", "a"); SqliteParameter("@b", "b") ])
            $"UPDATE {SqliteDb.TableName} SET data = json_remove(data, @a, @b)"
            "Field removal query not correct"
    }
    test "byId succeeds" {
        Expect.equal (Query.byId "test" "14") "test WHERE data->>'Id' = @id" "By-ID query not correct"
    }
    test "byFields succeeds" {
        Expect.equal
            (Query.byFields "unit" Any [ Field.GT "That" 14 ])
            "unit WHERE data->>'That' > @field0"
            "By-Field query not correct"
    }
    test "Definition.ensureTable succeeds" {
        Expect.equal
            (Query.Definition.ensureTable "tbl")
            "CREATE TABLE IF NOT EXISTS tbl (data TEXT NOT NULL)"
            "CREATE TABLE statement not correct"
    }
]

/// Unit tests for the Parameters module of the SQLite library
let parametersTests = testList "Parameters" [
    test "idParam succeeds" {
        let theParam = idParam 7
        Expect.equal theParam.ParameterName "@id" "The parameter name is incorrect"
        Expect.equal theParam.Value "7" "The parameter value is incorrect"
    }
    test "jsonParam succeeds" {
        let theParam = jsonParam "@test" {| Nice = "job" |}
        Expect.equal theParam.ParameterName "@test" "The parameter name is incorrect"
        Expect.equal theParam.Value """{"Nice":"job"}""" "The parameter value is incorrect"
    }
    testList "addFieldParam" [
        test "succeeds when adding a parameter" {
            let paramList = addFieldParam "@field" (Field.EQ "it" 99) []
            Expect.hasLength paramList 1 "There should have been a parameter added"
            let theParam = Seq.head paramList
            Expect.equal theParam.ParameterName "@field" "The parameter name is incorrect"
            Expect.equal theParam.Value 99 "The parameter value is incorrect"
        }
        test "succeeds when not adding a parameter" {
            let paramList = addFieldParam "@it" (Field.NEX "Coffee") []
            Expect.isEmpty paramList "There should not have been any parameters added"
        }
    ]
    test "noParams succeeds" {
        Expect.isEmpty noParams "The parameter list should have been empty"
    }
]
// Results are exhaustively executed in the context of other tests


(** INTEGRATION TESTS **)

/// Load a table with the test documents
let loadDocs () = backgroundTask {
    for doc in testDocuments do do! insert SqliteDb.TableName doc
}

/// Integration tests for the Configuration module of the SQLite library
let configurationTests = testList "Configuration" [
    test "useConnectionString / connectionString succeed" {
        try
            Configuration.useConnectionString "Data Source=test.db"
            Expect.equal
                Configuration.connectionString
                (Some "Data Source=test.db;Foreign Keys=True")
                "Connection string incorrect"
        finally
            Configuration.useConnectionString "Data Source=:memory:"
    }
]

/// Integration tests for the Custom module of the SQLite library
let customTests = testList "Custom" [
    testList "single" [
        testTask "succeeds when a row is found" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! doc =
                Custom.single
                    $"SELECT data FROM {SqliteDb.TableName} WHERE data ->> 'Id' = @id"
                    [ SqliteParameter("@id", "one") ]
                    fromData<JsonDocument>
            Expect.isSome doc "There should have been a document returned"
            Expect.equal doc.Value.Id "one" "The incorrect document was returned"
        }
        testTask "succeeds when a row is not found" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! doc =
                Custom.single
                    $"SELECT data FROM {SqliteDb.TableName} WHERE data ->> 'Id' = @id"
                    [ SqliteParameter("@id", "eighty") ]
                    fromData<JsonDocument>
            Expect.isNone doc "There should not have been a document returned"
        }
    ]
    testList "list" [
        testTask "succeeds when data is found" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! docs = Custom.list (Query.find SqliteDb.TableName) [] fromData<JsonDocument>
            Expect.hasCountOf docs 5u (fun _ -> true) "There should have been 5 documents returned"
        }
        testTask "succeeds when data is not found" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! docs =
                Custom.list
                    $"SELECT data FROM {SqliteDb.TableName} WHERE data ->> 'NumValue' > @value"
                    [ SqliteParameter("@value", 100) ]
                    fromData<JsonDocument>
            Expect.isEmpty docs "There should have been no documents returned"
        }
    ]
    testList "nonQuery" [
        testTask "succeeds when operating on data" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            do! Custom.nonQuery $"DELETE FROM {SqliteDb.TableName}" []

            let! remaining = Count.all SqliteDb.TableName
            Expect.equal remaining 0L "There should be no documents remaining in the table"
        }
        testTask "succeeds when no data matches where clause" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            do! Custom.nonQuery
                    $"DELETE FROM {SqliteDb.TableName} WHERE data ->> 'NumValue' > @value"
                    [ SqliteParameter("@value", 100) ]

            let! remaining = Count.all SqliteDb.TableName
            Expect.equal remaining 5L "There should be 5 documents remaining in the table"
        }
    ]
    testTask "scalar succeeds" {
        use! db = SqliteDb.BuildDb()

        let! nbr = Custom.scalar "SELECT 5 AS test_value" [] _.GetInt32(0)
        Expect.equal nbr 5 "The query should have returned the number 5"
    }
]

/// Integration tests for the Definition module of the SQLite library
let definitionTests = testList "Definition" [
    testTask "ensureTable succeeds" {
        use! db = SqliteDb.BuildDb()
        let itExists (name: string) =
            Custom.scalar
                $"SELECT EXISTS (SELECT 1 FROM {SqliteDb.Catalog} WHERE name = @name) AS it"
                [ SqliteParameter("@name", name) ]
                toExists
        
        let! exists     = itExists "ensured"
        let! alsoExists = itExists "idx_ensured_key"
        Expect.isFalse exists     "The table should not exist already"
        Expect.isFalse alsoExists "The key index should not exist already"

        do! Definition.ensureTable "ensured"
        let! exists'     = itExists "ensured"
        let! alsoExists' = itExists "idx_ensured_key"
        Expect.isTrue exists'    "The table should now exist"
        Expect.isTrue alsoExists' "The key index should now exist"
    }
    testTask "ensureFieldIndex succeeds" {
        use! db = SqliteDb.BuildDb()
        let indexExists () =
            Custom.scalar
                $"SELECT EXISTS (SELECT 1 FROM {SqliteDb.Catalog} WHERE name = 'idx_ensured_test') AS it"
                []
                toExists
        
        let! exists = indexExists ()
        Expect.isFalse exists "The index should not exist already"

        do! Definition.ensureTable      "ensured"
        do! Definition.ensureFieldIndex "ensured" "test" [ "Name"; "Age" ]
        let! exists' = indexExists ()
        Expect.isTrue exists' "The index should now exist"
    }
]

/// Integration tests for the (auto-opened) Document module of the SQLite library
let documentTests = testList "Document" [
    testList "insert" [
        testTask "succeeds" {
            use! db = SqliteDb.BuildDb()
            let! before = Find.all<SubDocument> SqliteDb.TableName
            Expect.equal before [] "There should be no documents in the table"
    
            let testDoc = { emptyDoc with Id = "turkey"; Sub = Some { Foo = "gobble"; Bar = "gobble" } }
            do! insert SqliteDb.TableName testDoc
            let! after = Find.all<JsonDocument> SqliteDb.TableName
            Expect.equal after [ testDoc ] "There should have been one document inserted"
        }
        testTask "fails for duplicate key" {
            use! db = SqliteDb.BuildDb()
            do! insert SqliteDb.TableName { emptyDoc with Id = "test" }
            Expect.throws
                (fun () ->
                    insert SqliteDb.TableName {emptyDoc with Id = "test" } |> Async.AwaitTask |> Async.RunSynchronously)
                "An exception should have been raised for duplicate document ID insert"
        }
        testTask "succeeds when adding a numeric auto ID" {
            try
                Configuration.useAutoIdStrategy Number
                Configuration.useIdField "Key"
                use! db = SqliteDb.BuildDb()
                let! before = Count.all SqliteDb.TableName
                Expect.equal before 0L "There should be no documents in the table"
                
                do! insert SqliteDb.TableName { Key = 0; Text = "one" }
                do! insert SqliteDb.TableName { Key = 0; Text = "two" }
                do! insert SqliteDb.TableName { Key = 77; Text = "three" }
                do! insert SqliteDb.TableName { Key = 0; Text = "four" }
                
                let! after = Find.allOrdered<NumIdDocument> SqliteDb.TableName [ Field.Named "Key" ]
                Expect.hasLength after 4 "There should have been 4 documents returned"
                Expect.equal (after |> List.map _.Key) [ 1; 2; 77; 78 ] "The IDs were not generated correctly"
            finally
                Configuration.useAutoIdStrategy Disabled
                Configuration.useIdField "Id"
        }
        testTask "succeeds when adding a GUID auto ID" {
            try
                Configuration.useAutoIdStrategy Guid
                use! db = SqliteDb.BuildDb()
                let! before = Count.all SqliteDb.TableName
                Expect.equal before 0L "There should be no documents in the table"
                
                do! insert SqliteDb.TableName { emptyDoc with Value = "one" }
                do! insert SqliteDb.TableName { emptyDoc with Value = "two" }
                do! insert SqliteDb.TableName { emptyDoc with Id = "abc123"; Value = "three" }
                do! insert SqliteDb.TableName { emptyDoc with Value = "four" }
                
                let! after = Find.all<JsonDocument> SqliteDb.TableName
                Expect.hasLength after 4 "There should have been 4 documents returned"
                Expect.hasCountOf after 3u (fun doc -> doc.Id.Length = 32) "Three of the IDs should have been GUIDs"
                Expect.hasCountOf after 1u (fun doc -> doc.Id = "abc123") "The provided ID should have been used as-is"
            finally
                Configuration.useAutoIdStrategy Disabled
        }
        testTask "succeeds when adding a RandomString auto ID" {
            try
                Configuration.useAutoIdStrategy RandomString
                Configuration.useIdStringLength 44
                use! db = SqliteDb.BuildDb()
                let! before = Count.all SqliteDb.TableName
                Expect.equal before 0L "There should be no documents in the table"
                
                do! insert SqliteDb.TableName { emptyDoc with Value = "one" }
                do! insert SqliteDb.TableName { emptyDoc with Value = "two" }
                do! insert SqliteDb.TableName { emptyDoc with Id = "abc123"; Value = "three" }
                do! insert SqliteDb.TableName { emptyDoc with Value = "four" }
                
                let! after = Find.all<JsonDocument> SqliteDb.TableName
                Expect.hasLength after 4 "There should have been 4 documents returned"
                Expect.hasCountOf
                    after 3u (fun doc -> doc.Id.Length = 44)
                    "Three of the IDs should have been 44-character random strings"
                Expect.hasCountOf after 1u (fun doc -> doc.Id = "abc123") "The provided ID should have been used as-is"
            finally
                Configuration.useAutoIdStrategy Disabled
                Configuration.useIdStringLength 16
        }
    ]
    testList "save" [
        testTask "succeeds when a document is inserted" {
            use! db = SqliteDb.BuildDb()
            let! before = Find.all<JsonDocument> SqliteDb.TableName
            Expect.equal before [] "There should be no documents in the table"
    
            let testDoc = { emptyDoc with Id = "test"; Sub = Some { Foo = "a"; Bar = "b" } }
            do! save SqliteDb.TableName testDoc
            let! after = Find.all<JsonDocument> SqliteDb.TableName
            Expect.equal after [ testDoc ] "There should have been one document inserted"
        }
        testTask "succeeds when a document is updated" {
            use! db = SqliteDb.BuildDb()
            let testDoc = { emptyDoc with Id = "test"; Sub = Some { Foo = "a"; Bar = "b" } }
            do! insert SqliteDb.TableName testDoc
    
            let! before = Find.byId<string, JsonDocument> SqliteDb.TableName "test"
            Expect.isSome before "There should have been a document returned"
            Expect.equal before.Value testDoc "The document is not correct"
    
            let upd8Doc = { testDoc with Sub = Some { Foo = "c"; Bar = "d" } }
            do! save SqliteDb.TableName upd8Doc
            let! after = Find.byId<string, JsonDocument> SqliteDb.TableName "test"
            Expect.isSome after "There should have been a document returned post-update"
            Expect.equal after.Value upd8Doc "The updated document is not correct"
        }
    ]
]

/// Integration tests for the Count module of the SQLite library
let countTests = testList "Count" [
    testTask "all succeeds" {
        use! db = SqliteDb.BuildDb()
        do! loadDocs ()

        let! theCount = Count.all SqliteDb.TableName
        Expect.equal theCount 5L "There should have been 5 matching documents"
    }
    testList "byFields" [
        testTask "succeeds for a numeric range" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()
    
            let! theCount = Count.byFields SqliteDb.TableName Any [ Field.BT "NumValue" 10 20 ]
            Expect.equal theCount 3L "There should have been 3 matching documents"
        }
        testTask "succeeds for a non-numeric range" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()
    
            let! theCount = Count.byFields SqliteDb.TableName Any [ Field.BT "Value" "aardvark" "apple" ]
            Expect.equal theCount 1L "There should have been 1 matching document"
        }
    ]
]

/// Integration tests for the Exists module of the SQLite library
let existsTests = testList "Exists" [
    testList "byId" [
        testTask "succeeds when a document exists" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! exists = Exists.byId SqliteDb.TableName "three"
            Expect.isTrue exists "There should have been an existing document"
        }
        testTask "succeeds when a document does not exist" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! exists = Exists.byId SqliteDb.TableName "seven"
            Expect.isFalse exists "There should not have been an existing document"
        }
    ]
    testList "byFields" [
        testTask "succeeds when documents exist" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! exists = Exists.byFields SqliteDb.TableName Any [ Field.EQ "NumValue" 10 ]
            Expect.isTrue exists "There should have been existing documents"
        }
        testTask "succeeds when no matching documents exist" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! exists = Exists.byFields SqliteDb.TableName Any [ Field.LT "Nothing" "none" ]
            Expect.isFalse exists "There should not have been any existing documents"
        }
    ]
]

/// Integration tests for the Find module of the SQLite library
let findTests = testList "Find" [
    testList "all" [
        testTask "succeeds when there is data" {
            use! db = SqliteDb.BuildDb()

            do! insert SqliteDb.TableName { Foo = "one"; Bar = "two" }
            do! insert SqliteDb.TableName { Foo = "three"; Bar = "four" }
            do! insert SqliteDb.TableName { Foo = "five"; Bar = "six" }

            let! results = Find.all<SubDocument> SqliteDb.TableName
            Expect.equal
                results
                [ { Foo = "one"; Bar = "two" }; { Foo = "three"; Bar = "four" }; { Foo = "five"; Bar = "six" } ]
                "There should have been 3 documents returned"
        }
        testTask "succeeds when there is no data" {
            use! db = SqliteDb.BuildDb()
            let! results = Find.all<SubDocument> SqliteDb.TableName
            Expect.equal results [] "There should have been no documents returned"
        }
    ]
    testList "allOrdered" [
        testTask "succeeds when ordering numerically" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()
            
            let! results = Find.allOrdered<JsonDocument> SqliteDb.TableName [ Field.Named "n:NumValue" ]
            Expect.hasLength results 5 "There should have been 5 documents returned"
            Expect.equal
                (results |> List.map _.Id |> String.concat "|")
                "one|three|two|four|five"
                "The documents were not ordered correctly"
        }
        testTask "succeeds when ordering numerically descending" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()
            
            let! results = Find.allOrdered<JsonDocument> SqliteDb.TableName [ Field.Named "n:NumValue DESC" ]
            Expect.hasLength results 5 "There should have been 5 documents returned"
            Expect.equal
                (results |> List.map _.Id |> String.concat "|")
                "five|four|two|three|one"
                "The documents were not ordered correctly"
        }
        testTask "succeeds when ordering alphabetically" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()
            
            let! results = Find.allOrdered<JsonDocument> SqliteDb.TableName [ Field.Named "Id DESC" ]
            Expect.hasLength results 5 "There should have been 5 documents returned"
            Expect.equal
                (results |> List.map _.Id |> String.concat "|")
                "two|three|one|four|five"
                "The documents were not ordered correctly"
        }
    ]
    testList "byId" [
        testTask "succeeds when a document is found" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! doc = Find.byId<string, JsonDocument> SqliteDb.TableName "two"
            Expect.isSome doc "There should have been a document returned"
            Expect.equal doc.Value.Id "two" "The incorrect document was returned"
        }
        testTask "succeeds when a document is not found" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! doc = Find.byId<string, JsonDocument> SqliteDb.TableName "three hundred eighty-seven"
            Expect.isNone doc "There should not have been a document returned"
        }
    ]
    testList "byFields" [
        testTask "succeeds when documents are found" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! docs = Find.byFields<JsonDocument> SqliteDb.TableName Any [ Field.GT "NumValue" 15 ]
            Expect.equal (List.length docs) 2 "There should have been two documents returned"
        }
        testTask "succeeds when documents are not found" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! docs = Find.byFields<JsonDocument> SqliteDb.TableName Any [ Field.GT "NumValue" 100 ]
            Expect.isTrue (List.isEmpty docs) "There should have been no documents returned"
        }
    ]
    testList "byFieldsOrdered" [
        testTask "succeeds when sorting ascending" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! docs =
                Find.byFieldsOrdered<JsonDocument>
                    SqliteDb.TableName Any [ Field.GT "NumValue" 15 ] [ Field.Named "Id" ]
            Expect.hasLength docs 2 "There should have been two documents returned"
            Expect.equal
                (docs |> List.map _.Id |> String.concat "|") "five|four" "The documents were not ordered correctly"
        }
        testTask "succeeds when sorting descending" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! docs =
                Find.byFieldsOrdered<JsonDocument>
                    SqliteDb.TableName Any [ Field.GT "NumValue" 15 ] [ Field.Named "Id DESC" ]
            Expect.hasLength docs 2 "There should have been two documents returned"
            Expect.equal
                (docs |> List.map _.Id |> String.concat "|") "four|five" "The documents were not ordered correctly"
        }
        testTask "succeeds when sorting case-sensitively" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! docs =
                Find.byFieldsOrdered<JsonDocument>
                    SqliteDb.TableName All [ Field.LE "NumValue" 10 ] [ Field.Named "Value" ]
            Expect.hasLength docs 3 "There should have been three documents returned"
            Expect.equal
                (docs |> List.map _.Id |> String.concat "|") "three|one|two" "Documents not ordered correctly"
        }
        testTask "succeeds when sorting case-insensitively" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! docs =
                Find.byFieldsOrdered<JsonDocument>
                    SqliteDb.TableName All [ Field.LE "NumValue" 10 ] [ Field.Named "i:Value" ]
            Expect.hasLength docs 3 "There should have been three documents returned"
            Expect.equal
                (docs |> List.map _.Id |> String.concat "|") "three|two|one" "Documents not ordered correctly"
        }
    ]
    testList "firstByFields" [
        testTask "succeeds when a document is found" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! doc = Find.firstByFields<JsonDocument> SqliteDb.TableName Any [ Field.EQ "Value" "another" ]
            Expect.isSome doc "There should have been a document returned"
            Expect.equal doc.Value.Id "two" "The incorrect document was returned"
        }
        testTask "succeeds when multiple documents are found" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! doc = Find.firstByFields<JsonDocument> SqliteDb.TableName Any [ Field.EQ "Sub.Foo" "green" ]
            Expect.isSome doc "There should have been a document returned"
            Expect.contains [ "two"; "four" ] doc.Value.Id "An incorrect document was returned"
        }
        testTask "succeeds when a document is not found" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! doc = Find.firstByFields<JsonDocument> SqliteDb.TableName Any [ Field.EQ "Value" "absent" ]
            Expect.isNone doc "There should not have been a document returned"
        }
    ]
    testList "firstByFieldsOrdered" [
        testTask "succeeds when sorting ascending" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! doc =
                Find.firstByFieldsOrdered<JsonDocument>
                    SqliteDb.TableName Any [ Field.EQ "Sub.Foo" "green" ] [ Field.Named "Sub.Bar" ]
            Expect.isSome doc "There should have been a document returned"
            Expect.equal "two" doc.Value.Id "An incorrect document was returned"
        }
        testTask "succeeds when sorting descending" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let! doc =
                Find.firstByFieldsOrdered<JsonDocument>
                    SqliteDb.TableName Any [ Field.EQ "Sub.Foo" "green" ] [ Field.Named "Sub.Bar DESC" ]
            Expect.isSome doc "There should have been a document returned"
            Expect.equal "four" doc.Value.Id "An incorrect document was returned"
        }
    ]
]

/// Integration tests for the Update module of the SQLite library
let updateTests = testList "Update" [
    testList "byId" [
        testTask "succeeds when a document is updated" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            let testDoc = { emptyDoc with Id = "one"; Sub = Some { Foo = "blue"; Bar = "red" } }
            do! Update.byId SqliteDb.TableName "one" testDoc
            let! after = Find.byId<string, JsonDocument> SqliteDb.TableName "one"
            Expect.isSome after "There should have been a document returned post-update"
            Expect.equal after.Value testDoc "The updated document is not correct"
        }
        testTask "succeeds when no document is updated" {
            use! db = SqliteDb.BuildDb()

            let! before = Find.all<JsonDocument> SqliteDb.TableName
            Expect.isEmpty before "There should have been no documents returned"
            
            // This not raising an exception is the test
            do! Update.byId
                    SqliteDb.TableName "test" { emptyDoc with Id = "x"; Sub = Some { Foo = "blue"; Bar = "red" } }
        }
    ]
    testList "byFunc" [
        testTask "succeeds when a document is updated" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            do! Update.byFunc SqliteDb.TableName (_.Id) { Id = "one"; Value = "le un"; NumValue = 1; Sub = None }
            let! after = Find.byId<string, JsonDocument> SqliteDb.TableName "one"
            Expect.isSome after "There should have been a document returned post-update"
            Expect.equal
                after.Value
                { Id = "one"; Value = "le un"; NumValue = 1; Sub = None }
                "The updated document is not correct"
        }
        testTask "succeeds when no document is updated" {
            use! db = SqliteDb.BuildDb()

            let! before = Find.all<JsonDocument> SqliteDb.TableName
            Expect.isEmpty before "There should have been no documents returned"
            
            // This not raising an exception is the test
            do! Update.byFunc SqliteDb.TableName (_.Id) { Id = "one"; Value = "le un"; NumValue = 1; Sub = None }
        }
    ]
]

/// Integration tests for the Patch module of the SQLite library
let patchTests = testList "Patch" [
    testList "byId" [
        testTask "succeeds when a document is updated" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()
            
            do! Patch.byId SqliteDb.TableName "one" {| NumValue = 44 |}
            let! after = Find.byId<string, JsonDocument> SqliteDb.TableName "one"
            Expect.isSome after "There should have been a document returned post-update"
            Expect.equal after.Value.NumValue 44 "The updated document is not correct"
        }
        testTask "succeeds when no document is updated" {
            use! db = SqliteDb.BuildDb()

            let! before = Find.all<SubDocument> SqliteDb.TableName
            Expect.isEmpty before "There should have been no documents returned"
            
            // This not raising an exception is the test
            do! Patch.byId SqliteDb.TableName "test" {| Foo = "green" |}
        }
    ]
    testList "byFields" [
        testTask "succeeds when a document is updated" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()
            
            do! Patch.byFields SqliteDb.TableName Any [ Field.EQ "Value" "purple" ] {| NumValue = 77 |}
            let! after = Count.byFields SqliteDb.TableName Any [ Field.EQ "NumValue" 77 ]
            Expect.equal after 2L "There should have been 2 documents returned"
        }
        testTask "succeeds when no document is updated" {
            use! db = SqliteDb.BuildDb()

            let! before = Find.all<SubDocument> SqliteDb.TableName
            Expect.isEmpty before "There should have been no documents returned"
            
            // This not raising an exception is the test
            do! Patch.byFields SqliteDb.TableName Any [ Field.EQ "Value" "burgundy" ] {| Foo = "green" |}
        }
    ]
]

/// Integration tests for the RemoveFields module of the SQLite library
let removeFieldsTests = testList "RemoveFields" [
    testList "byId" [
        testTask "succeeds when fields is removed" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()
            
            do! RemoveFields.byId SqliteDb.TableName "two" [ "Sub"; "Value" ]
            try
                let! _ = Find.byId<string, JsonDocument> SqliteDb.TableName "two"
                Expect.isTrue false "The updated document should have failed to parse"
            with
            | :? JsonException -> ()
            | exn as ex -> Expect.isTrue false $"Threw {ex.GetType().Name} ({ex.Message})"
        }
        testTask "succeeds when a field is not removed" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()
            
            // This not raising an exception is the test
            do! RemoveFields.byId SqliteDb.TableName "two" [ "AFieldThatIsNotThere" ]
        }
        testTask "succeeds when no document is matched" {
            use! db = SqliteDb.BuildDb()
            
            // This not raising an exception is the test
            do! RemoveFields.byId SqliteDb.TableName "two" [ "Value" ]
        }
    ]
    testList "byFields" [
        testTask "succeeds when a field is removed" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()
            
            do! RemoveFields.byFields SqliteDb.TableName Any [ Field.EQ "NumValue" 17 ] [ "Sub" ]
            try
                let! _ = Find.byId<string, JsonDocument> SqliteDb.TableName "four"
                Expect.isTrue false "The updated document should have failed to parse"
            with
            | :? JsonException -> ()
            | exn as ex -> Expect.isTrue false $"Threw {ex.GetType().Name} ({ex.Message})"
        }
        testTask "succeeds when a field is not removed" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()
            
            // This not raising an exception is the test
            do! RemoveFields.byFields SqliteDb.TableName Any [ Field.EQ "NumValue" 17 ] [ "Nothing" ]
        }
        testTask "succeeds when no document is matched" {
            use! db = SqliteDb.BuildDb()
            
            // This not raising an exception is the test
            do! RemoveFields.byFields SqliteDb.TableName Any [ Field.NE "Abracadabra" "apple" ] [ "Value" ]
        }
    ]
]

/// Integration tests for the Delete module of the SQLite library
let deleteTests = testList "Delete" [
    testList "byId" [
        testTask "succeeds when a document is deleted" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            do! Delete.byId SqliteDb.TableName "four"
            let! remaining = Count.all SqliteDb.TableName
            Expect.equal remaining 4L "There should have been 4 documents remaining"
        }
        testTask "succeeds when a document is not deleted" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            do! Delete.byId SqliteDb.TableName "thirty"
            let! remaining = Count.all SqliteDb.TableName
            Expect.equal remaining 5L "There should have been 5 documents remaining"
        }
    ]
    testList "byFields" [
        testTask "succeeds when documents are deleted" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            do! Delete.byFields SqliteDb.TableName Any [ Field.NE "Value" "purple" ]
            let! remaining = Count.all SqliteDb.TableName
            Expect.equal remaining 2L "There should have been 2 documents remaining"
        }
        testTask "succeeds when documents are not deleted" {
            use! db = SqliteDb.BuildDb()
            do! loadDocs ()

            do! Delete.byFields SqliteDb.TableName Any [ Field.EQ "Value" "crimson" ]
            let! remaining = Count.all SqliteDb.TableName
            Expect.equal remaining 5L "There should have been 5 documents remaining"
        }
    ]
]

/// All tests for the SQLite library
let all = testList "Sqlite" [
    testList "Unit" [ queryTests; parametersTests ]
    testSequenced <| testList "Integration" [
        configurationTests
        customTests
        definitionTests
        documentTests
        countTests
        existsTests
        findTests
        updateTests
        patchTests
        removeFieldsTests
        deleteTests
        test "clean up database" { Configuration.useConnectionString "data source=:memory:" }
    ]
]