{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-orphans -O0 #-}
{-# OPTIONS_GHC -Wno-unused-top-binds #-}

module EmbedTest (specsWith, cleanDB, embedMigrate) where

import Control.Exception (Exception, throw)
import Data.List.NonEmpty hiding (insert, length)
import qualified Data.Map as M
import qualified Data.Set as S
import qualified Data.Text as T

import EntityEmbedTest
import Init

data TestException = TestException
    deriving (Int -> TestException -> ShowS
[TestException] -> ShowS
TestException -> String
(Int -> TestException -> ShowS)
-> (TestException -> String)
-> ([TestException] -> ShowS)
-> Show TestException
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TestException -> ShowS
showsPrec :: Int -> TestException -> ShowS
$cshow :: TestException -> String
show :: TestException -> String
$cshowList :: [TestException] -> ShowS
showList :: [TestException] -> ShowS
Show, TestException -> TestException -> Bool
(TestException -> TestException -> Bool)
-> (TestException -> TestException -> Bool) -> Eq TestException
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TestException -> TestException -> Bool
== :: TestException -> TestException -> Bool
$c/= :: TestException -> TestException -> Bool
/= :: TestException -> TestException -> Bool
Eq)
instance Exception TestException

instance (PersistFieldSql a) => PersistFieldSql (NonEmpty a) where
    sqlType :: Proxy (NonEmpty a) -> SqlType
sqlType Proxy (NonEmpty a)
_ = SqlType
SqlString

instance (PersistField a) => PersistField (NonEmpty a) where
    toPersistValue :: NonEmpty a -> PersistValue
toPersistValue = [a] -> PersistValue
forall a. PersistField a => a -> PersistValue
toPersistValue ([a] -> PersistValue)
-> (NonEmpty a -> [a]) -> NonEmpty a -> PersistValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
toList
    fromPersistValue :: PersistValue -> Either Text (NonEmpty a)
fromPersistValue PersistValue
pv = do
        [a]
xs <- PersistValue -> Either Text [a]
forall a. PersistField a => PersistValue -> Either Text a
fromPersistValue PersistValue
pv
        case [a]
xs of
            [] -> Text -> Either Text (NonEmpty a)
forall a b. a -> Either a b
Left Text
"PersistField: NonEmpty found unexpected Empty List"
            (a
l : [a]
ls) -> NonEmpty a -> Either Text (NonEmpty a)
forall a b. b -> Either a b
Right (a
l a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
ls)

share
    [mkPersist sqlSettings{mpsGeneric = True}, mkMigrate "embedMigrate"]
    [persistUpperCase|

  OnlyName
    name Text
    deriving Show Eq Read Ord

  HasEmbed
    name Text
    embed OnlyName
    deriving Show Eq Read Ord

  HasEmbeds
    name Text
    embed OnlyName
    double HasEmbed
    deriving Show Eq Read Ord

  HasListEmbed
    name Text
    list [HasEmbed]
    deriving Show Eq Read Ord

  HasSetEmbed
    name Text
    set (S.Set HasEmbed)
    deriving Show Eq Read Ord

  HasMap
    name Text
    map (M.Map T.Text T.Text)
    deriving Show Eq Read Ord

  HasList
    list [HasListId]
    deriving Show Eq Read Ord

  EmbedsHasMap
    name Text Maybe
    embed HasMap
    deriving Show Eq Read Ord

  InList
    one Int
    two Int
    deriving Show Eq

  ListEmbed
    nested [InList]
    one Int
    two Int
    deriving Show Eq

  User
    ident Text
    password Text Maybe
    profile Profile
    deriving Show Eq Read Ord

  Profile
    firstName Text
    lastName Text
    contact Contact Maybe
    deriving Show Eq Read Ord

  Contact
    phone Int
    email T.Text
    deriving Show Eq Read Ord

  Account
    userIds       (NonEmpty (Key User))
    name          Text Maybe
    customDomains [Text]             -- we may want to allow multiple cust domains.  use [] instead of maybe

    deriving Show Eq Read Ord

  HasNestedList
    list [IntList]
    deriving Show Eq

  IntList
    ints [Int]
    deriving Show Eq

  -- We would like to be able to use OnlyNameId
  -- But (Key OnlyName) works
  MapIdValue
    map (M.Map T.Text (Key OnlyName))
    deriving Show Eq Read Ord

  HasArrayWithEntities
    hasEntity (Entity ARecord)
    arrayWithEntities [AnEntity]
    deriving Show Eq Read Ord

  -- Self refrences are only allowed as a nullable type:
  -- a Maybe or a List
  SelfList
    reference [SelfList]

  SelfMaybe
    reference SelfMaybe Maybe

  -- This failes
  -- SelfDirect
  --  reference SelfDirect
|]
cleanDB
    :: (PersistQuery backend, PersistEntityBackend HasMap ~ backend, MonadIO m)
    => ReaderT backend m ()
cleanDB :: forall backend (m :: * -> *).
(PersistQuery backend, PersistEntityBackend HasMap ~ backend,
 MonadIO m) =>
ReaderT backend m ()
cleanDB = do
    [Filter HasEmbed] -> 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 (HasEmbedGeneric backend)])
    [Filter HasEmbeds] -> 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 (HasEmbedsGeneric backend)])
    [Filter HasListEmbed] -> 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 (HasListEmbedGeneric backend)])
    [Filter HasSetEmbed] -> 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 (HasSetEmbedGeneric backend)])
    [Filter User] -> 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 (UserGeneric backend)])
    [Filter HasMap] -> 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 (HasMapGeneric backend)])
    [Filter HasList] -> 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 (HasListGeneric backend)])
    [Filter EmbedsHasMap] -> 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 (EmbedsHasMapGeneric backend)])
    [Filter ListEmbed] -> 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 (ListEmbedGeneric backend)])
    [Filter (ARecordGeneric SqlBackend)] -> 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 (ARecordGeneric backend)])
    [Filter Account] -> 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 (AccountGeneric backend)])
    [Filter HasNestedList] -> 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 (HasNestedListGeneric backend)])

_unlessM :: (MonadIO m) => IO Bool -> m () -> m ()
_unlessM :: forall (m :: * -> *). MonadIO m => IO Bool -> m () -> m ()
_unlessM IO Bool
predicate m ()
body = do
    Bool
b <- IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO Bool
predicate
    Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
b m ()
body

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
"embedded entities" (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
"simple entities" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: HasEmbedsGeneric backend
container =
                Text -> OnlyName -> HasEmbed -> HasEmbedsGeneric backend
forall backend.
Text -> OnlyName -> HasEmbed -> HasEmbedsGeneric backend
HasEmbeds
                    Text
"container"
                    (Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"2")
                    (Text -> OnlyName -> HasEmbed
forall backend. Text -> OnlyName -> HasEmbedGeneric backend
HasEmbed Text
"embed" (Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"1"))
        Key HasEmbeds
contK <- HasEmbeds -> ReaderT SqlBackend m (Key HasEmbeds)
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 HasEmbeds
forall {backend}. HasEmbedsGeneric backend
container
        Just Entity HasEmbeds
res <- [Filter HasEmbeds]
-> [SelectOpt HasEmbeds]
-> ReaderT SqlBackend m (Maybe (Entity HasEmbeds))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField HasEmbeds Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasEmbedsGeneric backend) typ
HasEmbedsName EntityField HasEmbeds Text -> Text -> Filter HasEmbeds
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"container"] []
        Entity HasEmbeds
res Entity HasEmbeds -> Entity HasEmbeds -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key HasEmbeds -> HasEmbeds -> Entity HasEmbeds
forall record. Key record -> record -> Entity record
Entity Key HasEmbeds
contK HasEmbeds
forall {backend}. HasEmbedsGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"query for equality of embeded entity" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: HasEmbedGeneric backend
container = Text -> OnlyName -> HasEmbedGeneric backend
forall backend. Text -> OnlyName -> HasEmbedGeneric backend
HasEmbed Text
"container" (Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"2")
        Key HasEmbed
contK <- HasEmbed -> ReaderT SqlBackend m (Key HasEmbed)
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 HasEmbed
forall {backend}. HasEmbedGeneric backend
container
        Just Entity HasEmbed
res <- [Filter HasEmbed]
-> [SelectOpt HasEmbed]
-> ReaderT SqlBackend m (Maybe (Entity HasEmbed))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField HasEmbed OnlyName
forall backend typ.
(typ ~ OnlyName) =>
EntityField (HasEmbedGeneric backend) typ
HasEmbedEmbed EntityField HasEmbed OnlyName -> OnlyName -> Filter HasEmbed
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"2"] []
        Entity HasEmbed
res Entity HasEmbed -> Entity HasEmbed -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key HasEmbed -> HasEmbed -> Entity HasEmbed
forall record. Key record -> record -> Entity record
Entity Key HasEmbed
contK HasEmbed
forall {backend}. HasEmbedGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Set" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: HasSetEmbedGeneric backend
container =
                Text -> Set HasEmbed -> HasSetEmbedGeneric backend
forall backend. Text -> Set HasEmbed -> HasSetEmbedGeneric backend
HasSetEmbed Text
"set" (Set HasEmbed -> HasSetEmbedGeneric backend)
-> Set HasEmbed -> HasSetEmbedGeneric backend
forall a b. (a -> b) -> a -> b
$
                    [HasEmbed] -> Set HasEmbed
forall a. Ord a => [a] -> Set a
S.fromList
                        [ Text -> OnlyName -> HasEmbed
forall backend. Text -> OnlyName -> HasEmbedGeneric backend
HasEmbed Text
"embed" (Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"1")
                        , Text -> OnlyName -> HasEmbed
forall backend. Text -> OnlyName -> HasEmbedGeneric backend
HasEmbed Text
"embed" (Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"2")
                        ]
        Key HasSetEmbed
contK <- HasSetEmbed -> ReaderT SqlBackend m (Key HasSetEmbed)
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 HasSetEmbed
forall {backend}. HasSetEmbedGeneric backend
container
        Just Entity HasSetEmbed
res <- [Filter HasSetEmbed]
-> [SelectOpt HasSetEmbed]
-> ReaderT SqlBackend m (Maybe (Entity HasSetEmbed))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField HasSetEmbed Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasSetEmbedGeneric backend) typ
HasSetEmbedName EntityField HasSetEmbed Text -> Text -> Filter HasSetEmbed
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"set"] []
        Entity HasSetEmbed
res Entity HasSetEmbed -> Entity HasSetEmbed -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key HasSetEmbed -> HasSetEmbed -> Entity HasSetEmbed
forall record. Key record -> record -> Entity record
Entity Key HasSetEmbed
contK HasSetEmbed
forall {backend}. HasSetEmbedGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Set empty" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: HasSetEmbedGeneric backend
container = Text -> Set HasEmbed -> HasSetEmbedGeneric backend
forall backend. Text -> Set HasEmbed -> HasSetEmbedGeneric backend
HasSetEmbed Text
"set empty" (Set HasEmbed -> HasSetEmbedGeneric backend)
-> Set HasEmbed -> HasSetEmbedGeneric backend
forall a b. (a -> b) -> a -> b
$ [HasEmbed] -> Set HasEmbed
forall a. Ord a => [a] -> Set a
S.fromList []
        Key HasSetEmbed
contK <- HasSetEmbed -> ReaderT SqlBackend m (Key HasSetEmbed)
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 HasSetEmbed
forall {backend}. HasSetEmbedGeneric backend
container
        Just Entity HasSetEmbed
res <- [Filter HasSetEmbed]
-> [SelectOpt HasSetEmbed]
-> ReaderT SqlBackend m (Maybe (Entity HasSetEmbed))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField HasSetEmbed Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasSetEmbedGeneric backend) typ
HasSetEmbedName EntityField HasSetEmbed Text -> Text -> Filter HasSetEmbed
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"set empty"] []
        Entity HasSetEmbed
res Entity HasSetEmbed -> Entity HasSetEmbed -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key HasSetEmbed -> HasSetEmbed -> Entity HasSetEmbed
forall record. Key record -> record -> Entity record
Entity Key HasSetEmbed
contK HasSetEmbed
forall {backend}. HasSetEmbedGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"exception" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ (IO () -> (TestException -> Bool) -> IO ())
-> (TestException -> Bool) -> IO () -> IO ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip IO () -> (TestException -> Bool) -> IO ()
forall e a.
(HasCallStack, Exception e) =>
IO a -> Selector e -> IO ()
shouldThrow (TestException -> TestException -> Bool
forall a. Eq a => a -> a -> Bool
== TestException
TestException) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: HasSetEmbedGeneric backend
container =
                Text -> Set HasEmbed -> HasSetEmbedGeneric backend
forall backend. Text -> Set HasEmbed -> HasSetEmbedGeneric backend
HasSetEmbed Text
"set" (Set HasEmbed -> HasSetEmbedGeneric backend)
-> Set HasEmbed -> HasSetEmbedGeneric backend
forall a b. (a -> b) -> a -> b
$
                    [HasEmbed] -> Set HasEmbed
forall a. Ord a => [a] -> Set a
S.fromList
                        [ Text -> OnlyName -> HasEmbed
forall backend. Text -> OnlyName -> HasEmbedGeneric backend
HasEmbed Text
"embed" (Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"1")
                        , Text -> OnlyName -> HasEmbed
forall backend. Text -> OnlyName -> HasEmbedGeneric backend
HasEmbed Text
"embed" (Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"2")
                        ]
        Key HasSetEmbed
contK <- HasSetEmbed -> ReaderT SqlBackend m (Key HasSetEmbed)
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 HasSetEmbed
forall {backend}. HasSetEmbedGeneric backend
container
        Just Entity HasSetEmbed
res <- [Filter HasSetEmbed]
-> [SelectOpt HasSetEmbed]
-> ReaderT SqlBackend m (Maybe (Entity HasSetEmbed))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField HasSetEmbed Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasSetEmbedGeneric backend) typ
HasSetEmbedName EntityField HasSetEmbed Text -> Text -> Filter HasSetEmbed
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. TestException -> Text
forall a e. Exception e => e -> a
throw TestException
TestException] []
        Entity HasSetEmbed
res Entity HasSetEmbed -> Entity HasSetEmbed -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key HasSetEmbed -> HasSetEmbed -> Entity HasSetEmbed
forall record. Key record -> record -> Entity record
Entity Key HasSetEmbed
contK HasSetEmbed
forall {backend}. HasSetEmbedGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"ListEmbed" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: HasListEmbedGeneric backend
container =
                Text -> [HasEmbed] -> HasListEmbedGeneric backend
forall backend. Text -> [HasEmbed] -> HasListEmbedGeneric backend
HasListEmbed
                    Text
"list"
                    [ Text -> OnlyName -> HasEmbed
forall backend. Text -> OnlyName -> HasEmbedGeneric backend
HasEmbed Text
"embed" (Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"1")
                    , Text -> OnlyName -> HasEmbed
forall backend. Text -> OnlyName -> HasEmbedGeneric backend
HasEmbed Text
"embed" (Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"2")
                    ]
        Key HasListEmbed
contK <- HasListEmbed -> ReaderT SqlBackend m (Key HasListEmbed)
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 HasListEmbed
forall {backend}. HasListEmbedGeneric backend
container
        Just Entity HasListEmbed
res <- [Filter HasListEmbed]
-> [SelectOpt HasListEmbed]
-> ReaderT SqlBackend m (Maybe (Entity HasListEmbed))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField HasListEmbed Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasListEmbedGeneric backend) typ
HasListEmbedName EntityField HasListEmbed Text -> Text -> Filter HasListEmbed
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"list"] []
        Entity HasListEmbed
res Entity HasListEmbed
-> Entity HasListEmbed -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key HasListEmbed -> HasListEmbed -> Entity HasListEmbed
forall record. Key record -> record -> Entity record
Entity Key HasListEmbed
contK HasListEmbed
forall {backend}. HasListEmbedGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"ListEmbed empty" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: HasListEmbedGeneric backend
container = Text -> [HasEmbed] -> HasListEmbedGeneric backend
forall backend. Text -> [HasEmbed] -> HasListEmbedGeneric backend
HasListEmbed Text
"list empty" []
        Key HasListEmbed
contK <- HasListEmbed -> ReaderT SqlBackend m (Key HasListEmbed)
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 HasListEmbed
forall {backend}. HasListEmbedGeneric backend
container
        Just Entity HasListEmbed
res <- [Filter HasListEmbed]
-> [SelectOpt HasListEmbed]
-> ReaderT SqlBackend m (Maybe (Entity HasListEmbed))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField HasListEmbed Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasListEmbedGeneric backend) typ
HasListEmbedName EntityField HasListEmbed Text -> Text -> Filter HasListEmbed
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"list empty"] []
        Entity HasListEmbed
res Entity HasListEmbed
-> Entity HasListEmbed -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key HasListEmbed -> HasListEmbed -> Entity HasListEmbed
forall record. Key record -> record -> Entity record
Entity Key HasListEmbed
contK HasListEmbed
forall {backend}. HasListEmbedGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"List empty" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: HasListGeneric backend
container = [HasListId] -> HasListGeneric backend
forall backend. [HasListId] -> HasListGeneric backend
HasList []
        HasListId
contK <- HasList -> ReaderT SqlBackend m HasListId
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 HasList
forall {backend}. HasListGeneric backend
container
        Just Entity HasList
res <- [Filter HasList]
-> [SelectOpt HasList]
-> ReaderT SqlBackend m (Maybe (Entity HasList))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [] []
        Entity HasList
res Entity HasList -> Entity HasList -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== HasListId -> HasList -> Entity HasList
forall record. Key record -> record -> Entity record
Entity HasListId
contK HasList
forall {backend}. HasListGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"NonEmpty List wrapper" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            con :: ContactGeneric backend
con = Int -> Text -> ContactGeneric backend
forall backend. Int -> Text -> ContactGeneric backend
Contact Int
123456 Text
"foo@bar.com"
        let
            prof :: ProfileGeneric backend
prof = Text -> Text -> Maybe Contact -> ProfileGeneric backend
forall backend.
Text -> Text -> Maybe Contact -> ProfileGeneric backend
Profile Text
"fstN" Text
"lstN" (Contact -> Maybe Contact
forall a. a -> Maybe a
Just Contact
forall {backend}. ContactGeneric backend
con)
        Key User
uid <- User -> ReaderT SqlBackend m (Key User)
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 (User -> ReaderT SqlBackend m (Key User))
-> User -> ReaderT SqlBackend m (Key User)
forall a b. (a -> b) -> a -> b
$ Text -> Maybe Text -> Profile -> User
forall backend.
Text -> Maybe Text -> Profile -> UserGeneric backend
User Text
"foo" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"pswd") Profile
forall {backend}. ProfileGeneric backend
prof
        let
            container :: Account
container = NonEmpty (Key User) -> Maybe Text -> [Text] -> Account
forall backend.
NonEmpty (Key User)
-> Maybe Text -> [Text] -> AccountGeneric backend
Account (Key User
uid Key User -> [Key User] -> NonEmpty (Key User)
forall a. a -> [a] -> NonEmpty a
:| []) (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"Account") []
        Key Account
contK <- Account -> ReaderT SqlBackend m (Key Account)
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 Account
container
        Just Entity Account
res <- [Filter Account]
-> [SelectOpt Account]
-> ReaderT SqlBackend m (Maybe (Entity Account))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField Account (NonEmpty (Key User))
forall backend typ.
(typ ~ NonEmpty (Key User)) =>
EntityField (AccountGeneric backend) typ
AccountUserIds EntityField Account (NonEmpty (Key User))
-> NonEmpty (Key User) -> Filter Account
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. (Key User
uid Key User -> [Key User] -> NonEmpty (Key User)
forall a. a -> [a] -> NonEmpty a
:| [])] []
        Entity Account
res Entity Account -> Entity Account -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key Account -> Account -> Entity Account
forall record. Key record -> record -> Entity record
Entity Key Account
contK Account
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Map" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: HasMapGeneric backend
container =
                Text -> Map Text Text -> HasMapGeneric backend
forall backend. Text -> Map Text Text -> HasMapGeneric backend
HasMap Text
"2 items" (Map Text Text -> HasMapGeneric backend)
-> Map Text Text -> HasMapGeneric backend
forall a b. (a -> b) -> a -> b
$
                    [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
                        [ (Text
"k1", Text
"v1")
                        , (Text
"k2", Text
"v2")
                        ]
        Key HasMap
contK <- HasMap -> ReaderT SqlBackend m (Key HasMap)
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 HasMap
forall {backend}. HasMapGeneric backend
container
        Just Entity HasMap
res <- [Filter HasMap]
-> [SelectOpt HasMap]
-> ReaderT SqlBackend m (Maybe (Entity HasMap))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField HasMap Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasMapGeneric backend) typ
HasMapName EntityField HasMap Text -> Text -> Filter HasMap
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"2 items"] []
        Entity HasMap
res Entity HasMap -> Entity HasMap -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key HasMap -> HasMap -> Entity HasMap
forall record. Key record -> record -> Entity record
Entity Key HasMap
contK HasMap
forall {backend}. HasMapGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Map empty" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: HasMapGeneric backend
container = Text -> Map Text Text -> HasMapGeneric backend
forall backend. Text -> Map Text Text -> HasMapGeneric backend
HasMap Text
"empty" (Map Text Text -> HasMapGeneric backend)
-> Map Text Text -> HasMapGeneric backend
forall a b. (a -> b) -> a -> b
$ [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList []
        Key HasMap
contK <- HasMap -> ReaderT SqlBackend m (Key HasMap)
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 HasMap
forall {backend}. HasMapGeneric backend
container
        Just Entity HasMap
res <- [Filter HasMap]
-> [SelectOpt HasMap]
-> ReaderT SqlBackend m (Maybe (Entity HasMap))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField HasMap Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasMapGeneric backend) typ
HasMapName EntityField HasMap Text -> Text -> Filter HasMap
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"empty"] []
        Entity HasMap
res Entity HasMap -> Entity HasMap -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key HasMap -> HasMap -> Entity HasMap
forall record. Key record -> record -> Entity record
Entity Key HasMap
contK HasMap
forall {backend}. HasMapGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Embeds a Map" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: EmbedsHasMapGeneric backend
container =
                Maybe Text -> HasMap -> EmbedsHasMapGeneric backend
forall backend. Maybe Text -> HasMap -> EmbedsHasMapGeneric backend
EmbedsHasMap (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"non-empty map") (HasMap -> EmbedsHasMapGeneric backend)
-> HasMap -> EmbedsHasMapGeneric backend
forall a b. (a -> b) -> a -> b
$
                    Text -> Map Text Text -> HasMap
forall backend. Text -> Map Text Text -> HasMapGeneric backend
HasMap Text
"2 items" (Map Text Text -> HasMap) -> Map Text Text -> HasMap
forall a b. (a -> b) -> a -> b
$
                        [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
                            [ (Text
"k1", Text
"v1")
                            , (Text
"k2", Text
"v2")
                            ]
        Key EmbedsHasMap
contK <- EmbedsHasMap -> ReaderT SqlBackend m (Key EmbedsHasMap)
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 EmbedsHasMap
forall {backend}. EmbedsHasMapGeneric backend
container
        Just Entity EmbedsHasMap
res <- [Filter EmbedsHasMap]
-> [SelectOpt EmbedsHasMap]
-> ReaderT SqlBackend m (Maybe (Entity EmbedsHasMap))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField EmbedsHasMap (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (EmbedsHasMapGeneric backend) typ
EmbedsHasMapName EntityField EmbedsHasMap (Maybe Text)
-> Maybe Text -> Filter EmbedsHasMap
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"non-empty map"] []
        Entity EmbedsHasMap
res Entity EmbedsHasMap
-> Entity EmbedsHasMap -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key EmbedsHasMap -> EmbedsHasMap -> Entity EmbedsHasMap
forall record. Key record -> record -> Entity record
Entity Key EmbedsHasMap
contK EmbedsHasMap
forall {backend}. EmbedsHasMapGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Embeds a Map empty" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        let
            container :: EmbedsHasMapGeneric backend
container = Maybe Text -> HasMap -> EmbedsHasMapGeneric backend
forall backend. Maybe Text -> HasMap -> EmbedsHasMapGeneric backend
EmbedsHasMap (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"empty map") (HasMap -> EmbedsHasMapGeneric backend)
-> HasMap -> EmbedsHasMapGeneric backend
forall a b. (a -> b) -> a -> b
$ Text -> Map Text Text -> HasMap
forall backend. Text -> Map Text Text -> HasMapGeneric backend
HasMap Text
"empty" (Map Text Text -> HasMap) -> Map Text Text -> HasMap
forall a b. (a -> b) -> a -> b
$ [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList []
        Key EmbedsHasMap
contK <- EmbedsHasMap -> ReaderT SqlBackend m (Key EmbedsHasMap)
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 EmbedsHasMap
forall {backend}. EmbedsHasMapGeneric backend
container
        Just Entity EmbedsHasMap
res <- [Filter EmbedsHasMap]
-> [SelectOpt EmbedsHasMap]
-> ReaderT SqlBackend m (Maybe (Entity EmbedsHasMap))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
forall (m :: * -> *) record.
(MonadIO m, PersistRecordBackend record SqlBackend) =>
[Filter record]
-> [SelectOpt record]
-> ReaderT SqlBackend m (Maybe (Entity record))
selectFirst [EntityField EmbedsHasMap (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (EmbedsHasMapGeneric backend) typ
EmbedsHasMapName EntityField EmbedsHasMap (Maybe Text)
-> Maybe Text -> Filter EmbedsHasMap
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"empty map"] []
        Entity EmbedsHasMap
res Entity EmbedsHasMap
-> Entity EmbedsHasMap -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key EmbedsHasMap -> EmbedsHasMap -> Entity EmbedsHasMap
forall record. Key record -> record -> Entity record
Entity Key EmbedsHasMap
contK EmbedsHasMap
forall {backend}. EmbedsHasMapGeneric backend
container

    String -> IO () -> SpecWith (Arg (IO ()))
forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
it String
"Embeds a Map with ids as values" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ RunDb SqlBackend m
runDb RunDb SqlBackend m -> RunDb SqlBackend m
forall a b. (a -> b) -> a -> b
$ do
        Key OnlyName
onId <- OnlyName -> ReaderT SqlBackend m (Key OnlyName)
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 (OnlyName -> ReaderT SqlBackend m (Key OnlyName))
-> OnlyName -> ReaderT SqlBackend m (Key OnlyName)
forall a b. (a -> b) -> a -> b
$ Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"nombre"
        Key OnlyName
onId2 <- OnlyName -> ReaderT SqlBackend m (Key OnlyName)
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 (OnlyName -> ReaderT SqlBackend m (Key OnlyName))
-> OnlyName -> ReaderT SqlBackend m (Key OnlyName)
forall a b. (a -> b) -> a -> b
$ Text -> OnlyName
forall backend. Text -> OnlyNameGeneric backend
OnlyName Text
"nombre2"
        let
            midValue :: MapIdValue
midValue = Map Text (Key OnlyName) -> MapIdValue
forall backend.
Map Text (Key OnlyName) -> MapIdValueGeneric backend
MapIdValue (Map Text (Key OnlyName) -> MapIdValue)
-> Map Text (Key OnlyName) -> MapIdValue
forall a b. (a -> b) -> a -> b
$ [(Text, Key OnlyName)] -> Map Text (Key OnlyName)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [(Text
"foo", Key OnlyName
onId), (Text
"bar", Key OnlyName
onId2)]
        Key MapIdValue
mK <- MapIdValue -> ReaderT SqlBackend m (Key MapIdValue)
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 MapIdValue
midValue
        Just MapIdValue
mv <- Key MapIdValue -> ReaderT SqlBackend m (Maybe MapIdValue)
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
forall record (m :: * -> *).
(MonadIO m, PersistRecordBackend record SqlBackend) =>
Key record -> ReaderT SqlBackend m (Maybe record)
get Key MapIdValue
mK
        MapIdValue
mv MapIdValue -> MapIdValue -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== MapIdValue
midValue