{-# LANGUAGE ScopedTypeVariables #-}

module ReadWriteTest where

import Init
import PersistentTestModels

specsWith :: forall m. (Runner SqlBackend m) => RunDb SqlBackend m -> Spec
specsWith :: forall (m :: * -> *).
Runner SqlBackend m =>
RunDb SqlBackend m -> Spec
specsWith RunDb SqlBackend m
originalRunDb = String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"ReadWriteTest" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
    let
        personFilters :: [Filter (PersonGeneric SqlBackend)]
personFilters = [] :: [Filter Person]
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"SqlReadBackend" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
        let
            runDb :: RunDb SqlReadBackend m
            runDb :: RunDb SqlReadBackend m
runDb = (SqlBackend -> SqlReadBackend)
-> RunDb SqlBackend m -> RunDb SqlReadBackend m
forall backend backend' (m :: * -> *).
MonadUnliftIO m =>
(backend -> backend') -> RunDb backend m -> RunDb backend' m
changeBackend SqlBackend -> SqlReadBackend
SqlReadBackend RunDb SqlBackend m
originalRunDb
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"type checks on all PersistStoreRead functions" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            RunDb SqlReadBackend m
runDb RunDb SqlReadBackend m -> RunDb SqlReadBackend m
forall a b. (a -> b) -> a -> b
$ do
                Maybe (PersonGeneric SqlBackend)
_ <- Key (PersonGeneric SqlBackend)
-> ReaderT SqlReadBackend m (Maybe (PersonGeneric SqlBackend))
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 SqlReadBackend) =>
Key record -> ReaderT SqlReadBackend m (Maybe record)
get (BackendKey SqlBackend -> Key (PersonGeneric SqlBackend)
forall backend. BackendKey backend -> Key (PersonGeneric backend)
PersonKey BackendKey SqlBackend
3)
                Map (Key (PersonGeneric SqlBackend)) (PersonGeneric SqlBackend)
_ <- [Key (PersonGeneric SqlBackend)]
-> ReaderT
     SqlReadBackend
     m
     (Map (Key (PersonGeneric SqlBackend)) (PersonGeneric SqlBackend))
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 SqlReadBackend) =>
[Key record] -> ReaderT SqlReadBackend m (Map (Key record) record)
getMany [BackendKey SqlBackend -> Key (PersonGeneric SqlBackend)
forall backend. BackendKey backend -> Key (PersonGeneric backend)
PersonKey BackendKey SqlBackend
1, BackendKey SqlBackend -> Key (PersonGeneric SqlBackend)
forall backend. BackendKey backend -> Key (PersonGeneric backend)
PersonKey BackendKey SqlBackend
2]
                () -> ReaderT SqlReadBackend m ()
forall a. a -> ReaderT SqlReadBackend m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"type checks on all PersistQueryRead functions" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            RunDb SqlReadBackend m
runDb RunDb SqlReadBackend m -> RunDb SqlReadBackend m
forall a b. (a -> b) -> a -> b
$ do
                [Entity (PersonGeneric SqlBackend)]
_ <- [Filter (PersonGeneric SqlBackend)]
-> [SelectOpt (PersonGeneric SqlBackend)]
-> ReaderT SqlReadBackend 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 [Filter (PersonGeneric SqlBackend)]
personFilters []
                Int
_ <- [Filter (PersonGeneric SqlBackend)] -> ReaderT SqlReadBackend 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 SqlReadBackend) =>
[Filter record] -> ReaderT SqlReadBackend m Int
count [Filter (PersonGeneric SqlBackend)]
personFilters
                () -> ReaderT SqlReadBackend m ()
forall a. a -> ReaderT SqlReadBackend m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"type checks on PersistUniqueRead functions" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            RunDb SqlReadBackend m
runDb RunDb SqlReadBackend m -> RunDb SqlReadBackend m
forall a b. (a -> b) -> a -> b
$ do
                Maybe (Entity (PersonGeneric SqlBackend))
_ <- Unique (PersonGeneric SqlBackend)
-> ReaderT
     SqlReadBackend m (Maybe (Entity (PersonGeneric SqlBackend)))
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 SqlReadBackend) =>
Unique record -> ReaderT SqlReadBackend m (Maybe (Entity record))
getBy (Text -> Unique (PersonGeneric SqlBackend)
forall backend. Text -> Unique (PersonGeneric backend)
PersonNameKey Text
"Matt")
                () -> ReaderT SqlReadBackend m ()
forall a. a -> ReaderT SqlReadBackend m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"SqlWriteBackend" (Spec -> Spec) -> Spec -> Spec
forall a b. (a -> b) -> a -> b
$ do
        let
            runDb :: RunDb SqlWriteBackend m
            runDb :: RunDb SqlWriteBackend m
runDb = (SqlBackend -> SqlWriteBackend)
-> RunDb SqlBackend m -> RunDb SqlWriteBackend m
forall backend backend' (m :: * -> *).
MonadUnliftIO m =>
(backend -> backend') -> RunDb backend m -> RunDb backend' m
changeBackend SqlBackend -> SqlWriteBackend
SqlWriteBackend RunDb SqlBackend m
originalRunDb

        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"type checks on PersistStoreWrite and Read functions" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            RunDb SqlWriteBackend m
runDb RunDb SqlWriteBackend m -> RunDb SqlWriteBackend m
forall a b. (a -> b) -> a -> b
$ do
                let
                    person :: PersonGeneric backend
person = Text -> Int -> Maybe Text -> PersonGeneric backend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
"Matt Parsons" Int
30 Maybe Text
forall a. Maybe a
Nothing
                Key (PersonGeneric SqlBackend)
k <- PersonGeneric SqlBackend
-> ReaderT SqlWriteBackend m (Key (PersonGeneric SqlBackend))
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 SqlWriteBackend,
 SafeToInsert record) =>
record -> ReaderT SqlWriteBackend m (Key record)
insert PersonGeneric SqlBackend
forall {backend}. PersonGeneric backend
person
                Maybe (PersonGeneric SqlBackend)
mperson <- Key (PersonGeneric SqlBackend)
-> ReaderT SqlWriteBackend m (Maybe (PersonGeneric SqlBackend))
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 SqlWriteBackend) =>
Key record -> ReaderT SqlWriteBackend m (Maybe record)
get Key (PersonGeneric SqlBackend)
k
                PersonGeneric SqlBackend -> Maybe (PersonGeneric SqlBackend)
forall a. a -> Maybe a
Just PersonGeneric SqlBackend
forall {backend}. PersonGeneric backend
person Maybe (PersonGeneric SqlBackend)
-> Maybe (PersonGeneric SqlBackend) -> ReaderT SqlWriteBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Maybe (PersonGeneric SqlBackend)
mperson

        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"type checks on PersistQueryWrite and Read functions" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            RunDb SqlWriteBackend m
runDb RunDb SqlWriteBackend m -> RunDb SqlWriteBackend m
forall a b. (a -> b) -> a -> b
$ do
                [Entity (PersonGeneric SqlBackend)]
_ <- [Filter (PersonGeneric SqlBackend)]
-> [SelectOpt (PersonGeneric SqlBackend)]
-> ReaderT SqlWriteBackend 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 [Filter (PersonGeneric SqlBackend)]
personFilters []
                [Filter (PersonGeneric SqlBackend)]
-> [Update (PersonGeneric SqlBackend)]
-> ReaderT SqlWriteBackend 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 SqlWriteBackend) =>
[Filter record] -> [Update record] -> ReaderT SqlWriteBackend m ()
updateWhere [Filter (PersonGeneric SqlBackend)]
personFilters []

        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"type checks on PersistUniqueWrite/Read functions" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            RunDb SqlWriteBackend m
runDb RunDb SqlWriteBackend m -> RunDb SqlWriteBackend m
forall a b. (a -> b) -> a -> b
$ do
                let
                    name_ :: Text
name_ = Text
"Matt Parsons New"
                    person :: PersonGeneric SqlBackend
person = Text -> Int -> Maybe Text -> PersonGeneric SqlBackend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
name_ Int
30 Maybe Text
forall a. Maybe a
Nothing
                Maybe (Key (PersonGeneric SqlBackend))
_mkey0 <- PersonGeneric SqlBackend
-> ReaderT
     SqlWriteBackend m (Maybe (Key (PersonGeneric SqlBackend)))
forall backend record (m :: * -> *).
(PersistUniqueWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Maybe (Key record))
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record SqlWriteBackend,
 SafeToInsert record) =>
record -> ReaderT SqlWriteBackend m (Maybe (Key record))
insertUnique PersonGeneric SqlBackend
person
                Maybe (Key (PersonGeneric SqlBackend))
mkey1 <- PersonGeneric SqlBackend
-> ReaderT
     SqlWriteBackend m (Maybe (Key (PersonGeneric SqlBackend)))
forall backend record (m :: * -> *).
(PersistUniqueWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Maybe (Key record))
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record SqlWriteBackend,
 SafeToInsert record) =>
record -> ReaderT SqlWriteBackend m (Maybe (Key record))
insertUnique PersonGeneric SqlBackend
person
                Maybe (Key (PersonGeneric SqlBackend))
mkey1 Maybe (Key (PersonGeneric SqlBackend))
-> Maybe (Key (PersonGeneric SqlBackend))
-> ReaderT SqlWriteBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Maybe (Key (PersonGeneric SqlBackend))
forall a. Maybe a
Nothing
                Maybe (Entity (PersonGeneric SqlBackend))
mperson <- [Filter (PersonGeneric SqlBackend)]
-> [SelectOpt (PersonGeneric SqlBackend)]
-> ReaderT
     SqlWriteBackend m (Maybe (Entity (PersonGeneric SqlBackend)))
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 SqlWriteBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlWriteBackend m (Maybe (Entity record))
selectFirst [EntityField (PersonGeneric SqlBackend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric SqlBackend) Text
-> Text -> Filter (PersonGeneric SqlBackend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
name_] []
                (Entity (PersonGeneric SqlBackend) -> PersonGeneric SqlBackend)
-> Maybe (Entity (PersonGeneric SqlBackend))
-> Maybe (PersonGeneric SqlBackend)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Entity (PersonGeneric SqlBackend) -> PersonGeneric SqlBackend
forall record. Entity record -> record
entityVal Maybe (Entity (PersonGeneric SqlBackend))
mperson Maybe (PersonGeneric SqlBackend)
-> Maybe (PersonGeneric SqlBackend) -> ReaderT SqlWriteBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric SqlBackend -> Maybe (PersonGeneric SqlBackend)
forall a. a -> Maybe a
Just PersonGeneric SqlBackend
person

                let
                    nameLuke :: Text
nameLuke = Text
"Luke Seale New"
                    personLuke :: PersonGeneric SqlBackend
personLuke = Text -> Int -> Maybe Text -> PersonGeneric SqlBackend
forall backend. Text -> Int -> Maybe Text -> PersonGeneric backend
Person Text
nameLuke Int
31 Maybe Text
forall a. Maybe a
Nothing
                Maybe ()
mkey2 <- PersonGeneric SqlBackend -> ReaderT SqlWriteBackend m (Maybe ())
forall backend record (m :: * -> *).
(PersistUniqueWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Maybe ())
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record SqlWriteBackend,
 SafeToInsert record) =>
record -> ReaderT SqlWriteBackend m (Maybe ())
insertUnique_ PersonGeneric SqlBackend
personLuke
                Maybe ()
mkey3 <- PersonGeneric SqlBackend -> ReaderT SqlWriteBackend m (Maybe ())
forall backend record (m :: * -> *).
(PersistUniqueWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Maybe ())
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record SqlWriteBackend,
 SafeToInsert record) =>
record -> ReaderT SqlWriteBackend m (Maybe ())
insertUnique_ PersonGeneric SqlBackend
personLuke
                Maybe ()
mkey3 Maybe () -> Maybe () -> ReaderT SqlWriteBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Maybe ()
forall a. Maybe a
Nothing
                Maybe (Entity (PersonGeneric SqlBackend))
mpersonLuke <- [Filter (PersonGeneric SqlBackend)]
-> [SelectOpt (PersonGeneric SqlBackend)]
-> ReaderT
     SqlWriteBackend m (Maybe (Entity (PersonGeneric SqlBackend)))
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 SqlWriteBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlWriteBackend m (Maybe (Entity record))
selectFirst [EntityField (PersonGeneric SqlBackend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (PersonGeneric backend) typ
PersonName EntityField (PersonGeneric SqlBackend) Text
-> Text -> Filter (PersonGeneric SqlBackend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
nameLuke] []
                (Entity (PersonGeneric SqlBackend) -> PersonGeneric SqlBackend)
-> Maybe (Entity (PersonGeneric SqlBackend))
-> Maybe (PersonGeneric SqlBackend)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Entity (PersonGeneric SqlBackend) -> PersonGeneric SqlBackend
forall record. Entity record -> record
entityVal Maybe (Entity (PersonGeneric SqlBackend))
mpersonLuke Maybe (PersonGeneric SqlBackend)
-> Maybe (PersonGeneric SqlBackend) -> ReaderT SqlWriteBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== PersonGeneric SqlBackend -> Maybe (PersonGeneric SqlBackend)
forall a. a -> Maybe a
Just PersonGeneric SqlBackend
personLuke