258 lines
14 KiB
Forth
258 lines
14 KiB
Forth
module CommonTests
|
|
|
|
open BitBadger.Documents
|
|
open Expecto
|
|
|
|
/// Test table name
|
|
let tbl = "test_table"
|
|
|
|
/// Tests which do not hit the database
|
|
let all =
|
|
testList "Common" [
|
|
testList "Op" [
|
|
test "EQ succeeds" {
|
|
Expect.equal (string EQ) "=" "The equals operator was not correct"
|
|
}
|
|
test "GT succeeds" {
|
|
Expect.equal (string GT) ">" "The greater than operator was not correct"
|
|
}
|
|
test "GE succeeds" {
|
|
Expect.equal (string GE) ">=" "The greater than or equal to operator was not correct"
|
|
}
|
|
test "LT succeeds" {
|
|
Expect.equal (string LT) "<" "The less than operator was not correct"
|
|
}
|
|
test "LE succeeds" {
|
|
Expect.equal (string LE) "<=" "The less than or equal to operator was not correct"
|
|
}
|
|
test "NE succeeds" {
|
|
Expect.equal (string NE) "<>" "The not equal to operator was not correct"
|
|
}
|
|
test "BT succeeds" {
|
|
Expect.equal (string BT) "BETWEEN" """The "between" operator was not correct"""
|
|
}
|
|
test "EX succeeds" {
|
|
Expect.equal (string EX) "IS NOT NULL" """The "exists" operator was not correct"""
|
|
}
|
|
test "NEX succeeds" {
|
|
Expect.equal (string NEX) "IS NULL" """The "not exists" operator was not correct"""
|
|
}
|
|
]
|
|
testList "Field" [
|
|
test "EQ succeeds" {
|
|
let field = Field.EQ "Test" 14
|
|
Expect.equal field.Name "Test" "Field name incorrect"
|
|
Expect.equal field.Op EQ "Operator incorrect"
|
|
Expect.equal field.Value 14 "Value incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "GT succeeds" {
|
|
let field = Field.GT "Great" "night"
|
|
Expect.equal field.Name "Great" "Field name incorrect"
|
|
Expect.equal field.Op GT "Operator incorrect"
|
|
Expect.equal field.Value "night" "Value incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "GE succeeds" {
|
|
let field = Field.GE "Nice" 88L
|
|
Expect.equal field.Name "Nice" "Field name incorrect"
|
|
Expect.equal field.Op GE "Operator incorrect"
|
|
Expect.equal field.Value 88L "Value incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "LT succeeds" {
|
|
let field = Field.LT "Lesser" "seven"
|
|
Expect.equal field.Name "Lesser" "Field name incorrect"
|
|
Expect.equal field.Op LT "Operator incorrect"
|
|
Expect.equal field.Value "seven" "Value incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "LE succeeds" {
|
|
let field = Field.LE "Nobody" "KNOWS";
|
|
Expect.equal field.Name "Nobody" "Field name incorrect"
|
|
Expect.equal field.Op LE "Operator incorrect"
|
|
Expect.equal field.Value "KNOWS" "Value incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "NE succeeds" {
|
|
let field = Field.NE "Park" "here"
|
|
Expect.equal field.Name "Park" "Field name incorrect"
|
|
Expect.equal field.Op NE "Operator incorrect"
|
|
Expect.equal field.Value "here" "Value incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "BT succeeds" {
|
|
let field = Field.BT "Age" 18 49
|
|
Expect.equal field.Name "Age" "Field name incorrect"
|
|
Expect.equal field.Op BT "Operator incorrect"
|
|
Expect.sequenceEqual (field.Value :?> obj list) [ 18; 49 ] "Value incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "EX succeeds" {
|
|
let field = Field.EX "Groovy"
|
|
Expect.equal field.Name "Groovy" "Field name incorrect"
|
|
Expect.equal field.Op EX "Operator incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "NEX succeeds" {
|
|
let field = Field.NEX "Rad"
|
|
Expect.equal field.Name "Rad" "Field name incorrect"
|
|
Expect.equal field.Op NEX "Operator incorrect"
|
|
Expect.isNone field.ParameterName "The default parameter name should be None"
|
|
Expect.isNone field.Qualifier "The default table qualifier should be None"
|
|
}
|
|
test "WithParameterName succeeds" {
|
|
let field = (Field.EQ "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.EQ "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.GE "SomethingCool" 18
|
|
Expect.equal "data->>'SomethingCool'" (field.Path PostgreSQL) "The PostgreSQL path is incorrect"
|
|
}
|
|
test "succeeds for a PostgreSQL single field with a qualifier" {
|
|
let field = { Field.LT "SomethingElse" 9 with Qualifier = Some "this" }
|
|
Expect.equal
|
|
"this.data->>'SomethingElse'" (field.Path PostgreSQL) "The PostgreSQL path is incorrect"
|
|
}
|
|
test "succeeds for a PostgreSQL nested field with no qualifier" {
|
|
let field = Field.EQ "My.Nested.Field" "howdy"
|
|
Expect.equal "data#>>'{My,Nested,Field}'" (field.Path PostgreSQL) "The PostgreSQL path is incorrect"
|
|
}
|
|
test "succeeds for a PostgreSQL nested field with a qualifier" {
|
|
let field = { Field.EQ "Nest.Away" "doc" with Qualifier = Some "bird" }
|
|
Expect.equal "bird.data#>>'{Nest,Away}'" (field.Path PostgreSQL) "The PostgreSQL path is incorrect"
|
|
}
|
|
test "succeeds for a SQLite single field with no qualifier" {
|
|
let field = Field.GE "SomethingCool" 18
|
|
Expect.equal "data->>'SomethingCool'" (field.Path SQLite) "The SQLite path is incorrect"
|
|
}
|
|
test "succeeds for a SQLite single field with a qualifier" {
|
|
let field = { Field.LT "SomethingElse" 9 with Qualifier = Some "this" }
|
|
Expect.equal "this.data->>'SomethingElse'" (field.Path SQLite) "The SQLite path is incorrect"
|
|
}
|
|
test "succeeds for a SQLite nested field with no qualifier" {
|
|
let field = Field.EQ "My.Nested.Field" "howdy"
|
|
Expect.equal "data->>'My'->>'Nested'->>'Field'" (field.Path SQLite) "The SQLite path is incorrect"
|
|
}
|
|
test "succeeds for a SQLite nested field with a qualifier" {
|
|
let field = { Field.EQ "Nest.Away" "doc" with Qualifier = Some "bird" }
|
|
Expect.equal "bird.data->>'Nest'->>'Away'" (field.Path SQLite) "The SQLite path is incorrect"
|
|
}
|
|
]
|
|
]
|
|
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"
|
|
}
|
|
]
|
|
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"
|
|
}
|
|
]
|
|
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"
|
|
}
|
|
]
|
|
]
|