{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# 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 :: 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 ()
deleteWhere ([] :: [Filter TestNonNull])
  [Filter TestNull] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter TestNull])

specsWith :: Runner SqlBackend m => RunDb SqlBackend m -> Spec
specsWith :: 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)
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 (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 (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 (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 (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 (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 ()
delete Key TestNonNull
k ReaderT SqlBackend m ()
-> ReaderT SqlBackend m (Key TestNonNull)
-> ReaderT SqlBackend m (Key TestNonNull)
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)
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 (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (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 ()
delete Key TestNull
k ReaderT SqlBackend m ()
-> ReaderT SqlBackend m (Key TestNull)
-> ReaderT SqlBackend m (Key TestNull)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Maybe Int -> ReaderT SqlBackend m (Key TestNull)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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)
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 (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Text
-> Text -> Checkmark -> ReaderT SqlBackend m (Key TestCheckmark)
forall (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
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 (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 ()
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 ()
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 (m :: * -> *) backend.
(MonadIO m, PersistStoreWrite backend,
 BaseBackend backend ~ SqlBackend) =>
Text -> Text -> Checkmark -> ReaderT backend m (Key TestCheckmark)
ins Text
"name" Text
"Melissa" Checkmark
Active)