Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Michelson contracts testing on a real Tezos network.
See the documentation for usage instructions.
Synopsis
- data Alias (kind :: AddressKind)
- type ContractAlias = Alias 'AddressKindContract
- type ImplicitAlias = Alias 'AddressKindImplicit
- data KindedAddress (kind :: AddressKind)
- type ContractAddress = KindedAddress 'AddressKindContract
- type ImplicitAddress = KindedAddress 'AddressKindImplicit
- data AddressWithAlias (kind :: AddressKind) = AddressWithAlias {
- awaAddress :: KindedAddress kind
- awaAlias :: Alias kind
- type ImplicitAddressWithAlias = AddressWithAlias 'AddressKindImplicit
- type ContractAddressWithAlias = AddressWithAlias 'AddressKindContract
- data ContractHandle (cp :: Type) (st :: Type) (vd :: Type) = (NiceParameter cp, NiceStorage st, NiceViewsDescriptor vd) => ContractHandle {}
- data TransferData = forall v addr.(NiceParameter v, ToL1Address addr) => TransferData {
- tdTo :: addr
- tdAmount :: Mutez
- tdEntrypoint :: EpName
- tdParameter :: v
- newtype TypedContract cp st vd = TypedContract (Contract (ToT cp) (ToT st))
- type Scenario m = MonadScenario m => Scenario' m
- data PureM a
- data ClientM a
- data TransferFailure
- testScenario :: TestName -> (forall m. Scenario m) -> TestTree
- testScenarioOnNetwork :: TestName -> Scenario ClientM -> TestTree
- scenarioNetwork :: NetworkT ClientM () -> Scenario' ClientM
- class MonadFail m => MonadScenario m where
- scenario :: ClevelandT m () -> Scenario' m
- getMorleyClientEnv :: MonadNetwork caps m => m MorleyClientEnv
- getOnlyRpcEnv :: MonadNetwork caps m => [SecretKey] -> m MorleyOnlyRpcEnv
- testScenarioOnEmulator :: TestName -> Scenario PureM -> TestTree
- scenarioEmulated :: EmulatedT PureM () -> Scenario' PureM
- withInitialNow :: Timestamp -> Scenario' PureM -> Scenario' PureM
- withInitialLevel :: Natural -> Scenario' PureM -> Scenario' PureM
- withMinBlockTime :: Natural -> Scenario' PureM -> Scenario' PureM
- withChainId :: ChainId -> 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 (MonadTransfer m, MonadOriginate 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 => ImplicitAddressWithAlias -> m a -> m a
- withMoneybag :: MonadCleveland caps m => ImplicitAddressWithAlias -> m a -> m a
- runIO :: (HasCallStack, MonadCleveland caps m) => IO res -> m res
- resolveAddress :: (HasCallStack, MonadCleveland caps m) => Alias kind -> m (KindedAddress kind)
- refillable :: (ToImplicitAddress addr, MonadCleveland caps m) => m addr -> m addr
- refillables :: (ToImplicitAddress addr, Traversable f, MonadCleveland caps m) => m (f addr) -> m (f addr)
- newAddress :: (HasCallStack, MonadCleveland caps m) => SpecificOrDefaultAlias -> m ImplicitAddressWithAlias
- newAddresses :: forall n n' caps m. (HasCallStack, MonadCleveland caps m, IsoNatPeano n n') => SizedList n SpecificOrDefaultAlias -> m (SizedList n ImplicitAddressWithAlias)
- newFreshAddress :: (HasCallStack, MonadCleveland caps m) => SpecificOrDefaultAlias -> m ImplicitAddressWithAlias
- importSecretKey :: MonadCleveland caps m => SecretKey -> SpecificOrDefaultAlias -> m ImplicitAddressWithAlias
- enumAliases :: forall n n'. (SingIPeano n, IsoNatPeano n n') => ImplicitAlias -> SizedList n SpecificOrDefaultAlias
- signBytes :: (HasCallStack, MonadCleveland caps m) => ByteString -> ImplicitAddressWithAlias -> m Signature
- signBinary :: (HasCallStack, BytesLike bs, MonadCleveland caps m) => bs -> ImplicitAddressWithAlias -> m (TSignature bs)
- originate :: forall contract r. (HasCallStack, ContractClass contract, OriginateFunc contract '[] r) => ContractAlias -> ContractStorage contract -> contract -> r
- data Large = Large
- transfer :: forall addr r. (HasCallStack, TransferFunc ('Incomplete (InitialTransferMode addr)) 'TransferIgnoreResult 'HasNoAmount r, ToL1Address addr) => addr -> r
- transferTicket :: forall cp vd arg m addr ticketerAddr mname. (MonadOpsInternal m, NiceParameter arg, NiceComparable arg, ImplicitAddressParameterHelper addr cp (Ticket arg), ToL1TAddress cp vd addr, ToAddress ticketerAddr, HasEntrypointArg cp (EntrypointRef mname) (Ticket arg), HasCallStack) => addr -> EntrypointRef mname -> ticketerAddr -> arg -> Natural -> m [ContractEvent]
- unsafeTransferTicket :: forall arg m addr ticketerAddr. (MonadOpsInternal m, NiceParameter arg, NiceComparable arg, ToL1Address addr, ToAddress ticketerAddr, HasCallStack) => addr -> EpName -> ticketerAddr -> arg -> Natural -> m [ContractEvent]
- data WithContractEvents = WithContractEvents
- data ContractEvent = ContractEvent {}
- calling :: forall mname. EntrypointRef mname -> forall epArg param. (NiceParameter epArg, HasEntrypointArg param (EntrypointRef mname) epArg) => epArg -> GenericCall ('Checked param)
- class Default a where
- def :: a
- unsafeCalling :: EpName -> forall epArg. NiceParameter epArg => epArg -> GenericCall 'Unchecked
- 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, ToL1Address addr) => addr -> m Mutez
- getDelegate :: (HasCallStack, MonadCleveland caps m, ToL1Address addr) => addr -> m (Maybe KeyHash)
- registerDelegate :: (HasCallStack, MonadCleveland caps m) => ImplicitAddressWithAlias -> m ()
- setDelegate :: (HasCallStack, MonadCleveland caps m) => ImplicitAddressWithAlias -> Maybe KeyHash -> 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, ToContractAddress 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) => ImplicitAddressWithAlias -> 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)
- getMinBlockTime :: (HasCallStack, MonadCleveland caps m) => m Natural
- data RunCode cp st vd = RunCode {
- rcContract :: Contract cp st vd
- rcParameter :: Value
- rcStorage :: Value
- rcAmount :: Mutez
- rcLevel :: Maybe Natural
- rcNow :: Maybe Timestamp
- rcBalance :: Mutez
- rcSource :: Maybe ImplicitAddress
- 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, MonadNetwork 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, MonadNetwork caps1 m1) => m1 a) -> m a
- inBatch :: (HasCallStack, MonadCleveland caps m) => ClevelandOpsBatch a -> m a
- getTicketBalance :: (MonadCleveland caps m, HasNoOpToT a, NiceComparable a, ToL1Address addr, ToContractAddress contractAddr) => addr -> contractAddr -> a -> m Natural
- getAllTicketBalances :: (MonadCleveland caps m, ToContractAddress addr) => addr -> m [SomeTicket]
- data SomeTicket where
- SomeTicket :: SingI t => Ticket (Value t) -> SomeTicket
- class ToAddress a where
- toAddress :: a -> Address
- class ToL1Address addr where
- toL1Address :: addr -> L1Address
- class (ToTAddress cp vd addr, ToL1Address addr) => ToL1TAddress cp vd addr where
- toL1TAddress :: addr -> L1TAddress cp vd
- class ToContractAddress addr where
- toContractAddress :: addr -> ContractAddress
- class ToImplicitAddress addr where
- toImplicitAddress :: addr -> ImplicitAddress
- data EntrypointRef (mname :: Maybe Symbol) where
- CallDefault :: EntrypointRef ('Nothing :: Maybe Symbol)
- Call :: forall (name :: Symbol). NiceEntrypointName name => EntrypointRef ('Just name)
- data VotingPowers
- data Mutez
- tz :: QuasiQuoter
- mkVotingPowers :: [(KeyHash, Natural)] -> VotingPowers
- mkVotingPowersFromMap :: Map KeyHash Natural -> VotingPowers
- failure :: forall a caps m. (HasCallStack, MonadCleveland caps m) => Doc -> m a
- assert :: (HasCallStack, MonadCleveland caps m) => Bool -> Doc -> 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) => Doc -> Maybe a -> m a
- evalRight :: (HasCallStack, MonadCleveland caps m) => (a -> Doc) -> Either a b -> m b
- newtype Showing a = Showing a
- callView :: forall name arg ret cp st vd m caps. (MonadCleveland caps m, HasView vd name arg ret, NiceParameter arg, NiceViewable ret, NiceStorage ret, KnownSymbol name, HasRPCRepr ret, IsoValue (AsRPC ret)) => ContractHandle cp st vd -> Label name -> arg -> m (AsRPC ret)
- unsafeCallView :: forall ret arg name addr m caps. (MonadCleveland caps m, NiceParameter arg, NiceViewable ret, NiceStorage ret, KnownSymbol name, HasRPCRepr ret, IsoValue (AsRPC ret), ToContractAddress addr) => addr -> Label name -> arg -> m (AsRPC ret)
- 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 ()
- expectCustomErrorAnyArg :: (HasCallStack, MonadCleveland caps m) => 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 => Doc -> 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 :: SpecificOrDefaultAlias
- pattern DefEpName :: EpName
- ep :: EntrypointNameConstructor epName a => a
- (?-) :: Text -> a -> (Text, a)
- type (:!) (name :: Symbol) a = NamedF Identity a name
- newtype NamedF (f :: Type -> Type) a (name :: Symbol) where
- testScenarioProps :: (HasCallStack, MonadIO m, MonadTest m) => Scenario PureM -> m ()
- data TezosClientEnv = TezosClientEnv {
- tceEndpointUrl :: BaseUrl
- tceTezosClientPath :: FilePath
- tceMbTezosClientDataDir :: Maybe FilePath
- tceAliasMap :: MVar (Maybe AliasesAndAddresses)
- data MorleyClientEnv = MorleyClientEnv {
- mceTezosClient :: TezosClientEnv
- mceLogAction :: ClientLogAction MorleyClientM
- mceSecretKey :: Maybe SecretKey
- mceClientEnv :: ClientEnv
- data NetworkEnv = NetworkEnv {
- neMorleyClientEnv :: MorleyClientEnv
- neSecretKey :: Maybe SecretKey
- neMoneybagAlias :: ImplicitAlias
- neExplicitDataDir :: Bool
- neVerbosity :: Word
- data MorleyLogs
- mkMorleyOnlyRpcEnvNetwork :: NetworkEnv -> [SecretKey] -> MorleyOnlyRpcEnv
- class TAsRPC (ToT t) ~ ToT (AsRPC t) => HasRPCRepr t where
- type AsRPC t
- deriveRPC :: String -> 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 Alias (kind :: AddressKind) #
Instances
IsString ContractAlias Source # | |
Defined in Test.Cleveland.Instances fromString :: String -> ContractAlias # | |
IsString ImplicitAlias Source # | |
Defined in Test.Cleveland.Instances fromString :: String -> ImplicitAlias # | |
GCompare Alias | |
GEq Alias | |
ArgDict (c :: AddressKind -> Constraint) Alias | |
Defined in Morley.Tezos.Address.Alias type ConstraintsFor Alias c # | |
(SingI kind, L1AddressKind kind) => FromJSON (Alias kind) | |
ToJSON (Alias kind) | |
Defined in Morley.Tezos.Address.Alias | |
Show (Alias kind) | |
NFData (Alias kind) | |
Defined in Morley.Tezos.Address.Alias | |
Eq (Alias kind) | |
Ord (Alias kind) | |
Defined in Morley.Tezos.Address.Alias | |
CmdArg (Alias kind) | |
Defined in Morley.Client.TezosClient.Types | |
Buildable (Alias kind) | |
Defined in Morley.Tezos.Address.Alias | |
type ConstraintsFor Alias (c :: AddressKind -> Constraint) | |
Defined in Morley.Tezos.Address.Alias type ConstraintsFor Alias (c :: AddressKind -> Constraint) = (c 'AddressKindImplicit, c 'AddressKindContract) |
type ContractAlias = Alias 'AddressKindContract #
type ImplicitAlias = Alias 'AddressKindImplicit #
data KindedAddress (kind :: AddressKind) #
Instances
type ContractAddress = KindedAddress 'AddressKindContract #
type ImplicitAddress = KindedAddress 'AddressKindImplicit #
data AddressWithAlias (kind :: AddressKind) #
AddressWithAlias | |
|
Instances
type ImplicitAddressWithAlias = AddressWithAlias 'AddressKindImplicit #
type ContractAddressWithAlias = AddressWithAlias 'AddressKindContract #
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 TransferData Source #
Information about transfer operation.
forall v addr.(NiceParameter v, ToL1Address addr) => TransferData | |
|
newtype TypedContract cp st vd Source #
A wrapper around Contract
to reduce awkwardness
TypedContract (Contract (ToT cp) (ToT st)) |
Instances
(NiceStorage st, NiceViewsDescriptor vd, NiceParameter cp) => ContractClass (TypedContract cp st vd) Source # | |
Defined in Test.Cleveland.Internal.Actions.Originate type ContractOriginateType (TypedContract cp st vd) :: OriginationType Source # initialStorageAndContract :: ContractStorage (TypedContract cp st vd) -> TypedContract cp st vd -> ODContractAndStorage (ContractOriginateType (TypedContract cp st vd)) Source # | |
type ContractOriginateType (TypedContract cp st vd) Source # | |
Defined in Test.Cleveland.Internal.Actions.Originate |
type Scenario m = MonadScenario m => Scenario' m Source #
A convenience type synonym for Scenario
` that has MonadScenario
constraint baked in.
Instances
MonadFail PureM Source # | |
Defined in Test.Cleveland.Internal.Pure | |
MonadIO PureM Source # | |
Defined in Test.Cleveland.Internal.Pure | |
Applicative PureM Source # | |
Functor PureM Source # | |
Monad PureM Source # | |
MonadScenario PureM Source # | |
Defined in Test.Cleveland.Internal.Scenario | |
MonadCatch PureM Source # | |
MonadThrow PureM Source # | |
Defined in Test.Cleveland.Internal.Pure | |
MonadState PureState PureM Source # | |
MonadWriter LogsInfo PureM Source # | |
MonadReader (IORef PureState) PureM Source # | |
Instances
MonadFail ClientM Source # | |
Defined in Test.Cleveland.Internal.Client | |
MonadIO ClientM Source # | |
Defined in Test.Cleveland.Internal.Client | |
Applicative ClientM Source # | |
Functor ClientM Source # | |
Monad ClientM Source # | |
MonadScenario ClientM Source # | |
Defined in Test.Cleveland.Internal.Scenario | |
MonadCatch ClientM Source # | |
MonadThrow ClientM Source # | |
Defined in Test.Cleveland.Internal.Client | |
MonadReader (IORef ClientState) ClientM Source # | |
Defined in Test.Cleveland.Internal.Client ask :: ClientM (IORef ClientState) # local :: (IORef ClientState -> IORef ClientState) -> ClientM a -> ClientM a # reader :: (IORef ClientState -> a) -> ClientM a # |
Validation
data TransferFailure Source #
Failures that could be expected in the execution of a transfer.
These can be caught and handled with attempt
.
Instances
Exception TransferFailure Source # | |
Defined in Test.Cleveland.Internal.Abstract | |
Show TransferFailure Source # | |
Defined in Test.Cleveland.Internal.Abstract showsPrec :: Int -> TransferFailure -> ShowS # show :: TransferFailure -> String # showList :: [TransferFailure] -> ShowS # | |
Eq TransferFailure Source # | |
Defined in Test.Cleveland.Internal.Abstract (==) :: TransferFailure -> TransferFailure -> Bool # (/=) :: TransferFailure -> TransferFailure -> Bool # | |
Buildable TransferFailure Source # | |
Defined in Test.Cleveland.Internal.Abstract build :: TransferFailure -> Doc buildList :: [TransferFailure] -> Doc |
Real network implementation based on octez-client
and RPC.
testScenario :: TestName -> (forall 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.
scenarioNetwork :: NetworkT ClientM () -> Scenario' ClientM Source #
Finalize a scenario that needs network-only features.
class MonadFail m => MonadScenario m where Source #
Typeclass for base monads that can implement a scenario.
scenario :: ClevelandT m () -> Scenario' m Source #
Finalize a generic cleveland scenario.
Instances
MonadScenario ClientM Source # | |
Defined in Test.Cleveland.Internal.Scenario | |
MonadScenario PureM Source # | |
Defined in Test.Cleveland.Internal.Scenario |
getMorleyClientEnv :: MonadNetwork caps m => m MorleyClientEnv Source #
Get a MorleyClientEnv
when running a test on network. Useful to run
f.ex. octez-client
inside a network test.
This is considered a pretty low-level function, so it's better to avoid it in most cases.
getOnlyRpcEnv :: MonadNetwork caps m => [SecretKey] -> m MorleyOnlyRpcEnv Source #
Get a MorleyOnlyRpcEnv
when running a test on network. Useful to run raw
network actions inside a network test.
This is considered a pretty low-level function, so it's better to avoid it in most cases.
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
withMinBlockTime :: Natural -> Scenario' PureM -> Scenario' PureM Source #
Similar to withInitialNow
but for the MINIMAL_BLOCK_DELAY
protocol constant.
withChainId :: ChainId -> Scenario' PureM -> Scenario' PureM Source #
Similar to withInitialNow
but for the chain id
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 (MonadTransfer m, MonadOriginate m) => MonadOps m Source #
Synonym typeclass for monads where network operations can occur.
This has instances for MonadCleveland
and ClevelandOpsBatch
contexts.
Practically, if you want to use transfer
or originate
in a monad, add a
MonadOps
constraint on it, f. ex.:
callEp1 :: MonadOps m => ContractHandle MyParam () () -> Integer -> m () callEp1 ch = transfer ch . calling (ep @"Entrypoint1")
Instances
(MonadTransfer m, MonadOriginate m) => MonadOps m Source # | |
Defined in Test.Cleveland.Internal.Actions.MonadOps |
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 EmulatedCaps
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 => ImplicitAddressWithAlias -> m a -> m a Source #
Update the current sender on whose behalf transfers and originations are invoked.
withMoneybag :: MonadCleveland caps m => ImplicitAddressWithAlias -> 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) => Alias kind -> m (KindedAddress kind) Source #
Get the address of the implicit account / contract associated with the given alias.
refillable :: (ToImplicitAddress addr, MonadCleveland caps m) => m addr -> m addr 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.
refillables :: (ToImplicitAddress addr, Traversable f, MonadCleveland caps m) => m (f addr) -> m (f addr) Source #
Mark multiple addresses as refillable
, useful with newAddresses
&c.
newAddress :: (HasCallStack, MonadCleveland caps m) => SpecificOrDefaultAlias -> m ImplicitAddressWithAlias 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 overridden with the--cleveland-moneybag-alias
command line option, theTASTY_CLEVELAND_MONEYBAG_ALIAS
env var, orwithMoneybag
.
newAddresses :: forall n n' caps m. (HasCallStack, MonadCleveland caps m, IsoNatPeano n n') => SizedList n SpecificOrDefaultAlias -> m (SizedList n ImplicitAddressWithAlias) Source #
Batched version of newAddress
newFreshAddress :: (HasCallStack, MonadCleveland caps m) => SpecificOrDefaultAlias -> m ImplicitAddressWithAlias 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.
importSecretKey :: MonadCleveland caps m => SecretKey -> SpecificOrDefaultAlias -> m ImplicitAddressWithAlias Source #
Import an (unencrypted) secret key as an alias. Can be used to get an
implicit address/alias with a specific key or key type. If you don't care
about the key or key type, consider using newAddress
or newAddresses
instead.
enumAliases :: forall n n'. (SingIPeano n, IsoNatPeano n n') => ImplicitAlias -> SizedList n SpecificOrDefaultAlias Source #
Create a list of similarly named SpecificAlias
es.
For example,
>>>
enumAliases @2 "operator" `isEquivalentTo` "operator-0" :< "operator-1" :< Nil
True
signBytes :: (HasCallStack, MonadCleveland caps m) => ByteString -> ImplicitAddressWithAlias -> m Signature Source #
Get the signature of the preapplied operation.
signBinary :: (HasCallStack, BytesLike bs, MonadCleveland caps m) => bs -> ImplicitAddressWithAlias -> m (TSignature bs) Source #
Type-safer version of signBytes
.
originate :: forall contract r. (HasCallStack, ContractClass contract, OriginateFunc contract '[] r) => ContractAlias -> ContractStorage contract -> contract -> r Source #
Originate a new contract with given data.
Can accept untypted or Lorentz contracts as-is. With typed Michelson contracts,
you need to wrap the contract in TypedContract
specifying its Haskell-land
parameter, storage types and view descriptors, e.g.
originate "typed contract" defaultStorage $ TypedContract @Param @Storage @() michelsonContract
Storage type can be auto-deduced in most cases, so you can skip it with @_
.
After the mandatory arguments, you can add Large
or a Mutez
value, e.g.
by using tz
quasi-quoter:
originate "contract" initialStorage contract Large originate "contract" initialStorage contract [tz|123micro|] originate "contract" initialStorage contract [tz|123micro|] Large
The order is arbitrary, but each can be specified at most once.
Mark a contract that doesn't fit into the origination size limit. This will execute multiple origination steps.
Such origination cannot be batched (it simply may not fit).
Instances
(OFConstraints ct 'PropLarge props r, GetLarge props ~ 'NotLarge) => OriginateFunc ct props (Large -> r) Source # | Set large origination. |
Defined in Test.Cleveland.Internal.Actions.Originate originate'r :: OriginateData (ContractOriginateType ct) (GetLarge props) -> Large -> r Source # |
transfer :: forall addr r. (HasCallStack, TransferFunc ('Incomplete (InitialTransferMode addr)) 'TransferIgnoreResult 'HasNoAmount r, ToL1Address addr) => addr -> r Source #
Base method for making a transfer.
You can specify additional arguments after the destination address to modify
optional transfer arguments. Those can either be Mutez
to specify transfer
amount (0 by default), or a specially constructed call descriptor. The order
is arbitrary, but it is usually more convenient to specify transfer amount
first. For example:
transfer addr [tz|123u|] $ calling (ep @"Entrypoint") () transfer addr [tz|123u|]
If the call isn't specified, then the default entrypoint will be called with
()
, i.e.
transfer addr
is functionally the same as
transfer addr $ calling def ()
If the address in the first argument is untyped, the transfer is unchecked.
Unchecked transfers must use unsafeCalling
for the call specification. You
can also use unsafeCalling
with typed address to force an unchecked
transfer.
See Test.Cleveland.Internal.Actions.Transfer for further explanation of the interface.
By default, the sender is the account associated with the moneybag
alias.
This can be overridden with the --cleveland-moneybag-alias
command line
option, the TASTY_CLEVELAND_MONEYBAG_ALIAS
env var, or withSender
.
In some polymorphic cases, you may need to add HasEntrypointArg
constraint:
>>>
:{
example :: (MonadCleveland caps m, NiceParameter cp) => ContractHandle cp st vd -> m () example ch = transfer ch (123 :: Mutez) :} ... ... Can not look up entrypoints in type ... cp ... The most likely reason it is ambiguous, or you need ... HasEntrypointArg cp (EntrypointRef 'Nothing) () ... constraint ...
You can fix this by adding the constraint:
>>>
:{
example :: ( MonadCleveland caps m, NiceParameter cp , HasEntrypointArg cp (EntrypointRef 'Nothing) ()) => ContractHandle cp st vd -> m () example ch = transfer ch (123 :: Mutez) :}
GHC may not always figure out the type of the entrypoint parameter. In that
case, it'll show unbound type variable, usually arg0
:
>>>
:{
example :: (MonadCleveland caps m, NiceParameter cp, NiceParameter arg) => ContractHandle cp st vd -> arg -> m () example ch x = transfer ch (123 :: Mutez) $ calling def x :} ... ... Can not look up entrypoints in type ... cp ... The most likely reason it is ambiguous, or you need ... HasEntrypointArg cp (EntrypointRef 'Nothing) arg0 ... constraint ...
Either specifying a concrete type in the constraint, or leaving it polymorphic, fixes this:
>>>
:{
example :: ( MonadCleveland caps m, NiceParameter cp, NiceParameter arg , HasEntrypointArg cp (EntrypointRef 'Nothing) Integer) => ContractHandle cp st vd -> Integer -> m () example ch x = transfer ch (123 :: Mutez) $ calling def x :}
>>>
:{
example :: ( MonadCleveland caps m, NiceParameter cp, NiceParameter arg , HasEntrypointArg cp (EntrypointRef 'Nothing) arg) => ContractHandle cp st vd -> arg -> m () example ch x = transfer ch (123 :: Mutez) $ calling def x :}
transferTicket :: forall cp vd arg m addr ticketerAddr mname. (MonadOpsInternal m, NiceParameter arg, NiceComparable arg, ImplicitAddressParameterHelper addr cp (Ticket arg), ToL1TAddress cp vd addr, ToAddress ticketerAddr, HasEntrypointArg cp (EntrypointRef mname) (Ticket arg), HasCallStack) => addr -> EntrypointRef mname -> ticketerAddr -> arg -> Natural -> m [ContractEvent] Source #
Transfer tickets.
unsafeTransferTicket :: forall arg m addr ticketerAddr. (MonadOpsInternal m, NiceParameter arg, NiceComparable arg, ToL1Address addr, ToAddress ticketerAddr, HasCallStack) => addr -> EpName -> ticketerAddr -> arg -> Natural -> m [ContractEvent] Source #
Transfer tickets without checking the recipient can accept them.
data WithContractEvents Source #
transfer
flag to signal we want contract events emitted by EMIT
returned. Passed in the variadic part of transfer
, e.g.
transfer addr [tz|123u|] WithContractEvents $ calling (ep @"Entrypoint") ()
Instances
(TransferFunc mode 'TransferWithEmits am r, NoDuplicateEmit emit, emit ~ 'TransferIgnoreResult) => TransferFunc mode emit am (WithContractEvents -> r) Source # | |
Defined in Test.Cleveland.Internal.Actions.Transfer transfer'r :: GenericTransferData mode -> WithContractEvents -> r Source # |
calling :: forall mname. EntrypointRef mname -> forall epArg param. (NiceParameter epArg, HasEntrypointArg param (EntrypointRef mname) epArg) => epArg -> GenericCall ('Checked param) Source #
Safely call an entrypoint specified by the first argument with the provided parameter.
The first character of the entrypoint name must be capitalized.
This is "safe" in the sense that the contract is checked if it indeed has the specified entrypoint and the entrypoint in question accepts the argument provided, a type error is raised otherwise.
transfer addr $ calling (ep @"Entrypoint") ()
Use CallDefault
or def
to call the default entrypoint.
transfer addr $ calling def ()
Notice that type variables for entrypoint argument and full parameter are specified after the entrypoint. This is done so more for readability. F. ex.:
transfer addr $ calling def @Integer 123
This does also marginally simplify type inference in the case of partial application.
A class for types with a default value.
Nothing
Instances
unsafeCalling :: EpName -> forall epArg. NiceParameter epArg => epArg -> GenericCall 'Unchecked Source #
Unsafely call an entrypoint specified by the first argument with the provided parameter.
This is "unsafe" in the sense that there is no check that the contract indeed has the specified entrypoint or that the entrypoint in question accepts the argument provided.
Also, no compile-time checks are performed on the entrypoint name, so it can be malformed.
transfer addr $ unsafeCalling (ep @"Entrypoint") ()
Overloaded labels are supported with unsafeCalling
, so you can specify the
entrypoint as an overloaded label:
transfer addr $ unsafeCalling #entrypoint ()
Use DefEpName
or def
to call the default entrypoint.
Notice that the type variable for the entrypoint argument is specified after the entrypoint. This is done so more for readability. F. ex.:
transfer addr $ calling def @Integer 123
This does also marginally simplify type inference in the case of partial application.
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
.
noViews :: forall {k1} {k2} contract (cp :: k1) (st :: k2). contract cp st () -> contract cp st () #
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, ToL1Address addr) => addr -> m Mutez Source #
Get the balance of the given address.
getDelegate :: (HasCallStack, MonadCleveland caps m, ToL1Address addr) => addr -> m (Maybe KeyHash) Source #
Get the delegate for the given contract/implicit address.
registerDelegate :: (HasCallStack, MonadCleveland caps m) => ImplicitAddressWithAlias -> m () Source #
Register the given implicit address as a delegate.
setDelegate :: (HasCallStack, MonadCleveland caps m) => ImplicitAddressWithAlias -> Maybe KeyHash -> m () Source #
Set/unset 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, ToContractAddress 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) => ImplicitAddressWithAlias -> 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.
getMinBlockTime :: (HasCallStack, MonadCleveland caps m) => m Natural Source #
Get minimal block delay in seconds. This is essentially the same as
getApproximateBlockInterval
, but returns a Natural
instead of Time
Second
.
Can be useful when testing code using MIN_BLOCK_TIME
instruction.
data RunCode cp st vd Source #
The data needed to call the /run_code
RPC endpoint.
RunCode | |
|
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, MonadNetwork 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, MonadNetwork 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.
getTicketBalance :: (MonadCleveland caps m, HasNoOpToT a, NiceComparable a, ToL1Address addr, ToContractAddress contractAddr) => addr -> contractAddr -> a -> m Natural Source #
Get balance for a particular ticket.
getAllTicketBalances :: (MonadCleveland caps m, ToContractAddress addr) => addr -> m [SomeTicket] Source #
Get balance for all contract's tickets.
data SomeTicket where Source #
SomeTicket :: SingI t => Ticket (Value t) -> SomeTicket |
Instances
Eq SomeTicket Source # | |
Defined in Test.Cleveland.Internal.Abstract (==) :: SomeTicket -> SomeTicket -> Bool # (/=) :: SomeTicket -> SomeTicket -> Bool # | |
Buildable SomeTicket Source # | |
Defined in Test.Cleveland.Internal.Abstract build :: SomeTicket -> Doc buildList :: [SomeTicket] -> Doc |
Address conversions
Instances
ToAddress AddressAndAlias Source # | |
Defined in Test.Cleveland.Internal.Abstract toAddress :: AddressAndAlias -> Address # | |
ToAddress EpAddress | |
Defined in Lorentz.Address | |
ToAddress Address | |
Defined in Lorentz.Address | |
ToAddress L1Address | |
Defined in Lorentz.Address | |
ToAddress (FutureContract cp) | |
Defined in Lorentz.Address | |
ToAddress (ContractRef cp) | |
Defined in Lorentz.Address | |
ToAddress (KindedAddress kind) | |
Defined in Lorentz.Address toAddress :: KindedAddress kind -> Address # | |
ToAddress (AddressWithAlias kind) | |
Defined in Morley.Client.Types toAddress :: AddressWithAlias kind -> Address # | |
ToAddress (TAddress cp vd) | |
Defined in Lorentz.Address | |
ToAddress (ContractHandle cp st vd) Source # | |
Defined in Test.Cleveland.Lorentz.Types toAddress :: ContractHandle cp st vd -> Address # |
class ToL1Address addr where Source #
toL1Address :: addr -> L1Address Source #
Instances
ToL1Address L1Address Source # | |
Defined in Test.Cleveland.Lorentz.Types toL1Address :: L1Address -> L1Address Source # | |
L1AddressKind kind => ToL1Address (KindedAddress kind) Source # | |
Defined in Test.Cleveland.Lorentz.Types toL1Address :: KindedAddress kind -> L1Address Source # | |
L1AddressKind kind => ToL1Address (AddressWithAlias kind) Source # | |
Defined in Test.Cleveland.Lorentz.Types toL1Address :: AddressWithAlias kind -> L1Address Source # | |
ToL1Address (ContractHandle cp st vd) Source # | |
Defined in Test.Cleveland.Lorentz.Types toL1Address :: ContractHandle cp st vd -> L1Address Source # | |
ToL1Address (L1TAddress cp vd) Source # | |
Defined in Test.Cleveland.Lorentz.Types toL1Address :: L1TAddress cp vd -> L1Address Source # |
class (ToTAddress cp vd addr, ToL1Address addr) => ToL1TAddress cp vd addr where Source #
Counterpart of ToTAddress
that converts to L1TAddress
rather than
TAddress
.
toL1TAddress :: addr -> L1TAddress cp vd Source #
Instances
(ToTAddress cp vd addr, ToL1Address addr) => ToL1TAddress cp vd addr Source # | |
Defined in Test.Cleveland.Lorentz.Types toL1TAddress :: addr -> L1TAddress cp vd Source # |
class ToContractAddress addr where Source #
toContractAddress :: addr -> ContractAddress Source #
Instances
ToContractAddress ContractAddress Source # | |
Defined in Test.Cleveland.Lorentz.Types | |
ToContractAddress ContractAddressWithAlias Source # | |
ToContractAddress (ContractHandle cp st vd) Source # | |
Defined in Test.Cleveland.Lorentz.Types toContractAddress :: ContractHandle cp st vd -> ContractAddress Source # |
class ToImplicitAddress addr where Source #
toImplicitAddress :: addr -> ImplicitAddress Source #
Instances
Primitives re-exports
data EntrypointRef (mname :: Maybe Symbol) where #
CallDefault :: EntrypointRef ('Nothing :: Maybe Symbol) | |
Call :: forall (name :: Symbol). NiceEntrypointName name => EntrypointRef ('Just name) |
Instances
(CheckStuckEp cp mname arg' arg, 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) | |
(NiceEntrypointName epName, mname ~ 'Just epName) => EntrypointNameConstructor epName (EntrypointRef mname) Source # | |
Defined in Test.Cleveland.Internal.Abstract ep :: EntrypointRef mname Source # | |
mname ~ ('Nothing :: Maybe Symbol) => Default (EntrypointRef mname) Source # | |
Defined in Test.Cleveland.Instances def :: EntrypointRef mname # |
data VotingPowers #
Instances
FromJSON VotingPowers | |
Defined in Morley.Michelson.Runtime.GState parseJSON :: Value -> Parser VotingPowers # parseJSONList :: Value -> Parser [VotingPowers] # | |
ToJSON VotingPowers | |
Defined in Morley.Michelson.Runtime.GState toJSON :: VotingPowers -> Value # toEncoding :: VotingPowers -> Encoding # toJSONList :: [VotingPowers] -> Value # toEncodingList :: [VotingPowers] -> Encoding # | |
Show VotingPowers | |
Defined in Morley.Michelson.Runtime.GState showsPrec :: Int -> VotingPowers -> ShowS # show :: VotingPowers -> String # showList :: [VotingPowers] -> ShowS # | |
Eq VotingPowers | |
Defined in Morley.Michelson.Runtime.GState (==) :: VotingPowers -> VotingPowers -> Bool # (/=) :: VotingPowers -> VotingPowers -> Bool # |
Instances
tz :: QuasiQuoter #
mkVotingPowers :: [(KeyHash, Natural)] -> VotingPowers #
mkVotingPowersFromMap :: Map KeyHash Natural -> VotingPowers #
Assertions
failure :: forall a caps m. (HasCallStack, MonadCleveland caps m) => Doc -> m a Source #
Fails the test with the given error message.
assert :: (HasCallStack, MonadCleveland caps m) => Bool -> Doc -> 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) => Doc -> Maybe a -> m a Source #
evalRight :: (HasCallStack, MonadCleveland caps m) => (a -> Doc) -> Either a b -> m b Source #
Derive a Buildable
instance for a type using show
.
Showing a |
Calling views
:: forall name arg ret cp st vd m caps. (MonadCleveland caps m, HasView vd name arg ret, NiceParameter arg, NiceViewable ret, NiceStorage ret, KnownSymbol name, HasRPCRepr ret, IsoValue (AsRPC ret)) | |
=> ContractHandle cp st vd | Contract to call. |
-> Label name | View name. Use |
-> arg | Parameter to pass to the view. |
-> m (AsRPC ret) |
Call an on-chain view by name. The existence of the view is checked at
compile time. If you don't have compile-time information about views, see
unsafeCallView
.
Example:
callView contract #sum (123, -321)
:: forall ret arg name addr m caps. (MonadCleveland caps m, NiceParameter arg, NiceViewable ret, NiceStorage ret, KnownSymbol name, HasRPCRepr ret, IsoValue (AsRPC ret), ToContractAddress addr) | |
=> addr | Contract to call. |
-> Label name | View name. Use |
-> arg | Parameter to pass to the view. |
-> m (AsRPC ret) |
Version of callView
that doesn't check if the view exists in the type.
You'll have to specify the return type. You can use TypeApplications
syntax
for that.
If the view doesn't exist or has incorrect type, a test failure will be thrown.
Note that first type argument is return type, the second is parameter type. The reason for this inversion is you often only need to specify the return type, while the parameter type can be either inferred or explicitly specified with a type annotation on the parameter argument value.
Examples:
unsafeCallView @() contract #id ()
Calls view id
with argument unit
and return type unit
.
unsafeCallView @(Integer, MText) contract #query [mt|hello|]
Calls view query
with argument string
and return type pair int string
.
unsafeCallView @Integer contract #sum (123 :: Natural, -321 :: Integer)
Calls view sum
with argument pair nat int
and return type int
. Type
annotations are required due to polymorphic numeric literals.
This last example could also be written as
unsafeCallView @Integer @(Natural, Integer) contract #sum (123, -321)
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.
expectCustomErrorAnyArg :: (HasCallStack, MonadCleveland caps m) => Label tag -> m a -> m () Source #
Version of expectCustomError
that ignores the argument (or whether it
even exists) and only checks the tag.
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 => Doc -> m a -> m a Source #
Prefix error messages 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
Boolean TransferFailurePredicate Source # | |
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 :: SpecificOrDefaultAlias Source #
Helper to use automatically determined unique alias.
ep :: EntrypointNameConstructor epName a => a Source #
A short partial constructor for EpName
or EntrypointRef
. It accepts a
type-level string as its type argument. The programmer is responsible for
validity. And this code is for tests anyway, so each failure is a
programmer mistake.
Note that entrypoint names should be capitalized, e.g.
ep @"Entrypoint"
corresponds to entrypoint
, etc.
It is intentionally here and not in some deeper module because the name is really short and more suitable for writing scenarios.
For EpName
, an instance is provided accepting a value-level Text
instead of a type-level symbol. This is mostly for cases where the
type-level symbol doesn't work. Note that value-level string will be used
verbatim, hence capitalization is arbitrary.
ep "entrypoint"
(?-) :: Text -> a -> (Text, a) infixr 0 Source #
Make a tuple with name without extra syntactic noise.
type (:!) (name :: Symbol) a = NamedF Identity a name #
Infix notation for the type of a named parameter.
newtype NamedF (f :: Type -> Type) a (name :: Symbol) #
Assign a name to a value of type a
wrapped in f
.
#verbose True :: NamedF Identity Bool "verbose"
pattern Arg :: a -> name :! a | Match on an argument without specifying its name. See also: |
pattern (:?) :: Name name -> Maybe a -> NamedF Maybe a name | |
pattern (:!) :: Name name -> a -> NamedF Identity a name |
Instances
(name ~ name', a ~ a', InjValue f) => IsLabel name (a -> NamedF f a' name') | |
Defined in Named.Internal | |
CanCastTo (f a) (g b) => CanCastTo (NamedF f a n :: Type) (NamedF g b m :: Type) | |
(HasAnnotation a, KnownSymbol name) => HasAnnotation (NamedF Identity a name) | |
Defined in Lorentz.Annotation getAnnotation :: FollowEntrypointFlag -> Notes (ToT (NamedF Identity a name)) annOptions :: Maybe AnnOptions | |
(HasAnnotation (Maybe a), KnownSymbol name) => HasAnnotation (NamedF Maybe a name) | |
Defined in Lorentz.Annotation getAnnotation :: FollowEntrypointFlag -> Notes (ToT (NamedF Maybe a name)) annOptions :: Maybe AnnOptions | |
Unwrappable (NamedF Identity a name) | |
Defined in Lorentz.Wrappable | |
Unwrappable (NamedF Maybe a name) | |
Defined in Lorentz.Wrappable | |
Wrappable (NamedF Identity a name) | |
Defined in Lorentz.Wrappable | |
Wrappable (NamedF Maybe a name) | |
Defined in Lorentz.Wrappable | |
HasRPCRepr a => HasRPCRepr (NamedF Identity a name) | |
Defined in Morley.AsRPC | |
HasRPCRepr a => HasRPCRepr (NamedF Maybe a name) | |
Defined in Morley.AsRPC | |
(TypeHasDoc (ApplyNamedFunctor f a), KnownSymbol n, KnownIsoT (ApplyNamedFunctor f Integer), Typeable f, Typeable a) => TypeHasDoc (NamedF f a n) | |
Defined in Morley.Michelson.Typed.Haskell.Doc type TypeDocFieldDescriptions (NamedF f a n) :: FieldDescriptions typeDocName :: Proxy (NamedF f a n) -> Text typeDocMdDescription :: Markdown typeDocMdReference :: Proxy (NamedF f a n) -> WithinParens -> Markdown typeDocDependencies :: Proxy (NamedF f a n) -> [SomeDocDefinitionItem] typeDocHaskellRep :: TypeDocHaskellRep (NamedF f a n) typeDocMichelsonRep :: TypeDocMichelsonRep (NamedF f a n) | |
IsoValue a => IsoValue (NamedF Identity a name) | |
IsoValue a => IsoValue (NamedF Maybe a name) | |
type Unwrappabled (NamedF Identity a name) | |
Defined in Lorentz.Wrappable | |
type Unwrappabled (NamedF Maybe a name) | |
Defined in Lorentz.Wrappable | |
type AsRPC (NamedF Identity a name) | |
type AsRPC (NamedF Maybe a name) | |
type TypeDocFieldDescriptions (NamedF f a n) | |
type ToT (NamedF Identity a name) | |
Defined in Morley.Michelson.Typed.Haskell.Value | |
type ToT (NamedF Maybe a name) | |
Defined in Morley.Michelson.Typed.Haskell.Value |
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 #
TezosClientEnv | |
|
data MorleyClientEnv #
MorleyClientEnv | |
|
Instances
HasTezosClientEnv MorleyClientEnv | |
MonadReader MorleyClientEnv MorleyClientM | |
Defined in Morley.Client.TezosClient.Types.MorleyClientM ask :: MorleyClientM MorleyClientEnv # local :: (MorleyClientEnv -> MorleyClientEnv) -> MorleyClientM a -> MorleyClientM a # reader :: (MorleyClientEnv -> a) -> MorleyClientM a # | |
HasLog MorleyClientEnv Message MorleyClientM | |
Defined in Morley.Client.TezosClient.Types.MorleyClientM 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) # |
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
Utilities
mapEach :: (Each s t a b, Applicative m) => (a -> m b) -> s -> m t Source #