{-# LANGUAGE ExistentialQuantification #-}
{-# language DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module JSONTest where
import Control.Monad.IO.Class (MonadIO)
import Data.Aeson
import qualified Data.Vector as V (fromList)
import Test.HUnit (assertBool)
import Test.Hspec.Expectations ()
import Database.Persist
import Database.Persist.Postgresql.JSON
import PgInit
share [mkPersist persistSettings, mkMigrate "jsonTestMigrate"] [persistLowerCase|
TestValue
json Value
deriving Show
|]
cleanDB :: (BaseBackend backend ~ SqlBackend, PersistQueryWrite backend, MonadIO m)
=> ReaderT backend m ()
cleanDB = deleteWhere ([] :: [Filter TestValue])
emptyArr :: Value
emptyArr = toJSON ([] :: [Value])
insert' :: (MonadIO m, PersistStoreWrite backend, BaseBackend backend ~ SqlBackend)
=> Value -> ReaderT backend m (Key TestValue)
insert' = insert . TestValue
matchKeys :: (Show record, Show (Key record), MonadIO m, Eq (Key record))
=> [Key record] -> [Entity record] -> m ()
matchKeys ys xs = do
msg1 `assertBoolIO` (xLen == yLen)
forM_ ys $ \y -> msg2 y `assertBoolIO` (y `elem` ks)
where ks = entityKey <$> xs
xLen = length xs
yLen = length ys
msg1 = mconcat
[ "\nexpected: ", show yLen
, "\n but got: ", show xLen
, "\n[xs: ", show xs, "]"
, "\n[ys: ", show ys, "]"
]
msg2 y = mconcat
[ "key \"", show y
, "\" not in result:\n ", show ks
]
setup :: IO TestKeys
setup = asIO $ runConn_ $ do
void $ runMigrationSilent jsonTestMigrate
testKeys
teardown :: IO ()
teardown = asIO $ runConn_ $ do
cleanDB
shouldBeIO :: (Show a, Eq a, MonadIO m) => a -> a -> m ()
shouldBeIO x y = liftIO $ shouldBe x y
assertBoolIO :: MonadIO m => String -> Bool -> m ()
assertBoolIO s b = liftIO $ assertBool s b
testKeys :: (Monad m, MonadIO m) => ReaderT SqlBackend m TestKeys
testKeys = do
nullK <- insert' Null
boolTK <- insert' $ Bool True
boolFK <- insert' $ toJSON False
num0K <- insert' $ Number 0
num1K <- insert' $ Number 1
numBigK <- insert' $ toJSON (1234567890 :: Int)
numFloatK <- insert' $ Number 0.0
numSmallK <- insert' $ Number 0.0000000000000000123
numFloat2K <- insert' $ Number 1.5
-- numBigFloatK will turn into 9876543210.123457 because JSON
numBigFloatK <- insert' $ toJSON (9876543210.123456789 :: Double)
strNullK <- insert' $ String ""
strObjK <- insert' $ String "{}"
strArrK <- insert' $ String "[]"
strAK <- insert' $ String "a"
strTestK <- insert' $ toJSON ("testing" :: Text)
str2K <- insert' $ String "2"
strFloatK <- insert' $ String "0.45876"
arrNullK <- insert' $ Array $ V.fromList []
arrListK <- insert' $ toJSON [emptyArr,emptyArr,toJSON [emptyArr,emptyArr]]
arrList2K <- insert' $ toJSON [emptyArr,toJSON [Number 3,Bool False]
,toJSON [emptyArr,toJSON [Object mempty]]
]
arrFilledK <- insert' $ toJSON [Null, Number 4, String "b"
,Object mempty, emptyArr
,object [ "test" .= [Null], "test2" .= String "yes"]
]
arrList3K <- insert' $ toJSON [toJSON [String "a"], Number 1]
arrList4K <- insert' $ toJSON [String "a", String "b", String "c", String "d"]
objNullK <- insert' $ Object mempty
objTestK <- insert' $ object ["test" .= Null, "test1" .= String "no"]
objDeepK <- insert' $ object ["c" .= Number 24.986, "foo" .= object ["deep1" .= Bool True]]
objEmptyK <- insert' $ object ["" .= Number 9001]
objFullK <- insert' $ object ["a" .= Number 1, "b" .= Number 2
,"c" .= Number 3, "d" .= Number 4
]
return TestKeys{..}
data TestKeys =
TestKeys { nullK :: Key TestValue
, boolTK :: Key TestValue
, boolFK :: Key TestValue
, num0K :: Key TestValue
, num1K :: Key TestValue
, numBigK :: Key TestValue
, numFloatK :: Key TestValue
, numSmallK :: Key TestValue
, numFloat2K :: Key TestValue
, numBigFloatK :: Key TestValue
, strNullK :: Key TestValue
, strObjK :: Key TestValue
, strArrK :: Key TestValue
, strAK :: Key TestValue
, strTestK :: Key TestValue
, str2K :: Key TestValue
, strFloatK :: Key TestValue
, arrNullK :: Key TestValue
, arrListK :: Key TestValue
, arrList2K :: Key TestValue
, arrFilledK :: Key TestValue
, objNullK :: Key TestValue
, objTestK :: Key TestValue
, objDeepK :: Key TestValue
, arrList3K :: Key TestValue
, arrList4K :: Key TestValue
, objEmptyK :: Key TestValue
, objFullK :: Key TestValue
} deriving (Eq, Ord, Show)
specs :: Spec
specs = afterAll_ teardown $ do
beforeAll setup $ do
describe "Testing JSON operators" $ do
describe "@>. object queries" $ do
it "matches an empty Object with any object" $
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. Object mempty] []
[objNullK, objTestK, objDeepK, objEmptyK, objFullK] `matchKeys` vals
it "matches a subset of object properties" $
-- {test: null, test1: no} @>. {test: null} == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. object ["test" .= Null]] []
[objTestK] `matchKeys` vals
it "matches a nested object against an empty object at the same key" $
-- {c: 24.986, foo: {deep1: true}} @>. {foo: {}} == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. object ["foo" .= object []]] []
[objDeepK] `matchKeys` vals
it "doesn't match a nested object against a string at the same key" $
-- {c: 24.986, foo: {deep1: true}} @>. {foo: nope} == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. object ["foo" .= String "nope"]] []
[] `matchKeys` vals
it "matches a nested object when the query object is identical" $
-- {c: 24.986, foo: {deep1: true}} @>. {foo: {deep1: true}} == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. (object ["foo" .= object ["deep1" .= True]])] []
[objDeepK] `matchKeys` vals
it "doesn't match a nested object when queried with that exact object" $
-- {c: 24.986, foo: {deep1: true}} @>. {deep1: true} == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. object ["deep1" .= True]] []
[] `matchKeys` vals
describe "@>. array queries" $ do
it "matches an empty Array with any list" $
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. emptyArr] []
[arrNullK, arrListK, arrList2K, arrFilledK, arrList3K, arrList4K] `matchKeys` vals
it "matches list when queried with subset (1 item)" $
-- [null, 4, 'b', {}, [], {test: [null], test2: 'yes'}] @>. [4] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON [4 :: Int]] []
[arrFilledK] `matchKeys` vals
it "matches list when queried with subset (2 items)" $
-- [null, 4, 'b', {}, [], {test: [null], test2: 'yes'}] @>. [null,'b'] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON [Null, String "b"]] []
[arrFilledK] `matchKeys` vals
it "doesn't match list when queried with intersecting list (1 match, 1 diff)" $
-- [null, 4, 'b', {}, [], {test: [null], test2: 'yes'}] @>. [null,'d'] == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON [emptyArr, String "d"]] []
[] `matchKeys` vals
it "matches list when queried with same list in different order" $
-- [null, 4, 'b', {}, [], {test: [null], test2: 'yes'}] @>.
-- [[],'b',{test: [null],test2: 'yes'},4,null,{}] == True
\TestKeys {..} -> runConnAssert $ do
let queryList =
toJSON [ emptyArr, String "b"
, object [ "test" .= [Null], "test2" .= String "yes"]
, Number 4, Null, Object mempty ]
vals <- selectList [TestValueJson @>. queryList ] []
[arrFilledK] `matchKeys` vals
it "doesn't match list when queried with same list + 1 item" $
-- [null,4,'b',{},[],{test:[null],test2:'yes'}] @>.
-- [null,4,'b',{},[],{test:[null],test2: 'yes'}, false] == False
\TestKeys {..} -> runConnAssert $ do
let testList =
toJSON [ Null, Number 4, String "b", Object mempty, emptyArr
, object [ "test" .= [Null], "test2" .= String "yes"]
, Bool False ]
vals <- selectList [TestValueJson @>. testList] []
[] `matchKeys` vals
it "matches list when it shares an empty object with the query list" $
-- [null,4,'b',{},[],{test: [null],test2: 'yes'}] @>. [{}] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON [Object mempty]] []
[arrFilledK] `matchKeys` vals
it "matches list with nested list, when queried with an empty nested list" $
-- [null,4,'b',{},[],{test:[null],test2:'yes'}] @>. [{test:[]}] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON [object ["test" .= emptyArr]]] []
[arrFilledK] `matchKeys` vals
it "doesn't match list with nested list, when queried with a diff. nested list" $
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] @>.
-- [{"test1":[null]}] == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON [object ["test1" .= [Null]]]] []
[] `matchKeys` vals
it "matches many nested lists when queried with empty nested list" $
-- [[],[],[[],[]]] @>. [[]] == True
-- [[],[3,false],[[],[{}]]] @>. [[]] == True
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] @>. [[]] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON [emptyArr]] []
[arrListK,arrList2K,arrFilledK, arrList3K] `matchKeys` vals
it "matches nested list when queried with a subset of that list" $
-- [[],[3,false],[[],[{}]]] @>. [[3]] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON [[3 :: Int]]] []
[arrList2K] `matchKeys` vals
it "doesn't match nested list againts a partial intersection of that list" $
-- [[],[3,false],[[],[{}]]] @>. [[true,3]] == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON [[Bool True, Number 3]]] []
[] `matchKeys` vals
it "matches list when queried with raw number contained in the list" $
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] @>. 4 == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. Number 4] []
[arrFilledK] `matchKeys` vals
it "doesn't match list when queried with raw value not contained in the list" $
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] @>. 99 == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. Number 99] []
[] `matchKeys` vals
it "matches list when queried with raw string contained in the list" $
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] @>. "b" == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. String "b"] []
[arrFilledK, arrList4K] `matchKeys` vals
it "doesn't match list with empty object when queried with \"{}\" " $
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] @>. "{}" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. String "{}"] []
[strObjK] `matchKeys` vals
it "doesnt match list with nested object when queried with object (not in list)" $
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] @>.
-- {"test":[null],"test2":"yes"} == False
\TestKeys {..} -> runConnAssert $ do
let queryObject = object [ "test" .= [Null], "test2" .= String "yes"]
vals <- selectList [TestValueJson @>. queryObject ] []
[] `matchKeys` vals
describe "@>. string queries" $ do
it "matches identical strings" $
-- "testing" @>. "testing" == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. String "testing"] []
[strTestK] `matchKeys` vals
it "doesnt match case insensitive" $
-- "testing" @>. "Testing" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. String "Testing"] []
[] `matchKeys` vals
it "doesn't match substrings" $
-- "testing" @>. "test" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. String "test"] []
[] `matchKeys` vals
it "doesn't match strings with object keys" $
-- "testing" @>. {"testing":1} == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. object ["testing" .= Number 1]] []
[] `matchKeys` vals
describe "@>. number queries" $ do
it "matches identical numbers" $
-- 1 @>. 1 == True
-- [1] @>. 1 == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON (1 :: Int)] []
[num1K, arrList3K] `matchKeys` vals
it "matches numbers when queried with float" $
-- 0 @>. 0.0 == True
-- 0.0 @>. 0.0 == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON (0.0 :: Double)] []
[num0K,numFloatK] `matchKeys` vals
it "does not match numbers when queried with a substring of that number" $
-- 1234567890 @>. 123456789 == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON (123456789 :: Int)] []
[] `matchKeys` vals
it "does not match number when queried with different number" $
-- 1234567890 @>. 234567890 == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON (234567890 :: Int)] []
[] `matchKeys` vals
it "does not match number when queried with string of that number" $
-- 1 @>. "1" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. String "1"] []
[] `matchKeys` vals
it "does not match number when queried with list of digits" $
-- 1234567890 @>. [1,2,3,4,5,6,7,8,9,0] == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON ([1,2,3,4,5,6,7,8,9,0] :: [Int])] []
[] `matchKeys` vals
describe "@>. boolean queries" $ do
it "matches identical booleans (True)" $
-- true @>. true == True
-- false @>. true == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. toJSON True] []
[boolTK] `matchKeys` vals
it "matches identical booleans (False)" $
-- false @>. false == True
-- true @>. false == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. Bool False] []
[boolFK] `matchKeys` vals
it "does not match boolean with string of boolean" $
-- true @>. "true" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. String "true"] []
[] `matchKeys` vals
describe "@>. null queries" $ do
it "matches nulls" $
-- null @>. null == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. Null] []
[nullK,arrFilledK] `matchKeys` vals
it "does not match null with string of null" $
-- null @>. "null" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson @>. String "null"] []
[] `matchKeys` vals
describe "<@. queries" $ do
it "matches subobject when queried with superobject" $
-- {} <@. {"test":null,"test1":"no","blabla":[]} == True
-- {"test":null,"test1":"no"} <@. {"test":null,"test1":"no","blabla":[]} == True
\TestKeys {..} -> runConnAssert $ do
let queryObject = object ["test" .= Null
, "test1" .= String "no"
, "blabla" .= emptyArr
]
vals <- selectList [TestValueJson <@. queryObject] []
[objNullK,objTestK] `matchKeys` vals
it "matches raw values and sublists when queried with superlist" $
-- [] <@. [null,4,"b",{},[],{"test":[null],"test2":"yes"},false] == True
-- null <@. [null,4,"b",{},[],{"test":[null],"test2":"yes"},false] == True
-- false <@. [null,4,"b",{},[],{"test":[null],"test2":"yes"},false] == True
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] <@.
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"},false] == True
\TestKeys {..} -> runConnAssert $ do
let queryList =
toJSON [ Null, Number 4, String "b", Object mempty, emptyArr
, object [ "test" .= [Null], "test2" .= String "yes"]
, Bool False ]
vals <- selectList [TestValueJson <@. queryList ] []
[arrNullK,arrFilledK,boolFK,nullK] `matchKeys` vals
it "matches identical strings" $
-- "a" <@. "a" == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson <@. String "a"] []
[strAK] `matchKeys` vals
it "matches identical big floats" $
-- 9876543210.123457 <@ 9876543210.123457 == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson <@. Number 9876543210.123457] []
[numBigFloatK] `matchKeys` vals
it "doesn't match different big floats" $
-- 9876543210.123457 <@. 9876543210.123456789 == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson <@. Number 9876543210.123456789] []
[] `matchKeys` vals
it "matches nulls" $
-- null <@. null == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson <@. Null] []
[nullK] `matchKeys` vals
describe "?. queries" $ do
it "matches top level keys and not the keys of nested objects" $
-- {"test":null,"test1":"no"} ?. "test" == True
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] ?. "test" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?. "test"] []
[objTestK] `matchKeys` vals
it "doesn't match nested key" $
-- {"c":24.986,"foo":{"deep1":true"}} ?. "deep1" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?. "deep1"] []
[] `matchKeys` vals
it "matches \"{}\" but not empty object when queried with \"{}\"" $
-- "{}" ?. "{}" == True
-- {} ?. "{}" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?. "{}"] []
[strObjK] `matchKeys` vals
it "matches raw empty str and empty str key when queried with \"\"" $
---- {} ?. "" == False
---- "" ?. "" == True
---- {"":9001} ?. "" == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?. ""] []
[strNullK,objEmptyK] `matchKeys` vals
it "matches lists containing string value when queried with raw string value" $
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] ?. "b" == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?. "b"] []
[arrFilledK,arrList4K,objFullK] `matchKeys` vals
it "matches lists, objects, and raw values correctly when queried with string" $
-- [["a"]] ?. "a" == False
-- "a" ?. "a" == True
-- ["a","b","c","d"] ?. "a" == True
-- {"a":1,"b":2,"c":3,"d":4} ?. "a" == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?. "a"] []
[strAK,arrList4K,objFullK] `matchKeys` vals
it "matches string list but not real list when queried with \"[]\"" $
-- "[]" ?. "[]" == True
-- [] ?. "[]" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?. "[]"] []
[strArrK] `matchKeys` vals
it "does not match null when queried with string null" $
-- null ?. "null" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?. "null"] []
[] `matchKeys` vals
it "does not match bool whe nqueried with string bool" $
-- true ?. "true" == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?. "true"] []
[] `matchKeys` vals
describe "?|. queries" $ do
it "matches raw vals, lists, objects, and nested objects" $
-- "a" ?|. ["a","b","c"] == True
-- [["a"],1] ?|. ["a","b","c"] == False
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] ?|. ["a","b","c"] == True
-- ["a","b","c","d"] ?|. ["a","b","c"] == True
-- {"a":1,"b":2,"c":3,"d":4} ?|. ["a","b","c"] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?|. ["a","b","c"]] []
[strAK,arrFilledK,objDeepK,arrList4K,objFullK] `matchKeys` vals
it "matches str object but not object when queried with \"{}\"" $
-- "{}" ?|. ["{}"] == True
-- {} ?|. ["{}"] == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?|. ["{}"]] []
[strObjK] `matchKeys` vals
it "doesn't match superstrings when queried with substring" $
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] ?|. ["test"] == False
-- "testing" ?|. ["test"] == False
-- {"test":null,"test1":"no"} ?|. ["test"] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?|. ["test"]] []
[objTestK] `matchKeys` vals
it "doesn't match nested keys" $
-- {"c":24.986,"foo":{"deep1":true"}} ?|. ["deep1"] == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?|. ["deep1"]] []
[] `matchKeys` vals
it "doesn't match anything when queried with empty list" $
-- ANYTHING ?|. [] == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?|. []] []
[] `matchKeys` vals
it "doesn't match raw, non-string, values when queried with strings" $
-- true ?|. ["true","null","1"] == False
-- null ?|. ["true","null","1"] == False
-- 1 ?|. ["true","null","1"] == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?|. ["true","null","1"]] []
[] `matchKeys` vals
it "matches string array when queried with \"[]\"" $
-- [] ?|. ["[]"] == False
-- "[]" ?|. ["[]"] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?|. ["[]"]] []
[strArrK] `matchKeys` vals
describe "?&. queries" $ do
it "matches anything when queried with an empty list" $
-- ANYTHING ?&. [] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?&. []] []
flip matchKeys vals [ nullK
, boolTK, boolFK
, num0K, num1K, numBigK, numFloatK
, numSmallK, numFloat2K, numBigFloatK
, strNullK, strObjK, strArrK, strAK
, strTestK, str2K, strFloatK
, arrNullK, arrListK, arrList2K
, arrFilledK, arrList3K, arrList4K
, objNullK, objTestK, objDeepK
, objEmptyK, objFullK
]
it "matches raw values, lists, and objects when queried with string" $
-- "a" ?&. ["a"] == True
-- [["a"],1] ?&. ["a"] == False
-- ["a","b","c","d"] ?&. ["a"] == True
-- {"a":1,"b":2,"c":3,"d":4} ?&. ["a"] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?&. ["a"]] []
[strAK,arrList4K,objFullK] `matchKeys` vals
it "matches raw values, lists, and objects when queried with multiple string" $
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] ?&. ["b","c"] == False
-- {"c":24.986,"foo":{"deep1":true"}} ?&. ["b","c"] == False
-- ["a","b","c","d"] ?&. ["b","c"] == True
-- {"a":1,"b":2,"c":3,"d":4} ?&. ["b","c"] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?&. ["b","c"]] []
[arrList4K,objFullK] `matchKeys` vals
it "matches object string when queried with \"{}\"" $
-- {} ?&. ["{}"] == False
-- "{}" ?&. ["{}"] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?&. ["{}"]] []
[strObjK] `matchKeys` vals
it "doesn't match superstrings when queried with substring" $
-- [null,4,"b",{},[],{"test":[null],"test2":"yes"}] ?&. ["test"] == False
-- "testing" ?&. ["test"] == False
-- {"test":null,"test1":"no"} ?&. ["test"] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?&. ["test"]] []
[objTestK] `matchKeys` vals
it "doesn't match nested keys" $
-- {"c":24.986,"foo":{"deep1":true"}} ?&. ["deep1"] == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?&. ["deep1"]] []
[] `matchKeys` vals
it "doesn't match anything when there is a partial match" $
-- "a" ?&. ["a","e"] == False
-- ["a","b","c","d"] ?&. ["a","e"] == False
-- {"a":1,"b":2,"c":3,"d":4} ?&. ["a","e"] == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?&. ["a","e"]] []
[] `matchKeys` vals
it "matches string array when queried with \"[]\"" $
-- [] ?&. ["[]"] == False
-- "[]" ?&. ["[]"] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?&. ["[]"]] []
[strArrK] `matchKeys` vals
it "doesn't match null when queried with string null" $
-- THIS WILL FAIL IF THE IMPLEMENTATION USES
-- @ '{null}' @
-- INSTEAD OF
-- @ ARRAY['null'] @
-- null ?&. ["null"] == False
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?&. ["null"]] []
[] `matchKeys` vals
it "doesn't match number when queried with str of that number" $
-- [["a"],1] ?&. ["1"] == False
-- "1" ?&. ["1"] == True
\TestKeys {..} -> runConnAssert $ do
str1 <- insert' $ toJSON $ String "1"
vals <- selectList [TestValueJson ?&. ["1"]] []
[str1] `matchKeys` vals
it "doesn't match empty objs or list when queried with empty string" $
-- {} ?&. [""] == False
-- [] ?&. [""] == False
-- "" ?&. [""] == True
-- {"":9001} ?&. [""] == True
\TestKeys {..} -> runConnAssert $ do
vals <- selectList [TestValueJson ?&. [""]] []
[strNullK,objEmptyK] `matchKeys` vals