{-# 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.Text as T
import qualified Data.Set as S

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
showList :: [TestException] -> ShowS
$cshowList :: [TestException] -> ShowS
show :: TestException -> String
$cshow :: TestException -> String
showsPrec :: Int -> TestException -> ShowS
$cshowsPrec :: Int -> TestException -> ShowS
Show, TestException -> TestException -> Bool
(TestException -> TestException -> Bool)
-> (TestException -> TestException -> Bool) -> Eq TestException
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TestException -> TestException -> Bool
$c/= :: TestException -> TestException -> Bool
== :: TestException -> TestException -> Bool
$c== :: 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
la -> [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 :: 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 ()
deleteWhere ([] :: [Filter (HasEmbedGeneric backend)])
  [Filter (HasEmbedsGeneric SqlBackend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (HasEmbedsGeneric backend)])
  [Filter (HasListEmbedGeneric SqlBackend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (HasListEmbedGeneric backend)])
  [Filter (HasSetEmbedGeneric SqlBackend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, 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 ()
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 ()
deleteWhere ([] :: [Filter (HasMapGeneric backend)])
  [Filter (HasListGeneric SqlBackend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (HasListGeneric backend)])
  [Filter (EmbedsHasMapGeneric SqlBackend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (EmbedsHasMapGeneric backend)])
  [Filter (ListEmbedGeneric SqlBackend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, 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 ()
deleteWhere ([] :: [Filter (ARecordGeneric backend)])
  [Filter (AccountGeneric SqlBackend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (AccountGeneric backend)])
  [Filter (HasNestedListGeneric SqlBackend)] -> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (HasNestedListGeneric backend)])

_unlessM :: MonadIO m => IO Bool -> m () -> m ()
_unlessM :: IO Bool -> m () -> m ()
_unlessM IO Bool
predicate m ()
body = do
    Bool
b <- IO Bool -> m Bool
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 :: 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 (HasEmbedsGeneric SqlBackend)
contK <- HasEmbedsGeneric SqlBackend
-> ReaderT SqlBackend m (Key (HasEmbedsGeneric SqlBackend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert HasEmbedsGeneric SqlBackend
forall backend. HasEmbedsGeneric backend
container
      Just Entity (HasEmbedsGeneric SqlBackend)
res <- [Filter (HasEmbedsGeneric SqlBackend)]
-> [SelectOpt (HasEmbedsGeneric SqlBackend)]
-> ReaderT
     SqlBackend m (Maybe (Entity (HasEmbedsGeneric SqlBackend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (HasEmbedsGeneric SqlBackend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasEmbedsGeneric backend) typ
HasEmbedsName EntityField (HasEmbedsGeneric SqlBackend) Text
-> Text -> Filter (HasEmbedsGeneric SqlBackend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"container"] []
      Entity (HasEmbedsGeneric SqlBackend)
res Entity (HasEmbedsGeneric SqlBackend)
-> Entity (HasEmbedsGeneric SqlBackend) -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (HasEmbedsGeneric SqlBackend)
-> HasEmbedsGeneric SqlBackend
-> Entity (HasEmbedsGeneric SqlBackend)
forall record. Key record -> record -> Entity record
Entity Key (HasEmbedsGeneric SqlBackend)
contK HasEmbedsGeneric SqlBackend
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) =>
record -> ReaderT backend 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))
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 (HasSetEmbedGeneric SqlBackend)
contK <- HasSetEmbedGeneric SqlBackend
-> ReaderT SqlBackend m (Key (HasSetEmbedGeneric SqlBackend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert HasSetEmbedGeneric SqlBackend
forall backend. HasSetEmbedGeneric backend
container
      Just Entity (HasSetEmbedGeneric SqlBackend)
res <- [Filter (HasSetEmbedGeneric SqlBackend)]
-> [SelectOpt (HasSetEmbedGeneric SqlBackend)]
-> ReaderT
     SqlBackend m (Maybe (Entity (HasSetEmbedGeneric SqlBackend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (HasSetEmbedGeneric SqlBackend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasSetEmbedGeneric backend) typ
HasSetEmbedName EntityField (HasSetEmbedGeneric SqlBackend) Text
-> Text -> Filter (HasSetEmbedGeneric SqlBackend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"set"] []
      Entity (HasSetEmbedGeneric SqlBackend)
res Entity (HasSetEmbedGeneric SqlBackend)
-> Entity (HasSetEmbedGeneric SqlBackend)
-> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (HasSetEmbedGeneric SqlBackend)
-> HasSetEmbedGeneric SqlBackend
-> Entity (HasSetEmbedGeneric SqlBackend)
forall record. Key record -> record -> Entity record
Entity Key (HasSetEmbedGeneric SqlBackend)
contK HasSetEmbedGeneric SqlBackend
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 (HasSetEmbedGeneric SqlBackend)
contK <- HasSetEmbedGeneric SqlBackend
-> ReaderT SqlBackend m (Key (HasSetEmbedGeneric SqlBackend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert HasSetEmbedGeneric SqlBackend
forall backend. HasSetEmbedGeneric backend
container
      Just Entity (HasSetEmbedGeneric SqlBackend)
res <- [Filter (HasSetEmbedGeneric SqlBackend)]
-> [SelectOpt (HasSetEmbedGeneric SqlBackend)]
-> ReaderT
     SqlBackend m (Maybe (Entity (HasSetEmbedGeneric SqlBackend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (HasSetEmbedGeneric SqlBackend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasSetEmbedGeneric backend) typ
HasSetEmbedName EntityField (HasSetEmbedGeneric SqlBackend) Text
-> Text -> Filter (HasSetEmbedGeneric SqlBackend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"set empty"] []
      Entity (HasSetEmbedGeneric SqlBackend)
res Entity (HasSetEmbedGeneric SqlBackend)
-> Entity (HasSetEmbedGeneric SqlBackend)
-> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (HasSetEmbedGeneric SqlBackend)
-> HasSetEmbedGeneric SqlBackend
-> Entity (HasSetEmbedGeneric SqlBackend)
forall record. Key record -> record -> Entity record
Entity Key (HasSetEmbedGeneric SqlBackend)
contK HasSetEmbedGeneric SqlBackend
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 (HasSetEmbedGeneric SqlBackend)
contK <- HasSetEmbedGeneric SqlBackend
-> ReaderT SqlBackend m (Key (HasSetEmbedGeneric SqlBackend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert HasSetEmbedGeneric SqlBackend
forall backend. HasSetEmbedGeneric backend
container
      Just Entity (HasSetEmbedGeneric SqlBackend)
res <- [Filter (HasSetEmbedGeneric SqlBackend)]
-> [SelectOpt (HasSetEmbedGeneric SqlBackend)]
-> ReaderT
     SqlBackend m (Maybe (Entity (HasSetEmbedGeneric SqlBackend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (HasSetEmbedGeneric SqlBackend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasSetEmbedGeneric backend) typ
HasSetEmbedName EntityField (HasSetEmbedGeneric SqlBackend) Text
-> Text -> Filter (HasSetEmbedGeneric SqlBackend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. TestException -> Text
forall a e. Exception e => e -> a
throw TestException
TestException] []
      Entity (HasSetEmbedGeneric SqlBackend)
res Entity (HasSetEmbedGeneric SqlBackend)
-> Entity (HasSetEmbedGeneric SqlBackend)
-> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (HasSetEmbedGeneric SqlBackend)
-> HasSetEmbedGeneric SqlBackend
-> Entity (HasSetEmbedGeneric SqlBackend)
forall record. Key record -> record -> Entity record
Entity Key (HasSetEmbedGeneric SqlBackend)
contK HasSetEmbedGeneric SqlBackend
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 (HasListEmbedGeneric SqlBackend)
contK <- HasListEmbedGeneric SqlBackend
-> ReaderT SqlBackend m (Key (HasListEmbedGeneric SqlBackend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert HasListEmbedGeneric SqlBackend
forall backend. HasListEmbedGeneric backend
container
      Just Entity (HasListEmbedGeneric SqlBackend)
res <- [Filter (HasListEmbedGeneric SqlBackend)]
-> [SelectOpt (HasListEmbedGeneric SqlBackend)]
-> ReaderT
     SqlBackend m (Maybe (Entity (HasListEmbedGeneric SqlBackend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (HasListEmbedGeneric SqlBackend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasListEmbedGeneric backend) typ
HasListEmbedName EntityField (HasListEmbedGeneric SqlBackend) Text
-> Text -> Filter (HasListEmbedGeneric SqlBackend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"list"] []
      Entity (HasListEmbedGeneric SqlBackend)
res Entity (HasListEmbedGeneric SqlBackend)
-> Entity (HasListEmbedGeneric SqlBackend)
-> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (HasListEmbedGeneric SqlBackend)
-> HasListEmbedGeneric SqlBackend
-> Entity (HasListEmbedGeneric SqlBackend)
forall record. Key record -> record -> Entity record
Entity Key (HasListEmbedGeneric SqlBackend)
contK HasListEmbedGeneric SqlBackend
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 (HasListEmbedGeneric SqlBackend)
contK <- HasListEmbedGeneric SqlBackend
-> ReaderT SqlBackend m (Key (HasListEmbedGeneric SqlBackend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert HasListEmbedGeneric SqlBackend
forall backend. HasListEmbedGeneric backend
container
      Just Entity (HasListEmbedGeneric SqlBackend)
res <- [Filter (HasListEmbedGeneric SqlBackend)]
-> [SelectOpt (HasListEmbedGeneric SqlBackend)]
-> ReaderT
     SqlBackend m (Maybe (Entity (HasListEmbedGeneric SqlBackend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (HasListEmbedGeneric SqlBackend) Text
forall backend typ.
(typ ~ Text) =>
EntityField (HasListEmbedGeneric backend) typ
HasListEmbedName EntityField (HasListEmbedGeneric SqlBackend) Text
-> Text -> Filter (HasListEmbedGeneric SqlBackend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text
"list empty"] []
      Entity (HasListEmbedGeneric SqlBackend)
res Entity (HasListEmbedGeneric SqlBackend)
-> Entity (HasListEmbedGeneric SqlBackend)
-> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (HasListEmbedGeneric SqlBackend)
-> HasListEmbedGeneric SqlBackend
-> Entity (HasListEmbedGeneric SqlBackend)
forall record. Key record -> record -> Entity record
Entity Key (HasListEmbedGeneric SqlBackend)
contK HasListEmbedGeneric SqlBackend
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 <- HasListGeneric SqlBackend -> ReaderT SqlBackend m HasListId
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert HasListGeneric SqlBackend
forall backend. HasListGeneric backend
container
      Just Entity (HasListGeneric SqlBackend)
res <- [Filter (HasListGeneric SqlBackend)]
-> [SelectOpt (HasListGeneric SqlBackend)]
-> ReaderT
     SqlBackend m (Maybe (Entity (HasListGeneric SqlBackend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [] []
      Entity (HasListGeneric SqlBackend)
res Entity (HasListGeneric SqlBackend)
-> Entity (HasListGeneric SqlBackend) -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== HasListId
-> HasListGeneric SqlBackend -> Entity (HasListGeneric SqlBackend)
forall record. Key record -> record -> Entity record
Entity HasListId
contK HasListGeneric SqlBackend
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) =>
record -> ReaderT backend 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 :: AccountGeneric SqlBackend
container = NonEmpty (Key User)
-> Maybe Text -> [Text] -> AccountGeneric SqlBackend
forall backend.
NonEmpty (Key User)
-> Maybe Text -> [Text] -> AccountGeneric backend
Account (Key User
uidKey User -> [Key User] -> NonEmpty (Key User)
forall a. a -> [a] -> NonEmpty a
:|[]) (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"Account") []
      Key (AccountGeneric SqlBackend)
contK <- AccountGeneric SqlBackend
-> ReaderT SqlBackend m (Key (AccountGeneric SqlBackend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert AccountGeneric SqlBackend
container
      Just Entity (AccountGeneric SqlBackend)
res <- [Filter (AccountGeneric SqlBackend)]
-> [SelectOpt (AccountGeneric SqlBackend)]
-> ReaderT
     SqlBackend m (Maybe (Entity (AccountGeneric SqlBackend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (AccountGeneric SqlBackend) (NonEmpty (Key User))
forall backend typ.
(typ ~ NonEmpty (Key User)) =>
EntityField (AccountGeneric backend) typ
AccountUserIds EntityField (AccountGeneric SqlBackend) (NonEmpty (Key User))
-> NonEmpty (Key User) -> Filter (AccountGeneric SqlBackend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. (Key User
uidKey User -> [Key User] -> NonEmpty (Key User)
forall a. a -> [a] -> NonEmpty a
:|[])] []
      Entity (AccountGeneric SqlBackend)
res Entity (AccountGeneric SqlBackend)
-> Entity (AccountGeneric SqlBackend) -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (AccountGeneric SqlBackend)
-> AccountGeneric SqlBackend -> Entity (AccountGeneric SqlBackend)
forall record. Key record -> record -> Entity record
Entity Key (AccountGeneric SqlBackend)
contK AccountGeneric SqlBackend
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) =>
record -> ReaderT backend 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))
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) =>
record -> ReaderT backend 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))
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 (EmbedsHasMapGeneric SqlBackend)
contK <- EmbedsHasMapGeneric SqlBackend
-> ReaderT SqlBackend m (Key (EmbedsHasMapGeneric SqlBackend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert EmbedsHasMapGeneric SqlBackend
forall backend. EmbedsHasMapGeneric backend
container
      Just Entity (EmbedsHasMapGeneric SqlBackend)
res <- [Filter (EmbedsHasMapGeneric SqlBackend)]
-> [SelectOpt (EmbedsHasMapGeneric SqlBackend)]
-> ReaderT
     SqlBackend m (Maybe (Entity (EmbedsHasMapGeneric SqlBackend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (EmbedsHasMapGeneric SqlBackend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (EmbedsHasMapGeneric backend) typ
EmbedsHasMapName EntityField (EmbedsHasMapGeneric SqlBackend) (Maybe Text)
-> Maybe Text -> Filter (EmbedsHasMapGeneric SqlBackend)
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 (EmbedsHasMapGeneric SqlBackend)
res Entity (EmbedsHasMapGeneric SqlBackend)
-> Entity (EmbedsHasMapGeneric SqlBackend)
-> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (EmbedsHasMapGeneric SqlBackend)
-> EmbedsHasMapGeneric SqlBackend
-> Entity (EmbedsHasMapGeneric SqlBackend)
forall record. Key record -> record -> Entity record
Entity Key (EmbedsHasMapGeneric SqlBackend)
contK EmbedsHasMapGeneric SqlBackend
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 (EmbedsHasMapGeneric SqlBackend)
contK <- EmbedsHasMapGeneric SqlBackend
-> ReaderT SqlBackend m (Key (EmbedsHasMapGeneric SqlBackend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert EmbedsHasMapGeneric SqlBackend
forall backend. EmbedsHasMapGeneric backend
container
      Just Entity (EmbedsHasMapGeneric SqlBackend)
res <- [Filter (EmbedsHasMapGeneric SqlBackend)]
-> [SelectOpt (EmbedsHasMapGeneric SqlBackend)]
-> ReaderT
     SqlBackend m (Maybe (Entity (EmbedsHasMapGeneric SqlBackend)))
forall backend (m :: * -> *) record.
(PersistQueryRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record]
-> [SelectOpt record] -> ReaderT backend m (Maybe (Entity record))
selectFirst [EntityField (EmbedsHasMapGeneric SqlBackend) (Maybe Text)
forall backend typ.
(typ ~ Maybe Text) =>
EntityField (EmbedsHasMapGeneric backend) typ
EmbedsHasMapName EntityField (EmbedsHasMapGeneric SqlBackend) (Maybe Text)
-> Maybe Text -> Filter (EmbedsHasMapGeneric SqlBackend)
forall v typ.
PersistField typ =>
EntityField v typ -> typ -> Filter v
==. Text -> Maybe Text
forall a. a -> Maybe a
Just Text
"empty map"] []
      Entity (EmbedsHasMapGeneric SqlBackend)
res Entity (EmbedsHasMapGeneric SqlBackend)
-> Entity (EmbedsHasMapGeneric SqlBackend)
-> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== Key (EmbedsHasMapGeneric SqlBackend)
-> EmbedsHasMapGeneric SqlBackend
-> Entity (EmbedsHasMapGeneric SqlBackend)
forall record. Key record -> record -> Entity record
Entity Key (EmbedsHasMapGeneric SqlBackend)
contK EmbedsHasMapGeneric SqlBackend
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) =>
record -> ReaderT backend 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) =>
record -> ReaderT backend 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 :: MapIdValueGeneric SqlBackend
midValue = Map Text (Key OnlyName) -> MapIdValueGeneric SqlBackend
forall backend.
Map Text (Key OnlyName) -> MapIdValueGeneric backend
MapIdValue (Map Text (Key OnlyName) -> MapIdValueGeneric SqlBackend)
-> Map Text (Key OnlyName) -> MapIdValueGeneric SqlBackend
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 (MapIdValueGeneric SqlBackend)
mK <- MapIdValueGeneric SqlBackend
-> ReaderT SqlBackend m (Key (MapIdValueGeneric SqlBackend))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert MapIdValueGeneric SqlBackend
midValue
      Just MapIdValueGeneric SqlBackend
mv <- Key (MapIdValueGeneric SqlBackend)
-> ReaderT SqlBackend m (Maybe (MapIdValueGeneric SqlBackend))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (MapIdValueGeneric SqlBackend)
mK
      MapIdValueGeneric SqlBackend
mv MapIdValueGeneric SqlBackend
-> MapIdValueGeneric SqlBackend -> ReaderT SqlBackend m ()
forall a (m :: * -> *).
(HasCallStack, Eq a, Show a, MonadIO m) =>
a -> a -> m ()
@== MapIdValueGeneric SqlBackend
midValue