{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -Wno-unused-top-binds #-}
module MigrationOnlyTest (specsWith, migrateAll1, migrateAll2) where

import qualified Data.Text as T

import Database.Persist.TH
import Init

share [mkPersist sqlSettings { mpsGeneric = True }, mkMigrate "migrateAll1"] [persistLowerCase|
TwoField1 sql=two_field
    field1 Int
    field2 T.Text
    field3 Bool Maybe
    deriving Eq Show
|]

share [mkPersist sqlSettings { mpsGeneric = True }, mkMigrate "migrateAll2", mkDeleteCascade sqlSettings] [persistLowerCase|
TwoField
    field1 Int
    field2 T.Text
    field3 Bool Maybe MigrationOnly
    deriving Eq Show

Referencing
    field1 Int
    field2 TwoFieldId MigrationOnly
|]

specsWith
    :: (MonadIO m, PersistQueryWrite backend, PersistStoreWrite backend, PersistQueryWrite (BaseBackend backend))
    => RunDb backend m
    -> Maybe (ReaderT backend m a)
    -> Spec
specsWith :: RunDb backend m -> Maybe (ReaderT backend m a) -> Spec
specsWith RunDb backend m
runDb Maybe (ReaderT backend m a)
mmigrate = String -> Spec -> Spec
forall a. HasCallStack => String -> SpecWith a -> SpecWith a
describe String
"MigrationOnly field" (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
"doesn't have the field in the Haskell entity" (IO () -> SpecWith (Arg (IO ())))
-> IO () -> SpecWith (Arg (IO ()))
forall a b. (a -> b) -> a -> b
$ IO () -> IO ()
forall a. IO a -> IO a
asIO (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ RunDb backend m
runDb RunDb backend m -> RunDb backend m
forall a b. (a -> b) -> a -> b
$ do
        Maybe (ReaderT backend m a) -> ReaderT backend m ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ Maybe (ReaderT backend m a)
mmigrate
        Maybe (ReaderT backend m a) -> ReaderT backend m ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ Maybe (ReaderT backend m a)
mmigrate
        let tf :: TwoFieldGeneric backend
tf = Int -> Text -> TwoFieldGeneric backend
forall backend. Int -> Text -> TwoFieldGeneric backend
TwoField Int
5 Text
"hello"
        Key (TwoFieldGeneric (BaseBackend backend))
tid <- TwoFieldGeneric (BaseBackend backend)
-> ReaderT backend m (Key (TwoFieldGeneric (BaseBackend backend)))
forall backend record (m :: * -> *).
(PersistStoreWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
record -> ReaderT backend m (Key record)
insert TwoFieldGeneric (BaseBackend backend)
forall backend. TwoFieldGeneric backend
tf
        Maybe (TwoFieldGeneric (BaseBackend backend))
mtf <- Key (TwoFieldGeneric (BaseBackend backend))
-> ReaderT
     backend m (Maybe (TwoFieldGeneric (BaseBackend backend)))
forall backend record (m :: * -> *).
(PersistStoreRead backend, MonadIO m,
 PersistRecordBackend record backend) =>
Key record -> ReaderT backend m (Maybe record)
get Key (TwoFieldGeneric (BaseBackend backend))
tid
        IO () -> ReaderT backend m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> ReaderT backend m ()) -> IO () -> ReaderT backend m ()
forall a b. (a -> b) -> a -> b
$ Maybe (TwoFieldGeneric (BaseBackend backend))
mtf Maybe (TwoFieldGeneric (BaseBackend backend))
-> Maybe (TwoFieldGeneric (BaseBackend backend)) -> IO ()
forall a. (HasCallStack, Eq a, Show a) => a -> a -> IO ()
@?= TwoFieldGeneric (BaseBackend backend)
-> Maybe (TwoFieldGeneric (BaseBackend backend))
forall a. a -> Maybe a
Just TwoFieldGeneric (BaseBackend backend)
forall backend. TwoFieldGeneric backend
tf
        [Filter (TwoFieldGeneric (BaseBackend backend))]
-> ReaderT backend m ()
forall backend (m :: * -> *) record.
(PersistQueryWrite backend, MonadIO m,
 PersistRecordBackend record backend) =>
[Filter record] -> ReaderT backend m ()
deleteWhere ([] :: [Filter (TwoFieldGeneric backend)])