{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}

module PersistentTest
    ( module PersistentTest
    , cleanDB
    , testMigrate
    , noPrefixMigrate
    , customPrefixMigrate
    , treeMigrate
    ) where

import Control.Monad.Fail
import Control.Monad.IO.Class
import Data.Aeson
import Data.Conduit
import qualified Data.Conduit.List as CL
import Data.Functor.Constant
import Data.Functor.Identity
import qualified Data.Map as Map
import Data.Maybe (fromJust)
import Data.Proxy (Proxy (..))
import Test.HUnit hiding (Test)
import Test.Hspec.QuickCheck (prop)
import UnliftIO (MonadUnliftIO, catch)
import Web.PathPieces (PathPiece (..))

import Database.Persist
import Init
import PersistTestPetCollarType
import PersistTestPetType
import PersistentTestModels

catchPersistException :: (MonadUnliftIO m, MonadFail m) => m a -> b -> m b
catchPersistException :: forall (m :: * -> *) a b.
(MonadUnliftIO m, MonadFail m) =>
m a -> b -> m b
catchPersistException m a
action b
errValue = do
    Left b
res <-
        (a -> Either b a
forall a b. b -> Either a b
Right (a -> Either b a) -> m a -> m (Either b a)
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` m a
action)
            m (Either b a)
-> (PersistException -> m (Either b a)) -> m (Either b a)
forall (m :: * -> *) e a.
(MonadUnliftIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` (\(PersistException
_ :: PersistException) -> Either b a -> m (Either b a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Either b a -> m (Either b a)) -> Either b a -> m (Either b a)
forall a b. (a -> b) -> a -> b
$ b -> Either b a
forall a b. a -> Either a b
Left b
errValue)
    b -> m b
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return b
res

filterOrSpecs
    :: forall m backend
     . (Runner backend m)
    => RunDb backend m
    -> Spec
filterOrSpecs :: forall (m :: * -> *) backend.
Runner backend m =>
RunDb backend m -> Spec
filterOrSpecs RunDb backend m
runDb = String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"FilterOr" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"FilterOr []" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p :: PersonGeneric backend
p = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"z" Int
1 Maybe Text
forall a. Maybe a
Nothing
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonGeneric backend
forall {backend}. PersonGeneric backend
p
        [Entity (PersonGeneric backend)]
ps <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [[Filter (PersonGeneric backend)] -> Filter (PersonGeneric backend)
forall record. [Filter record] -> Filter record
FilterOr []] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge]
        [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall (m :: * -> *) a. MonadIO m => [a] -> m ()
assertEmpty [Entity (PersonGeneric backend)]
ps
    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"||. []" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p :: PersonGeneric backend
p = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"z" Int
1 Maybe Text
forall a. Maybe a
Nothing
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonGeneric backend
forall {backend}. PersonGeneric backend
p
        Int
c <- [Filter (PersonGeneric backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([Filter (PersonGeneric backend)] -> ReaderT backend m Int)
-> [Filter (PersonGeneric backend)] -> ReaderT backend m Int
forall a b. (a -> b) -> a -> b
$ [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"a"] [Filter (PersonGeneric backend)]
-> [Filter (PersonGeneric backend)]
-> [Filter (PersonGeneric backend)]
forall v. [Filter v] -> [Filter v] -> [Filter v]
||. []
        Int
c Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== (Int
1 :: Int)

-- Test proper polymorphism
_polymorphic
    :: ( MonadFail m
       , MonadIO m
       , PersistQuery backend
       , BaseBackend backend ~ PersistEntityBackend Pet
       )
    => ReaderT backend m ()
_polymorphic :: forall (m :: * -> *) backend.
(MonadFail m, MonadIO m, PersistQuery backend,
 BaseBackend backend ~ PersistEntityBackend Pet) =>
ReaderT backend m ()
_polymorphic = do
    ((Entity Key (PersonGeneric SqlBackend)
id' PersonGeneric SqlBackend
_) : [Entity (PersonGeneric SqlBackend)]
_) <- [Filter (PersonGeneric SqlBackend)]
-> [SelectOpt (PersonGeneric SqlBackend)]
-> ReaderT backend m [Entity (PersonGeneric SqlBackend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [] [Int -> SelectOpt (PersonGeneric SqlBackend)
forall record. Int -> SelectOpt record
LimitTo Int
1]
    [Entity Pet]
_ <- [Filter Pet] -> [SelectOpt Pet] -> ReaderT backend m [Entity Pet]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField Pet (Key (PersonGeneric SqlBackend))
forall backend typ.
(typ ~ Key (PersonGeneric backend)) =>
EntityField (PetGeneric backend) typ
PetOwnerId EntityField Pet (Key (PersonGeneric SqlBackend))
-> Key (PersonGeneric SqlBackend) -> Filter Pet
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Key (PersonGeneric SqlBackend)
id'] []
    Pet -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ (Pet -> ReaderT backend m ()) -> Pet -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ Key (PersonGeneric SqlBackend) -> Text -> PetType -> Pet
forall backend.
Key (PersonGeneric backend)
-> Text -> PetType -> PetGeneric backend
Pet Key (PersonGeneric SqlBackend)
id' Text
"foo" PetType
Cat
    () -> ReaderT backend m ()
forall a. a -> ReaderT backend m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- Some lens stuff
type ASetter s t a b = (a -> Identity b) -> s -> Identity t

set :: ASetter s t a b -> b -> s -> t
set :: forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter s t a b
l b
b = Identity t -> t
forall a. Identity a -> a
runIdentity (Identity t -> t) -> (s -> Identity t) -> s -> t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ASetter s t a b
l (\a
_ -> b -> Identity b
forall a. a -> Identity a
Identity b
b))

type Getting r s t a b = (a -> Constant r b) -> s -> Constant r t

view :: s -> Getting a s t a b -> a
view :: forall s a t b. s -> Getting a s t a b -> a
view s
s Getting a s t a b
l = Constant a t -> a
forall {k} a (b :: k). Constant a b -> a
getConstant (Getting a s t a b
l a -> Constant a b
forall {k} a (b :: k). a -> Constant a b
Constant s
s)

safeToRemoveSpec
    :: forall backend m. (Runner backend m) => RunDb backend m -> Spec
safeToRemoveSpec :: forall backend (m :: * -> *).
Runner backend m =>
RunDb backend m -> Spec
safeToRemoveSpec RunDb backend m
runDb = do
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"DudeWeirdColumns" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"can insert and get" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            let
                m :: DudeWeirdColumnsGeneric backend
m = Text -> DudeWeirdColumnsGeneric backend
forall backend. Text -> DudeWeirdColumnsGeneric backend
DudeWeirdColumns Text
"hello"
            RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
                Key (DudeWeirdColumnsGeneric backend)
k <- DudeWeirdColumnsGeneric backend
-> ReaderT backend m (Key (DudeWeirdColumnsGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert DudeWeirdColumnsGeneric backend
forall {backend}. DudeWeirdColumnsGeneric backend
m
                Maybe (DudeWeirdColumnsGeneric backend)
mval <- Key (DudeWeirdColumnsGeneric backend)
-> ReaderT backend m (Maybe (DudeWeirdColumnsGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (DudeWeirdColumnsGeneric backend)
k
                IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ (DudeWeirdColumnsGeneric backend -> Text)
-> Maybe (DudeWeirdColumnsGeneric backend) -> Maybe Text
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap DudeWeirdColumnsGeneric backend -> Text
forall backend. DudeWeirdColumnsGeneric backend -> Text
dudeWeirdColumnsName Maybe (DudeWeirdColumnsGeneric backend)
mval Maybe Text -> Maybe Text -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"hello"
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"can putMany" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            let
                ms :: [DudeWeirdColumnsGeneric backend]
ms =
                    [ Text -> DudeWeirdColumnsGeneric backend
forall backend. Text -> DudeWeirdColumnsGeneric backend
DudeWeirdColumns Text
"hello"
                    , Text -> DudeWeirdColumnsGeneric backend
forall backend. Text -> DudeWeirdColumnsGeneric backend
DudeWeirdColumns Text
"goodbyue"
                    ]
            RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ [DudeWeirdColumnsGeneric backend] -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistUniqueWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
[record] -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
[record] -> ReaderT backend m ()
putMany [DudeWeirdColumnsGeneric backend]
forall {backend}. [DudeWeirdColumnsGeneric backend]
ms

specsWith :: forall backend m. (Runner backend m) => RunDb backend m -> Spec
specsWith :: forall backend (m :: * -> *).
Runner backend m =>
RunDb backend m -> Spec
specsWith RunDb backend m
runDb = String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"persistent" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"SafeToRemove" (RunDb backend m -> Spec
forall backend (m :: * -> *).
Runner backend m =>
RunDb backend m -> Spec
safeToRemoveSpec RunDb backend m
runDb)
    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"fieldLens" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
        let
            michael :: Entity (PersonGeneric SqlBackend)
michael = Key (PersonGeneric SqlBackend)
-> PersonGeneric SqlBackend -> Entity (PersonGeneric SqlBackend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric SqlBackend)
forall a. HasCallStack => a
undefined (PersonGeneric SqlBackend -> Entity (PersonGeneric SqlBackend))
-> PersonGeneric SqlBackend -> Entity (PersonGeneric SqlBackend)
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric SqlBackend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael" Int
28 Maybe Text
forall a. Maybe a
Nothing :: Entity Person
            michaelP1 :: PersonGeneric SqlBackend
michaelP1 = Text -> Int -> Maybe Text -> PersonGeneric SqlBackend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael" Int
29 Maybe Text
forall a. Maybe a
Nothing :: Person
        Entity (PersonGeneric SqlBackend)
-> Getting
     Int
     (Entity (PersonGeneric SqlBackend))
     (Entity (PersonGeneric SqlBackend))
     Int
     Int
-> Int
forall s a t b. s -> Getting a s t a b -> a
view Entity (PersonGeneric SqlBackend)
michael (EntityField (PersonGeneric SqlBackend) Int
-> forall (f :: * -> *).
   Functor f =>
   (Int -> f Int)
   -> Entity (PersonGeneric SqlBackend)
   -> f (Entity (PersonGeneric SqlBackend))
forall record field.
PersistEntity record =>
EntityField record field
-> forall (f :: * -> *).
   Functor f =>
   (field -> f field) -> Entity record -> f (Entity record)
forall field.
EntityField (PersonGeneric SqlBackend) field
-> forall (f :: * -> *).
   Functor f =>
   (field -> f field)
   -> Entity (PersonGeneric SqlBackend)
   -> f (Entity (PersonGeneric SqlBackend))
fieldLens EntityField (PersonGeneric SqlBackend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge) Int -> Int -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= Int
28
        Entity (PersonGeneric SqlBackend) -> PersonGeneric SqlBackend
forall record. Entity record -> record
entityVal (ASetter
  (Entity (PersonGeneric SqlBackend))
  (Entity (PersonGeneric SqlBackend))
  Int
  Int
-> Int
-> Entity (PersonGeneric SqlBackend)
-> Entity (PersonGeneric SqlBackend)
forall s t a b. ASetter s t a b -> b -> s -> t
set (EntityField (PersonGeneric SqlBackend) Int
-> forall (f :: * -> *).
   Functor f =>
   (Int -> f Int)
   -> Entity (PersonGeneric SqlBackend)
   -> f (Entity (PersonGeneric SqlBackend))
forall record field.
PersistEntity record =>
EntityField record field
-> forall (f :: * -> *).
   Functor f =>
   (field -> f field) -> Entity record -> f (Entity record)
forall field.
EntityField (PersonGeneric SqlBackend) field
-> forall (f :: * -> *).
   Functor f =>
   (field -> f field)
   -> Entity (PersonGeneric SqlBackend)
   -> f (Entity (PersonGeneric SqlBackend))
fieldLens EntityField (PersonGeneric SqlBackend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge) Int
29 Entity (PersonGeneric SqlBackend)
michael) PersonGeneric SqlBackend -> PersonGeneric SqlBackend -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= PersonGeneric SqlBackend
michaelP1

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"FilterAnd []" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p :: PersonGeneric backend
p = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"z" Int
1 Maybe Text
forall a. Maybe a
Nothing
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonGeneric backend
forall {backend}. PersonGeneric backend
p
        [Entity (PersonGeneric backend)]
ps <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [[Filter (PersonGeneric backend)] -> Filter (PersonGeneric backend)
forall record. [Filter record] -> Filter record
FilterAnd []] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge]
        [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall (m :: * -> *) a. MonadIO m => [a] -> m ()
assertNotEmpty [Entity (PersonGeneric backend)]
ps

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Filter In" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        [Entity (PersonGeneric backend)]
_ <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Text
-> FilterValue Text
-> PersistFilter
-> Filter (PersonGeneric backend)
forall record typ.
PersistField typ =>
EntityField record typ
-> FilterValue typ -> PersistFilter -> Filter record
Filter EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName ([Text] -> FilterValue Text
forall typ. [typ] -> FilterValue typ
FilterValues [Text
"Kostas"]) PersistFilter
In] []
        () -> ReaderT backend m ()
forall a. a -> ReaderT backend m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"order of opts is irrelevant" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            eq :: (a, b, c) -> (a, b) -> m ()
eq (a
a, b
b, c
_) (a
c, b
d) = (a
a, b
b) (a, b) -> (a, b) -> m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== (a
c, b
d)
            limitOffsetOrder' :: [SelectOpt Person] -> (Int, Int, [SelectOpt Person])
            limitOffsetOrder' :: [SelectOpt (PersonGeneric SqlBackend)]
-> (Int, Int, [SelectOpt (PersonGeneric SqlBackend)])
limitOffsetOrder' = [SelectOpt (PersonGeneric SqlBackend)]
-> (Int, Int, [SelectOpt (PersonGeneric SqlBackend)])
forall val.
PersistEntity val =>
[SelectOpt val] -> (Int, Int, [SelectOpt val])
limitOffsetOrder
        [SelectOpt (PersonGeneric SqlBackend)]
-> (Int, Int, [SelectOpt (PersonGeneric SqlBackend)])
limitOffsetOrder' [EntityField (PersonGeneric SqlBackend) Int
-> SelectOpt (PersonGeneric SqlBackend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric SqlBackend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge] (Int, Int, [SelectOpt (PersonGeneric SqlBackend)])
-> (Int, Int) -> ReaderT backend m ()
forall {a} {b} {m :: * -> *} {c}.
(Eq a, Eq b, Show a, Show b, MonadIO m) =>
(a, b, c) -> (a, b) -> m ()
`eq` (Int
0, Int
0)
        [SelectOpt (PersonGeneric SqlBackend)]
-> (Int, Int, [SelectOpt (PersonGeneric SqlBackend)])
limitOffsetOrder' [Int -> SelectOpt (PersonGeneric SqlBackend)
forall record. Int -> SelectOpt record
LimitTo Int
2, EntityField (PersonGeneric SqlBackend) Int
-> SelectOpt (PersonGeneric SqlBackend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric SqlBackend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge] (Int, Int, [SelectOpt (PersonGeneric SqlBackend)])
-> (Int, Int) -> ReaderT backend m ()
forall {a} {b} {m :: * -> *} {c}.
(Eq a, Eq b, Show a, Show b, MonadIO m) =>
(a, b, c) -> (a, b) -> m ()
`eq` (Int
2, Int
0)
        [SelectOpt (PersonGeneric SqlBackend)]
-> (Int, Int, [SelectOpt (PersonGeneric SqlBackend)])
limitOffsetOrder' [EntityField (PersonGeneric SqlBackend) Int
-> SelectOpt (PersonGeneric SqlBackend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric SqlBackend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge, Int -> SelectOpt (PersonGeneric SqlBackend)
forall record. Int -> SelectOpt record
LimitTo Int
2] (Int, Int, [SelectOpt (PersonGeneric SqlBackend)])
-> (Int, Int) -> ReaderT backend m ()
forall {a} {b} {m :: * -> *} {c}.
(Eq a, Eq b, Show a, Show b, MonadIO m) =>
(a, b, c) -> (a, b) -> m ()
`eq` (Int
2, Int
0)
        [SelectOpt (PersonGeneric SqlBackend)]
-> (Int, Int, [SelectOpt (PersonGeneric SqlBackend)])
limitOffsetOrder' [Int -> SelectOpt (PersonGeneric SqlBackend)
forall record. Int -> SelectOpt record
LimitTo Int
2, EntityField (PersonGeneric SqlBackend) Int
-> SelectOpt (PersonGeneric SqlBackend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric SqlBackend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge, Int -> SelectOpt (PersonGeneric SqlBackend)
forall record. Int -> SelectOpt record
OffsetBy Int
3] (Int, Int, [SelectOpt (PersonGeneric SqlBackend)])
-> (Int, Int) -> ReaderT backend m ()
forall {a} {b} {m :: * -> *} {c}.
(Eq a, Eq b, Show a, Show b, MonadIO m) =>
(a, b, c) -> (a, b) -> m ()
`eq` (Int
2, Int
3)

        [PersonGeneric backend] -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
[record] -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
[record] -> ReaderT backend m ()
insertMany_
            [ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"z" Int
1 Maybe Text
forall a. Maybe a
Nothing
            , Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"y" Int
2 Maybe Text
forall a. Maybe a
Nothing
            , Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"x" Int
1 Maybe Text
forall a. Maybe a
Nothing
            , Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"w" Int
2 Maybe Text
forall a. Maybe a
Nothing
            , Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"v" Int
1 Maybe Text
forall a. Maybe a
Nothing
            , Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"u" Int
2 Maybe Text
forall a. Maybe a
Nothing
            ]

        [Text]
a <-
            (Entity (PersonGeneric backend) -> Text)
-> [Entity (PersonGeneric backend)] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (PersonGeneric backend -> Text
forall backend. PersonGeneric backend -> Text
personName (PersonGeneric backend -> Text)
-> (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> Entity (PersonGeneric backend)
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal)
                ([Entity (PersonGeneric backend)] -> [Text])
-> ReaderT backend m [Entity (PersonGeneric backend)]
-> ReaderT backend m [Text]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge, EntityField (PersonGeneric backend) Text
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Asc EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName, Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
OffsetBy Int
2, Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
LimitTo Int
3]
        [Text]
a [Text] -> [Text] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [Text
"y", Text
"v", Text
"x"]

        [Text]
b <-
            (Entity (PersonGeneric backend) -> Text)
-> [Entity (PersonGeneric backend)] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (PersonGeneric backend -> Text
forall backend. PersonGeneric backend -> Text
personName (PersonGeneric backend -> Text)
-> (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> Entity (PersonGeneric backend)
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal)
                ([Entity (PersonGeneric backend)] -> [Text])
-> ReaderT backend m [Entity (PersonGeneric backend)]
-> ReaderT backend m [Text]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [] [Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
OffsetBy Int
2, EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge, Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
LimitTo Int
3, EntityField (PersonGeneric backend) Text
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Asc EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName]
        [Text]
b [Text] -> [Text] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [Text]
a

        [Text]
c <-
            (Entity (PersonGeneric backend) -> Text)
-> [Entity (PersonGeneric backend)] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (PersonGeneric backend -> Text
forall backend. PersonGeneric backend -> Text
personName (PersonGeneric backend -> Text)
-> (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> Entity (PersonGeneric backend)
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal)
                ([Entity (PersonGeneric backend)] -> [Text])
-> ReaderT backend m [Entity (PersonGeneric backend)]
-> ReaderT backend m [Text]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList
                    []
                    [Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
OffsetBy Int
2, EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge, Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
LimitTo Int
3, EntityField (PersonGeneric backend) Text
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Asc EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName, Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
LimitTo Int
1, Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
OffsetBy Int
1]
        [Text]
c [Text] -> [Text] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [Text]
a

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"passes the general tests" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            mic26 :: PersonGeneric backend
mic26 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael" Int
26 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
micK <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
mic26
        [Entity (PersonGeneric backend)]
results <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael"] []
        [Entity (PersonGeneric backend)]
results [Entity (PersonGeneric backend)]
-> [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
micK PersonGeneric backend
forall {backend}. PersonGeneric backend
mic26]

        [Entity (PersonGeneric backend)]
results' <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<. Int
28] []
        [Entity (PersonGeneric backend)]
results' [Entity (PersonGeneric backend)]
-> [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
micK PersonGeneric backend
forall {backend}. PersonGeneric backend
mic26]

        PersonGeneric backend
p28 <- Key (PersonGeneric backend)
-> [Update (PersonGeneric backend)]
-> ReaderT backend m (PersonGeneric backend)
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> [Update record] -> ReaderT backend m record
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> [Update record] -> ReaderT backend m record
updateGet Key (PersonGeneric backend)
micK [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Update (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Update v
=. Int
28]
        PersonGeneric backend -> Int
forall backend. PersonGeneric backend -> Int
personAge PersonGeneric backend
p28 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
28

        [Filter (PersonGeneric backend)]
-> [Update (PersonGeneric backend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> [Update record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> [Update record] -> ReaderT backend m ()
updateWhere [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael"] [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Update (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Update v
=. Int
29]
        Int
uc <- [Filter (PersonGeneric backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael"]
        Int
uc Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
1
        Just PersonGeneric backend
mic29 <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
micK
        PersonGeneric backend -> Int
forall backend. PersonGeneric backend -> Int
personAge PersonGeneric backend
mic29 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
29

        let
            louis :: PersonGeneric backend
louis = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Louis" Int
55 (Maybe Text -> PersonGeneric backend)
-> Maybe Text -> PersonGeneric backend
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"brown"
        Bool
ex0 <- [Filter (PersonGeneric backend)] -> ReaderT backend m Bool
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Bool
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Bool
exists [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Louis"]
        Bool
ex0 Bool -> Bool -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Bool
False
        Key (PersonGeneric backend)
louisK <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
louis
        Bool
ex1 <- [Filter (PersonGeneric backend)] -> ReaderT backend m Bool
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Bool
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Bool
exists [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Louis"]
        Bool
ex1 Bool -> Bool -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Bool
True
        Key (PersonGeneric backend) -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
delete Key (PersonGeneric backend)
louisK

        let
            eli :: PersonGeneric backend
eli = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Eliezer" Int
2 (Maybe Text -> PersonGeneric backend)
-> Maybe Text -> PersonGeneric backend
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"blue"
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonGeneric backend
forall {backend}. PersonGeneric backend
eli
        [Entity (PersonGeneric backend)]
pasc <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Asc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge]
        (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
map Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal [Entity (PersonGeneric backend)]
pasc [PersonGeneric backend]
-> [PersonGeneric backend] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [PersonGeneric backend
forall {backend}. PersonGeneric backend
eli, PersonGeneric backend
mic29]

        let
            abe30 :: PersonGeneric backend
abe30 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Abe" Int
30 (Maybe Text -> PersonGeneric backend)
-> Maybe Text -> PersonGeneric backend
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"black"
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonGeneric backend
forall {backend}. PersonGeneric backend
abe30
        -- pdesc <- selectList [PersonAge <. 30] [Desc PersonName]
        (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
map Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal [Entity (PersonGeneric backend)]
pasc [PersonGeneric backend]
-> [PersonGeneric backend] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [PersonGeneric backend
forall {backend}. PersonGeneric backend
eli, PersonGeneric backend
mic29]

        [Entity (PersonGeneric backend)]
abes <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Abe"] []
        (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
map Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal [Entity (PersonGeneric backend)]
abes [PersonGeneric backend]
-> [PersonGeneric backend] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [PersonGeneric backend
forall {backend}. PersonGeneric backend
abe30]

        Just (Entity Key (PersonGeneric backend)
_ PersonGeneric backend
p3) <- Unique (PersonGeneric backend)
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall backend record (m :: * -> *).
(PersistUniqueRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Unique record -> ReaderT backend m (Maybe (Entity record))
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Unique record -> ReaderT backend m (Maybe (Entity record))
getBy (Unique (PersonGeneric backend)
 -> ReaderT backend m (Maybe (Entity (PersonGeneric backend))))
-> Unique (PersonGeneric backend)
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall a b. (a -> b) -> a -> b
$ Text -> Unique (PersonGeneric backend)
forall backend. Text -> Unique (PersonGeneric backend)
PersonNameKey Text
"Michael"
        PersonGeneric backend
p3 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
mic29

        [Entity (PersonGeneric backend)]
ps <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (PersonGeneric backend) typ
PersonColor EntityField (PersonGeneric backend) (Maybe Text)
-> Maybe Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"blue"] []
        (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
map Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal [Entity (PersonGeneric backend)]
ps [PersonGeneric backend]
-> [PersonGeneric backend] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [PersonGeneric backend
forall {backend}. PersonGeneric backend
eli]

        [Entity (PersonGeneric backend)]
ps2 <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (PersonGeneric backend) typ
PersonColor EntityField (PersonGeneric backend) (Maybe Text)
-> Maybe Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Maybe Text
forall a. Maybe a
Nothing] []
        (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
map Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal [Entity (PersonGeneric backend)]
ps2 [PersonGeneric backend]
-> [PersonGeneric backend] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [PersonGeneric backend
mic29]

        Key (PersonGeneric backend) -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
delete Key (PersonGeneric backend)
micK
        Maybe (PersonGeneric backend)
Nothing <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
micK
        () -> ReaderT backend m ()
forall a. a -> ReaderT backend m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"persistIdField" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p :: PersonGeneric backend
p = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"foo" Int
100 (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"blue")
            q :: PersonGeneric backend
q = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"bar" Int
101 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
pk <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p
        Key (PersonGeneric backend)
qk <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
q

        Maybe (Entity (PersonGeneric backend))
mp <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (PersonGeneric backend) (Key (PersonGeneric backend))
forall record.
PersistEntity record =>
EntityField record (Key record)
persistIdField EntityField (PersonGeneric backend) (Key (PersonGeneric backend))
-> Key (PersonGeneric backend) -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Key (PersonGeneric backend)
pk] []
        (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> Maybe (Entity (PersonGeneric backend))
-> Maybe (PersonGeneric backend)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal Maybe (Entity (PersonGeneric backend))
mp Maybe (PersonGeneric backend)
-> Maybe (PersonGeneric backend) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend -> Maybe (PersonGeneric backend)
forall a. a -> Maybe a
Just PersonGeneric backend
forall {backend}. PersonGeneric backend
p

        Maybe (Entity (PersonGeneric backend))
mq <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (PersonGeneric backend) (Key (PersonGeneric backend))
forall record.
PersistEntity record =>
EntityField record (Key record)
persistIdField EntityField (PersonGeneric backend) (Key (PersonGeneric backend))
-> Key (PersonGeneric backend) -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Key (PersonGeneric backend)
qk] []
        (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> Maybe (Entity (PersonGeneric backend))
-> Maybe (PersonGeneric backend)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal Maybe (Entity (PersonGeneric backend))
mq Maybe (PersonGeneric backend)
-> Maybe (PersonGeneric backend) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend -> Maybe (PersonGeneric backend)
forall a. a -> Maybe a
Just PersonGeneric backend
forall {backend}. PersonGeneric backend
q

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"!=." (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        [Filter (PersonGeneric backend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (PersonGeneric backend)])
        let
            mic :: PersonGeneric backend
mic = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael" Int
25 Maybe Text
forall a. Maybe a
Nothing
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonGeneric backend
forall {backend}. PersonGeneric backend
mic
        let
            eli :: PersonGeneric backend
eli = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Eliezer" Int
25 (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"Red")
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonGeneric backend
forall {backend}. PersonGeneric backend
eli

        [Entity (PersonGeneric backend)]
pne <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
!=. Text
"Michael"] []
        (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
map Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal [Entity (PersonGeneric backend)]
pne [PersonGeneric backend]
-> [PersonGeneric backend] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [PersonGeneric backend
forall {backend}. PersonGeneric backend
eli]

        [Entity (PersonGeneric backend)]
ps <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (PersonGeneric backend) typ
PersonColor EntityField (PersonGeneric backend) (Maybe Text)
-> Maybe Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
!=. Maybe Text
forall a. Maybe a
Nothing] []
        (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
map Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal [Entity (PersonGeneric backend)]
ps [PersonGeneric backend]
-> [PersonGeneric backend] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [PersonGeneric backend
forall {backend}. PersonGeneric backend
eli]

        [Entity (PersonGeneric backend)]
pnm <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
!=. Text
"Eliezer"] []
        (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
map Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal [Entity (PersonGeneric backend)]
pnm [PersonGeneric backend]
-> [PersonGeneric backend] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [PersonGeneric backend
forall {backend}. PersonGeneric backend
mic]

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Double Maybe" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        [Filter (PersonMayGeneric backend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (PersonMayGeneric backend)])
        let
            mic :: PersonMayGeneric backend
mic = Maybe Text -> Maybe Text -> PersonMayGeneric backend
forall backend.
Maybe Text -> Maybe Text -> PersonMayGeneric backend
PersonMay (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"Michael") Maybe Text
forall a. Maybe a
Nothing
        PersonMayGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonMayGeneric backend
forall {backend}. PersonMayGeneric backend
mic
        let
            eli :: PersonMayGeneric backend
eli = Maybe Text -> Maybe Text -> PersonMayGeneric backend
forall backend.
Maybe Text -> Maybe Text -> PersonMayGeneric backend
PersonMay (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"Eliezer") (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"Red")
        PersonMayGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonMayGeneric backend
forall {backend}. PersonMayGeneric backend
eli
        [Entity (PersonMayGeneric backend)]
pe <- [Filter (PersonMayGeneric backend)]
-> [SelectOpt (PersonMayGeneric backend)]
-> ReaderT backend m [Entity (PersonMayGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonMayGeneric backend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (PersonMayGeneric backend) typ
PersonMayName EntityField (PersonMayGeneric backend) (Maybe Text)
-> Maybe Text -> Filter (PersonMayGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Maybe Text
forall a. Maybe a
Nothing, EntityField (PersonMayGeneric backend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (PersonMayGeneric backend) typ
PersonMayColor EntityField (PersonMayGeneric backend) (Maybe Text)
-> Maybe Text -> Filter (PersonMayGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Maybe Text
forall a. Maybe a
Nothing] []
        (Entity (PersonMayGeneric backend) -> PersonMayGeneric backend)
-> [Entity (PersonMayGeneric backend)]
-> [PersonMayGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
map Entity (PersonMayGeneric backend) -> PersonMayGeneric backend
forall record. Entity record -> record
entityVal [Entity (PersonMayGeneric backend)]
pe [PersonMayGeneric backend]
-> [PersonMayGeneric backend] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== []
        [Entity (PersonMayGeneric backend)]
pne <- [Filter (PersonMayGeneric backend)]
-> [SelectOpt (PersonMayGeneric backend)]
-> ReaderT backend m [Entity (PersonMayGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonMayGeneric backend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (PersonMayGeneric backend) typ
PersonMayName EntityField (PersonMayGeneric backend) (Maybe Text)
-> Maybe Text -> Filter (PersonMayGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
!=. Maybe Text
forall a. Maybe a
Nothing, EntityField (PersonMayGeneric backend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (PersonMayGeneric backend) typ
PersonMayColor EntityField (PersonMayGeneric backend) (Maybe Text)
-> Maybe Text -> Filter (PersonMayGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
!=. Maybe Text
forall a. Maybe a
Nothing] []
        (Entity (PersonMayGeneric backend) -> PersonMayGeneric backend)
-> [Entity (PersonMayGeneric backend)]
-> [PersonMayGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
map Entity (PersonMayGeneric backend) -> PersonMayGeneric backend
forall record. Entity record -> record
entityVal [Entity (PersonMayGeneric backend)]
pne [PersonMayGeneric backend]
-> [PersonMayGeneric backend] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [PersonMayGeneric backend
forall {backend}. PersonMayGeneric backend
eli]

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"and/or" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        [Filter (Person1Generic backend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (Person1Generic backend)])
        [Person1Generic backend] -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
[record] -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
[record] -> ReaderT backend m ()
insertMany_
            [ Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"Michael" Int
25
            , Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"Miriam" Int
25
            , Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"Michael" Int
30
            , Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"Michael" Int
35
            ]

        Int
c10 <-
            [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([Filter (Person1Generic backend)] -> ReaderT backend m Int)
-> [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall a b. (a -> b) -> a -> b
$
                [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael"] [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall v. [Filter v] -> [Filter v] -> [Filter v]
||. [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Miriam", EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Int
25]
        Int
c10 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
4
        Int
c12 <-
            [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count
                [ [Filter (Person1Generic backend)]
-> Filter (Person1Generic backend)
forall record. [Filter record] -> Filter record
FilterOr
                    [[Filter (Person1Generic backend)]
-> Filter (Person1Generic backend)
forall record. [Filter record] -> Filter record
FilterAnd [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael"], [Filter (Person1Generic backend)]
-> Filter (Person1Generic backend)
forall record. [Filter record] -> Filter record
FilterAnd [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Miriam"]]
                ]
        Int
c12 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
4
        Int
c14 <-
            [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count
                [ [Filter (Person1Generic backend)]
-> Filter (Person1Generic backend)
forall record. [Filter record] -> Filter record
FilterOr
                    [ [Filter (Person1Generic backend)]
-> Filter (Person1Generic backend)
forall record. [Filter record] -> Filter record
FilterAnd [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael"]
                    , [Filter (Person1Generic backend)]
-> Filter (Person1Generic backend)
forall record. [Filter record] -> Filter record
FilterAnd [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Miriam"]
                    , [Filter (Person1Generic backend)]
-> Filter (Person1Generic backend)
forall record. [Filter record] -> Filter record
FilterAnd [EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
>. Int
29, EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<=. Int
30]
                    ]
                ]
        Int
c14 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
4

        Int
c20 <-
            [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([Filter (Person1Generic backend)] -> ReaderT backend m Int)
-> [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall a b. (a -> b) -> a -> b
$ [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Miriam"] [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall v. [Filter v] -> [Filter v] -> [Filter v]
||. [EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
>. Int
29, EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<=. Int
30]
        Int
c20 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
2
        Int
c22 <- [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([Filter (Person1Generic backend)] -> ReaderT backend m Int)
-> [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall a b. (a -> b) -> a -> b
$ [EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<=. Int
30] [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall a. [a] -> [a] -> [a]
++ [EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
>. Int
29]
        Int
c22 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
1
        Int
c24 <- [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([Filter (Person1Generic backend)] -> ReaderT backend m Int)
-> [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall a b. (a -> b) -> a -> b
$ [[Filter (Person1Generic backend)]
-> Filter (Person1Generic backend)
forall record. [Filter record] -> Filter record
FilterAnd [EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<=. Int
30, EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
>. Int
29]]
        Int
c24 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
1
        Int
c26 <- [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([Filter (Person1Generic backend)] -> ReaderT backend m Int)
-> [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall a b. (a -> b) -> a -> b
$ [EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<=. Int
30] [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall a. [a] -> [a] -> [a]
++ [EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
>. Int
29]
        Int
c26 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
1

        Int
c34 <-
            [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([Filter (Person1Generic backend)] -> ReaderT backend m Int)
-> [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall a b. (a -> b) -> a -> b
$
                [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael"]
                    [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall v. [Filter v] -> [Filter v] -> [Filter v]
||. [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Mirieam"] [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall a. [a] -> [a] -> [a]
++ [EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<. Int
35]
        Int
c34 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
3
        Int
c30 <-
            [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([Filter (Person1Generic backend)] -> ReaderT backend m Int)
-> [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall a b. (a -> b) -> a -> b
$
                ([EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael"] [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall v. [Filter v] -> [Filter v] -> [Filter v]
||. [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Miriam"])
                    [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall a. [a] -> [a] -> [a]
++ [EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<. Int
35]
        Int
c30 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
3
        Int
c36 <-
            [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([Filter (Person1Generic backend)] -> ReaderT backend m Int)
-> [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall a b. (a -> b) -> a -> b
$
                [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael"]
                    [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall v. [Filter v] -> [Filter v] -> [Filter v]
||. ([EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Miriam"] [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall a. [a] -> [a] -> [a]
++ [EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<. Int
35])
        Int
c36 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
4

        Int
c40 <-
            [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([Filter (Person1Generic backend)] -> ReaderT backend m Int)
-> [Filter (Person1Generic backend)] -> ReaderT backend m Int
forall a b. (a -> b) -> a -> b
$
                ( [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael"]
                    [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall v. [Filter v] -> [Filter v] -> [Filter v]
||. [EntityField (Person1Generic backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (Person1Generic backend) typ
Person1Name EntityField (Person1Generic backend) Text
-> Text -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Miriam"]
                    [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
-> [Filter (Person1Generic backend)]
forall v. [Filter v] -> [Filter v] -> [Filter v]
||. [EntityField (Person1Generic backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (Person1Generic backend) typ
Person1Age EntityField (Person1Generic backend) Int
-> Int -> Filter (Person1Generic backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<. Int
35]
                )
        Int
c40 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
4

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"deleteWhere" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        Key (PersonGeneric backend)
key2 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert (PersonGeneric backend
 -> ReaderT backend m (Key (PersonGeneric backend)))
-> PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael2" Int
90 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
_ <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert (PersonGeneric backend
 -> ReaderT backend m (Key (PersonGeneric backend)))
-> PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael3" Int
90 Maybe Text
forall a. Maybe a
Nothing
        let
            p91 :: PersonGeneric backend
p91 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael4" Int
91 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
key91 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p91

        [Entity (PersonGeneric backend)]
ps90 <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Int
90] []
        [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall (m :: * -> *) a. MonadIO m => [a] -> m ()
assertNotEmpty [Entity (PersonGeneric backend)]
ps90
        [Filter (PersonGeneric backend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Int
90]
        [Entity (PersonGeneric backend)]
ps90' <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Int
90] []
        [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall (m :: * -> *) a. MonadIO m => [a] -> m ()
assertEmpty [Entity (PersonGeneric backend)]
ps90'
        Maybe (PersonGeneric backend)
Nothing <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
key2

        Just PersonGeneric backend
p2_91 <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
key91
        PersonGeneric backend
forall {backend}. PersonGeneric backend
p91 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
p2_91

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"deleteBy" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ (PersonGeneric backend -> ReaderT backend m ())
-> PersonGeneric backend -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael2" Int
27 Maybe Text
forall a. Maybe a
Nothing
        let
            p3 :: PersonGeneric backend
p3 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael3" Int
27 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
key3 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p3

        [Entity (PersonGeneric backend)]
ps2 <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael2"] []
        [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall (m :: * -> *) a. MonadIO m => [a] -> m ()
assertNotEmpty [Entity (PersonGeneric backend)]
ps2

        Unique (PersonGeneric backend) -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistUniqueWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Unique record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Unique record -> ReaderT backend m ()
deleteBy (Unique (PersonGeneric backend) -> ReaderT backend m ())
-> Unique (PersonGeneric backend) -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ Text -> Unique (PersonGeneric backend)
forall backend. Text -> Unique (PersonGeneric backend)
PersonNameKey Text
"Michael2"
        [Entity (PersonGeneric backend)]
ps2' <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael2"] []
        [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall (m :: * -> *) a. MonadIO m => [a] -> m ()
assertEmpty [Entity (PersonGeneric backend)]
ps2'

        Just PersonGeneric backend
p32 <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
key3
        PersonGeneric backend
forall {backend}. PersonGeneric backend
p3 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
p32

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"delete" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        Key (PersonGeneric backend)
key2 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert (PersonGeneric backend
 -> ReaderT backend m (Key (PersonGeneric backend)))
-> PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael2" Int
27 Maybe Text
forall a. Maybe a
Nothing
        let
            p3 :: PersonGeneric backend
p3 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael3" Int
27 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
key3 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p3

        [Entity (PersonGeneric backend)]
pm2 <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael2"] []
        [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall (m :: * -> *) a. MonadIO m => [a] -> m ()
assertNotEmpty [Entity (PersonGeneric backend)]
pm2
        Key (PersonGeneric backend) -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
delete Key (PersonGeneric backend)
key2
        [Entity (PersonGeneric backend)]
pm2' <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael2"] []
        [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall (m :: * -> *) a. MonadIO m => [a] -> m ()
assertEmpty [Entity (PersonGeneric backend)]
pm2'

        Just PersonGeneric backend
p <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
key3
        PersonGeneric backend
forall {backend}. PersonGeneric backend
p3 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
p

    String -> (BackendKey SqlBackend -> Bool) -> Spec
forall prop.
(HasCallStack, Testable prop) =>
String -> prop -> Spec
prop String
"toPathPiece . fromPathPiece" ((BackendKey SqlBackend -> Bool) -> Spec)
-> (BackendKey SqlBackend -> Bool) -> Spec
forall a b. (a -> b) -> a -> b
$ \BackendKey SqlBackend
piece ->
        let
            key1 :: BackendKey SqlBackend
key1 = BackendKey SqlBackend
piece :: (BackendKey SqlBackend)
            key2 :: BackendKey SqlBackend
key2 = Maybe (BackendKey SqlBackend) -> BackendKey SqlBackend
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (BackendKey SqlBackend) -> BackendKey SqlBackend)
-> Maybe (BackendKey SqlBackend) -> BackendKey SqlBackend
forall a b. (a -> b) -> a -> b
$ Text -> Maybe (BackendKey SqlBackend)
forall s. PathPiece s => Text -> Maybe s
fromPathPiece (Text -> Maybe (BackendKey SqlBackend))
-> Text -> Maybe (BackendKey SqlBackend)
forall a b. (a -> b) -> a -> b
$ BackendKey SqlBackend -> Text
forall s. PathPiece s => s -> Text
toPathPiece BackendKey SqlBackend
key1 :: (BackendKey SqlBackend)
         in
            BackendKey SqlBackend -> Text
forall s. PathPiece s => s -> Text
toPathPiece BackendKey SqlBackend
key1 Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== BackendKey SqlBackend -> Text
forall s. PathPiece s => s -> Text
toPathPiece BackendKey SqlBackend
key2

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"replace" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        Key (PersonGeneric backend)
key2 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert (PersonGeneric backend
 -> ReaderT backend m (Key (PersonGeneric backend)))
-> PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael2" Int
27 Maybe Text
forall a. Maybe a
Nothing
        let
            p3 :: PersonGeneric backend
p3 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael3" Int
27 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
-> PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
replace Key (PersonGeneric backend)
key2 PersonGeneric backend
forall {backend}. PersonGeneric backend
p3
        Just PersonGeneric backend
p <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
key2
        PersonGeneric backend
p PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
forall {backend}. PersonGeneric backend
p3

        -- test replace an empty key
        Key (PersonGeneric backend) -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
delete Key (PersonGeneric backend)
key2
        Maybe (PersonGeneric backend)
Nothing <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
key2
        ()
_ <- Key (PersonGeneric backend)
-> PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
replace Key (PersonGeneric backend)
key2 PersonGeneric backend
forall {backend}. PersonGeneric backend
p3
        Maybe (PersonGeneric backend)
Nothing <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
key2
        () -> ReaderT backend m ()
forall a. a -> ReaderT backend m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

        let
            mic :: PersonGeneric backend
mic = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael" Int
25 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
micK <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
mic
        Just PersonGeneric backend
p1 <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
micK
        PersonGeneric backend
p1 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
forall {backend}. PersonGeneric backend
mic

        Key (PersonGeneric backend)
-> PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
replace Key (PersonGeneric backend)
micK (PersonGeneric backend -> ReaderT backend m ())
-> PersonGeneric backend -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael" Int
25 Maybe Text
forall a. Maybe a
Nothing
        Just PersonGeneric backend
p2 <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
micK
        PersonGeneric backend
p2 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
forall {backend}. PersonGeneric backend
mic

        Key (PersonGeneric backend)
-> PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
replace Key (PersonGeneric backend)
micK (PersonGeneric backend -> ReaderT backend m ())
-> PersonGeneric backend -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael" Int
26 Maybe Text
forall a. Maybe a
Nothing
        Just PersonGeneric backend
mic26 <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
micK
        PersonGeneric backend
mic26 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@/= PersonGeneric backend
forall {backend}. PersonGeneric backend
mic
        PersonGeneric backend -> Int
forall backend. PersonGeneric backend -> Int
personAge PersonGeneric backend
mic26 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric Any -> Int
forall backend. PersonGeneric backend -> Int
personAge PersonGeneric Any
forall {backend}. PersonGeneric backend
mic Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"getBy" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p2 :: PersonGeneric backend
p2 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael2" Int
27 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
key2 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p2
        Just (Entity Key (PersonGeneric backend)
k PersonGeneric backend
p) <- Unique (PersonGeneric backend)
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall backend record (m :: * -> *).
(PersistUniqueRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Unique record -> ReaderT backend m (Maybe (Entity record))
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Unique record -> ReaderT backend m (Maybe (Entity record))
getBy (Unique (PersonGeneric backend)
 -> ReaderT backend m (Maybe (Entity (PersonGeneric backend))))
-> Unique (PersonGeneric backend)
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall a b. (a -> b) -> a -> b
$ Text -> Unique (PersonGeneric backend)
forall backend. Text -> Unique (PersonGeneric backend)
PersonNameKey Text
"Michael2"
        PersonGeneric backend
p PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
forall {backend}. PersonGeneric backend
p2
        Key (PersonGeneric backend)
k Key (PersonGeneric backend)
-> Key (PersonGeneric backend) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (PersonGeneric backend)
key2
        Maybe (Entity (PersonGeneric backend))
Nothing <- Unique (PersonGeneric backend)
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall backend record (m :: * -> *).
(PersistUniqueRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Unique record -> ReaderT backend m (Maybe (Entity record))
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Unique record -> ReaderT backend m (Maybe (Entity record))
getBy (Unique (PersonGeneric backend)
 -> ReaderT backend m (Maybe (Entity (PersonGeneric backend))))
-> Unique (PersonGeneric backend)
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall a b. (a -> b) -> a -> b
$ Text -> Unique (PersonGeneric backend)
forall backend. Text -> Unique (PersonGeneric backend)
PersonNameKey Text
"Michael9"

        Just (Entity Key (PersonGeneric backend)
k' PersonGeneric backend
p') <- PersonGeneric backend
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall record (m :: * -> *) backend.
(MonadIO m, PersistUniqueRead backend,
 PersistRecordBackend record backend, AtLeastOneUniqueKey record) =>
record -> ReaderT backend m (Maybe (Entity record))
getByValue PersonGeneric backend
forall {backend}. PersonGeneric backend
p2
        Key (PersonGeneric backend)
k' Key (PersonGeneric backend)
-> Key (PersonGeneric backend) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (PersonGeneric backend)
k
        PersonGeneric backend
p' PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
p
        () -> ReaderT backend m ()
forall a. a -> ReaderT backend m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"updateGet" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p25 :: PersonGeneric backend
p25 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael" Int
25 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
key25 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p25
        PersonGeneric backend
pBlue28 <- Key (PersonGeneric backend)
-> [Update (PersonGeneric backend)]
-> ReaderT backend m (PersonGeneric backend)
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> [Update record] -> ReaderT backend m record
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> [Update record] -> ReaderT backend m record
updateGet Key (PersonGeneric backend)
key25 [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Update (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Update v
=. Int
28, EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Update (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Update v
=. Text
"Updated"]
        PersonGeneric backend
pBlue28 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Updated" Int
28 Maybe Text
forall a. Maybe a
Nothing
        PersonGeneric backend
pBlue30 <- Key (PersonGeneric backend)
-> [Update (PersonGeneric backend)]
-> ReaderT backend m (PersonGeneric backend)
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> [Update record] -> ReaderT backend m record
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> [Update record] -> ReaderT backend m record
updateGet Key (PersonGeneric backend)
key25 [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Update (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Update v
+=. Int
2]
        PersonGeneric backend
pBlue30 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Updated" Int
30 Maybe Text
forall a. Maybe a
Nothing

    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"repsertMany" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"adds new rows when no conflicts" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
            ids :: [Key (Person1Generic backend)]
ids@[Key (Person1Generic backend)
johnId, Key (Person1Generic backend)
janeId, Key (Person1Generic backend)
aliceId, Key (Person1Generic backend)
eveId] <-
                Int
-> ReaderT backend m (Key (Person1Generic backend))
-> ReaderT backend m [Key (Person1Generic backend)]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
4 (ReaderT backend m (Key (Person1Generic backend))
 -> ReaderT backend m [Key (Person1Generic backend)])
-> ReaderT backend m (Key (Person1Generic backend))
-> ReaderT backend m [Key (Person1Generic backend)]
forall a b. (a -> b) -> a -> b
$ IO (Key (Person1Generic backend))
-> ReaderT backend m (Key (Person1Generic backend))
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (BackendKey backend -> Key (Person1Generic backend)
forall backend. BackendKey backend -> Key (Person1Generic backend)
Person1Key (BackendKey backend -> Key (Person1Generic backend))
-> IO (BackendKey backend) -> IO (Key (Person1Generic backend))
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` IO (BackendKey backend)
forall backend. GenerateKey backend => IO (BackendKey backend)
generateKey)
            let
                john :: Person1Generic backend
john = Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"john" Int
20
            let
                jane :: Person1Generic backend
jane = Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"jane" Int
18
            let
                alice :: Person1Generic backend
alice = Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"alice" Int
18
            let
                eve :: Person1Generic backend
eve = Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"eve" Int
19

            Key (Person1Generic backend)
-> Person1Generic backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
insertKey Key (Person1Generic backend)
johnId Person1Generic backend
forall {backend}. Person1Generic backend
john
            Key (Person1Generic backend)
-> Person1Generic backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
insertKey Key (Person1Generic backend)
janeId Person1Generic backend
forall {backend}. Person1Generic backend
jane

            ()
_ <- [(Key (Person1Generic backend), Person1Generic backend)]
-> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[(Key record, record)] -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
[(Key record, record)] -> ReaderT backend m ()
repsertMany [(Key (Person1Generic backend)
aliceId, Person1Generic backend
forall {backend}. Person1Generic backend
alice), (Key (Person1Generic backend)
eveId, Person1Generic backend
forall {backend}. Person1Generic backend
eve)]
            Map (Key (Person1Generic backend)) (Person1Generic backend)
es <- [Key (Person1Generic backend)]
-> ReaderT
     backend
     m
     (Map (Key (Person1Generic backend)) (Person1Generic backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Key record] -> ReaderT backend m (Map (Key record) record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
[Key record] -> ReaderT backend m (Map (Key record) record)
getMany [Key (Person1Generic backend)]
ids

            let
                rs :: [Person1Generic backend]
rs = [Person1Generic backend
forall {backend}. Person1Generic backend
john, Person1Generic backend
forall {backend}. Person1Generic backend
jane, Person1Generic backend
forall {backend}. Person1Generic backend
alice, Person1Generic backend
forall {backend}. Person1Generic backend
eve]
            Map (Key (Person1Generic backend)) (Person1Generic backend)
es Map (Key (Person1Generic backend)) (Person1Generic backend)
-> Map (Key (Person1Generic backend)) (Person1Generic backend)
-> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [(Key (Person1Generic backend), Person1Generic backend)]
-> Map (Key (Person1Generic backend)) (Person1Generic backend)
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([Key (Person1Generic backend)]
-> [Person1Generic backend]
-> [(Key (Person1Generic backend), Person1Generic backend)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Key (Person1Generic backend)]
ids [Person1Generic backend]
forall {backend}. [Person1Generic backend]
rs)
            (Key (Person1Generic backend) -> ReaderT backend m ())
-> [Key (Person1Generic backend)] -> ReaderT backend m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Key (Person1Generic backend) -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
delete [Key (Person1Generic backend)]
ids

        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"handles conflicts by replacing old keys with new records" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
            let
                john :: Person1Generic backend
john = Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"john" Int
20
            let
                jane :: Person1Generic backend
jane = Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"jane" Int
18
            let
                alice :: Person1Generic backend
alice = Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"alice" Int
18
            let
                eve :: Person1Generic backend
eve = Text -> Int -> Person1Generic backend
forall backend. Text -> Int -> Person1Generic backend
Person1 Text
"eve" Int
19

            Key (Person1Generic backend)
johnId <- Person1Generic backend
-> ReaderT backend m (Key (Person1Generic backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert Person1Generic backend
forall {backend}. Person1Generic backend
john
            Key (Person1Generic backend)
janeId <- Person1Generic backend
-> ReaderT backend m (Key (Person1Generic backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert Person1Generic backend
forall {backend}. Person1Generic backend
jane

            ()
_ <- [(Key (Person1Generic backend), Person1Generic backend)]
-> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[(Key record, record)] -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
[(Key record, record)] -> ReaderT backend m ()
repsertMany [(Key (Person1Generic backend)
johnId, Person1Generic backend
forall {backend}. Person1Generic backend
alice), (Key (Person1Generic backend)
janeId, Person1Generic backend
forall {backend}. Person1Generic backend
eve)]
            (Just Person1Generic backend
alice') <- Key (Person1Generic backend)
-> ReaderT backend m (Maybe (Person1Generic backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (Person1Generic backend)
johnId
            (Just Person1Generic backend
eve') <- Key (Person1Generic backend)
-> ReaderT backend m (Maybe (Person1Generic backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (Person1Generic backend)
janeId

            [Person1Generic backend
alice', Person1Generic backend
eve'] [Person1Generic backend]
-> [Person1Generic backend] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [Person1Generic backend
forall {backend}. Person1Generic backend
alice, Person1Generic backend
forall {backend}. Person1Generic backend
eve]
            (Key (Person1Generic backend) -> ReaderT backend m ())
-> [Key (Person1Generic backend)] -> ReaderT backend m ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Key (Person1Generic backend) -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
delete [Key (Person1Generic backend)
johnId, Key (Person1Generic backend)
janeId]

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"updateWhere" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p1 :: PersonGeneric backend
p1 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael" Int
25 Maybe Text
forall a. Maybe a
Nothing
        let
            p2 :: PersonGeneric backend
p2 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael2" Int
25 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
key1 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p1
        Key (PersonGeneric backend)
key2 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p2
        [Filter (PersonGeneric backend)]
-> [Update (PersonGeneric backend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> [Update record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> [Update record] -> ReaderT backend m ()
updateWhere
            [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Michael2"]
            [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Update (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Update v
+=. Int
3, EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Update (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Update v
=. Text
"Updated"]
        Just PersonGeneric backend
pBlue28 <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
key2
        PersonGeneric backend
pBlue28 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Updated" Int
28 Maybe Text
forall a. Maybe a
Nothing
        Just PersonGeneric backend
p <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
key1
        PersonGeneric backend
p PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
forall {backend}. PersonGeneric backend
p1

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"selectList" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p25 :: PersonGeneric backend
p25 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael" Int
25 Maybe Text
forall a. Maybe a
Nothing
        let
            p26 :: PersonGeneric backend
p26 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael2" Int
26 Maybe Text
forall a. Maybe a
Nothing
        [Key (PersonGeneric backend)
key25, Key (PersonGeneric backend)
key26] <- [PersonGeneric backend]
-> ReaderT backend m [Key (PersonGeneric backend)]
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
[record] -> ReaderT backend m [Key record]
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
[record] -> ReaderT backend m [Key record]
insertMany [PersonGeneric backend
forall {backend}. PersonGeneric backend
p25, PersonGeneric backend
forall {backend}. PersonGeneric backend
p26]
        [Entity (PersonGeneric backend)]
ps1 <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Asc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge]
        [Entity (PersonGeneric backend)]
ps1 [Entity (PersonGeneric backend)]
-> [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [(Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
key25 PersonGeneric backend
forall {backend}. PersonGeneric backend
p25), (Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
key26 PersonGeneric backend
forall {backend}. PersonGeneric backend
p26)]
        -- limit
        [Entity (PersonGeneric backend)]
ps2 <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Asc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge, Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
LimitTo Int
1]
        [Entity (PersonGeneric backend)]
ps2 [Entity (PersonGeneric backend)]
-> [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [(Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
key25 PersonGeneric backend
forall {backend}. PersonGeneric backend
p25)]
        -- offset
        [Entity (PersonGeneric backend)]
ps3 <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Asc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge, Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
OffsetBy Int
1]
        [Entity (PersonGeneric backend)]
ps3 [Entity (PersonGeneric backend)]
-> [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [(Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
key26 PersonGeneric backend
forall {backend}. PersonGeneric backend
p26)]
        -- limit & offset
        [Entity (PersonGeneric backend)]
ps4 <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Asc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge, Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
LimitTo Int
1, Int -> SelectOpt (PersonGeneric backend)
forall record. Int -> SelectOpt record
OffsetBy Int
1]
        [Entity (PersonGeneric backend)]
ps4 [Entity (PersonGeneric backend)]
-> [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [(Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
key26 PersonGeneric backend
forall {backend}. PersonGeneric backend
p26)]

        [Entity (PersonGeneric backend)]
ps5 <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge]
        [Entity (PersonGeneric backend)]
ps5 [Entity (PersonGeneric backend)]
-> [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [(Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
key26 PersonGeneric backend
forall {backend}. PersonGeneric backend
p26), (Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
key25 PersonGeneric backend
forall {backend}. PersonGeneric backend
p25)]
        [Entity (PersonGeneric backend)]
ps6 <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Int
26] []
        [Entity (PersonGeneric backend)]
ps6 [Entity (PersonGeneric backend)]
-> [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [(Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
key26 PersonGeneric backend
forall {backend}. PersonGeneric backend
p26)]

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"selectSource" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p1 :: PersonGeneric backend
p1 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"selectSource1" Int
1 Maybe Text
forall a. Maybe a
Nothing
            p2 :: PersonGeneric backend
p2 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"selectSource2" Int
2 Maybe Text
forall a. Maybe a
Nothing
            p3 :: PersonGeneric backend
p3 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"selectSource3" Int
3 Maybe Text
forall a. Maybe a
Nothing
        [Key (PersonGeneric backend)
k1, Key (PersonGeneric backend)
k2, Key (PersonGeneric backend)
k3] <- [PersonGeneric backend]
-> ReaderT backend m [Key (PersonGeneric backend)]
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
[record] -> ReaderT backend m [Key record]
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
[record] -> ReaderT backend m [Key record]
insertMany [PersonGeneric backend
forall {backend}. PersonGeneric backend
p1, PersonGeneric backend
forall {backend}. PersonGeneric backend
p2, PersonGeneric backend
forall {backend}. PersonGeneric backend
p3]

        Maybe (Entity (PersonGeneric backend))
ps1 <- ConduitT
  ()
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Entity (PersonGeneric backend)))
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) r.
MonadUnliftIO m =>
ConduitT () Void (ResourceT m) r -> m r
runConduitRes (ConduitT
   ()
   Void
   (ResourceT (ReaderT backend m))
   (Maybe (Entity (PersonGeneric backend)))
 -> ReaderT backend m (Maybe (Entity (PersonGeneric backend))))
-> ConduitT
     ()
     Void
     (ResourceT (ReaderT backend m))
     (Maybe (Entity (PersonGeneric backend)))
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall a b. (a -> b) -> a -> b
$ [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ConduitM
     ()
     (Entity (PersonGeneric backend))
     (ResourceT (ReaderT backend m))
     ()
forall record backend (m :: * -> *).
(PersistQueryRead backend, MonadResource m,
 PersistRecordBackend record backend, MonadReader backend m) =>
[Filter record]
-> [SelectOpt record] -> ConduitM () (Entity record) m ()
selectSource [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge] ConduitM
  ()
  (Entity (PersonGeneric backend))
  (ResourceT (ReaderT backend m))
  ()
-> ConduitT
     (Entity (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     (Maybe (Entity (PersonGeneric backend)))
-> ConduitT
     ()
     Void
     (ResourceT (ReaderT backend m))
     (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
.| ConduitT
  (Entity (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await
        Maybe (Entity (PersonGeneric backend))
ps1 Maybe (Entity (PersonGeneric backend))
-> Maybe (Entity (PersonGeneric backend)) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Entity (PersonGeneric backend)
-> Maybe (Entity (PersonGeneric backend))
forall a. a -> Maybe a
Just (Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
k3 PersonGeneric backend
forall {backend}. PersonGeneric backend
p3)

        [Entity (PersonGeneric backend)]
ps2 <-
            ConduitT
  ()
  Void
  (ResourceT (ReaderT backend m))
  [Entity (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall (m :: * -> *) r.
MonadUnliftIO m =>
ConduitT () Void (ResourceT m) r -> m r
runConduitRes (ConduitT
   ()
   Void
   (ResourceT (ReaderT backend m))
   [Entity (PersonGeneric backend)]
 -> ReaderT backend m [Entity (PersonGeneric backend)])
-> ConduitT
     ()
     Void
     (ResourceT (ReaderT backend m))
     [Entity (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall a b. (a -> b) -> a -> b
$ [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ConduitM
     ()
     (Entity (PersonGeneric backend))
     (ResourceT (ReaderT backend m))
     ()
forall record backend (m :: * -> *).
(PersistQueryRead backend, MonadResource m,
 PersistRecordBackend record backend, MonadReader backend m) =>
[Filter record]
-> [SelectOpt record] -> ConduitM () (Entity record) m ()
selectSource [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<. Int
3] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Asc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge] ConduitM
  ()
  (Entity (PersonGeneric backend))
  (ResourceT (ReaderT backend m))
  ()
-> ConduitT
     (Entity (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     [Entity (PersonGeneric backend)]
-> ConduitT
     ()
     Void
     (ResourceT (ReaderT backend m))
     [Entity (PersonGeneric backend)]
forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
.| ConduitT
  (Entity (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  [Entity (PersonGeneric backend)]
forall (m :: * -> *) a o. Monad m => ConduitT a o m [a]
CL.consume
        [Entity (PersonGeneric backend)]
ps2 [Entity (PersonGeneric backend)]
-> [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
k1 PersonGeneric backend
forall {backend}. PersonGeneric backend
p1, Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
k2 PersonGeneric backend
forall {backend}. PersonGeneric backend
p2]

        ConduitT () Void (ResourceT (ReaderT backend m)) ()
-> ReaderT backend m ()
forall (m :: * -> *) r.
MonadUnliftIO m =>
ConduitT () Void (ResourceT m) r -> m r
runConduitRes (ConduitT () Void (ResourceT (ReaderT backend m)) ()
 -> ReaderT backend m ())
-> ConduitT () Void (ResourceT (ReaderT backend m)) ()
-> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$
            [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ConduitM
     ()
     (Entity (PersonGeneric backend))
     (ResourceT (ReaderT backend m))
     ()
forall record backend (m :: * -> *).
(PersistQueryRead backend, MonadResource m,
 PersistRecordBackend record backend, MonadReader backend m) =>
[Filter record]
-> [SelectOpt record] -> ConduitM () (Entity record) m ()
selectSource [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge] ConduitM
  ()
  (Entity (PersonGeneric backend))
  (ResourceT (ReaderT backend m))
  ()
-> ConduitT
     (Entity (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
-> ConduitT () Void (ResourceT (ReaderT backend m)) ()
forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
.| do
                Maybe (Entity (PersonGeneric backend))
e1 <- ConduitT
  (Entity (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await
                Maybe (Entity (PersonGeneric backend))
e1 Maybe (Entity (PersonGeneric backend))
-> Maybe (Entity (PersonGeneric backend))
-> ConduitT
     (Entity (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Entity (PersonGeneric backend)
-> Maybe (Entity (PersonGeneric backend))
forall a. a -> Maybe a
Just (Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
k3 PersonGeneric backend
forall {backend}. PersonGeneric backend
p3)

                Maybe (Entity (PersonGeneric backend))
e2 <- ConduitT
  (Entity (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await
                Maybe (Entity (PersonGeneric backend))
e2 Maybe (Entity (PersonGeneric backend))
-> Maybe (Entity (PersonGeneric backend))
-> ConduitT
     (Entity (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Entity (PersonGeneric backend)
-> Maybe (Entity (PersonGeneric backend))
forall a. a -> Maybe a
Just (Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
k2 PersonGeneric backend
forall {backend}. PersonGeneric backend
p2)

                Maybe (Entity (PersonGeneric backend))
e3 <- ConduitT
  (Entity (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await
                Maybe (Entity (PersonGeneric backend))
e3 Maybe (Entity (PersonGeneric backend))
-> Maybe (Entity (PersonGeneric backend))
-> ConduitT
     (Entity (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Entity (PersonGeneric backend)
-> Maybe (Entity (PersonGeneric backend))
forall a. a -> Maybe a
Just (Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
k1 PersonGeneric backend
forall {backend}. PersonGeneric backend
p1)

                Maybe (Entity (PersonGeneric backend))
e4 <- ConduitT
  (Entity (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await
                Maybe (Entity (PersonGeneric backend))
e4 Maybe (Entity (PersonGeneric backend))
-> Maybe (Entity (PersonGeneric backend))
-> ConduitT
     (Entity (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Maybe (Entity (PersonGeneric backend))
forall a. Maybe a
Nothing

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"selectFirst" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ (PersonGeneric backend -> ReaderT backend m ())
-> PersonGeneric backend -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Michael" Int
26 Maybe Text
forall a. Maybe a
Nothing
        let
            pOld :: PersonGeneric backend
pOld = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Oldie" Int
75 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
kOld <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
pOld

        Maybe (Entity (PersonGeneric backend))
x <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge]
        Maybe (Entity (PersonGeneric backend))
x Maybe (Entity (PersonGeneric backend))
-> Maybe (Entity (PersonGeneric backend)) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Entity (PersonGeneric backend)
-> Maybe (Entity (PersonGeneric backend))
forall a. a -> Maybe a
Just (Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
kOld PersonGeneric backend
forall {backend}. PersonGeneric backend
pOld)

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"selectKeys" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p1 :: PersonGeneric backend
p1 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"selectKeys1" Int
1 Maybe Text
forall a. Maybe a
Nothing
            p2 :: PersonGeneric backend
p2 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"selectKeys2" Int
2 Maybe Text
forall a. Maybe a
Nothing
            p3 :: PersonGeneric backend
p3 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"selectKeys3" Int
3 Maybe Text
forall a. Maybe a
Nothing
        [Key (PersonGeneric backend)
k1, Key (PersonGeneric backend)
k2, Key (PersonGeneric backend)
k3] <- [PersonGeneric backend]
-> ReaderT backend m [Key (PersonGeneric backend)]
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
[record] -> ReaderT backend m [Key record]
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
[record] -> ReaderT backend m [Key record]
insertMany [PersonGeneric backend
forall {backend}. PersonGeneric backend
p1, PersonGeneric backend
forall {backend}. PersonGeneric backend
p2, PersonGeneric backend
forall {backend}. PersonGeneric backend
p3]

        Maybe (Key (PersonGeneric backend))
ps1 <- ConduitT
  ()
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Key (PersonGeneric backend)))
-> ReaderT backend m (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) r.
MonadUnliftIO m =>
ConduitT () Void (ResourceT m) r -> m r
runConduitRes (ConduitT
   ()
   Void
   (ResourceT (ReaderT backend m))
   (Maybe (Key (PersonGeneric backend)))
 -> ReaderT backend m (Maybe (Key (PersonGeneric backend))))
-> ConduitT
     ()
     Void
     (ResourceT (ReaderT backend m))
     (Maybe (Key (PersonGeneric backend)))
-> ReaderT backend m (Maybe (Key (PersonGeneric backend)))
forall a b. (a -> b) -> a -> b
$ [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ConduitM
     () (Key (PersonGeneric backend)) (ResourceT (ReaderT backend m)) ()
forall record backend (m :: * -> *).
(PersistQueryRead backend, MonadResource m,
 PersistRecordBackend record backend, MonadReader backend m) =>
[Filter record]
-> [SelectOpt record] -> ConduitM () (Key record) m ()
selectKeys [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge] ConduitM
  () (Key (PersonGeneric backend)) (ResourceT (ReaderT backend m)) ()
-> ConduitT
     (Key (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     (Maybe (Key (PersonGeneric backend)))
-> ConduitT
     ()
     Void
     (ResourceT (ReaderT backend m))
     (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
.| ConduitT
  (Key (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await
        Maybe (Key (PersonGeneric backend))
ps1 Maybe (Key (PersonGeneric backend))
-> Maybe (Key (PersonGeneric backend)) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (PersonGeneric backend) -> Maybe (Key (PersonGeneric backend))
forall a. a -> Maybe a
Just Key (PersonGeneric backend)
k3

        [Key (PersonGeneric backend)]
ps2 <- ConduitT
  ()
  Void
  (ResourceT (ReaderT backend m))
  [Key (PersonGeneric backend)]
-> ReaderT backend m [Key (PersonGeneric backend)]
forall (m :: * -> *) r.
MonadUnliftIO m =>
ConduitT () Void (ResourceT m) r -> m r
runConduitRes (ConduitT
   ()
   Void
   (ResourceT (ReaderT backend m))
   [Key (PersonGeneric backend)]
 -> ReaderT backend m [Key (PersonGeneric backend)])
-> ConduitT
     ()
     Void
     (ResourceT (ReaderT backend m))
     [Key (PersonGeneric backend)]
-> ReaderT backend m [Key (PersonGeneric backend)]
forall a b. (a -> b) -> a -> b
$ [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ConduitM
     () (Key (PersonGeneric backend)) (ResourceT (ReaderT backend m)) ()
forall record backend (m :: * -> *).
(PersistQueryRead backend, MonadResource m,
 PersistRecordBackend record backend, MonadReader backend m) =>
[Filter record]
-> [SelectOpt record] -> ConduitM () (Key record) m ()
selectKeys [EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge EntityField (PersonGeneric backend) Int
-> Int -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
<. Int
3] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Asc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge] ConduitM
  () (Key (PersonGeneric backend)) (ResourceT (ReaderT backend m)) ()
-> ConduitT
     (Key (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     [Key (PersonGeneric backend)]
-> ConduitT
     ()
     Void
     (ResourceT (ReaderT backend m))
     [Key (PersonGeneric backend)]
forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
.| ConduitT
  (Key (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  [Key (PersonGeneric backend)]
forall (m :: * -> *) a o. Monad m => ConduitT a o m [a]
CL.consume
        [Key (PersonGeneric backend)]
ps2 [Key (PersonGeneric backend)]
-> [Key (PersonGeneric backend)] -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== [Key (PersonGeneric backend)
k1, Key (PersonGeneric backend)
k2]

        ConduitT () Void (ResourceT (ReaderT backend m)) ()
-> ReaderT backend m ()
forall (m :: * -> *) r.
MonadUnliftIO m =>
ConduitT () Void (ResourceT m) r -> m r
runConduitRes (ConduitT () Void (ResourceT (ReaderT backend m)) ()
 -> ReaderT backend m ())
-> ConduitT () Void (ResourceT (ReaderT backend m)) ()
-> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$
            [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ConduitM
     () (Key (PersonGeneric backend)) (ResourceT (ReaderT backend m)) ()
forall record backend (m :: * -> *).
(PersistQueryRead backend, MonadResource m,
 PersistRecordBackend record backend, MonadReader backend m) =>
[Filter record]
-> [SelectOpt record] -> ConduitM () (Key record) m ()
selectKeys [] [EntityField (PersonGeneric backend) Int
-> SelectOpt (PersonGeneric backend)
forall record typ. EntityField record typ -> SelectOpt record
Desc EntityField (PersonGeneric backend) Int
forall backend typ.
(typ ~ Int) =>
EntityField (PersonGeneric backend) typ
PersonAge] ConduitM
  () (Key (PersonGeneric backend)) (ResourceT (ReaderT backend m)) ()
-> ConduitT
     (Key (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
-> ConduitT () Void (ResourceT (ReaderT backend m)) ()
forall (m :: * -> *) a b c r.
Monad m =>
ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r
.| do
                Maybe (Key (PersonGeneric backend))
e1 <- ConduitT
  (Key (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await
                Maybe (Key (PersonGeneric backend))
e1 Maybe (Key (PersonGeneric backend))
-> Maybe (Key (PersonGeneric backend))
-> ConduitT
     (Key (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (PersonGeneric backend) -> Maybe (Key (PersonGeneric backend))
forall a. a -> Maybe a
Just Key (PersonGeneric backend)
k3

                Maybe (Key (PersonGeneric backend))
e2 <- ConduitT
  (Key (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await
                Maybe (Key (PersonGeneric backend))
e2 Maybe (Key (PersonGeneric backend))
-> Maybe (Key (PersonGeneric backend))
-> ConduitT
     (Key (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (PersonGeneric backend) -> Maybe (Key (PersonGeneric backend))
forall a. a -> Maybe a
Just Key (PersonGeneric backend)
k2

                Maybe (Key (PersonGeneric backend))
e3 <- ConduitT
  (Key (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await
                Maybe (Key (PersonGeneric backend))
e3 Maybe (Key (PersonGeneric backend))
-> Maybe (Key (PersonGeneric backend))
-> ConduitT
     (Key (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (PersonGeneric backend) -> Maybe (Key (PersonGeneric backend))
forall a. a -> Maybe a
Just Key (PersonGeneric backend)
k1

                Maybe (Key (PersonGeneric backend))
e4 <- ConduitT
  (Key (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) i o. Monad m => ConduitT i o m (Maybe i)
await
                Maybe (Key (PersonGeneric backend))
e4 Maybe (Key (PersonGeneric backend))
-> Maybe (Key (PersonGeneric backend))
-> ConduitT
     (Key (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Maybe (Key (PersonGeneric backend))
forall a. Maybe a
Nothing

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"insertMany_ with no arguments" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        ()
_ <- [PersonGeneric backend] -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
[record] -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
[record] -> ReaderT backend m ()
insertMany_ ([] :: [PersonGeneric backend])
        Int
rows <-
            ([Filter (PersonGeneric backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([] :: [Filter (PersonGeneric backend)]) :: ReaderT backend m Int)
        Int
rows Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
0
        [Key (PersonGeneric backend)]
_ <- [PersonGeneric backend]
-> ReaderT backend m [Key (PersonGeneric backend)]
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
[record] -> ReaderT backend m [Key record]
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
[record] -> ReaderT backend m [Key record]
insertMany ([] :: [PersonGeneric backend])
        Int
rows2 <- [Filter (PersonGeneric backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([] :: [Filter (PersonGeneric backend)])
        Int
rows2 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
0
        ()
_ <- [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Entity record] -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
[Entity record] -> ReaderT backend m ()
insertEntityMany ([] :: [Entity (PersonGeneric backend)])
        Int
rows3 <- [Filter (PersonGeneric backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([] :: [Filter (PersonGeneric backend)])
        Int
rows3 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
0

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"insertEntityMany" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        Key (PersonGeneric backend)
id1 : Key (PersonGeneric backend)
id2 : Key (PersonGeneric backend)
id3 : Key (PersonGeneric backend)
id4 : Key (PersonGeneric backend)
id5 : [] <-
            IO [Key (PersonGeneric backend)]
-> ReaderT backend m [Key (PersonGeneric backend)]
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Key (PersonGeneric backend)]
 -> ReaderT backend m [Key (PersonGeneric backend)])
-> IO [Key (PersonGeneric backend)]
-> ReaderT backend m [Key (PersonGeneric backend)]
forall a b. (a -> b) -> a -> b
$ Int
-> IO (Key (PersonGeneric backend))
-> IO [Key (PersonGeneric backend)]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
5 (BackendKey backend -> Key (PersonGeneric backend)
forall backend. BackendKey backend -> Key (PersonGeneric backend)
PersonKey (BackendKey backend -> Key (PersonGeneric backend))
-> IO (BackendKey backend) -> IO (Key (PersonGeneric backend))
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` IO (BackendKey backend)
forall backend. GenerateKey backend => IO (BackendKey backend)
generateKey)
        let
            p1 :: Entity (PersonGeneric backend)
p1 = Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
id1 (PersonGeneric backend -> Entity (PersonGeneric backend))
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"insertEntityMany1" Int
1 Maybe Text
forall a. Maybe a
Nothing
            p2 :: Entity (PersonGeneric backend)
p2 = Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
id2 (PersonGeneric backend -> Entity (PersonGeneric backend))
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"insertEntityMany2" Int
2 Maybe Text
forall a. Maybe a
Nothing
            p3 :: Entity (PersonGeneric backend)
p3 = Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
id3 (PersonGeneric backend -> Entity (PersonGeneric backend))
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"insertEntityMany3" Int
3 Maybe Text
forall a. Maybe a
Nothing
            p4 :: Entity (PersonGeneric backend)
p4 = Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
id4 (PersonGeneric backend -> Entity (PersonGeneric backend))
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"insertEntityMany4" Int
3 Maybe Text
forall a. Maybe a
Nothing
            p5 :: Entity (PersonGeneric backend)
p5 = Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
id5 (PersonGeneric backend -> Entity (PersonGeneric backend))
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"insertEntityMany5" Int
3 Maybe Text
forall a. Maybe a
Nothing
        [Entity (PersonGeneric backend)] -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Entity record] -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
[Entity record] -> ReaderT backend m ()
insertEntityMany [Entity (PersonGeneric backend)
p1, Entity (PersonGeneric backend)
p2, Entity (PersonGeneric backend)
p3, Entity (PersonGeneric backend)
p4, Entity (PersonGeneric backend)
p5]
        Int
rows <- [Filter (PersonGeneric backend)] -> ReaderT backend m Int
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m Int
count ([] :: [Filter (PersonGeneric backend)])
        Int
rows Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Int
5

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"insertBy" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        Right Key (PersonGeneric backend)
_ <- PersonGeneric backend
-> ReaderT
     backend
     m
     (Either
        (Entity (PersonGeneric backend)) (Key (PersonGeneric backend)))
forall record backend (m :: * -> *).
(MonadIO m, PersistUniqueWrite backend,
 PersistRecordBackend record backend, AtLeastOneUniqueKey record,
 SafeToInsert record) =>
record -> ReaderT backend m (Either (Entity record) (Key record))
insertBy (PersonGeneric backend
 -> ReaderT
      backend
      m
      (Either
         (Entity (PersonGeneric backend)) (Key (PersonGeneric backend))))
-> PersonGeneric backend
-> ReaderT
     backend
     m
     (Either
        (Entity (PersonGeneric backend)) (Key (PersonGeneric backend)))
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"name" Int
1 Maybe Text
forall a. Maybe a
Nothing
        Left Entity (PersonGeneric backend)
_ <- PersonGeneric backend
-> ReaderT
     backend
     m
     (Either
        (Entity (PersonGeneric backend)) (Key (PersonGeneric backend)))
forall record backend (m :: * -> *).
(MonadIO m, PersistUniqueWrite backend,
 PersistRecordBackend record backend, AtLeastOneUniqueKey record,
 SafeToInsert record) =>
record -> ReaderT backend m (Either (Entity record) (Key record))
insertBy (PersonGeneric backend
 -> ReaderT
      backend
      m
      (Either
         (Entity (PersonGeneric backend)) (Key (PersonGeneric backend))))
-> PersonGeneric backend
-> ReaderT
     backend
     m
     (Either
        (Entity (PersonGeneric backend)) (Key (PersonGeneric backend)))
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"name" Int
1 Maybe Text
forall a. Maybe a
Nothing
        Right Key (PersonGeneric backend)
_ <- PersonGeneric backend
-> ReaderT
     backend
     m
     (Either
        (Entity (PersonGeneric backend)) (Key (PersonGeneric backend)))
forall record backend (m :: * -> *).
(MonadIO m, PersistUniqueWrite backend,
 PersistRecordBackend record backend, AtLeastOneUniqueKey record,
 SafeToInsert record) =>
record -> ReaderT backend m (Either (Entity record) (Key record))
insertBy (PersonGeneric backend
 -> ReaderT
      backend
      m
      (Either
         (Entity (PersonGeneric backend)) (Key (PersonGeneric backend))))
-> PersonGeneric backend
-> ReaderT
     backend
     m
     (Either
        (Entity (PersonGeneric backend)) (Key (PersonGeneric backend)))
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"name2" Int
1 Maybe Text
forall a. Maybe a
Nothing
        () -> ReaderT backend m ()
forall a. a -> ReaderT backend m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"insertKey" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        Key (PersonGeneric backend)
k <- IO (Key (PersonGeneric backend))
-> ReaderT backend m (Key (PersonGeneric backend))
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (BackendKey backend -> Key (PersonGeneric backend)
forall backend. BackendKey backend -> Key (PersonGeneric backend)
PersonKey (BackendKey backend -> Key (PersonGeneric backend))
-> IO (BackendKey backend) -> IO (Key (PersonGeneric backend))
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` IO (BackendKey backend)
forall backend. GenerateKey backend => IO (BackendKey backend)
generateKey)
        Key (PersonGeneric backend)
-> PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
insertKey Key (PersonGeneric backend)
k (PersonGeneric backend -> ReaderT backend m ())
-> PersonGeneric backend -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Key" Int
26 Maybe Text
forall a. Maybe a
Nothing
        Just (Entity Key (PersonGeneric backend)
k2 PersonGeneric backend
_) <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Key"] []
        Key (PersonGeneric backend)
k2 Key (PersonGeneric backend)
-> Key (PersonGeneric backend) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (PersonGeneric backend)
k

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"insertEntity" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        Entity Key (PersonGeneric backend)
k PersonGeneric backend
p <- PersonGeneric backend
-> ReaderT backend m (Entity (PersonGeneric backend))
forall e backend (m :: * -> *).
(PersistStoreWrite backend, PersistRecordBackend e backend,
 SafeToInsert e, MonadIO m, HasCallStack) =>
e -> ReaderT backend m (Entity e)
insertEntity (PersonGeneric backend
 -> ReaderT backend m (Entity (PersonGeneric backend)))
-> PersonGeneric backend
-> ReaderT backend m (Entity (PersonGeneric backend))
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"name" Int
1 Maybe Text
forall a. Maybe a
Nothing
        Just PersonGeneric backend
p2 <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PersonGeneric backend)
k
        PersonGeneric backend
p2 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
p

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"insertRecord" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            record :: PersonGeneric backend
record = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"name" Int
1 Maybe Text
forall a. Maybe a
Nothing
        PersonGeneric backend
record' <- PersonGeneric backend -> ReaderT backend m (PersonGeneric backend)
forall record backend (m :: * -> *).
(PersistEntityBackend record ~ BaseBackend backend,
 PersistEntity record, MonadIO m, PersistStoreWrite backend,
 SafeToInsert record, HasCallStack) =>
record -> ReaderT backend m record
insertRecord PersonGeneric backend
forall {backend}. PersonGeneric backend
record
        PersonGeneric backend
record' PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
forall {backend}. PersonGeneric backend
record

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"getEntity" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        Entity Key (PersonGeneric backend)
k PersonGeneric backend
p <- PersonGeneric backend
-> ReaderT backend m (Entity (PersonGeneric backend))
forall e backend (m :: * -> *).
(PersistStoreWrite backend, PersistRecordBackend e backend,
 SafeToInsert e, MonadIO m, HasCallStack) =>
e -> ReaderT backend m (Entity e)
insertEntity (PersonGeneric backend
 -> ReaderT backend m (Entity (PersonGeneric backend)))
-> PersonGeneric backend
-> ReaderT backend m (Entity (PersonGeneric backend))
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"name" Int
1 Maybe Text
forall a. Maybe a
Nothing
        Just (Entity Key (PersonGeneric backend)
k2 PersonGeneric backend
p2) <- Key (PersonGeneric backend)
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall e backend (m :: * -> *).
(PersistStoreRead backend, PersistRecordBackend e backend,
 MonadIO m) =>
Key e -> ReaderT backend m (Maybe (Entity e))
getEntity Key (PersonGeneric backend)
k
        PersonGeneric backend
p PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
p2
        Key (PersonGeneric backend)
k Key (PersonGeneric backend)
-> Key (PersonGeneric backend) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (PersonGeneric backend)
k2

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"getJustEntity" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p1 :: PersonGeneric backend
p1 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"name" Int
1 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
k1 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p1
        Entity Key (PersonGeneric backend)
k2 PersonGeneric backend
p2 <- Key (PersonGeneric backend)
-> ReaderT backend m (Entity (PersonGeneric backend))
forall record backend (m :: * -> *).
(PersistEntityBackend record ~ BaseBackend backend, MonadIO m,
 PersistEntity record, PersistStoreRead backend) =>
Key record -> ReaderT backend m (Entity record)
getJustEntity Key (PersonGeneric backend)
k1
        PersonGeneric backend
forall {backend}. PersonGeneric backend
p1 PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
p2
        Key (PersonGeneric backend)
k1 Key (PersonGeneric backend)
-> Key (PersonGeneric backend) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (PersonGeneric backend)
k2

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"repsert" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        Key (PersonGeneric backend)
k <- IO (Key (PersonGeneric backend))
-> ReaderT backend m (Key (PersonGeneric backend))
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (BackendKey backend -> Key (PersonGeneric backend)
forall backend. BackendKey backend -> Key (PersonGeneric backend)
PersonKey (BackendKey backend -> Key (PersonGeneric backend))
-> IO (BackendKey backend) -> IO (Key (PersonGeneric backend))
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` IO (BackendKey backend)
forall backend. GenerateKey backend => IO (BackendKey backend)
generateKey)
        Maybe (Entity (PersonGeneric backend))
Nothing <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Repsert"] []
        Key (PersonGeneric backend)
-> PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
repsert Key (PersonGeneric backend)
k (PersonGeneric backend -> ReaderT backend m ())
-> PersonGeneric backend -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Repsert" Int
26 Maybe Text
forall a. Maybe a
Nothing
        Just (Entity Key (PersonGeneric backend)
k2 PersonGeneric backend
_) <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Repsert"] []
        Key (PersonGeneric backend)
k2 Key (PersonGeneric backend)
-> Key (PersonGeneric backend) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (PersonGeneric backend)
k
        Key (PersonGeneric backend)
-> PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> record -> ReaderT backend m ()
repsert Key (PersonGeneric backend)
k (PersonGeneric backend -> ReaderT backend m ())
-> PersonGeneric backend -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Repsert" Int
27 Maybe Text
forall a. Maybe a
Nothing
        Just (Entity Key (PersonGeneric backend)
k3 PersonGeneric backend
p) <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m (Maybe (Entity (PersonGeneric backend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> Text -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"Repsert"] []
        Key (PersonGeneric backend)
k3 Key (PersonGeneric backend)
-> Key (PersonGeneric backend) -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (PersonGeneric backend)
k
        Int
27 Int -> Int -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend -> Int
forall backend. PersonGeneric backend -> Int
personAge PersonGeneric backend
p

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"retrieves a belongsToJust association" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p :: PersonGeneric backend
p = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"pet owner" Int
30 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
person <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p
        let
            cat :: PetGeneric backend
cat = Key (PersonGeneric backend)
-> Text -> PetType -> PetGeneric backend
forall backend.
Key (PersonGeneric backend)
-> Text -> PetType -> PetGeneric backend
Pet Key (PersonGeneric backend)
person Text
"Mittens" PetType
Cat
        PersonGeneric backend
p2 <- Key (PersonGeneric backend)
-> ReaderT backend m (PersonGeneric backend)
forall record backend (m :: * -> *).
(PersistStoreRead backend, PersistRecordBackend record backend,
 MonadIO m) =>
Key record -> ReaderT backend m record
getJust (Key (PersonGeneric backend)
 -> ReaderT backend m (PersonGeneric backend))
-> Key (PersonGeneric backend)
-> ReaderT backend m (PersonGeneric backend)
forall a b. (a -> b) -> a -> b
$ PetGeneric backend -> Key (PersonGeneric backend)
forall backend. PetGeneric backend -> Key (PersonGeneric backend)
petOwnerId PetGeneric backend
cat
        PersonGeneric backend
forall {backend}. PersonGeneric backend
p PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
p2
        PersonGeneric backend
p3 <- (PetGeneric backend -> Key (PersonGeneric backend))
-> PetGeneric backend -> ReaderT backend m (PersonGeneric backend)
forall ent1 ent2 backend (m :: * -> *).
(PersistStoreRead backend, PersistEntity ent1,
 PersistRecordBackend ent2 backend, MonadIO m) =>
(ent1 -> Key ent2) -> ent1 -> ReaderT backend m ent2
belongsToJust PetGeneric backend -> Key (PersonGeneric backend)
forall backend. PetGeneric backend -> Key (PersonGeneric backend)
petOwnerId PetGeneric backend
cat
        PersonGeneric backend
forall {backend}. PersonGeneric backend
p PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
p3

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"retrieves a belongsTo association" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p :: PersonGeneric backend
p = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"pet owner" Int
30 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
person <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p
        let
            cat :: MaybeOwnedPetGeneric backend
cat = Maybe (Key (PersonGeneric backend))
-> Text -> PetType -> MaybeOwnedPetGeneric backend
forall backend.
Maybe (Key (PersonGeneric backend))
-> Text -> PetType -> MaybeOwnedPetGeneric backend
MaybeOwnedPet (Key (PersonGeneric backend) -> Maybe (Key (PersonGeneric backend))
forall a. a -> Maybe a
Just Key (PersonGeneric backend)
person) Text
"Mittens" PetType
Cat
        PersonGeneric backend
p2 <- Key (PersonGeneric backend)
-> ReaderT backend m (PersonGeneric backend)
forall record backend (m :: * -> *).
(PersistStoreRead backend, PersistRecordBackend record backend,
 MonadIO m) =>
Key record -> ReaderT backend m record
getJust (Key (PersonGeneric backend)
 -> ReaderT backend m (PersonGeneric backend))
-> Key (PersonGeneric backend)
-> ReaderT backend m (PersonGeneric backend)
forall a b. (a -> b) -> a -> b
$ Maybe (Key (PersonGeneric backend)) -> Key (PersonGeneric backend)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (Key (PersonGeneric backend))
 -> Key (PersonGeneric backend))
-> Maybe (Key (PersonGeneric backend))
-> Key (PersonGeneric backend)
forall a b. (a -> b) -> a -> b
$ MaybeOwnedPetGeneric backend -> Maybe (Key (PersonGeneric backend))
forall backend.
MaybeOwnedPetGeneric backend -> Maybe (Key (PersonGeneric backend))
maybeOwnedPetOwnerId MaybeOwnedPetGeneric backend
cat
        PersonGeneric backend
forall {backend}. PersonGeneric backend
p PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
p2
        Just PersonGeneric backend
p4 <- (MaybeOwnedPetGeneric backend
 -> Maybe (Key (PersonGeneric backend)))
-> MaybeOwnedPetGeneric backend
-> ReaderT backend m (Maybe (PersonGeneric backend))
forall ent1 ent2 backend (m :: * -> *).
(PersistStoreRead backend, PersistEntity ent1,
 PersistRecordBackend ent2 backend, MonadIO m) =>
(ent1 -> Maybe (Key ent2))
-> ent1 -> ReaderT backend m (Maybe ent2)
belongsTo MaybeOwnedPetGeneric backend -> Maybe (Key (PersonGeneric backend))
forall backend.
MaybeOwnedPetGeneric backend -> Maybe (Key (PersonGeneric backend))
maybeOwnedPetOwnerId MaybeOwnedPetGeneric backend
cat
        PersonGeneric backend
forall {backend}. PersonGeneric backend
p PersonGeneric backend
-> PersonGeneric backend -> ReaderT backend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric backend
p4

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"derivePersistField" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        Key (PersonGeneric backend)
person <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert (PersonGeneric backend
 -> ReaderT backend m (Key (PersonGeneric backend)))
-> PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"pet owner" Int
30 Maybe Text
forall a. Maybe a
Nothing
        Key (PetGeneric backend)
catKey <- PetGeneric backend -> ReaderT backend m (Key (PetGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert (PetGeneric backend
 -> ReaderT backend m (Key (PetGeneric backend)))
-> PetGeneric backend
-> ReaderT backend m (Key (PetGeneric backend))
forall a b. (a -> b) -> a -> b
$ Key (PersonGeneric backend)
-> Text -> PetType -> PetGeneric backend
forall backend.
Key (PersonGeneric backend)
-> Text -> PetType -> PetGeneric backend
Pet Key (PersonGeneric backend)
person Text
"Mittens" PetType
Cat
        Just PetGeneric backend
cat' <- Key (PetGeneric backend)
-> ReaderT backend m (Maybe (PetGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PetGeneric backend)
catKey
        IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ PetGeneric backend -> PetType
forall backend. PetGeneric backend -> PetType
petType PetGeneric backend
cat' PetType -> PetType -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= PetType
Cat
        Key (PetGeneric backend)
dog <- PetGeneric backend -> ReaderT backend m (Key (PetGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert (PetGeneric backend
 -> ReaderT backend m (Key (PetGeneric backend)))
-> PetGeneric backend
-> ReaderT backend m (Key (PetGeneric backend))
forall a b. (a -> b) -> a -> b
$ Key (PersonGeneric backend)
-> Text -> PetType -> PetGeneric backend
forall backend.
Key (PersonGeneric backend)
-> Text -> PetType -> PetGeneric backend
Pet Key (PersonGeneric backend)
person Text
"Spike" PetType
Dog
        Just PetGeneric backend
dog' <- Key (PetGeneric backend)
-> ReaderT backend m (Maybe (PetGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (PetGeneric backend)
dog
        IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ PetGeneric backend -> PetType
forall backend. PetGeneric backend -> PetType
petType PetGeneric backend
dog' PetType -> PetType -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= PetType
Dog

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"derivePersistFieldJSON" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            mittensCollar :: PetCollar
mittensCollar = Text -> Bool -> PetCollar
PetCollar Text
"Mittens\n1-714-668-9672" Bool
True
        Key (PersonGeneric backend)
pkey <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert (PersonGeneric backend
 -> ReaderT backend m (Key (PersonGeneric backend)))
-> PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall a b. (a -> b) -> a -> b
$ Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"pet owner" Int
30 Maybe Text
forall a. Maybe a
Nothing
        Key (OutdoorPetGeneric backend)
catKey <- OutdoorPetGeneric backend
-> ReaderT backend m (Key (OutdoorPetGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert (OutdoorPetGeneric backend
 -> ReaderT backend m (Key (OutdoorPetGeneric backend)))
-> OutdoorPetGeneric backend
-> ReaderT backend m (Key (OutdoorPetGeneric backend))
forall a b. (a -> b) -> a -> b
$ Key (PersonGeneric backend)
-> PetCollar -> PetType -> OutdoorPetGeneric backend
forall backend.
Key (PersonGeneric backend)
-> PetCollar -> PetType -> OutdoorPetGeneric backend
OutdoorPet Key (PersonGeneric backend)
pkey PetCollar
mittensCollar PetType
Cat
        Just (OutdoorPet Key (PersonGeneric backend)
_ PetCollar
collar' PetType
_) <- Key (OutdoorPetGeneric backend)
-> ReaderT backend m (Maybe (OutdoorPetGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (OutdoorPetGeneric backend)
catKey
        IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ PetCollar
collar' PetCollar -> PetCollar -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= PetCollar
mittensCollar

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"idIn" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p1 :: PersonGeneric backend
p1 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"D" Int
0 Maybe Text
forall a. Maybe a
Nothing
            p2 :: PersonGeneric backend
p2 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"E" Int
1 Maybe Text
forall a. Maybe a
Nothing
            p3 :: PersonGeneric backend
p3 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"F" Int
2 Maybe Text
forall a. Maybe a
Nothing
        Key (PersonGeneric backend)
pid1 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p1
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonGeneric backend
forall {backend}. PersonGeneric backend
p2
        Key (PersonGeneric backend)
pid3 <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p3
        [Entity (PersonGeneric backend)]
x <- [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) (Key (PersonGeneric backend))
forall backend typ.
(typ ~ Key (PersonGeneric backend)) =>
EntityField (PersonGeneric backend) typ
PersonId EntityField (PersonGeneric backend) (Key (PersonGeneric backend))
-> [Key (PersonGeneric backend)] -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> [typ] -> Filter v
<-. [Key (PersonGeneric backend)
pid1, Key (PersonGeneric backend)
pid3]] []
        IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ [Entity (PersonGeneric backend)]
x [Entity (PersonGeneric backend)]
-> [Entity (PersonGeneric backend)] -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= [Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
pid1 PersonGeneric backend
forall {backend}. PersonGeneric backend
p1, Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
pid3 PersonGeneric backend
forall {backend}. PersonGeneric backend
p3]

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"In" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        let
            p1 :: PersonGeneric backend
p1 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"D" Int
0 Maybe Text
forall a. Maybe a
Nothing
            p2 :: PersonGeneric backend
p2 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"E" Int
1 Maybe Text
forall a. Maybe a
Nothing
            p3 :: PersonGeneric backend
p3 = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"F" Int
2 (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"blue")
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonGeneric backend
forall {backend}. PersonGeneric backend
p1
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonGeneric backend
forall {backend}. PersonGeneric backend
p2
        PersonGeneric backend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m ()
insert_ PersonGeneric backend
forall {backend}. PersonGeneric backend
p3
        [PersonGeneric backend]
x1 <- (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal ([Entity (PersonGeneric backend)] -> [PersonGeneric backend])
-> ReaderT backend m [Entity (PersonGeneric backend)]
-> ReaderT backend m [PersonGeneric backend]
forall a b. (a -> b) -> ReaderT backend m a -> ReaderT backend m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> [Text] -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> [typ] -> Filter v
<-. [Text
"D"]] []
        IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ [PersonGeneric backend]
x1 [PersonGeneric backend] -> [PersonGeneric backend] -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= [PersonGeneric backend
forall {backend}. PersonGeneric backend
p1]
        [PersonGeneric backend]
x2 <- (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal ([Entity (PersonGeneric backend)] -> [PersonGeneric backend])
-> ReaderT backend m [Entity (PersonGeneric backend)]
-> ReaderT backend m [PersonGeneric backend]
forall a b. (a -> b) -> ReaderT backend m a -> ReaderT backend m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric backend) Text
-> [Text] -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> [typ] -> Filter v
/<-. [Text
"D"]] []
        IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ [PersonGeneric backend]
x2 [PersonGeneric backend] -> [PersonGeneric backend] -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= [PersonGeneric backend
forall {backend}. PersonGeneric backend
p2, PersonGeneric backend
forall {backend}. PersonGeneric backend
p3]

        [PersonGeneric backend]
x3 <- (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal ([Entity (PersonGeneric backend)] -> [PersonGeneric backend])
-> ReaderT backend m [Entity (PersonGeneric backend)]
-> ReaderT backend m [PersonGeneric backend]
forall a b. (a -> b) -> ReaderT backend m a -> ReaderT backend m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (PersonGeneric backend) typ
PersonColor EntityField (PersonGeneric backend) (Maybe Text)
-> [Maybe Text] -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> [typ] -> Filter v
<-. [Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"blue"]] []
        IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ [PersonGeneric backend]
x3 [PersonGeneric backend] -> [PersonGeneric backend] -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= [PersonGeneric backend
forall {backend}. PersonGeneric backend
p3]
        [PersonGeneric backend]
x4 <- (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal ([Entity (PersonGeneric backend)] -> [PersonGeneric backend])
-> ReaderT backend m [Entity (PersonGeneric backend)]
-> ReaderT backend m [PersonGeneric backend]
forall a b. (a -> b) -> ReaderT backend m a -> ReaderT backend m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (PersonGeneric backend) typ
PersonColor EntityField (PersonGeneric backend) (Maybe Text)
-> [Maybe Text] -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> [typ] -> Filter v
/<-. [Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"blue"]] []
        IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ [PersonGeneric backend]
x4 [PersonGeneric backend] -> [PersonGeneric backend] -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= [PersonGeneric backend
forall {backend}. PersonGeneric backend
p1, PersonGeneric backend
forall {backend}. PersonGeneric backend
p2]

        [PersonGeneric backend]
x5 <-
            (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal ([Entity (PersonGeneric backend)] -> [PersonGeneric backend])
-> ReaderT backend m [Entity (PersonGeneric backend)]
-> ReaderT backend m [PersonGeneric backend]
forall a b. (a -> b) -> ReaderT backend m a -> ReaderT backend m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (PersonGeneric backend) typ
PersonColor EntityField (PersonGeneric backend) (Maybe Text)
-> [Maybe Text] -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> [typ] -> Filter v
<-. [Maybe Text
forall a. Maybe a
Nothing, Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"blue"]] []
        IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ [PersonGeneric backend]
x5 [PersonGeneric backend] -> [PersonGeneric backend] -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= [PersonGeneric backend
forall {backend}. PersonGeneric backend
p1, PersonGeneric backend
forall {backend}. PersonGeneric backend
p2, PersonGeneric backend
forall {backend}. PersonGeneric backend
p3]
        [PersonGeneric backend]
x6 <- (Entity (PersonGeneric backend) -> PersonGeneric backend)
-> [Entity (PersonGeneric backend)] -> [PersonGeneric backend]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Entity (PersonGeneric backend) -> PersonGeneric backend
forall record. Entity record -> record
entityVal ([Entity (PersonGeneric backend)] -> [PersonGeneric backend])
-> ReaderT backend m [Entity (PersonGeneric backend)]
-> ReaderT backend m [PersonGeneric backend]
forall a b. (a -> b) -> ReaderT backend m a -> ReaderT backend m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` [Filter (PersonGeneric backend)]
-> [SelectOpt (PersonGeneric backend)]
-> ReaderT backend m [Entity (PersonGeneric backend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField (PersonGeneric backend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (PersonGeneric backend) typ
PersonColor EntityField (PersonGeneric backend) (Maybe Text)
-> [Maybe Text] -> Filter (PersonGeneric backend)
forall v typ.
PersistField typ =>
EntityField v typ -> [typ] -> Filter v
/<-. [Maybe Text
forall a. Maybe a
Nothing]] []
        IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ [PersonGeneric backend]
x6 [PersonGeneric backend] -> [PersonGeneric backend] -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= [PersonGeneric backend
forall {backend}. PersonGeneric backend
p3]

    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"toJSON" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"serializes" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
            let
                p :: PersonGeneric backend
p = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"D" Int
0 Maybe Text
forall a. Maybe a
Nothing
            Key (PersonGeneric backend)
k <- PersonGeneric backend
-> ReaderT backend m (Key (PersonGeneric backend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall {backend}. PersonGeneric backend
p
            IO () -> ReaderT backend m ()
forall a. IO a -> ReaderT backend m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$
                Entity (PersonGeneric backend) -> Value
forall a. ToJSON a => a -> Value
toJSON (Key (PersonGeneric backend)
-> PersonGeneric backend -> Entity (PersonGeneric backend)
forall record. Key record -> record -> Entity record
Entity Key (PersonGeneric backend)
k PersonGeneric backend
forall {backend}. PersonGeneric backend
p)
                    Value -> Value -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= [Pair] -> Value
object
                        [(Key
"id", Key (PersonGeneric backend) -> Value
forall a. ToJSON a => a -> Value
toJSON Key (PersonGeneric backend)
k), (Key
"color", Value
Null), (Key
"name", Text -> Value
String Text
"D"), (Key
"age", Scientific -> Value
Number Scientific
0)]

    {- FIXME
        prop "fromJSON . toJSON $ key" $ \(person :: Key Person) ->
          case (fromJSON . toJSON) person of
            Success p -> p == person
            _ -> error "fromJSON"
    -}

    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"strictness" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"bang" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ (StrictGeneric Any -> IO (StrictGeneric Any)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (StrictGeneric Any -> IO (StrictGeneric Any))
-> StrictGeneric Any -> IO (StrictGeneric Any)
forall a b. (a -> b) -> a -> b
$! Int -> Int -> Int -> StrictGeneric Any
forall backend. Int -> Int -> Int -> StrictGeneric backend
Strict (String -> Int
forall a. HasCallStack => String -> a
error String
"foo") Int
5 Int
5) IO (StrictGeneric Any) -> Selector ErrorCall -> IO ()
forall e a.
(HasCallStack, Exception e) =>
IO a -> Selector e -> IO ()
`shouldThrow` Selector ErrorCall
anyErrorCall
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"tilde" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ IO Strict -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Strict -> IO Strict
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Strict -> IO Strict) -> Strict -> IO Strict
forall a b. (a -> b) -> a -> b
$! Int -> Int -> Int -> Strict
forall backend. Int -> Int -> Int -> StrictGeneric backend
Strict Int
5 (String -> Int
forall a. HasCallStack => String -> a
error String
"foo") Int
5 :: IO Strict)
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"blank" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ (StrictGeneric Any -> IO (StrictGeneric Any)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (StrictGeneric Any -> IO (StrictGeneric Any))
-> StrictGeneric Any -> IO (StrictGeneric Any)
forall a b. (a -> b) -> a -> b
$! Int -> Int -> Int -> StrictGeneric Any
forall backend. Int -> Int -> Int -> StrictGeneric backend
Strict Int
5 Int
5 (String -> Int
forall a. HasCallStack => String -> a
error String
"foo")) IO (StrictGeneric Any) -> Selector ErrorCall -> IO ()
forall e a.
(HasCallStack, Exception e) =>
IO a -> Selector e -> IO ()
`shouldThrow` Selector ErrorCall
anyErrorCall

    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"documentation syntax" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
        let
            edef :: EntityDef
edef = Proxy Relationship -> EntityDef
forall record (proxy :: * -> *).
PersistEntity record =>
proxy record -> EntityDef
forall (proxy :: * -> *). proxy Relationship -> EntityDef
entityDef (Proxy Relationship
forall {k} (t :: k). Proxy t
Proxy :: Proxy Relationship)
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"provides comments on entity def" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            EntityDef -> Maybe Text
getEntityComments EntityDef
edef
                Maybe Text -> Maybe Text -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Text -> Maybe Text
forall a. a -> Maybe a
Just
                    Text
"This is a doc comment for a relationship.\nOnly the first line requires a pipe.\nPipes are optional on subsequent lines.\n"
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"provides comments on the field" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            let
                [FieldDef
nameField, FieldDef
_] = EntityDef -> [FieldDef]
getEntityFields EntityDef
edef
            FieldDef -> Maybe Text
fieldComments FieldDef
nameField
                Maybe Text -> Maybe Text -> IO ()
forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`shouldBe` Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"Fields should be documentable.\n"