{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}

module UniqueTest where

import Init

share
    [mkPersist sqlSettings, mkMigrate "uniqueMigrate"]
    [persistLowerCase|
  TestNonNull
    fieldA Int
    UniqueTestNonNull fieldA sql=UniqueTestNonNull !force
    deriving Eq Show
  TestNull
    fieldA Int
    fieldB Int Maybe
    UniqueTestNull fieldA fieldB sql=UniqueTestNonNullSqlName !force
    deriving Eq Show

  TestCheckmark
    name   Text
    value  Text
    active Checkmark nullable
    UniqueTestCheckmark name active !force
    deriving Eq Show
|]

cleanDB
    :: (MonadIO m, PersistQuery backend, PersistEntityBackend TestNonNull ~ backend)
    => ReaderT backend m ()
cleanDB :: forall (m :: * -> *) backend.
(MonadIO m, PersistQuery backend,
 PersistEntityBackend TestNonNull ~ backend) =>
ReaderT backend m ()
cleanDB = do
    [Filter TestNonNull] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter TestNonNull])
    [Filter TestNull] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter TestNull])

specsWith :: (Runner SqlBackend m) => RunDb SqlBackend m -> Spec
specsWith :: forall (m :: * -> *).
Runner SqlBackend m =>
RunDb SqlBackend m -> Spec
specsWith RunDb SqlBackend m
runDb =
    String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"uniqueness constraints" (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
"are respected for non-nullable Ints" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            let
                ins :: Int -> ReaderT SqlBackend m (Key TestNonNull)
ins = TestNonNull -> ReaderT SqlBackend m (Key TestNonNull)
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record SqlBackend,
 SafeToInsert record) =>
record -> ReaderT SqlBackend m (Key record)
insert (TestNonNull -> ReaderT SqlBackend m (Key TestNonNull))
-> (Int -> TestNonNull)
-> Int
-> ReaderT SqlBackend m (Key TestNonNull)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> TestNonNull
TestNonNull
            (RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestNonNull) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT SqlBackend m (Key TestNonNull) -> ReaderT SqlBackend m ())
-> ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m ()
forall a b. (a -> b) -> a -> b
$ Int -> ReaderT SqlBackend m (Key TestNonNull)
ins Int
1 ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m (Key TestNonNull)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> ReaderT SqlBackend m (Key TestNonNull)
ins Int
2)
            (RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestNonNull) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT SqlBackend m (Key TestNonNull) -> ReaderT SqlBackend m ())
-> ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m ()
forall a b. (a -> b) -> a -> b
$ Int -> ReaderT SqlBackend m (Key TestNonNull)
ins Int
1 ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m (Key TestNonNull)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> ReaderT SqlBackend m (Key TestNonNull)
ins Int
2 ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m (Key TestNonNull)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> ReaderT SqlBackend m (Key TestNonNull)
ins Int
1) IO () -> Selector SomeException -> IO ()
forall e a.
(HasCallStack, Exception e) =>
IO a -> Selector e -> IO ()
`shouldThrow` Selector SomeException
anyException
            (RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestNonNull) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT SqlBackend m (Key TestNonNull) -> ReaderT SqlBackend m ())
-> ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m ()
forall a b. (a -> b) -> a -> b
$ Int -> ReaderT SqlBackend m (Key TestNonNull)
ins Int
1 ReaderT SqlBackend m (Key TestNonNull)
-> (Key TestNonNull -> ReaderT SqlBackend m (Key TestNonNull))
-> ReaderT SqlBackend m (Key TestNonNull)
forall a b.
ReaderT SqlBackend m a
-> (a -> ReaderT SqlBackend m b) -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Key TestNonNull
k -> Int -> ReaderT SqlBackend m (Key TestNonNull)
ins Int
2 ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m () -> ReaderT SqlBackend m ()
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Key TestNonNull -> ReaderT SqlBackend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record SqlBackend) =>
Key record -> ReaderT SqlBackend m ()
delete Key TestNonNull
k ReaderT SqlBackend m ()
-> ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m (Key TestNonNull)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> ReaderT SqlBackend m (Key TestNonNull)
ins Int
1)
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"are respected for nullable Ints" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            let
                ins :: Int -> Maybe Int -> ReaderT backend m (Key TestNull)
ins Int
a Maybe Int
b = TestNull -> ReaderT backend m (Key TestNull)
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert (TestNull -> ReaderT backend m (Key TestNull))
-> TestNull -> ReaderT backend m (Key TestNull)
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Int -> TestNull
TestNull Int
a Maybe Int
b
                ctx :: ReaderT SqlBackend m (Key TestNull)
ctx =
                    Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Int -> Maybe Int -> ReaderT backend m (Key TestNull)
ins Int
1 Maybe Int
forall a. Maybe a
Nothing
                        ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Int -> Maybe Int -> ReaderT backend m (Key TestNull)
ins Int
1 Maybe Int
forall a. Maybe a
Nothing
                        ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Int -> Maybe Int -> ReaderT backend m (Key TestNull)
ins Int
1 Maybe Int
forall a. Maybe a
Nothing
                        ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Int -> Maybe Int -> ReaderT backend m (Key TestNull)
ins Int
1 (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
3)
                        ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Int -> Maybe Int -> ReaderT backend m (Key TestNull)
ins Int
1 (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4)
            (RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestNull) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void ReaderT SqlBackend m (Key TestNull)
ctx)
            (RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestNull) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT SqlBackend m (Key TestNull) -> ReaderT SqlBackend m ())
-> ReaderT SqlBackend m (Key TestNull) -> ReaderT SqlBackend m ()
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestNull)
ctx ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Int -> Maybe Int -> ReaderT backend m (Key TestNull)
ins Int
1 (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
3)) IO () -> Selector SomeException -> IO ()
forall e a.
(HasCallStack, Exception e) =>
IO a -> Selector e -> IO ()
`shouldThrow` Selector SomeException
anyException
            (RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestNull) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT SqlBackend m (Key TestNull) -> ReaderT SqlBackend m ())
-> ReaderT SqlBackend m (Key TestNull) -> ReaderT SqlBackend m ()
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestNull)
ctx ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Int -> Maybe Int -> ReaderT backend m (Key TestNull)
ins Int
1 (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4)) IO () -> Selector SomeException -> IO ()
forall e a.
(HasCallStack, Exception e) =>
IO a -> Selector e -> IO ()
`shouldThrow` Selector SomeException
anyException
            (RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestNull) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT SqlBackend m (Key TestNull) -> ReaderT SqlBackend m ())
-> ReaderT SqlBackend m (Key TestNull) -> ReaderT SqlBackend m ()
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestNull)
ctx ReaderT SqlBackend m (Key TestNull)
-> (Key TestNull -> ReaderT SqlBackend m (Key TestNull))
-> ReaderT SqlBackend m (Key TestNull)
forall a b.
ReaderT SqlBackend m a
-> (a -> ReaderT SqlBackend m b) -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Key TestNull
k -> Key TestNull -> ReaderT SqlBackend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record SqlBackend) =>
Key record -> ReaderT SqlBackend m ()
delete Key TestNull
k ReaderT SqlBackend m ()
-> ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Int -> Maybe Int -> ReaderT backend m (Key TestNull)
ins Int
1 (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4))
        String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"work for Checkmark" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ do
            let
                ins :: Text -> Text -> Checkmark -> ReaderT backend m (Key TestCheckmark)
ins Text
k Text
v Checkmark
a = TestCheckmark -> ReaderT backend m (Key TestCheckmark)
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend, SafeToInsert record) =>
record -> ReaderT backend m (Key record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record backend,
 SafeToInsert record) =>
record -> ReaderT backend m (Key record)
insert (TestCheckmark -> ReaderT backend m (Key TestCheckmark))
-> TestCheckmark -> ReaderT backend m (Key TestCheckmark)
forall a b. (a -> b) -> a -> b
$ Text -> Text -> Checkmark -> TestCheckmark
TestCheckmark Text
k Text
v Checkmark
a
                ctx :: ReaderT SqlBackend m (Key TestCheckmark)
ctx =
                    Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Text -> Text -> Checkmark -> ReaderT backend m (Key TestCheckmark)
ins Text
"name" Text
"John" Checkmark
Inactive
                        ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m (Key TestCheckmark)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Text -> Text -> Checkmark -> ReaderT backend m (Key TestCheckmark)
ins Text
"name" Text
"Stewart" Checkmark
Inactive
                        ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m (Key TestCheckmark)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Text -> Text -> Checkmark -> ReaderT backend m (Key TestCheckmark)
ins Text
"name" Text
"Doroty" Checkmark
Active
                        ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m (Key TestCheckmark)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Text -> Text -> Checkmark -> ReaderT backend m (Key TestCheckmark)
ins Text
"color" Text
"blue" Checkmark
Inactive
            (RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestCheckmark) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void ReaderT SqlBackend m (Key TestCheckmark)
ctx)
            (RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestCheckmark) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT SqlBackend m (Key TestCheckmark)
 -> ReaderT SqlBackend m ())
-> ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m ()
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestCheckmark)
ctx ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m (Key TestCheckmark)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Text -> Text -> Checkmark -> ReaderT backend m (Key TestCheckmark)
ins Text
"name" Text
"Melissa" Checkmark
Active) IO () -> Selector SomeException -> IO ()
forall e a.
(HasCallStack, Exception e) =>
IO a -> Selector e -> IO ()
`shouldThrow` Selector SomeException
anyException
            (RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestCheckmark) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT SqlBackend m (Key TestCheckmark)
 -> ReaderT SqlBackend m ())
-> ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m ()
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestCheckmark)
ctx ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m (Key TestCheckmark)
forall a b.
ReaderT SqlBackend m a
-> ReaderT SqlBackend m b -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Text -> Text -> Checkmark -> ReaderT backend m (Key TestCheckmark)
ins Text
"name" Text
"Melissa" Checkmark
Inactive)
            (RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m () -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT SqlBackend m () -> ReaderT SqlBackend m ())
-> ReaderT SqlBackend m () -> ReaderT SqlBackend m ()
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestCheckmark)
ctx ReaderT SqlBackend m (Key TestCheckmark)
-> (Key TestCheckmark -> ReaderT SqlBackend m ())
-> ReaderT SqlBackend m ()
forall a b.
ReaderT SqlBackend m a
-> (a -> ReaderT SqlBackend m b) -> ReaderT SqlBackend m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Key TestCheckmark
 -> [Update TestCheckmark] -> ReaderT SqlBackend m ())
-> [Update TestCheckmark]
-> Key TestCheckmark
-> ReaderT SqlBackend m ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip Key TestCheckmark
-> [Update TestCheckmark] -> ReaderT SqlBackend m ()
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> [Update record] -> ReaderT backend m ()
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record SqlBackend) =>
Key record -> [Update record] -> ReaderT SqlBackend m ()
update [EntityField TestCheckmark Checkmark
forall typ. (typ ~ Checkmark) => EntityField TestCheckmark typ
TestCheckmarkActive EntityField TestCheckmark Checkmark
-> Checkmark -> Update TestCheckmark
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Update v
=. Checkmark
Active])
            ( RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ ReaderT SqlBackend m (Key TestCheckmark) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (ReaderT SqlBackend m (Key TestCheckmark)
 -> ReaderT SqlBackend m ())
-> ReaderT SqlBackend m (Key TestCheckmark)
-> ReaderT SqlBackend m ()
forall a b. (a -> b) -> a -> b
$ do
                    ReaderT SqlBackend m (Key TestCheckmark) -> ReaderT SqlBackend m ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void ReaderT SqlBackend m (Key TestCheckmark)
ctx
                    [Filter TestCheckmark]
-> [Update TestCheckmark] -> ReaderT SqlBackend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> [Update record] -> ReaderT backend m ()
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record] -> [Update record] -> ReaderT SqlBackend m ()
updateWhere
                        [EntityField TestCheckmark Text
forall typ. (typ ~ Text) => EntityField TestCheckmark typ
TestCheckmarkName EntityField TestCheckmark Text -> Text -> Filter TestCheckmark
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"name"]
                        [EntityField TestCheckmark Checkmark
forall typ. (typ ~ Checkmark) => EntityField TestCheckmark typ
TestCheckmarkActive EntityField TestCheckmark Checkmark
-> Checkmark -> Update TestCheckmark
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Update v
=. Checkmark
Inactive]
                    Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall {backend} {m :: * -> *}.
(BaseBackend backend ~ SqlBackend, MonadIO m,
 PersistStoreWrite backend) =>
Text -> Text -> Checkmark -> ReaderT backend m (Key TestCheckmark)
ins Text
"name" Text
"Melissa" Checkmark
Active
                )