497 lines
24 KiB
Forth
497 lines
24 KiB
Forth
module CommonTests
|
|
|
|
open BitBadger.Documents
|
|
open Expecto
|
|
|
|
/// Test table name
|
|
let tbl = "test_table"
|
|
|
|
/// Unit tests for the Op DU
|
|
let comparisonTests = testList "Comparison.OpSql" [
|
|
test "Equal succeeds" {
|
|
Expect.equal (Equal "").OpSql "=" "The Equals SQL was not correct"
|
|
}
|
|
test "Greater succeeds" {
|
|
Expect.equal (Greater "").OpSql ">" "The Greater SQL was not correct"
|
|
}
|
|
test "GreaterOrEqual succeeds" {
|
|
Expect.equal (GreaterOrEqual "").OpSql ">=" "The GreaterOrEqual SQL was not correct"
|
|
}
|
|
test "Less succeeds" {
|
|
Expect.equal (Less "").OpSql "<" "The Less SQL was not correct"
|
|
}
|
|
test "LessOrEqual succeeds" {
|
|
Expect.equal (LessOrEqual "").OpSql "<=" "The LessOrEqual SQL was not correct"
|
|
}
|
|
test "NotEqual succeeds" {
|
|
Expect.equal (NotEqual "").OpSql "<>" "The NotEqual SQL was not correct"
|
|
}
|
|
test "Between succeeds" {
|
|
Expect.equal (Between("", "")).OpSql "BETWEEN" "The Between SQL was not correct"
|
|
}
|
|
test "In succeeds" {
|
|
Expect.equal (In []).OpSql "IN" "The In SQL was not correct"
|
|
}
|
|
test "InArray succeeds" {
|
|
Expect.equal (InArray("", [])).OpSql "?|" "The InArray SQL was not correct"
|
|
}
|
|
test "Exists succeeds" {
|
|
Expect.equal Exists.OpSql "IS NOT NULL" "The Exists SQL was not correct"
|
|
}
|
|
test "NotExists succeeds" {
|
|
Expect.equal NotExists.OpSql "IS NULL" "The NotExists SQL was not correct"
|
|
}
|
|
]
|
|
|
|
/// Unit tests for the Field class
|
|
let fieldTests = testList "Field" [
|
|
test "Equal succeeds" {
|
|
let field = Field.Equal "Test" 14
|
|
Expect.equal field.Name "Test" "Field name incorrect"
|
|
Expect.equal field.Comparison (Equal 14) "Comparison incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "Greater succeeds" {
|
|
let field = Field.Greater "Great" "night"
|
|
Expect.equal field.Name "Great" "Field name incorrect"
|
|
Expect.equal field.Comparison (Greater "night") "Comparison incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "GreaterOrEqual succeeds" {
|
|
let field = Field.GreaterOrEqual "Nice" 88L
|
|
Expect.equal field.Name "Nice" "Field name incorrect"
|
|
Expect.equal field.Comparison (GreaterOrEqual 88L) "Comparison incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "Less succeeds" {
|
|
let field = Field.Less "Lesser" "seven"
|
|
Expect.equal field.Name "Lesser" "Field name incorrect"
|
|
Expect.equal field.Comparison (Less "seven") "Comparison incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "LessOrEqual succeeds" {
|
|
let field = Field.LessOrEqual "Nobody" "KNOWS";
|
|
Expect.equal field.Name "Nobody" "Field name incorrect"
|
|
Expect.equal field.Comparison (LessOrEqual "KNOWS") "Comparison incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "NotEqual succeeds" {
|
|
let field = Field.NotEqual "Park" "here"
|
|
Expect.equal field.Name "Park" "Field name incorrect"
|
|
Expect.equal field.Comparison (NotEqual "here") "Comparison incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "Between succeeds" {
|
|
let field = Field.Between "Age" 18 49
|
|
Expect.equal field.Name "Age" "Field name incorrect"
|
|
Expect.equal field.Comparison (Between(18, 49)) "Comparison incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "In succeeds" {
|
|
let field = Field.In "Here" [| 8; 16; 32 |]
|
|
Expect.equal field.Name "Here" "Field name incorrect"
|
|
match field.Comparison with
|
|
| In values -> Expect.equal (List.ofSeq values) [ box 8; box 16; box 32 ] "Comparison incorrect"
|
|
| it -> Expect.isTrue false $"Expected In, received %A{it}"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "InArray succeeds" {
|
|
let field = Field.InArray "ArrayField" "table" [| "z" |]
|
|
Expect.equal field.Name "ArrayField" "Field name incorrect"
|
|
match field.Comparison with
|
|
| InArray (table, values) ->
|
|
Expect.equal table "table" "Comparison table incorrect"
|
|
Expect.equal (List.ofSeq values) [ box "z" ] "Comparison values incorrect"
|
|
| it -> Expect.isTrue false $"Expected InArray, received %A{it}"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "Exists succeeds" {
|
|
let field = Field.Exists "Groovy"
|
|
Expect.equal field.Name "Groovy" "Field name incorrect"
|
|
Expect.equal field.Comparison Exists "Comparison incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "NotExists succeeds" {
|
|
let field = Field.NotExists "Rad"
|
|
Expect.equal field.Name "Rad" "Field name incorrect"
|
|
Expect.equal field.Comparison NotExists "Comparison incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
testList "NameToPath" [
|
|
test "succeeds for PostgreSQL and a simple name" {
|
|
Expect.equal "data->>'Simple'" (Field.NameToPath "Simple" PostgreSQL AsSql) "Path not constructed correctly"
|
|
}
|
|
test "succeeds for SQLite and a simple name" {
|
|
Expect.equal "data->>'Simple'" (Field.NameToPath "Simple" SQLite AsSql) "Path not constructed correctly"
|
|
}
|
|
test "succeeds for PostgreSQL and a nested name" {
|
|
Expect.equal
|
|
"data#>>'{A,Long,Path,to,the,Property}'"
|
|
(Field.NameToPath "A.Long.Path.to.the.Property" PostgreSQL AsSql)
|
|
"Path not constructed correctly"
|
|
}
|
|
test "succeeds for SQLite and a nested name" {
|
|
Expect.equal
|
|
"data->'A'->'Long'->'Path'->'to'->'the'->>'Property'"
|
|
(Field.NameToPath "A.Long.Path.to.the.Property" SQLite AsSql)
|
|
"Path not constructed correctly"
|
|
}
|
|
]
|
|
test "WithParameterName succeeds" {
|
|
let field = (Field.Equal "Bob" "Tom").WithParameterName "@name"
|
|
Expect.isSome field.ParameterName "The parameter name should have been filled"
|
|
Expect.equal "@name" field.ParameterName.Value "The parameter name is incorrect"
|
|
}
|
|
test "WithQualifier succeeds" {
|
|
let field = (Field.Equal "Bill" "Matt").WithQualifier "joe"
|
|
Expect.isSome field.Qualifier "The table qualifier should have been filled"
|
|
Expect.equal "joe" field.Qualifier.Value "The table qualifier is incorrect"
|
|
}
|
|
testList "Path" [
|
|
test "succeeds for a PostgreSQL single field with no qualifier" {
|
|
let field = Field.GreaterOrEqual "SomethingCool" 18
|
|
Expect.equal "data->>'SomethingCool'" (field.Path PostgreSQL AsSql) "The PostgreSQL path is incorrect"
|
|
}
|
|
test "succeeds for a PostgreSQL single field with a qualifier" {
|
|
let field = { Field.Less "SomethingElse" 9 with Qualifier = Some "this" }
|
|
Expect.equal "this.data->>'SomethingElse'" (field.Path PostgreSQL AsSql) "The PostgreSQL path is incorrect"
|
|
}
|
|
test "succeeds for a PostgreSQL nested field with no qualifier" {
|
|
let field = Field.Equal "My.Nested.Field" "howdy"
|
|
Expect.equal "data#>>'{My,Nested,Field}'" (field.Path PostgreSQL AsSql) "The PostgreSQL path is incorrect"
|
|
}
|
|
test "succeeds for a PostgreSQL nested field with a qualifier" {
|
|
let field = { Field.Equal "Nest.Away" "doc" with Qualifier = Some "bird" }
|
|
Expect.equal "bird.data#>>'{Nest,Away}'" (field.Path PostgreSQL AsSql) "The PostgreSQL path is incorrect"
|
|
}
|
|
test "succeeds for a SQLite single field with no qualifier" {
|
|
let field = Field.GreaterOrEqual "SomethingCool" 18
|
|
Expect.equal "data->>'SomethingCool'" (field.Path SQLite AsSql) "The SQLite path is incorrect"
|
|
}
|
|
test "succeeds for a SQLite single field with a qualifier" {
|
|
let field = { Field.Less "SomethingElse" 9 with Qualifier = Some "this" }
|
|
Expect.equal "this.data->>'SomethingElse'" (field.Path SQLite AsSql) "The SQLite path is incorrect"
|
|
}
|
|
test "succeeds for a SQLite nested field with no qualifier" {
|
|
let field = Field.Equal "My.Nested.Field" "howdy"
|
|
Expect.equal "data->'My'->'Nested'->>'Field'" (field.Path SQLite AsSql) "The SQLite path is incorrect"
|
|
}
|
|
test "succeeds for a SQLite nested field with a qualifier" {
|
|
let field = { Field.Equal "Nest.Away" "doc" with Qualifier = Some "bird" }
|
|
Expect.equal "bird.data->'Nest'->>'Away'" (field.Path SQLite AsSql) "The SQLite path is incorrect"
|
|
}
|
|
]
|
|
]
|
|
|
|
/// Unit tests for the FieldMatch DU
|
|
let fieldMatchTests = testList "FieldMatch.ToString" [
|
|
test "succeeds for Any" {
|
|
Expect.equal (string Any) "OR" "SQL for Any is incorrect"
|
|
}
|
|
test "succeeds for All" {
|
|
Expect.equal (string All) "AND" "SQL for All is incorrect"
|
|
}
|
|
]
|
|
|
|
/// Unit tests for the ParameterName class
|
|
let parameterNameTests = testList "ParameterName.Derive" [
|
|
test "succeeds with existing name" {
|
|
let name = ParameterName()
|
|
Expect.equal (name.Derive(Some "@taco")) "@taco" "Name should have been @taco"
|
|
Expect.equal (name.Derive None) "@field0" "Counter should not have advanced for named field"
|
|
}
|
|
test "succeeds with non-existent name" {
|
|
let name = ParameterName()
|
|
Expect.equal (name.Derive None) "@field0" "Anonymous field name should have been returned"
|
|
Expect.equal (name.Derive None) "@field1" "Counter should have advanced from previous call"
|
|
Expect.equal (name.Derive None) "@field2" "Counter should have advanced from previous call"
|
|
Expect.equal (name.Derive None) "@field3" "Counter should have advanced from previous call"
|
|
}
|
|
]
|
|
|
|
/// Unit tests for the AutoId DU
|
|
let autoIdTests = testList "AutoId" [
|
|
test "GenerateGuid succeeds" {
|
|
let autoId = AutoId.GenerateGuid()
|
|
Expect.isNotNull autoId "The GUID auto-ID should not have been null"
|
|
Expect.stringHasLength autoId 32 "The GUID auto-ID should have been 32 characters long"
|
|
Expect.equal autoId (autoId.ToLowerInvariant ()) "The GUID auto-ID should have been lowercase"
|
|
}
|
|
test "GenerateRandomString succeeds" {
|
|
[ 6; 8; 12; 20; 32; 57; 64 ]
|
|
|> List.iter (fun length ->
|
|
let autoId = AutoId.GenerateRandomString length
|
|
Expect.isNotNull autoId $"Random string ({length}) should not have been null"
|
|
Expect.stringHasLength autoId length $"Random string should have been {length} characters long"
|
|
Expect.equal autoId (autoId.ToLowerInvariant ()) $"Random string ({length}) should have been lowercase")
|
|
}
|
|
testList "NeedsAutoId" [
|
|
test "succeeds when no auto ID is configured" {
|
|
Expect.isFalse (AutoId.NeedsAutoId Disabled (obj ()) "id") "Disabled auto-ID never needs an automatic ID"
|
|
}
|
|
test "fails for any when the ID property is not found" {
|
|
Expect.throwsT<System.InvalidOperationException>
|
|
(fun () -> AutoId.NeedsAutoId Number {| Key = "" |} "Id" |> ignore)
|
|
"Non-existent ID property should have thrown an exception"
|
|
}
|
|
test "succeeds for byte when the ID is zero" {
|
|
Expect.isTrue (AutoId.NeedsAutoId Number {| Id = int8 0 |} "Id") "Zero ID should have returned true"
|
|
}
|
|
test "succeeds for byte when the ID is non-zero" {
|
|
Expect.isFalse (AutoId.NeedsAutoId Number {| Id = int8 4 |} "Id") "Non-zero ID should have returned false"
|
|
}
|
|
test "succeeds for short when the ID is zero" {
|
|
Expect.isTrue (AutoId.NeedsAutoId Number {| Id = int16 0 |} "Id") "Zero ID should have returned true"
|
|
}
|
|
test "succeeds for short when the ID is non-zero" {
|
|
Expect.isFalse (AutoId.NeedsAutoId Number {| Id = int16 7 |} "Id") "Non-zero ID should have returned false"
|
|
}
|
|
test "succeeds for int when the ID is zero" {
|
|
Expect.isTrue (AutoId.NeedsAutoId Number {| Id = 0 |} "Id") "Zero ID should have returned true"
|
|
}
|
|
test "succeeds for int when the ID is non-zero" {
|
|
Expect.isFalse (AutoId.NeedsAutoId Number {| Id = 32 |} "Id") "Non-zero ID should have returned false"
|
|
}
|
|
test "succeeds for long when the ID is zero" {
|
|
Expect.isTrue (AutoId.NeedsAutoId Number {| Id = 0L |} "Id") "Zero ID should have returned true"
|
|
}
|
|
test "succeeds for long when the ID is non-zero" {
|
|
Expect.isFalse (AutoId.NeedsAutoId Number {| Id = 80L |} "Id") "Non-zero ID should have returned false"
|
|
}
|
|
test "fails for number when the ID is not a number" {
|
|
Expect.throwsT<System.InvalidOperationException>
|
|
(fun () -> AutoId.NeedsAutoId Number {| Id = "" |} "Id" |> ignore)
|
|
"Numeric ID against a string should have thrown an exception"
|
|
}
|
|
test "succeeds for GUID when the ID is blank" {
|
|
Expect.isTrue (AutoId.NeedsAutoId Guid {| Id = "" |} "Id") "Blank ID should have returned true"
|
|
}
|
|
test "succeeds for GUID when the ID is filled" {
|
|
Expect.isFalse (AutoId.NeedsAutoId Guid {| Id = "abc" |} "Id") "Filled ID should have returned false"
|
|
}
|
|
test "fails for GUID when the ID is not a string" {
|
|
Expect.throwsT<System.InvalidOperationException>
|
|
(fun () -> AutoId.NeedsAutoId Guid {| Id = 8 |} "Id" |> ignore)
|
|
"String ID against a number should have thrown an exception"
|
|
}
|
|
test "succeeds for RandomString when the ID is blank" {
|
|
Expect.isTrue (AutoId.NeedsAutoId RandomString {| Id = "" |} "Id") "Blank ID should have returned true"
|
|
}
|
|
test "succeeds for RandomString when the ID is filled" {
|
|
Expect.isFalse (AutoId.NeedsAutoId RandomString {| Id = "x" |} "Id") "Filled ID should have returned false"
|
|
}
|
|
test "fails for RandomString when the ID is not a string" {
|
|
Expect.throwsT<System.InvalidOperationException>
|
|
(fun () -> AutoId.NeedsAutoId RandomString {| Id = 33 |} "Id" |> ignore)
|
|
"String ID against a number should have thrown an exception"
|
|
}
|
|
]
|
|
]
|
|
|
|
/// Unit tests for the Configuration module
|
|
let configurationTests = testList "Configuration" [
|
|
test "useSerializer succeeds" {
|
|
try
|
|
Configuration.useSerializer
|
|
{ new IDocumentSerializer with
|
|
member _.Serialize<'T>(it: 'T) : string = """{"Overridden":true}"""
|
|
member _.Deserialize<'T>(it: string) : 'T = Unchecked.defaultof<'T>
|
|
}
|
|
|
|
let serialized = Configuration.serializer().Serialize {| Foo = "howdy"; Bar = "bye" |}
|
|
Expect.equal serialized """{"Overridden":true}""" "Specified serializer was not used"
|
|
|
|
let deserialized = Configuration.serializer().Deserialize<obj> """{"Something":"here"}"""
|
|
Expect.isNull deserialized "Specified serializer should have returned null"
|
|
finally
|
|
Configuration.useSerializer DocumentSerializer.``default``
|
|
}
|
|
test "serializer returns configured serializer" {
|
|
Expect.isTrue (obj.ReferenceEquals(DocumentSerializer.``default``, Configuration.serializer ()))
|
|
"Serializer should have been the same"
|
|
}
|
|
test "useIdField / idField succeeds" {
|
|
try
|
|
Expect.equal (Configuration.idField ()) "Id" "The default configured ID field was incorrect"
|
|
Configuration.useIdField "id"
|
|
Expect.equal (Configuration.idField ()) "id" "useIdField did not set the ID field"
|
|
finally
|
|
Configuration.useIdField "Id"
|
|
}
|
|
test "useAutoIdStrategy / autoIdStrategy succeeds" {
|
|
try
|
|
Expect.equal (Configuration.autoIdStrategy ()) Disabled "The default auto-ID strategy was incorrect"
|
|
Configuration.useAutoIdStrategy Guid
|
|
Expect.equal (Configuration.autoIdStrategy ()) Guid "The auto-ID strategy was not set correctly"
|
|
finally
|
|
Configuration.useAutoIdStrategy Disabled
|
|
}
|
|
test "useIdStringLength / idStringLength succeeds" {
|
|
try
|
|
Expect.equal (Configuration.idStringLength ()) 16 "The default ID string length was incorrect"
|
|
Configuration.useIdStringLength 33
|
|
Expect.equal (Configuration.idStringLength ()) 33 "The ID string length was not set correctly"
|
|
finally
|
|
Configuration.useIdStringLength 16
|
|
}
|
|
]
|
|
|
|
/// Unit tests for the Query module
|
|
let queryTests = testList "Query" [
|
|
test "statementWhere succeeds" {
|
|
Expect.equal (Query.statementWhere "x" "y") "x WHERE y" "Statements not combined correctly"
|
|
}
|
|
testList "Definition" [
|
|
test "ensureTableFor succeeds" {
|
|
Expect.equal
|
|
(Query.Definition.ensureTableFor "my.table" "JSONB")
|
|
"CREATE TABLE IF NOT EXISTS my.table (data JSONB NOT NULL)"
|
|
"CREATE TABLE statement not constructed correctly"
|
|
}
|
|
testList "ensureKey" [
|
|
test "succeeds when a schema is present" {
|
|
Expect.equal
|
|
(Query.Definition.ensureKey "test.table" PostgreSQL)
|
|
"CREATE UNIQUE INDEX IF NOT EXISTS idx_table_key ON test.table ((data->>'Id'))"
|
|
"CREATE INDEX for key statement with schema not constructed correctly"
|
|
}
|
|
test "succeeds when a schema is not present" {
|
|
Expect.equal
|
|
(Query.Definition.ensureKey "table" SQLite)
|
|
"CREATE UNIQUE INDEX IF NOT EXISTS idx_table_key ON table ((data->>'Id'))"
|
|
"CREATE INDEX for key statement without schema not constructed correctly"
|
|
}
|
|
]
|
|
testList "ensureIndexOn" [
|
|
test "succeeds for multiple fields and directions" {
|
|
Expect.equal
|
|
(Query.Definition.ensureIndexOn
|
|
"test.table" "gibberish" [ "taco"; "guac DESC"; "salsa ASC" ] PostgreSQL)
|
|
([ "CREATE INDEX IF NOT EXISTS idx_table_gibberish ON test.table "
|
|
"((data->>'taco'), (data->>'guac') DESC, (data->>'salsa') ASC)" ]
|
|
|> String.concat "")
|
|
"CREATE INDEX for multiple field statement incorrect"
|
|
}
|
|
test "succeeds for nested PostgreSQL field" {
|
|
Expect.equal
|
|
(Query.Definition.ensureIndexOn tbl "nest" [ "a.b.c" ] PostgreSQL)
|
|
$"CREATE INDEX IF NOT EXISTS idx_{tbl}_nest ON {tbl} ((data#>>'{{a,b,c}}'))"
|
|
"CREATE INDEX for nested PostgreSQL field incorrect"
|
|
}
|
|
test "succeeds for nested SQLite field" {
|
|
Expect.equal
|
|
(Query.Definition.ensureIndexOn tbl "nest" [ "a.b.c" ] SQLite)
|
|
$"CREATE INDEX IF NOT EXISTS idx_{tbl}_nest ON {tbl} ((data->'a'->'b'->>'c'))"
|
|
"CREATE INDEX for nested SQLite field incorrect"
|
|
}
|
|
]
|
|
]
|
|
test "insert succeeds" {
|
|
Expect.equal (Query.insert tbl) $"INSERT INTO {tbl} VALUES (@data)" "INSERT statement not correct"
|
|
}
|
|
test "save succeeds" {
|
|
Expect.equal
|
|
(Query.save tbl)
|
|
$"INSERT INTO {tbl} VALUES (@data) ON CONFLICT ((data->>'Id')) DO UPDATE SET data = EXCLUDED.data"
|
|
"INSERT ON CONFLICT UPDATE statement not correct"
|
|
}
|
|
test "count succeeds" {
|
|
Expect.equal (Query.count tbl) $"SELECT COUNT(*) AS it FROM {tbl}" "Count query not correct"
|
|
}
|
|
test "exists succeeds" {
|
|
Expect.equal
|
|
(Query.exists tbl "turkey")
|
|
$"SELECT EXISTS (SELECT 1 FROM {tbl} WHERE turkey) AS it"
|
|
"Exists query not correct"
|
|
}
|
|
test "find succeeds" {
|
|
Expect.equal (Query.find tbl) $"SELECT data FROM {tbl}" "Find query not correct"
|
|
}
|
|
test "update succeeds" {
|
|
Expect.equal (Query.update tbl) $"UPDATE {tbl} SET data = @data" "Update query not correct"
|
|
}
|
|
test "delete succeeds" {
|
|
Expect.equal (Query.delete tbl) $"DELETE FROM {tbl}" "Delete query not correct"
|
|
}
|
|
testList "orderBy" [
|
|
test "succeeds for no fields" {
|
|
Expect.equal (Query.orderBy [] PostgreSQL) "" "Order By should have been blank (PostgreSQL)"
|
|
Expect.equal (Query.orderBy [] SQLite) "" "Order By should have been blank (SQLite)"
|
|
}
|
|
test "succeeds for PostgreSQL with one field and no direction" {
|
|
Expect.equal
|
|
(Query.orderBy [ Field.Named "TestField" ] PostgreSQL)
|
|
" ORDER BY data->>'TestField'"
|
|
"Order By not constructed correctly"
|
|
}
|
|
test "succeeds for SQLite with one field and no direction" {
|
|
Expect.equal
|
|
(Query.orderBy [ Field.Named "TestField" ] SQLite)
|
|
" ORDER BY data->>'TestField'"
|
|
"Order By not constructed correctly"
|
|
}
|
|
test "succeeds for PostgreSQL with multiple fields and direction" {
|
|
Expect.equal
|
|
(Query.orderBy
|
|
[ Field.Named "Nested.Test.Field DESC"; Field.Named "AnotherField"; Field.Named "It DESC" ]
|
|
PostgreSQL)
|
|
" ORDER BY data#>>'{Nested,Test,Field}' DESC, data->>'AnotherField', data->>'It' DESC"
|
|
"Order By not constructed correctly"
|
|
}
|
|
test "succeeds for SQLite with multiple fields and direction" {
|
|
Expect.equal
|
|
(Query.orderBy
|
|
[ Field.Named "Nested.Test.Field DESC"; Field.Named "AnotherField"; Field.Named "It DESC" ]
|
|
SQLite)
|
|
" ORDER BY data->'Nested'->'Test'->>'Field' DESC, data->>'AnotherField', data->>'It' DESC"
|
|
"Order By not constructed correctly"
|
|
}
|
|
test "succeeds for PostgreSQL numeric fields" {
|
|
Expect.equal
|
|
(Query.orderBy [ Field.Named "n:Test" ] PostgreSQL)
|
|
" ORDER BY (data->>'Test')::numeric"
|
|
"Order By not constructed correctly for numeric field"
|
|
}
|
|
test "succeeds for SQLite numeric fields" {
|
|
Expect.equal
|
|
(Query.orderBy [ Field.Named "n:Test" ] SQLite)
|
|
" ORDER BY data->>'Test'"
|
|
"Order By not constructed correctly for numeric field"
|
|
}
|
|
test "succeeds for PostgreSQL case-insensitive ordering" {
|
|
Expect.equal
|
|
(Query.orderBy [ Field.Named "i:Test.Field DESC NULLS FIRST" ] PostgreSQL)
|
|
" ORDER BY LOWER(data#>>'{Test,Field}') DESC NULLS FIRST"
|
|
"Order By not constructed correctly for case-insensitive field"
|
|
}
|
|
test "succeeds for SQLite case-insensitive ordering" {
|
|
Expect.equal
|
|
(Query.orderBy [ Field.Named "i:Test.Field ASC NULLS LAST" ] SQLite)
|
|
" ORDER BY data->'Test'->>'Field' COLLATE NOCASE ASC NULLS LAST"
|
|
"Order By not constructed correctly for case-insensitive field"
|
|
}
|
|
]
|
|
]
|
|
|
|
/// Tests which do not hit the database
|
|
let all = testList "Common" [
|
|
comparisonTests
|
|
fieldTests
|
|
fieldMatchTests
|
|
parameterNameTests
|
|
autoIdTests
|
|
queryTests
|
|
testSequenced configurationTests
|
|
]
|