Safe Haskell | None |
---|---|
Language | Haskell2010 |
Michelson contracts testing on a real Tezos network.
See the documentation for usage instructions.
Synopsis
- data AliasHint
- data ContractHandle (cp :: Type) (st :: Type) (vd :: Type) = (NiceParameter cp, NiceStorage st, NiceViewsDescriptor vd) => ContractHandle {
- chContractName :: Text
- chAddress :: Address
- data OriginateData param st vd = OriginateData {
- odName :: AliasHint
- odBalance :: Mutez
- odStorage :: st
- odContract :: Contract param st vd
- data UntypedOriginateData = UntypedOriginateData {
- uodName :: AliasHint
- uodBalance :: Mutez
- uodStorage :: Value
- uodContract :: Contract
- data TransferData = forall v addr.(NiceParameter v, ToAddress addr) => TransferData {
- tdTo :: addr
- tdAmount :: Mutez
- tdEntrypoint :: EpName
- tdParameter :: v
- data Scenario m
- data PureM a
- data TransferFailure
- testScenario :: TestName -> (forall m. MonadFail m => Scenario m) -> TestTree
- testScenarioOnNetwork :: TestName -> Scenario ClientM -> TestTree
- scenario :: ClevelandT m () -> Scenario m
- testScenarioOnEmulator :: TestName -> Scenario PureM -> TestTree
- scenarioEmulated :: EmulatedT PureM () -> Scenario PureM
- withInitialNow :: Timestamp -> Scenario PureM -> Scenario PureM
- withInitialLevel :: Natural -> Scenario PureM -> Scenario PureM
- collectLogs :: LogsInfo -> MorleyLogs
- logsForAddress :: (Each s s ScenarioLogs ScenarioLogs, ToAddress addr) => addr -> s -> [MorleyLogs]
- type MonadCleveland caps m = (m ~ ReaderT caps (ClevelandBaseMonad caps), HasClevelandCaps caps)
- class Functor m => MonadOps m
- type MonadEmulated caps m = (MonadCleveland caps m, HasEmulatedCaps caps)
- type ClevelandT m = ReaderT (ClevelandCaps m) m
- type EmulatedT m = ReaderT (EmulatedCaps m) m
- withSender :: MonadCleveland caps m => Address -> m a -> m a
- withMoneybag :: MonadCleveland caps m => Address -> m a -> m a
- runIO :: (HasCallStack, MonadCleveland caps m) => IO res -> m res
- resolveAddress :: (HasCallStack, MonadCleveland caps m) => AliasHint -> m Address
- refillable :: MonadCleveland caps m => m Address -> m Address
- newAddress :: (HasCallStack, MonadCleveland caps m) => SpecificOrDefaultAliasHint -> m Address
- newFreshAddress :: (HasCallStack, MonadCleveland caps m) => SpecificOrDefaultAliasHint -> m Address
- enumAliasHints :: forall n n'. (SingIPeano n, IsoNatPeano n n') => AliasHint -> SizedList n SpecificOrDefaultAliasHint
- signBytes :: (HasCallStack, MonadCleveland caps m) => ByteString -> Address -> m Signature
- signBinary :: (HasCallStack, BytesLike bs, MonadCleveland caps m) => bs -> Address -> m (TSignature bs)
- originate :: forall cp st vd m. (HasCallStack, MonadOps m) => OriginateData cp st vd -> m (ContractHandle cp st vd)
- originateSimple :: forall cp st vd m. (HasCallStack, MonadOps m) => AliasHint -> st -> Contract cp st vd -> m (ContractHandle cp st vd)
- originateUntyped :: (HasCallStack, MonadOps m) => UntypedOriginateData -> m Address
- originateUntypedSimple :: (HasCallStack, MonadOps m) => AliasHint -> Value -> Contract -> m Address
- originateTypedSimple :: forall cp st vd m. (HasCallStack, MonadOps m, NiceParameter cp, NiceStorage st, NiceViewsDescriptor vd) => AliasHint -> st -> Contract (ToT cp) (ToT st) -> m (ContractHandle cp st vd)
- originateLarge :: forall param st vd m caps. (HasCallStack, MonadCleveland caps m) => OriginateData param st vd -> m (ContractHandle param st vd)
- originateLargeSimple :: forall param st vd m caps. (HasCallStack, MonadCleveland caps m) => AliasHint -> st -> Contract param st vd -> m (ContractHandle param st vd)
- originateLargeUntyped :: (HasCallStack, MonadCleveland caps m) => UntypedOriginateData -> m Address
- originateLargeUntypedSimple :: (HasCallStack, MonadCleveland caps m) => AliasHint -> Value -> Contract -> m Address
- transfer :: (HasCallStack, MonadOps m) => TransferData -> m ()
- transferMoney :: (HasCallStack, MonadOps m, ToAddress addr) => addr -> Mutez -> m ()
- call :: forall param vd addr m epRef epArg. (HasCallStack, MonadOps m, ToTAddress param vd addr, HasEntrypointArg param epRef epArg, IsoValue epArg, Typeable epArg) => addr -> epRef -> epArg -> m ()
- importUntypedContract :: (HasCallStack, MonadCleveland caps m) => FilePath -> m Contract
- importContract :: (HasCallStack, NiceParameter param, NiceStorage st, NiceViewsDescriptor vd, DemoteViewsDescriptor vd, MonadCleveland caps m) => FilePath -> m (Contract param st vd)
- noViews :: forall k1 k2 contract (cp :: k1) (st :: k2). contract cp st () -> contract cp st ()
- comment :: (HasCallStack, MonadCleveland caps m) => Text -> m ()
- getBalance :: (HasCallStack, MonadCleveland caps m, ToAddress addr) => addr -> m Mutez
- getDelegate :: (HasCallStack, MonadCleveland caps m, ToAddress addr) => addr -> m (Maybe KeyHash)
- registerDelegate :: (HasCallStack, MonadCleveland caps m, ToAddress addr) => addr -> m ()
- getMorleyLogs :: forall a caps m. MonadEmulated caps m => m a -> m (LogsInfo, a)
- getMorleyLogs_ :: MonadEmulated caps m => m () -> m LogsInfo
- getStorage :: forall st addr caps m. (HasCallStack, MonadCleveland caps m, ToStorageType st addr, IsoValue (AsRPC st)) => addr -> m (AsRPC st)
- getFullStorage :: forall st addr caps m. (HasCallStack, MonadEmulated caps m, ToStorageType st addr) => addr -> m st
- getSomeStorage :: forall addr caps m. (HasCallStack, MonadCleveland caps m, ToAddress addr) => addr -> m SomeAnnotatedValue
- getAllBigMapValues :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NiceUnpackedValue v) => BigMapId k v -> m [v]
- getAllBigMapValuesMaybe :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NiceUnpackedValue v) => BigMapId k v -> m (Maybe [v])
- getBigMapSize :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NiceUnpackedValue v) => BigMapId k v -> m Natural
- getBigMapSizeMaybe :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NiceUnpackedValue v) => BigMapId k v -> m (Maybe Natural)
- getBigMapValueMaybe :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NicePackedValue k, NiceUnpackedValue v) => BigMapId k v -> k -> m (Maybe v)
- getBigMapValue :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NicePackedValue k, NiceUnpackedValue v, Buildable k) => BigMapId k v -> k -> m v
- getPublicKey :: (HasCallStack, MonadCleveland caps m) => Address -> m PublicKey
- getChainId :: (HasCallStack, MonadCleveland caps m) => m ChainId
- advanceTime :: forall unit caps m. (HasCallStack, MonadCleveland caps m, KnownDivRat unit Second) => Time unit -> m ()
- advanceLevel :: forall caps m. (HasCallStack, MonadCleveland caps m) => Natural -> m ()
- advanceToLevel :: forall caps m. (HasCallStack, MonadCleveland caps m) => Natural -> m ()
- getNow :: (HasCallStack, MonadCleveland caps m) => m Timestamp
- getLevel :: (HasCallStack, MonadCleveland caps m) => m Natural
- getApproximateBlockInterval :: (HasCallStack, MonadCleveland caps m) => m (Time Second)
- data RunCode cp st vd = RunCode {
- rcContract :: Contract cp st vd
- rcStorage :: MaybeRPC st
- rcParameter :: MaybeRPC cp
- rcAmount :: Mutez
- rcBalance :: Mutez
- rcSource :: Maybe Address
- data MaybeRPC v where
- runCode :: (HasCallStack, MonadCleveland caps m, HasRPCRepr st, IsoValue (AsRPC st)) => RunCode cp st vd -> m (AsRPC st)
- branchout :: forall caps m. MonadEmulated caps m => [(Text, m ())] -> m ()
- offshoot :: forall caps m. MonadEmulated caps m => Text -> m () -> m ()
- setVotingPowers :: MonadEmulated caps m => VotingPowers -> m ()
- whenEmulation :: MonadCleveland caps m => (forall caps1 m1. (EqBaseMonad caps caps1, MonadEmulated caps1 m1) => m1 ()) -> m ()
- whenNetwork :: MonadCleveland caps m => (forall caps1 m1. (EqBaseMonad caps caps1, MonadCleveland caps1 m1) => m1 ()) -> m ()
- ifEmulation :: forall a caps m. MonadCleveland caps m => (forall caps1 m1. (EqBaseMonad caps caps1, MonadEmulated caps1 m1) => m1 a) -> (forall caps1 m1. (EqBaseMonad caps caps1, MonadCleveland caps1 m1) => m1 a) -> m a
- inBatch :: (HasCallStack, MonadCleveland caps m) => ClevelandOpsBatch a -> m a
- data EntrypointRef (mname :: Maybe Symbol) where
- CallDefault :: EntrypointRef ('Nothing :: Maybe Symbol)
- Call :: forall (name :: Symbol). NiceEntrypointName name => EntrypointRef ('Just name)
- data VotingPowers
- mkVotingPowers :: [(KeyHash, Natural)] -> VotingPowers
- mkVotingPowersFromMap :: Map KeyHash Natural -> VotingPowers
- failure :: forall a caps m. (HasCallStack, MonadCleveland caps m) => Builder -> m a
- assert :: (HasCallStack, MonadCleveland caps m) => Bool -> Builder -> m ()
- (@==) :: (HasCallStack, MonadCleveland caps m, Eq a, Buildable a) => a -> a -> m ()
- (@/=) :: (HasCallStack, MonadCleveland caps m, Eq a, Buildable a) => a -> a -> m ()
- (@@==) :: (HasCallStack, MonadCleveland caps m, Eq a, Buildable a) => m a -> a -> m ()
- (@@/=) :: (HasCallStack, MonadCleveland caps m, Eq a, Buildable a) => m a -> a -> m ()
- checkCompares :: forall a b caps m. (HasCallStack, MonadCleveland caps m, Buildable a, Buildable b) => a -> (a -> b -> Bool) -> b -> m ()
- checkComparesWith :: forall a b caps m. (HasCallStack, MonadCleveland caps m) => (a -> Text) -> a -> (a -> b -> Bool) -> (b -> Text) -> b -> m ()
- evalJust :: (HasCallStack, MonadCleveland caps m) => Builder -> Maybe a -> m a
- evalRight :: (HasCallStack, MonadCleveland caps m) => (a -> Builder) -> Either a b -> m b
- newtype Showing a = Showing a
- attempt :: forall e caps m a. (HasCallStack, MonadCleveland caps m, Exception e) => m a -> m (Either e a)
- catchTransferFailure :: (HasCallStack, MonadCleveland caps m) => m a -> m TransferFailure
- checkTransferFailure :: (HasCallStack, MonadCleveland caps m) => TransferFailure -> TransferFailurePredicate -> m ()
- expectTransferFailure :: (HasCallStack, MonadCleveland caps m) => TransferFailurePredicate -> m a -> m ()
- expectFailedWith :: forall err a caps m. (HasCallStack, MonadCleveland caps m, NiceConstant err) => err -> m a -> m ()
- expectError :: forall err a caps m. (HasCallStack, MonadCleveland caps m, IsError err) => err -> m a -> m ()
- expectCustomError :: forall arg a tag caps m. (HasCallStack, MonadCleveland caps m, IsError (CustomError tag), MustHaveErrorArg tag (MText, arg)) => Label tag -> arg -> m a -> m ()
- expectCustomError_ :: (HasCallStack, MonadCleveland caps m, IsError (CustomError tag), MustHaveErrorArg tag (MText, ())) => Label tag -> m a -> m ()
- expectCustomErrorNoArg :: (HasCallStack, MonadCleveland caps m, IsError (CustomError tag), MustHaveErrorArg tag MText) => Label tag -> m a -> m ()
- expectNumericError :: forall err a caps m. (HasCallStack, MonadCleveland caps m, IsError err) => ErrorTagMap -> err -> m a -> m ()
- clarifyErrors :: forall caps m a. MonadCleveland caps m => Builder -> m a -> m a
- data TransferFailurePredicate
- shiftOverflow :: TransferFailurePredicate
- emptyTransaction :: TransferFailurePredicate
- badParameter :: TransferFailurePredicate
- gasExhaustion :: TransferFailurePredicate
- failedWith :: SomeConstant -> TransferFailurePredicate
- addressIs :: ToAddress addr => addr -> TransferFailurePredicate
- constant :: forall err. NiceConstant err => err -> SomeConstant
- lerror :: forall err. IsError err => err -> SomeConstant
- customError :: forall arg tag. (IsError (CustomError tag), MustHaveErrorArg tag (MText, arg)) => Label tag -> arg -> SomeConstant
- customError_ :: (IsError (CustomError tag), MustHaveErrorArg tag (MText, ())) => Label tag -> SomeConstant
- customErrorNoArg :: (IsError (CustomError tag), MustHaveErrorArg tag MText) => Label tag -> SomeConstant
- numericError :: forall err. IsError err => ErrorTagMap -> err -> SomeConstant
- auto :: SpecificOrDefaultAliasHint
- pattern DefEpName :: EpName
- ep :: HasCallStack => Text -> EpName
- (?-) :: Text -> a -> (Text, a)
- testScenarioProps :: (HasCallStack, MonadIO m, MonadTest m) => Scenario PureM -> m ()
- data TezosClientEnv = TezosClientEnv {}
- type MorleyClientEnv = MorleyClientEnv' MorleyClientM
- data MorleyClientEnv' (m :: Type -> Type) = MorleyClientEnv {
- mceTezosClient :: TezosClientEnv
- mceLogAction :: ClientLogAction m
- mceSecretKey :: Maybe SecretKey
- mceClientEnv :: ClientEnv
- data NetworkEnv = NetworkEnv {
- neMorleyClientEnv :: MorleyClientEnv
- neSecretKey :: Maybe SecretKey
- neMoneybagAlias :: Alias
- data MorleyLogs
- mkMorleyOnlyRpcEnvNetwork :: NetworkEnv -> [SecretKey] -> MorleyOnlyRpcEnv
- class TAsRPC (ToT t) ~ ToT (AsRPC t) => HasRPCRepr t where
- type AsRPC t
- deriveRPC :: String -> Q [Dec]
- deriveRPCWithStrategy :: String -> GenericStrategy -> Q [Dec]
- deriveManyRPC :: String -> [String] -> Q [Dec]
- deriveManyRPCWithStrategy :: String -> [String] -> GenericStrategy -> Q [Dec]
- mapEach :: (Each s t a b, Applicative m) => (a -> m b) -> s -> m t
- forEach :: (Each s t a b, Applicative m) => s -> (a -> m b) -> m t
Documentation
data ContractHandle (cp :: Type) (st :: Type) (vd :: Type) Source #
Handle to a contract.
This is what you get when originating a contract and that allows further operations with the contract within the test framework.
Note that this is part of the testing framework and exists solely in Haskell
world, so it has no IsoValue
and related instances and cannot be used in
Lorentz code.
(NiceParameter cp, NiceStorage st, NiceViewsDescriptor vd) => ContractHandle | |
|
Instances
data OriginateData param st vd Source #
OriginateData | |
|
data UntypedOriginateData Source #
Untyped version of OriginateData. It can be used for interaction with raw Michelson contracts
UntypedOriginateData | |
|
data TransferData Source #
Information about transfer operation.
forall v addr.(NiceParameter v, ToAddress addr) => TransferData | |
|
Instances
Validation
data TransferFailure Source #
Failures that could be expected in the execution of a transfer.
These can be caught and handled with attempt
.
Instances
Eq TransferFailure Source # | |
Defined in Test.Cleveland.Internal.Abstract (==) :: TransferFailure -> TransferFailure -> Bool # (/=) :: TransferFailure -> TransferFailure -> Bool # | |
Show TransferFailure Source # | |
Defined in Test.Cleveland.Internal.Abstract showsPrec :: Int -> TransferFailure -> ShowS # show :: TransferFailure -> String # showList :: [TransferFailure] -> ShowS # | |
Exception TransferFailure Source # | |
Defined in Test.Cleveland.Internal.Abstract | |
Buildable TransferFailure Source # | |
Defined in Test.Cleveland.Internal.Abstract build :: TransferFailure -> Builder # |
Real network implementation based on tezos-client
and RPC.
testScenario :: TestName -> (forall m. MonadFail m => Scenario m) -> TestTree Source #
Create a tasty test case from a Scenario
.
This will create a test tree with 2 tests:
one that runs the Scenario
on the Morley.Michelson.Runtime emulator,
and another that runs it on a real Tezos network.
The network config is read from the command line/environment variables.
Use --help
to see the available options.
If a TestTree
contains many tests scheduled to run on a real Tezos network,
those tests will be run sequentially.
scenario :: ClevelandT m () -> Scenario m Source #
Finalize a generic cleveland scenario.
Emulation tests
testScenarioOnEmulator :: TestName -> Scenario PureM -> TestTree Source #
Create a tasty test case from an emulated Scenario
.
This will create a test tree with 1 test,
which will run the Scenario
on the Morley.Michelson.Runtime emulator.
scenarioEmulated :: EmulatedT PureM () -> Scenario PureM Source #
Finalize a scenario that needs emulator-only features.
withInitialLevel :: Natural -> Scenario PureM -> Scenario PureM Source #
Similar to withInitialNow
but for the initial level
collectLogs :: LogsInfo -> MorleyLogs Source #
Collect logs produced by all contracts into the single list
logsForAddress :: (Each s s ScenarioLogs ScenarioLogs, ToAddress addr) => addr -> s -> [MorleyLogs] Source #
Get logs for a given address from LogsInfo
Cleveland actions
type MonadCleveland caps m = (m ~ ReaderT caps (ClevelandBaseMonad caps), HasClevelandCaps caps) Source #
Constraint for a monad in which we can do cleveland actions.
class Functor m => MonadOps m Source #
Typeclass for monads where operations-related actions can occur.
This is implemented for MonadCleveland
and batch context.
Has Functor
as a superclass constraint for convenience, all the related methods
require it.
Instances
MonadOps ClevelandOpsBatch Source # | |
Defined in Test.Cleveland.Internal.Actions withOpsCap :: (ClevelandOpsImpl ClevelandOpsBatch -> ClevelandOpsBatch a) -> ClevelandOpsBatch a Source # | |
(HasClevelandCaps caps, ClevelandBaseMonad caps ~ m) => MonadOps (ReaderT caps m) Source # | |
Defined in Test.Cleveland.Internal.Actions withOpsCap :: (ClevelandOpsImpl (ReaderT caps m) -> ReaderT caps m a) -> ReaderT caps m a Source # |
type MonadEmulated caps m = (MonadCleveland caps m, HasEmulatedCaps caps) Source #
Constraint for a monad in which we can do cleveland actions that can't be run on a real network.
It requires the EmulatedImpl
capability.
type ClevelandT m = ReaderT (ClevelandCaps m) m Source #
Monad transformer that adds only the ClevelandCaps
capabilities.
type EmulatedT m = ReaderT (EmulatedCaps m) m Source #
Monad transformer that adds both ClevelandCaps
and EmulatedCaps
capabilities.
withSender :: MonadCleveland caps m => Address -> m a -> m a Source #
Update the current sender on whose behalf transfers and originations are invoked.
withMoneybag :: MonadCleveland caps m => Address -> m a -> m a Source #
Update the current moneybag that transfers money on the newly created addresses. For the rare occasions when this is necessary.
runIO :: (HasCallStack, MonadCleveland caps m) => IO res -> m res Source #
Runs an IO
action.
resolveAddress :: (HasCallStack, MonadCleveland caps m) => AliasHint -> m Address Source #
Get the address of the implicit account / contract associated with the given alias hint.
refillable :: MonadCleveland caps m => m Address -> m Address Source #
Simple combinator that marks address as "refillable".
If a refillable address lacks funds for the next operation, some funds will automatically be transferred to it.
newAddress :: (HasCallStack, MonadCleveland caps m) => SpecificOrDefaultAliasHint -> m Address Source #
If the given alias is already associated with an existing address, that address will be reused and returned. Otherwise, generate a new secret key and record it with given alias.
If the account has too low of a balance, a small amount of XTZ will be transferred to it.
Notes:
- By default, the XTZ is transferred from the account associated with the
moneybag
alias. This can be overriden with the--cleveland-moneybag-alias
command line option, theTASTY_CLEVELAND_MONEYBAG_ALIAS
env var, orwithMoneybag
. - Beware that if an "alias prefix" is set, it'll be prepended to the given alias hint.
An "alias prefix" can be set using the
--cleveland-alias-prefix
command line option, theTASTY_CLEVELAND_ALIAS_PREFIX
env var, or withsetAliasPrefix
. > do > addr1 <- newAddress "alias" > addr2 <- resolveAddress $ mkAlias "prefix.alias" > addr1 @== addr2
newFreshAddress :: (HasCallStack, MonadCleveland caps m) => SpecificOrDefaultAliasHint -> m Address Source #
Generate a new secret key and record it with given alias. If the alias is already known, the key will be overwritten. The address is guaranteed to be fresh, i. e. no operations on it have been made.
Notes:
- Beware that if an "alias prefix" is set, it'll be prepended to the given alias.
An "alias prefix" can be set using the
--cleveland-alias-prefix
command line option, theTASTY_CLEVELAND_ALIAS_PREFIX
env var, or withsetAliasPrefix
. > do > addr1 <- newFreshAddress "alias" > addr2 <- resolveAddress $ mkAlias "prefix.alias" > addr1 @== addr2
enumAliasHints :: forall n n'. (SingIPeano n, IsoNatPeano n n') => AliasHint -> SizedList n SpecificOrDefaultAliasHint Source #
Create a list of similarly named SpecificAliasHint
s.
For example,
>>>
enumAliasHints @2 "operator" `isEquivalentTo` "operator-0" :< "operator-1" :< Nil
True
signBytes :: (HasCallStack, MonadCleveland caps m) => ByteString -> Address -> m Signature Source #
Get the signature of the preapplied operation.
signBinary :: (HasCallStack, BytesLike bs, MonadCleveland caps m) => bs -> Address -> m (TSignature bs) Source #
Type-safer version of signBytes
.
originate :: forall cp st vd m. (HasCallStack, MonadOps m) => OriginateData cp st vd -> m (ContractHandle cp st vd) Source #
Lorentz version for origination.
By default, the sender is the account associated with the moneybag
alias.
This can be overriden with the --cleveland-moneybag-alias
command line option, the
TASTY_CLEVELAND_MONEYBAG_ALIAS
env var, or withSender
.
originateSimple :: forall cp st vd m. (HasCallStack, MonadOps m) => AliasHint -> st -> Contract cp st vd -> m (ContractHandle cp st vd) Source #
A simplified version of the originate command. The contract will have 0 balance.
originateUntyped :: (HasCallStack, MonadOps m) => UntypedOriginateData -> m Address Source #
Originate a new raw Michelson contract with given data.
originateUntypedSimple :: (HasCallStack, MonadOps m) => AliasHint -> Value -> Contract -> m Address Source #
A simplified version of the originateUntyped command. The contract will have 0 balance.
originateTypedSimple :: forall cp st vd m. (HasCallStack, MonadOps m, NiceParameter cp, NiceStorage st, NiceViewsDescriptor vd) => AliasHint -> st -> Contract (ToT cp) (ToT st) -> m (ContractHandle cp st vd) Source #
Like originateUntypedSimple
, but accepts typed contract and initial storage
as a Haskell value.
originateLarge :: forall param st vd m caps. (HasCallStack, MonadCleveland caps m) => OriginateData param st vd -> m (ContractHandle param st vd) Source #
Lorentz version for large origination.
originateLargeSimple :: forall param st vd m caps. (HasCallStack, MonadCleveland caps m) => AliasHint -> st -> Contract param st vd -> m (ContractHandle param st vd) Source #
A simplified version of the originateLarge command. The contract will have 0 balance.
originateLargeUntyped :: (HasCallStack, MonadCleveland caps m) => UntypedOriginateData -> m Address Source #
Originate a new Michelson contract that doesn't fit into the origination size limit, by executing multiple operation steps.
This operation cannot be batched (it simply may not fit).
originateLargeUntypedSimple :: (HasCallStack, MonadCleveland caps m) => AliasHint -> Value -> Contract -> m Address Source #
A simplified version of the originateLargeUntyped command. The contract will have 0 balance.
transfer :: (HasCallStack, MonadOps m) => TransferData -> m () Source #
Base method for making a transfer.
Avoid using this method in favour of transferMoney
and call
, unless
you need the semantics of both in one operation.
transferMoney :: (HasCallStack, MonadOps m, ToAddress addr) => addr -> Mutez -> m () Source #
Simply transfer money to an address.
This assumes that target address is either an implicit address or has a default entrypoint with a unit argument; otherwise the call fails.
call :: forall param vd addr m epRef epArg. (HasCallStack, MonadOps m, ToTAddress param vd addr, HasEntrypointArg param epRef epArg, IsoValue epArg, Typeable epArg) => addr -> epRef -> epArg -> m () Source #
Call a certain entrypoint of the given contract.
By default, the sender is the account associated with the moneybag
alias.
This can be overriden with the --cleveland-moneybag-alias
command line option, the
TASTY_CLEVELAND_MONEYBAG_ALIAS
env var, or withSender
.
importUntypedContract :: (HasCallStack, MonadCleveland caps m) => FilePath -> m Contract Source #
Import an untyped contract from file.
importContract :: (HasCallStack, NiceParameter param, NiceStorage st, NiceViewsDescriptor vd, DemoteViewsDescriptor vd, MonadCleveland caps m) => FilePath -> m (Contract param st vd) Source #
Import a contract from file.
The compiler must be able to infer the types of parameter, storage and views.
In case there are no views or you don't care, you can use noViews
.
comment :: (HasCallStack, MonadCleveland caps m) => Text -> m () Source #
Print the given string verbatim as a comment. At the moment, this is a no-op in emulator tests.
getBalance :: (HasCallStack, MonadCleveland caps m, ToAddress addr) => addr -> m Mutez Source #
Get the balance of the given address.
getDelegate :: (HasCallStack, MonadCleveland caps m, ToAddress addr) => addr -> m (Maybe KeyHash) Source #
Get the delegate for the given contract. Fails on implicit contracts.
registerDelegate :: (HasCallStack, MonadCleveland caps m, ToAddress addr) => addr -> m () Source #
Register the given address as a valid delegate.
getMorleyLogs :: forall a caps m. MonadEmulated caps m => m a -> m (LogsInfo, a) Source #
Returns the result of the action with the logs it produced. Logs are messages
printed by the Lorentz instruction printComment
.
This function can be combined either with lens-based accessors or helper functions to get more specific information about logs.
Examples:
(logsInfo, _) <- getMorleyLogs scenario
logsInfo ^.. each . logsL == [MorleyLogs ["log"], MorleyLogs ["log2"]]
logsInfo ^.. each . filterLogsByAddrL addr
== [MorleyLogs ["log"]]
(logsInfo, _) <- getMorleyLogs scenario
collectLogs logsInfo == MorleyLogs ["log", "log2"]
logsForAddress logsInfo
== [MorleyLogs ["log"]]
getMorleyLogs_ :: MonadEmulated caps m => m () -> m LogsInfo Source #
Version of getMorleyLogs
for actions that don't return a result.
getStorage :: forall st addr caps m. (HasCallStack, MonadCleveland caps m, ToStorageType st addr, IsoValue (AsRPC st)) => addr -> m (AsRPC st) Source #
Retrieve a contract's storage in its "RPC representation" (i.e., all its big_maps will be replaced by big_map IDs).
If the storage is of a user-defined type, then deriveRPC
/
deriveManyRPC
should be used to create an RPC representation of the storage
type.
data MyStorage = MyStorage { field1 :: Natural, field2 :: BigMap Integer MText } deriveRPC "MyStorage"
getFullStorage :: forall st addr caps m. (HasCallStack, MonadEmulated caps m, ToStorageType st addr) => addr -> m st Source #
Retrieve a contract's full storage, including the contents of its big_maps.
This function can only be used in emulator-only tests.
getSomeStorage :: forall addr caps m. (HasCallStack, MonadCleveland caps m, ToAddress addr) => addr -> m SomeAnnotatedValue Source #
Similar to getStorage
, but doesn't require knowing
the storage type in advance.
Use the optics in AnnotatedValue
to
read data from the storage.
getAllBigMapValues :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NiceUnpackedValue v) => BigMapId k v -> m [v] Source #
Like getAllBigMapValuesMaybe
, but fails the tests instead of returning Nothing
.
getAllBigMapValuesMaybe :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NiceUnpackedValue v) => BigMapId k v -> m (Maybe [v]) Source #
Retrieve all big_map values, given a big_map ID.
Returns Nothing
when the big_map ID does not exist.
getBigMapSize :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NiceUnpackedValue v) => BigMapId k v -> m Natural Source #
Like getBigMapSizeMaybe
, but fails the tests instead of returning Nothing
.
getBigMapSizeMaybe :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NiceUnpackedValue v) => BigMapId k v -> m (Maybe Natural) Source #
Retrieve a big_map size, given a big_map ID.
Returns Nothing
when the big_map ID does not exist.
O(n), because it's implemented with getBigMapValues
.
getBigMapValueMaybe :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NicePackedValue k, NiceUnpackedValue v) => BigMapId k v -> k -> m (Maybe v) Source #
Retrieve a big_map value, given a big_map ID and a key.
Returns Nothing
when the big_map ID does not exist, or it exists but
does not contain the given key.
getBigMapValue :: forall k v caps m. (HasCallStack, MonadCleveland caps m, NiceComparable k, NicePackedValue k, NiceUnpackedValue v, Buildable k) => BigMapId k v -> k -> m v Source #
Like getBigMapValueMaybe
, but fails the tests instead of returning Nothing
.
getPublicKey :: (HasCallStack, MonadCleveland caps m) => Address -> m PublicKey Source #
Get the public key associated with given address. Fail if given address is not an implicit account.
getChainId :: (HasCallStack, MonadCleveland caps m) => m ChainId Source #
Get the chain's ChainId
.
advanceTime :: forall unit caps m. (HasCallStack, MonadCleveland caps m, KnownDivRat unit Second) => Time unit -> m () Source #
Advance at least the given amount of time, or until a new block is baked, whichever happens last.
On a real network, this is implemented using threadDelay
, so it's advisable
to use small amounts of time only.
advanceLevel :: forall caps m. (HasCallStack, MonadCleveland caps m) => Natural -> m () Source #
Wait till the provided number of levels is past.
advanceToLevel :: forall caps m. (HasCallStack, MonadCleveland caps m) => Natural -> m () Source #
Wait till the provided level is reached.
getNow :: (HasCallStack, MonadCleveland caps m) => m Timestamp Source #
Get the timestamp observed by the last block to be baked.
getLevel :: (HasCallStack, MonadCleveland caps m) => m Natural Source #
Get the current level observed by the last block to be baked.
getApproximateBlockInterval :: (HasCallStack, MonadCleveland caps m) => m (Time Second) Source #
Get approximate block interval in seconds. Note, that this value is minimal bound and real intervals can be larger, see http://tezos.gitlab.io/active/consensus.html#minimal-block-delay-function for more information about block delays.
data RunCode cp st vd Source #
The data needed to call the /run_code
RPC endpoint.
RunCode | |
|
NotRPC :: forall v. IsoValue v => v -> MaybeRPC v | |
IsRPC :: forall v. (SingI (ToT v), IsoValue (AsRPC v), HasRPCRepr v) => AsRPC v -> MaybeRPC v |
Instances
HasNoOp (ToT v) => ToExpression (MaybeRPC v) | |
Defined in Morley.AsRPC toExpression :: MaybeRPC v -> Expression |
runCode :: (HasCallStack, MonadCleveland caps m, HasRPCRepr st, IsoValue (AsRPC st)) => RunCode cp st vd -> m (AsRPC st) Source #
Execute a contract's code without originating it. The chain's state will not be modified.
Notes:
- If the contract's code emits operations, they will not be executed.
- The sender's account won't be debited.
- When running an _originated_ contract, the
BALANCE
instruction returns the sum of the contract's balance before the transfer operation + the amount of tz being transferred. In other words, this invariant holds:BALANCE >= AMOUNT
. However, sincerunCode
allows overriding theBALANCE
instruction, then this invariant no longer holds. It's possible thatBALANCE < AMOUNT
.
branchout :: forall caps m. MonadEmulated caps m => [(Text, m ())] -> m () Source #
Execute multiple testing scenarios independently.
- Actions performed before
branchout
will be observed by all branches. - Actions performed in branches will _not_ be observed by any actions performed after
branchout
. - Actions performed in one branch will _not_ be observed by another branch.
- The test succeeds IFF all branches succeed.
- If any branch fails, the test ends immediately and the remaining branches won't be executed.
The following property holds:
pre >> branchout [a, b, c] = branchout [pre >> a, pre >> b, pre >> c]
The list of branches must be non-empty.
offshoot :: forall caps m. MonadEmulated caps m => Text -> m () -> m () Source #
setVotingPowers :: MonadEmulated caps m => VotingPowers -> m () Source #
Updates voting power accessible via VOTING_POWER
and similar
instructions.
whenEmulation :: MonadCleveland caps m => (forall caps1 m1. (EqBaseMonad caps caps1, MonadEmulated caps1 m1) => m1 ()) -> m () Source #
Perform an action if we are currently in emulation mode.
See also ifEmulation
note on constraints.
whenNetwork :: MonadCleveland caps m => (forall caps1 m1. (EqBaseMonad caps caps1, MonadCleveland caps1 m1) => m1 ()) -> m () Source #
Perform an action if we are currently in network mode.
See also ifEmulation
note on constraints.
ifEmulation :: forall a caps m. MonadCleveland caps m => (forall caps1 m1. (EqBaseMonad caps caps1, MonadEmulated caps1 m1) => m1 a) -> (forall caps1 m1. (EqBaseMonad caps caps1, MonadCleveland caps1 m1) => m1 a) -> m a Source #
Perform one action if we are currently in emulation mode, another otherwise
Functions passed as the first two arguments are universally quantified over
the outer monad, so if additional constraints are required beyond
MonadEmulated
or MonadCleveland
, those constraints have to go on the base
monad, e.g.
someFunction :: (MonadCleveland caps m, MonadFail (ClevelandBaseMonad caps)) => m () someFunction = whenEmulation do Just x <- pure (Just 1 :: Maybe Int) -- this would error without MonadFail runIO $ print x
inBatch :: (HasCallStack, MonadCleveland caps m) => ClevelandOpsBatch a -> m a Source #
Run operations in a batch.
Best used with the ApplicativeDo
GHC extension.
Example:
contract <- inBatch $ do contract <- originate ... for_ [1..3] i -> transfer ... return contract
Batched operations should be applied to chain faster, but note that batches have their own limits. For instance, at the moment of writing, the gas limit on a batch is 10x of gas limit applied to a single operation.
A context of a batch is only Applicative
, not Monad
. This means that:
- Return values of one function cannot be passed to another function in the same batch, it can only be returned;
- Sometimes the compiler does not recognize that only
Applicative
context is required, in case of any issues with that - follow the error messages.
Primitives re-exports
data EntrypointRef (mname :: Maybe Symbol) where #
CallDefault :: EntrypointRef ('Nothing :: Maybe Symbol) | |
Call :: forall (name :: Symbol). NiceEntrypointName name => EntrypointRef ('Just name) |
Instances
(GetEntrypointArgCustom cp mname ~ arg, ParameterDeclaresEntrypoints cp) => HasEntrypointArg (cp :: Type) (EntrypointRef mname) arg | |
Defined in Lorentz.Entrypoints.Core useHasEntrypointArg :: EntrypointRef mname -> (Dict (ParameterScope (ToT arg)), EpName) |
data VotingPowers #
Instances
Eq VotingPowers | |
Defined in Morley.Michelson.Runtime.GState (==) :: VotingPowers -> VotingPowers -> Bool # (/=) :: VotingPowers -> VotingPowers -> Bool # | |
Show VotingPowers | |
Defined in Morley.Michelson.Runtime.GState showsPrec :: Int -> VotingPowers -> ShowS # show :: VotingPowers -> String # showList :: [VotingPowers] -> ShowS # | |
ToJSON VotingPowers | |
Defined in Morley.Michelson.Runtime.GState toJSON :: VotingPowers -> Value # toEncoding :: VotingPowers -> Encoding # toJSONList :: [VotingPowers] -> Value # toEncodingList :: [VotingPowers] -> Encoding # | |
FromJSON VotingPowers | |
Defined in Morley.Michelson.Runtime.GState parseJSON :: Value -> Parser VotingPowers # parseJSONList :: Value -> Parser [VotingPowers] # |
mkVotingPowers :: [(KeyHash, Natural)] -> VotingPowers #
mkVotingPowersFromMap :: Map KeyHash Natural -> VotingPowers #
Assertions
failure :: forall a caps m. (HasCallStack, MonadCleveland caps m) => Builder -> m a Source #
Fails the test with the given error message.
assert :: (HasCallStack, MonadCleveland caps m) => Bool -> Builder -> m () Source #
Fails the test with the given error message if the given condition is false.
:: (HasCallStack, MonadCleveland caps m, Eq a, Buildable a) | |
=> a | The actual value. |
-> a | The expected value. |
-> m () |
x @== expected
fails the test if x
is not equal to expected
.
(@/=) :: (HasCallStack, MonadCleveland caps m, Eq a, Buildable a) => a -> a -> m () infix 1 Source #
Fails the test if the two given values are equal.
:: (HasCallStack, MonadCleveland caps m, Eq a, Buildable a) | |
=> m a | The actual value. |
-> a | The expected value. |
-> m () |
Monadic version of @==
.
getBalance addr @@== 10
(@@/=) :: (HasCallStack, MonadCleveland caps m, Eq a, Buildable a) => m a -> a -> m () infix 1 Source #
Monadic version of @/=
.
getBalance addr @@/= 10
checkCompares :: forall a b caps m. (HasCallStack, MonadCleveland caps m, Buildable a, Buildable b) => a -> (a -> b -> Bool) -> b -> m () Source #
Fails the test if the comparison operator fails when applied to the given arguments. Prints an error message with both arguments.
Example:
checkCompares 2 (>) 1
checkComparesWith :: forall a b caps m. (HasCallStack, MonadCleveland caps m) => (a -> Text) -> a -> (a -> b -> Bool) -> (b -> Text) -> b -> m () Source #
Like checkCompares
, but with an explicit show function.
This function does not have any constraint on the type parameters a
and b
.
For example, to print with pretty
:
checkComparesWith pretty a (<) pretty b
evalJust :: (HasCallStack, MonadCleveland caps m) => Builder -> Maybe a -> m a Source #
evalRight :: (HasCallStack, MonadCleveland caps m) => (a -> Builder) -> Either a b -> m b Source #
Derive a Buildable
instance for a type using show
.
Showing a |
Exception handling
attempt :: forall e caps m a. (HasCallStack, MonadCleveland caps m, Exception e) => m a -> m (Either e a) Source #
Attempt to run an action and return its result or, if interpretation fails, an error.
catchTransferFailure :: (HasCallStack, MonadCleveland caps m) => m a -> m TransferFailure Source #
Asserts that a transfer should fail, and returns the exception.
checkTransferFailure :: (HasCallStack, MonadCleveland caps m) => TransferFailure -> TransferFailurePredicate -> m () Source #
Check whether a given predicate holds for a given TransferFailure
.
expectTransferFailure :: (HasCallStack, MonadCleveland caps m) => TransferFailurePredicate -> m a -> m () Source #
Asserts that a transfer should fail, and runs some TransferFailurePredicate
s over the
exception.
expectTransferFailure (failedWith (constant @MText "NOT_ADMIN")) $ call contractAddr (Call @"Ep") arg
call contractAddr (Call @"Ep") arg & expectTransferFailure ( failedWith (customError #tag 3) && addressIs contractAddr )
expectFailedWith :: forall err a caps m. (HasCallStack, MonadCleveland caps m, NiceConstant err) => err -> m a -> m () Source #
Asserts that interpretation of a contract ended with FAILWITH
, returning the given constant
value.
expectError :: forall err a caps m. (HasCallStack, MonadCleveland caps m, IsError err) => err -> m a -> m () Source #
Asserts that interpretation of a contract ended with FAILWITH
, returning the given lorentz
error.
expectCustomError :: forall arg a tag caps m. (HasCallStack, MonadCleveland caps m, IsError (CustomError tag), MustHaveErrorArg tag (MText, arg)) => Label tag -> arg -> m a -> m () Source #
Asserts that interpretation of a contract ended with FAILWITH
, returning the given custom
lorentz error.
expectCustomError_ :: (HasCallStack, MonadCleveland caps m, IsError (CustomError tag), MustHaveErrorArg tag (MText, ())) => Label tag -> m a -> m () Source #
Version of expectCustomError
for error with unit
argument.
expectCustomErrorNoArg :: (HasCallStack, MonadCleveland caps m, IsError (CustomError tag), MustHaveErrorArg tag MText) => Label tag -> m a -> m () Source #
Version of expectCustomError
specialized for expecting NoErrorArg
s.
expectNumericError :: forall err a caps m. (HasCallStack, MonadCleveland caps m, IsError err) => ErrorTagMap -> err -> m a -> m () Source #
Asserts that interpretation of a contract ended with FAILWITH
, returning the given lorentz
numeric error.
clarifyErrors :: forall caps m a. MonadCleveland caps m => Builder -> m a -> m a Source #
Prefix scenario-custom error messages (i.e. CustomTestError
either from pure or non-pure
implementation), potentially thrown from the given code block.
The prefix will be put at a separate line before the main text, if text is multiline, otherwise
it will be separated from the main text with :
.
This affects errors produced by functions like failure
, assert
, @==
, etc.
Errors related to events in the chain will not be touched.
Example:
for [1..10] \i -> clarifyErrors ("For i=" +| i |+ "") $ askContract i @@== i * 2
Exception predicates
data TransferFailurePredicate Source #
A predicate that checks whether a transfer operation failed for the expected reason.
Predicates can be combined using the &&
and ||
operators.
Instances
shiftOverflow :: TransferFailurePredicate Source #
Asserts that interpretation of a contract failed due to an overflow error.
emptyTransaction :: TransferFailurePredicate Source #
Asserts that an action failed due to an attempt to transfer 0tz towards a simple address.
badParameter :: TransferFailurePredicate Source #
Asserts that an action failed due to an attempt to call a contract with an invalid parameter.
gasExhaustion :: TransferFailurePredicate Source #
Asserts that interpretation of a contract failed due to gas exhaustion.
failedWith :: SomeConstant -> TransferFailurePredicate Source #
Asserts that interpretation of a contract ended with FAILWITH
, throwing the given error.
This function should be used together with one of the "FAILWITH
constructors"
(e.g. constant
, customError
).
:: ToAddress addr | |
=> addr | The expected address. |
-> TransferFailurePredicate |
Asserts that the error occurred while interpreting the contract with the given address.
FAILWITH
errors
Convert the many error formats available in morley
and lorentz
to SomeConstant
.
constant :: forall err. NiceConstant err => err -> SomeConstant Source #
A constant michelson value that a contract threw with FAILWITH
.
customError :: forall arg tag. (IsError (CustomError tag), MustHaveErrorArg tag (MText, arg)) => Label tag -> arg -> SomeConstant Source #
A custom lorentz error.
customError_ :: (IsError (CustomError tag), MustHaveErrorArg tag (MText, ())) => Label tag -> SomeConstant Source #
A custom lorentz error with a unit
argument.
customErrorNoArg :: (IsError (CustomError tag), MustHaveErrorArg tag MText) => Label tag -> SomeConstant Source #
A custom lorentz error with no argument.
numericError :: forall err. IsError err => ErrorTagMap -> err -> SomeConstant Source #
A lorentz numeric error.
Helpers
auto :: SpecificOrDefaultAliasHint Source #
Helper to use automatically determined unique alias.
ep :: HasCallStack => Text -> EpName Source #
A short partial constructor for EpName
. It is supposed to be
applied to string constants, so programmer is responsible for
validity. And this code is for tests anyway, so each failure is a
programmer mistake.
It is intentionally here and not in some deeper module because the name is really short and more suitable for writing scenarios.
(?-) :: Text -> a -> (Text, a) infixr 0 Source #
Make a tuple with name without extra syntactic noise.
Integration with hedgehog
testScenarioProps :: (HasCallStack, MonadIO m, MonadTest m) => Scenario PureM -> m () Source #
Run an Scenario
via the Morley.Michelson.Runtime emulator,
inside an hedgehog
property.
Config (reexports)
data TezosClientEnv #
type MorleyClientEnv = MorleyClientEnv' MorleyClientM #
data MorleyClientEnv' (m :: Type -> Type) #
MorleyClientEnv | |
|
Instances
MonadReader MorleyClientEnv MorleyClientM | |
Defined in Morley.Client.Full ask :: MorleyClientM MorleyClientEnv # local :: (MorleyClientEnv -> MorleyClientEnv) -> MorleyClientM a -> MorleyClientM a # reader :: (MorleyClientEnv -> a) -> MorleyClientM a # | |
HasLog MorleyClientEnv Message MorleyClientM | |
Defined in Morley.Client.Full getLogAction :: MorleyClientEnv -> LogAction MorleyClientM Message # setLogAction :: LogAction MorleyClientM Message -> MorleyClientEnv -> MorleyClientEnv # overLogAction :: (LogAction MorleyClientM Message -> LogAction MorleyClientM Message) -> MorleyClientEnv -> MorleyClientEnv # logActionL :: Lens' MorleyClientEnv (LogAction MorleyClientM Message) # | |
HasTezosClientEnv (MorleyClientEnv' m) | |
Defined in Morley.Client.Env |
data NetworkEnv Source #
NetworkEnv | |
|
data MorleyLogs #
Instances
Config utilities
mkMorleyOnlyRpcEnvNetwork Source #
:: NetworkEnv | |
-> [SecretKey] | Extra secrets that should be known |
-> MorleyOnlyRpcEnv |
Construct MorleyOnlyRpcEnv
from NetworkEnv
.
AsRPC
class TAsRPC (ToT t) ~ ToT (AsRPC t) => HasRPCRepr t #
Instances
deriveRPCWithStrategy :: String -> GenericStrategy -> Q [Dec] #
Utilities
mapEach :: (Each s t a b, Applicative m) => (a -> m b) -> s -> m t Source #