{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE RecordWildCards, 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.HashMap.Lazy as M
import qualified Data.Map as Map
import Data.Maybe (fromJust)
import Test.Hspec.QuickCheck(prop)
import Test.HUnit hiding (Test)
import UnliftIO (MonadUnliftIO, catch)
import Web.PathPieces (PathPiece (..))
import Data.Proxy (Proxy(..))

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

catchPersistException :: (MonadUnliftIO m, MonadFail m) => m a -> b -> m b
catchPersistException :: 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 (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 (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 (m :: * -> *) a. Monad m => a -> m a
return  b
res

filterOrSpecs
    :: forall m backend. Runner backend m
    => RunDb backend m
    -> Spec
filterOrSpecs :: 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) =>
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) =>
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
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 :: 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 (PetGeneric SqlBackend)]
_ <- [Filter (PetGeneric SqlBackend)]
-> [SelectOpt (PetGeneric SqlBackend)]
-> ReaderT backend m [Entity (PetGeneric SqlBackend)]
forall record backend (m :: * -> *).
(MonadIO m, PersistQueryRead backend,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m [Entity record]
selectList [EntityField
  (PetGeneric SqlBackend) (Key (PersonGeneric SqlBackend))
forall backend typ.
(typ ~ Key (PersonGeneric backend)) =>
EntityField (PetGeneric backend) typ
PetOwnerId EntityField
  (PetGeneric SqlBackend) (Key (PersonGeneric SqlBackend))
-> Key (PersonGeneric SqlBackend) -> Filter (PetGeneric SqlBackend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Key (PersonGeneric SqlBackend)
id'] []
    PetGeneric SqlBackend -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m ()
insert_ (PetGeneric SqlBackend -> ReaderT backend m ())
-> PetGeneric SqlBackend -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ Key (PersonGeneric SqlBackend)
-> Text -> PetType -> PetGeneric SqlBackend
forall backend.
Key (PersonGeneric backend)
-> Text -> PetType -> PetGeneric backend
Pet Key (PersonGeneric SqlBackend)
id' Text
"foo" PetType
Cat
    () -> ReaderT backend m ()
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 :: 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 :: s -> Getting a s t a b -> a
view s
s Getting a s t a b
l = Constant a t -> a
forall a k (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 :: 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) =>
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)
get Key (DudeWeirdColumnsGeneric backend)
k
                IO () -> ReaderT backend m ()
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 (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) =>
[record] -> ReaderT backend m ()
putMany [DudeWeirdColumnsGeneric backend]
forall backend. [DudeWeirdColumnsGeneric backend]
ms

specsWith :: forall backend m. Runner backend m => RunDb backend m -> Spec
specsWith :: 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)
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)
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) =>
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 (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) =>
[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) =>
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
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 ()
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
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)
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
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) =>
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
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 ()
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) =>
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) =>
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))
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 ()
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)
get Key (PersonGeneric backend)
micK
      () -> ReaderT backend m ()
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) =>
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) =>
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))
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 (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))
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 (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 ()
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) =>
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) =>
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 ()
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) =>
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) =>
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 ()
deleteWhere ([] :: [Filter (Person1Generic backend)])
      [Person1Generic backend] -> ReaderT backend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[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
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
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
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
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
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
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
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
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
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
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
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) =>
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) =>
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) =>
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 ()
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)
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)
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) =>
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) =>
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 ()
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)
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) =>
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) =>
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 ()
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)
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) =>
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 ()
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)
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 ()
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)
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 ()
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)
get Key (PersonGeneric backend)
key2
      () -> ReaderT backend m ()
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) =>
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)
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 ()
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)
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 ()
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)
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) =>
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))
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))
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 (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) =>
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
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
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 (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 (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 ()
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 ()
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 ()
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)
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 ()
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) =>
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) =>
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 ()
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)
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)
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 ()
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) =>
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) =>
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 ()
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)
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)
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) =>
[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) =>
[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))
  ()
-> ConduitM
     (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 =>
ConduitM a b m () -> ConduitM b c m r -> ConduitM a c m r
.| ConduitM
  (Entity (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) i. Monad m => Consumer i 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))
  ()
-> ConduitM
     (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 =>
ConduitM a b m () -> ConduitM b c m r -> ConduitM a c m r
.| ConduitM
  (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))
  ()
-> ConduitM
     (Entity (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
-> ConduitT () Void (ResourceT (ReaderT backend m)) ()
forall (m :: * -> *) a b c r.
Monad m =>
ConduitM a b m () -> ConduitM b c m r -> ConduitM a c m r
.| do
          Maybe (Entity (PersonGeneric backend))
e1 <- ConduitM
  (Entity (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) i. Monad m => Consumer i m (Maybe i)
await
          Maybe (Entity (PersonGeneric backend))
e1 Maybe (Entity (PersonGeneric backend))
-> Maybe (Entity (PersonGeneric backend))
-> ConduitM
     (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 <- ConduitM
  (Entity (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) i. Monad m => Consumer i m (Maybe i)
await
          Maybe (Entity (PersonGeneric backend))
e2 Maybe (Entity (PersonGeneric backend))
-> Maybe (Entity (PersonGeneric backend))
-> ConduitM
     (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 <- ConduitM
  (Entity (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) i. Monad m => Consumer i m (Maybe i)
await
          Maybe (Entity (PersonGeneric backend))
e3 Maybe (Entity (PersonGeneric backend))
-> Maybe (Entity (PersonGeneric backend))
-> ConduitM
     (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 <- ConduitM
  (Entity (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Entity (PersonGeneric backend)))
forall (m :: * -> *) i. Monad m => Consumer i m (Maybe i)
await
          Maybe (Entity (PersonGeneric backend))
e4 Maybe (Entity (PersonGeneric backend))
-> Maybe (Entity (PersonGeneric backend))
-> ConduitM
     (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) =>
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) =>
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))
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) =>
[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)) ()
-> ConduitM
     (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 =>
ConduitM a b m () -> ConduitM b c m r -> ConduitM a c m r
.| ConduitM
  (Key (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) i. Monad m => Consumer i 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)) ()
-> ConduitM
     (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 =>
ConduitM a b m () -> ConduitM b c m r -> ConduitM a c m r
.| ConduitM
  (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)) ()
-> ConduitM
     (Key (PersonGeneric backend))
     Void
     (ResourceT (ReaderT backend m))
     ()
-> ConduitT () Void (ResourceT (ReaderT backend m)) ()
forall (m :: * -> *) a b c r.
Monad m =>
ConduitM a b m () -> ConduitM b c m r -> ConduitM a c m r
.| do
          Maybe (Key (PersonGeneric backend))
e1 <- ConduitM
  (Key (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) i. Monad m => Consumer i m (Maybe i)
await
          Maybe (Key (PersonGeneric backend))
e1 Maybe (Key (PersonGeneric backend))
-> Maybe (Key (PersonGeneric backend))
-> ConduitM
     (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 <- ConduitM
  (Key (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) i. Monad m => Consumer i m (Maybe i)
await
          Maybe (Key (PersonGeneric backend))
e2 Maybe (Key (PersonGeneric backend))
-> Maybe (Key (PersonGeneric backend))
-> ConduitM
     (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 <- ConduitM
  (Key (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) i. Monad m => Consumer i m (Maybe i)
await
          Maybe (Key (PersonGeneric backend))
e3 Maybe (Key (PersonGeneric backend))
-> Maybe (Key (PersonGeneric backend))
-> ConduitM
     (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 <- ConduitM
  (Key (PersonGeneric backend))
  Void
  (ResourceT (ReaderT backend m))
  (Maybe (Key (PersonGeneric backend)))
forall (m :: * -> *) i. Monad m => Consumer i m (Maybe i)
await
          Maybe (Key (PersonGeneric backend))
e4 Maybe (Key (PersonGeneric backend))
-> Maybe (Key (PersonGeneric backend))
-> ConduitM
     (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) =>
[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
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) =>
[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
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 ()
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
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 (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 (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 ()
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
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) =>
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) =>
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) =>
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 (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 (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 (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 ()
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))
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,
 MonadIO m) =>
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)
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) =>
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,
 MonadIO m) =>
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) =>
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 (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 (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))
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 ()
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))
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 ()
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))
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) =>
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) =>
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) =>
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) =>
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)
get Key (PetGeneric backend)
catKey
      IO () -> ReaderT backend m ()
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) =>
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)
get Key (PetGeneric backend)
dog
      IO () -> ReaderT backend m ()
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) =>
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) =>
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)
get Key (OutdoorPetGeneric backend)
catKey
      IO () -> ReaderT backend m ()
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) =>
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) =>
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) =>
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 (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) =>
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) =>
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) =>
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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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 (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) =>
record -> ReaderT backend m (Key record)
insert PersonGeneric backend
forall backend. PersonGeneric backend
p
      IO () -> ReaderT backend m ()
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 ()
@?=
        Object -> Value
Object ([(Text, Value)] -> Object
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
M.fromList [(Text
"id", Key (PersonGeneric backend) -> Value
forall a. ToJSON a => a -> Value
toJSON Key (PersonGeneric backend)
k), (Text
"color",Value
Null),(Text
"name",Text -> Value
String Text
"D"),(Text
"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 (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 (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 (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
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.\nYou need to put the pipe character for each line of documentation.\nBut you can resume the doc comments afterwards.\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"