Test.Cleveland.Internal.Abstract

Abstract cleveland interface not bound to a particular implementation.

The interface may look a bit untyped and unsafe in some places. For example, in order to call a contract one should supply a simple address rather than a contract ref, so it is easy to pass a value of wrong type. Also it is easy to call a non-existing entrypoint.

Subjectively, it makes writing test scenarios easier because you have to prove less to the compiler. It also makes implementation of cleveland engine a bit easier. Of course, it also makes it easier to make certain mistakes. However, we expect users of this interface to also use the functionality of the Test.Cleveland.Internal.Pure module and convert cleveland scenarios to purely testable scenarios for integrational testing engine. In this case errors should be detected almost as quickly as they would reported by the compiler, at least before trying to run scenario on a live network.

Also this interface uses Address rather than EpAddress. I (@gromak) concluded that EpAddress can not be passed to octez-client. For key addresses it just does not make sense and for contract addresses I get such errors:

  bad contract notation
  Invalid contract notation "KT1VrFpBPwBTm3hsK7DB7SPmY8fTHJ3vY6sJ%mint"

Documentation

type LogsInfo = [ScenarioLogs]

data ScenarioLogs

Constructors

ScenarioLogs

Fields

• _slAddr :: Address
• _slLog :: MorleyLogs

Instances

Show ScenarioLogs

Defined in Test.Cleveland.Internal.Abstract

Methods

showsPrec :: Int -> ScenarioLogs -> ShowS

show :: ScenarioLogs -> String

showList :: [ScenarioLogs] -> ShowS

Eq ScenarioLogs

Defined in Test.Cleveland.Internal.Abstract

Methods

(==) :: ScenarioLogs -> ScenarioLogs -> Bool

(/=) :: ScenarioLogs -> ScenarioLogs -> Bool

MonadWriter LogsInfo PureM

Defined in Test.Cleveland.Internal.Pure

Methods

writer :: (a, LogsInfo) -> PureM a

tell :: LogsInfo -> PureM ()

listen :: PureM a -> PureM (a, LogsInfo)

pass :: PureM (a, LogsInfo -> LogsInfo) -> PureM a

data NetworkEnv

Constructors

NetworkEnv

Fields

• neMorleyClientEnv :: MorleyClientEnv
• neSecretKey :: Maybe SecretKey
• neMoneybagAlias :: ImplicitAlias
• neExplicitDataDir :: Bool
• neVerbosity :: Word

data EmulatedImpl m

A record data type with all base methods one can use during cleveland, but which are available only when running on an emulated environment (e.g. Morley.Michelson.Runtime) and not on a real network.

Constructors

EmulatedImpl

Fields

• eiBranchout :: [(Text, m ())] -> m ()

  Execute multiple testing scenarios independently.

  • Actions performed before eiBranchout will be observed by all branches.
  • Actions performed in branches will _not_ be observed by any actions performed after eiBranchout.
  • 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.

• eiGetStorage :: forall st addr. (HasCallStack, ToStorageType st addr) => addr -> m st

  Retrieve a contract's full storage, including the contents of its big_maps. This function can only be used in emulator-only tests.

• eiGetMorleyLogs :: forall a. m a -> m (LogsInfo, a)

  Returns the result of the action with the logs it produced

• eiSetVotingPowers :: VotingPowers -> m ()

  Change voting power distribution.

data RunCode cp st vd

The data needed to call the /run_code RPC endpoint.

Constructors

RunCode

Fields

• rcContract :: Contract cp st vd
• rcParameter :: Value

  The parameter value should have the same "structure" as cp, except it _may_ also have big_map IDs. E.g. if the contract's parameter is pair (big_map string string) (big_map string string), then rcParameter may be one of:

  • pair (big_map string string) (big_map string string)

  • pair nat (big_map string string)

  • pair (big_map string string) nat

  • pair nat nat

  ... where nat represents a big_map ID.

• rcStorage :: Value

  The storage value should have the same "structure" as st, except it _may_ also have big_map IDs. See the documentation of rcParameter.

• rcAmount :: Mutez

  The value that will be returned by the AMOUNT instruction.

• rcLevel :: Maybe Natural

  The value that will be returned by the LEVEL instruction.

• rcNow :: Maybe Timestamp

  The value that will be returned by the NOW instruction.

• rcBalance :: Mutez

  The balance that will be returned by the BALANCE instruction.

• rcSource :: Maybe ImplicitAddress

  The value that will be returned by the SOURCE instruction.

data SomeTicket where

Constructors

SomeTicket :: SingI t => Ticket (Value t) -> SomeTicket

Instances

Eq SomeTicket

Defined in Test.Cleveland.Internal.Abstract

Methods

(==) :: SomeTicket -> SomeTicket -> Bool

(/=) :: SomeTicket -> SomeTicket -> Bool

Buildable SomeTicket

Defined in Test.Cleveland.Internal.Abstract

Methods

build :: SomeTicket -> Doc

buildList :: [SomeTicket] -> Doc

data ClevelandMiscImpl m

A record data type with all base methods one can use during a cleveland test.

Constructors

ClevelandMiscImpl

Fields

• cmiRunIO :: forall res. HasCallStack => IO res -> m res

  Runs an IO action.

• cmiResolveAddress :: forall kind. HasCallStack => AddressOrAlias kind -> m (AddressWithAlias kind)

  Get the address of the implicit account / contract associated with the given alias.

• cmiGenKey :: HasCallStack => SpecificOrDefaultAlias -> m ImplicitAddressWithAlias

  Generate a secret key and store it with given alias. If a key with this alias already exists, the corresponding address will be returned and no state will be changed.

• cmiImportKey :: HasCallStack => SecretKey -> SpecificOrDefaultAlias -> m ImplicitAddressWithAlias

  Import a given secret key.

• cmiGenFreshKey :: HasCallStack => SpecificOrDefaultAlias -> m ImplicitAddressWithAlias

  Generate a secret key and store it with given alias. Unlike cmiGenKey this function overwrites the existing key when given alias is already stored.

• cmiSignBytes :: HasCallStack => ByteString -> ImplicitAddressWithAlias -> m Signature

  Get the signature of the preapplied operation.

• cmiOriginateLargeUntyped :: forall oty. HasCallStack => Sender -> OriginateData oty 'IsLarge -> m ContractAddress

  Originate a new raw Michelson contract that doesn't fit into the origination size limit, by executing multiple operation steps.

  Note that this is not part of ClevelandOpsImpl because large origination is _not_ a primitive operation. Also, it cannot appear in a batch (it simply may not fit).

• cmiComment :: HasCallStack => Text -> m ()

  Print the given string verbatim as a comment. At the moment, this is a no-op in emulator tests.

• cmiGetBalance :: HasCallStack => L1Address -> m Mutez

  Get the balance of the given address.

• cmiGetSomeStorage :: HasCallStack => ContractAddress -> m SomeAnnotatedValue
• cmiGetBigMapValueMaybe :: forall k v. (HasCallStack, NiceComparable k, NicePackedValue k, NiceUnpackedValue v) => BigMapId k v -> k -> m (Maybe v)

  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.

• cmiGetAllBigMapValuesMaybe :: forall k v. (HasCallStack, NiceComparable k, NiceUnpackedValue v) => BigMapId k v -> m (Maybe [v])

  Retrieve all big_map values, given a big_map ID. Returns Nothing when the big_map ID does not exist.

• cmiGetPublicKey :: HasCallStack => ImplicitAddressWithAlias -> m PublicKey

  Get the public key associated with the given address. Fail if the given address is not an implicit account.

• cmiGetDelegate :: HasCallStack => L1Address -> m (Maybe KeyHash)

  Get the delegate for the given contract. Fails on implicit contracts.

• cmiGetChainId :: HasCallStack => m ChainId

  Get the chain's ChainId.

• cmiAdvanceTime :: forall unit. (HasCallStack, KnownDivRat unit Second) => Time unit -> m ()

  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.

• cmiAdvanceToLevel :: HasCallStack => (Natural -> Natural) -> m ()

  Advance at least to the level returned by the callback, accepting current level.

• cmiGetNow :: HasCallStack => m Timestamp

  Get the timestamp observed by the last block to be baked.

• cmiGetLevel :: HasCallStack => m Natural

  Get the current level observed by the last block to be baked.

• cmiFailure :: forall a. HasCallStack => Doc -> m a

  Fails the test with the given error message.

• cmiThrow :: forall a. HasCallStack => SomeException -> m a

  Rethrow arbitrary error without affecting the call stack. Used internally. You probably want to use cmiFailure

• cmiGetApproximateBlockInterval :: HasCallStack => m (Time Second)

  Get approximate block interval in seconds. Note, that this value is minimal bound and real intervals can be larger.

• cmiAttempt :: forall a e. (Exception e, HasCallStack) => m a -> m (Either e a)

  Attempts to perform an action, returning either the result of the action or an exception.

• cmiMarkAddressRefillable :: ImplicitAddress -> m ()

  Marks a given address as "refillable", i.e. if the address lacks funds for the next operation, some funds will automatically be transferred to it.

• cmiUnderlyingImpl :: m (Either (EmulatedImpl m) NetworkEnv)

  Produce underlying implementation specific data. Used to run emulation-only or network-only actions in a polymorphic context.

• cmiRunCode :: forall cp st vd. (HasCallStack, HasRPCRepr st, IsoValue (AsRPC st)) => Sender -> RunCode cp st vd -> m (AsRPC st)

  Execute a contract's code without originating it. The chain's state will not be modified.

• cmiTicketBalance :: forall t. (ForbidOp t, Comparable t) => L1Address -> ContractAddress -> Value t -> m Natural

  Get balance for a praticular ticket.

• cmiAllTicketBalances :: ContractAddress -> m [SomeTicket]

  Get balance for all tickets by scanning the contract's storage.

data ClevelandOpsImpl m

A record data type with operations creating primitives.

Constructors

ClevelandOpsImpl

Fields

• coiRunOperationBatch :: HasCallStack => [OperationInfo ClevelandInput] -> m [OperationInfo ClevelandResult]

  Perform a batch of operations.

newtype DefaultAliasCounter

Counter which is used to provide different default aliases.

Constructors

DefaultAliasCounter

Fields

• unDefaultAliasCounter :: Natural

Instances

Show DefaultAliasCounter

Defined in Test.Cleveland.Internal.Abstract

Methods

showsPrec :: Int -> DefaultAliasCounter -> ShowS

show :: DefaultAliasCounter -> String

showList :: [DefaultAliasCounter] -> ShowS

Eq DefaultAliasCounter

Defined in Test.Cleveland.Internal.Abstract

Methods

(==) :: DefaultAliasCounter -> DefaultAliasCounter -> Bool

(/=) :: DefaultAliasCounter -> DefaultAliasCounter -> Bool

data SpecificOrDefaultAlias

An alias with default value that can be used to define unique alias automatically.

Constructors

SpecificAlias ImplicitAlias

DefaultAlias

Instances

IsString SpecificOrDefaultAlias

Defined in Test.Cleveland.Internal.Abstract

Methods

fromString :: String -> SpecificOrDefaultAlias

Show SpecificOrDefaultAlias

Defined in Test.Cleveland.Internal.Abstract

Methods

showsPrec :: Int -> SpecificOrDefaultAlias -> ShowS

show :: SpecificOrDefaultAlias -> String

showList :: [SpecificOrDefaultAlias] -> ShowS

Default SpecificOrDefaultAlias

Defined in Test.Cleveland.Internal.Abstract

Methods

def :: SpecificOrDefaultAlias

newtype Moneybag

Designates the address that gifts money to new addresses.

Once a new address is allocated in a test scenario, we have to transfer some money to it so that it is able to serve as transactions sender. Moneybag serves as a source of that money.

We do not use Sender for this purpose because in most situations changing moneybag is not necessary. If a user wraps a large piece of their script with withSender call and that changes the moneybag - this behaviour may be undesired and unexpected to the user.

Constructors

Moneybag

Fields

• unMoneybag :: ImplicitAddressWithAlias

newtype Sender

Designates the special sender address.

Transfers and some other operations will occur on behalf of this address. This is initialized to moneybag address and then can be locally modified.

Operations in ClevelandOpsImpl are affected by this address.

Constructors

Sender

Fields

• unSender :: ImplicitAddressWithAlias

data BatchResultMismatch

A batch returned invalid output, e.g. origination address when transaction was supplied.

Constructors

BatchResultMismatch Text

Carries expected operation type in lowercase

Instances

Buildable BatchResultMismatch

Defined in Test.Cleveland.Internal.Abstract

Methods

build :: BatchResultMismatch -> Doc

buildList :: [BatchResultMismatch] -> Doc

data ClevelandResult

Designates an operation result.

Instances

OperationInfoDescriptor ClevelandResult

Defined in Test.Cleveland.Internal.Abstract

Associated Types

type TransferInfo ClevelandResult

type TransferTicketInfo ClevelandResult

type OriginationInfo ClevelandResult

type RevealInfo ClevelandResult

type DelegationInfo ClevelandResult

type DelegationInfo ClevelandResult

Defined in Test.Cleveland.Internal.Abstract

type DelegationInfo ClevelandResult = DelegationInfo Result

type OriginationInfo ClevelandResult

Defined in Test.Cleveland.Internal.Abstract

type OriginationInfo ClevelandResult = OriginationInfo Result

type RevealInfo ClevelandResult

Defined in Test.Cleveland.Internal.Abstract

type RevealInfo ClevelandResult = RevealInfo Result

type TransferInfo ClevelandResult

Defined in Test.Cleveland.Internal.Abstract

type TransferInfo ClevelandResult = [ContractEvent]

type TransferTicketInfo ClevelandResult

Defined in Test.Cleveland.Internal.Abstract

type TransferTicketInfo ClevelandResult = [ContractEvent]

data ContractEvent

Data structure representing a contract event.

Constructors

ContractEvent

Fields

• ceSource :: ContractAddress
• ceTag :: Text
• cePayload :: Maybe SomeAnnotatedValue

data ClevelandInput

Designates an operation input.

Instances

OperationInfoDescriptor ClevelandInput

Defined in Test.Cleveland.Internal.Abstract

Associated Types

type TransferInfo ClevelandInput

type TransferTicketInfo ClevelandInput

type OriginationInfo ClevelandInput

type RevealInfo ClevelandInput

type DelegationInfo ClevelandInput

type DelegationInfo ClevelandInput

Defined in Test.Cleveland.Internal.Abstract

type DelegationInfo ClevelandInput = Maybe KeyHash

type OriginationInfo ClevelandInput

Defined in Test.Cleveland.Internal.Abstract

type OriginationInfo ClevelandInput = SomeOriginateData 'NotLarge

type RevealInfo ClevelandInput

Defined in Test.Cleveland.Internal.Abstract

type RevealInfo ClevelandInput = PublicKey

type TransferInfo ClevelandInput

Defined in Test.Cleveland.Internal.Abstract

type TransferInfo ClevelandInput = TransferData

type TransferTicketInfo ClevelandInput

Defined in Test.Cleveland.Internal.Abstract

type TransferTicketInfo ClevelandInput = TransferTicketData

data SomeOriginateData large where

OriginateData existential over OriginationType.

Constructors

SomeOriginateData :: OriginateData oty large -> SomeOriginateData large

newtype TypedContract cp st vd

A wrapper around Contract to reduce awkwardness

Constructors

TypedContract (Contract (ToT cp) (ToT st))

Instances

(NiceStorage st, NiceViewsDescriptor vd, NiceParameter cp) => ContractClass (TypedContract cp st vd)

Defined in Test.Cleveland.Internal.Actions.Originate

Associated Types

type ContractOriginateType (TypedContract cp st vd) :: OriginationType

Methods

initialStorageAndContract :: ContractStorage (TypedContract cp st vd) -> TypedContract cp st vd -> ODContractAndStorage (ContractOriginateType (TypedContract cp st vd))

type ContractOriginateType (TypedContract cp st vd)

Defined in Test.Cleveland.Internal.Actions.Originate

type ContractOriginateType (TypedContract cp st vd) = 'OTTypedMorley cp st vd

data TransferTicketData

Information about transfer operation.

Constructors

forall t addr.(WellTyped t, ToL1Address addr) => TransferTicketData

Fields

• ttdTo :: addr

  Receiver address for this transaction.

• ttdEntrypoint :: EpName

  An entrypoint to be called.

• ttdParameter :: Value ('TTicket t)

  Ticket and amount to transfer.

data TransferData

Information about transfer operation.

Constructors

forall v addr.(NiceParameter v, ToL1Address addr) => TransferData

Fields

• tdTo :: addr

  Receiver address for this transaction.

• tdAmount :: Mutez

  Amount to be transferred.

• tdEntrypoint :: EpName

  An entrypoint to be called. Consider using ep in testing scenarios.

• tdParameter :: v

  Parameter that will be used for a contract call. Set to () for transfers to key addresses.

data ODContractAndStorage oty where

Constructors

ODContractAndStorageLorentz

Lorentz contract and storage.

Fields

• :: { odStorage :: st

  Initial storage.

•    , odContract :: Contract param st vd

  The contract itself.

  We are using Lorentz version here which is convenient. However, keep in mind that if someone wants to test a contract from .tz file, they should use OTUntyped origination type.

•    } -> ODContractAndStorage ('OTTypedLorentz param st vd)

ODContractAndStorageUntyped

Untyped contract and storage.

Fields

• :: { uodStorage :: Value

  Initial storage.

•    , uodContract :: Contract

  The contract itself.

•    } -> ODContractAndStorage 'OTUntyped

ODContractAndStorageTyped

Typed Morley contract and storage.

Fields

• :: (NiceStorage st, NiceViewsDescriptor vd, NiceParameter cp)
• => { todStorage :: st

  Initial storage.

•    , todContract :: Contract (ToT cp) (ToT st)

  The contract itself.

•    } -> ODContractAndStorage ('OTTypedMorley cp st vd)

data OriginateData oty large

Data common for all origination types.

Constructors

OriginateData

Fields

• odName :: ContractAlias

  Alias for the originated contract.

• odBalance :: Mutez

  Initial balance.

• odDelegate :: Maybe KeyHash

  Contract delegate.

• odContractAndStorage :: ODContractAndStorage oty

data OriginationType where

Constructors

OTTypedLorentz :: Type -> Type -> Type -> OriginationType

OTTypedMorley :: Type -> Type -> Type -> OriginationType

OTUntyped :: OriginationType

data LargeOrigination

Whether this contract should be originated in a single origination operation or, if it goes over the origination size limit, in multiple operations.

Constructors

IsLarge

NotLarge

mkDefaultAlias :: Natural -> ImplicitAlias

auto :: SpecificOrDefaultAlias

Helper to use automatically determined unique alias.

slAddr :: Lens' ScenarioLogs Address

slLog :: Lens' ScenarioLogs MorleyLogs

data NetworkCaps m

A record with all the capabilities available to a cleveland test on the network.

Constructors

NetworkCaps

Fields

• ncNetworkEnv :: NetworkEnv
• ncClevelandCaps :: ClevelandCaps m

Instances

Monad m => HasClevelandCaps (NetworkCaps m)

Defined in Test.Cleveland.Internal.Abstract

Associated Types

type ClevelandBaseMonad (NetworkCaps m) :: Type -> Type

Methods

clevelandCapsL :: Lens' (NetworkCaps m) (ClevelandCaps (ClevelandBaseMonad (NetworkCaps m)))

Monad m => HasNetworkCaps (NetworkCaps m)

Defined in Test.Cleveland.Internal.Abstract

Methods

getNetworkEnvCap :: NetworkCaps m -> NetworkEnv

type ClevelandBaseMonad (NetworkCaps m)

Defined in Test.Cleveland.Internal.Abstract

type ClevelandBaseMonad (NetworkCaps m) = m

data EmulatedCaps m

A record with all the capabilities available to a cleveland test on the emulator.

Constructors

EmulatedCaps

Fields

• ecEmulatedCap :: EmulatedImpl m
• ecClevelandCaps :: ClevelandCaps m

Instances

Monad m => HasClevelandCaps (EmulatedCaps m)

Defined in Test.Cleveland.Internal.Abstract

Associated Types

type ClevelandBaseMonad (EmulatedCaps m) :: Type -> Type

Methods

clevelandCapsL :: Lens' (EmulatedCaps m) (ClevelandCaps (ClevelandBaseMonad (EmulatedCaps m)))

Monad m => HasEmulatedCaps (EmulatedCaps m)

Defined in Test.Cleveland.Internal.Abstract

Methods

getEmulatedCap :: EmulatedCaps m -> EmulatedImpl (ClevelandBaseMonad (EmulatedCaps m))

type ClevelandBaseMonad (EmulatedCaps m)

Defined in Test.Cleveland.Internal.Abstract

type ClevelandBaseMonad (EmulatedCaps m) = m

data ClevelandCaps m

A record with all the capabilities available to any cleveland test.

Constructors

ClevelandCaps

Fields

• ccSender :: Sender
• ccMoneybag :: Moneybag
• ccMiscCap :: ClevelandMiscImpl m
• ccOpsCap :: Sender -> ClevelandOpsImpl m

Instances

Monad m => HasClevelandCaps (ClevelandCaps m)

Defined in Test.Cleveland.Internal.Abstract

Associated Types

type ClevelandBaseMonad (ClevelandCaps m) :: Type -> Type

Methods

clevelandCapsL :: Lens' (ClevelandCaps m) (ClevelandCaps (ClevelandBaseMonad (ClevelandCaps m)))

type ClevelandBaseMonad (ClevelandCaps m)

Defined in Test.Cleveland.Internal.Abstract

type ClevelandBaseMonad (ClevelandCaps m) = m

class NiceEntrypointName epName => EntrypointNameConstructor (epName :: Symbol) a where

Methods

ep :: a

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"

Instances

NiceEntrypointName epName => EntrypointNameConstructor epName EpName

Defined in Test.Cleveland.Internal.Abstract

Methods

ep :: EpName

(NiceEntrypointName epName, mname ~ 'Just epName) => EntrypointNameConstructor epName (EntrypointRef mname)

Defined in Test.Cleveland.Internal.Abstract

Methods

ep :: EntrypointRef mname

(any ~ "", t ~ Text) => EntrypointNameConstructor any (t -> EpName)

Defined in Test.Cleveland.Internal.Abstract

Methods

ep :: t -> EpName

data GenericTestError

Constructors

UnexpectedSuccess

Instances

Exception GenericTestError

Defined in Test.Cleveland.Internal.Abstract

Methods

toException :: GenericTestError -> SomeException

fromException :: SomeException -> Maybe GenericTestError

displayException :: GenericTestError -> String

Show GenericTestError

Defined in Test.Cleveland.Internal.Abstract

Methods

showsPrec :: Int -> GenericTestError -> ShowS

show :: GenericTestError -> String

showList :: [GenericTestError] -> ShowS

Buildable GenericTestError

Defined in Test.Cleveland.Internal.Abstract

Methods

build :: GenericTestError -> Doc

buildList :: [GenericTestError] -> Doc

data TransferFailureReason

Constructors

FailedWith ExpressionOrTypedValue (Maybe ErrorSrcPos)

Expect that interpretation of contract with the given address ended with FAILWITH.

EmptyTransaction

Expect failure due to an attempt to transfer 0tz towards a simple address.

BadParameter

Expect failure due to an attempt to call a contract with an invalid parameter.

MutezArithError MutezArithErrorType

Expect failure due to an arithmetic over-/underflow

ShiftOverflow

Expect that interpretation of contract with the given address ended with an overflow error.

GasExhaustion

Instances

Show TransferFailureReason

Defined in Test.Cleveland.Internal.Abstract

Methods

showsPrec :: Int -> TransferFailureReason -> ShowS

show :: TransferFailureReason -> String

showList :: [TransferFailureReason] -> ShowS

Eq TransferFailureReason

Defined in Test.Cleveland.Internal.Abstract

Methods

(==) :: TransferFailureReason -> TransferFailureReason -> Bool

(/=) :: TransferFailureReason -> TransferFailureReason -> Bool

Buildable TransferFailureReason

Defined in Test.Cleveland.Internal.Abstract

Methods

build :: TransferFailureReason -> Doc

buildList :: [TransferFailureReason] -> Doc

type ToCallSeqM k = State [(k, [CallSequenceOp])]

Helper synonym for toCallSeq

data CallSequenceOp

Constructors

forall a.(Buildable a, Show a) => CallSequenceOp

Fields

• csoData :: a
• csoSubCalls :: CallSequence

Instances

Show CallSequenceOp

Defined in Test.Cleveland.Internal.Abstract

Methods

showsPrec :: Int -> CallSequenceOp -> ShowS

show :: CallSequenceOp -> String

showList :: [CallSequenceOp] -> ShowS

Buildable CallSequenceOp

Defined in Test.Cleveland.Internal.Abstract

Methods

build :: CallSequenceOp -> Doc

buildList :: [CallSequenceOp] -> Doc

newtype CallSequence

Constructors

CallSequence [CallSequenceOp]

Instances

Monoid CallSequence

Defined in Test.Cleveland.Internal.Abstract

Methods

mempty :: CallSequence

mappend :: CallSequence -> CallSequence -> CallSequence

mconcat :: [CallSequence] -> CallSequence

Semigroup CallSequence

Defined in Test.Cleveland.Internal.Abstract

Methods

(<>) :: CallSequence -> CallSequence -> CallSequence

sconcat :: NonEmpty CallSequence -> CallSequence

stimes :: Integral b => b -> CallSequence -> CallSequence

Show CallSequence

Defined in Test.Cleveland.Internal.Abstract

Methods

showsPrec :: Int -> CallSequence -> ShowS

show :: CallSequence -> String

showList :: [CallSequence] -> ShowS

Buildable CallSequence

Defined in Test.Cleveland.Internal.Abstract

Methods

build :: CallSequence -> Doc

buildList :: [CallSequence] -> Doc

Container CallSequence

Defined in Test.Cleveland.Internal.Abstract

Associated Types

type Element CallSequence

Methods

toList :: CallSequence -> [Element CallSequence]

null :: CallSequence -> Bool

foldr :: (Element CallSequence -> b -> b) -> b -> CallSequence -> b

foldl :: (b -> Element CallSequence -> b) -> b -> CallSequence -> b

foldl' :: (b -> Element CallSequence -> b) -> b -> CallSequence -> b

length :: CallSequence -> Int

elem :: Element CallSequence -> CallSequence -> Bool

foldMap :: Monoid m => (Element CallSequence -> m) -> CallSequence -> m

fold :: CallSequence -> Element CallSequence

foldr' :: (Element CallSequence -> b -> b) -> b -> CallSequence -> b

notElem :: Element CallSequence -> CallSequence -> Bool

all :: (Element CallSequence -> Bool) -> CallSequence -> Bool

any :: (Element CallSequence -> Bool) -> CallSequence -> Bool

and :: CallSequence -> Bool

or :: CallSequence -> Bool

find :: (Element CallSequence -> Bool) -> CallSequence -> Maybe (Element CallSequence)

safeHead :: CallSequence -> Maybe (Element CallSequence)

safeMaximum :: CallSequence -> Maybe (Element CallSequence)

safeMinimum :: CallSequence -> Maybe (Element CallSequence)

safeFoldr1 :: (Element CallSequence -> Element CallSequence -> Element CallSequence) -> CallSequence -> Maybe (Element CallSequence)

safeFoldl1 :: (Element CallSequence -> Element CallSequence -> Element CallSequence) -> CallSequence -> Maybe (Element CallSequence)

type Element CallSequence

Defined in Test.Cleveland.Internal.Abstract

type Element CallSequence = Element [CallSequenceOp]

data TransferFailure

Failures that could be expected in the execution of a transfer. These can be caught and handled with attempt.

Constructors

TransferFailure

Fields

• tfAddressAndAlias :: AddressAndAlias
• tfCallSeqence :: CallSequence
• tfReason :: TransferFailureReason

Instances

Exception TransferFailure

Defined in Test.Cleveland.Internal.Abstract

Methods

toException :: TransferFailure -> SomeException

fromException :: SomeException -> Maybe TransferFailure

displayException :: TransferFailure -> String

Show TransferFailure

Defined in Test.Cleveland.Internal.Abstract

Methods

showsPrec :: Int -> TransferFailure -> ShowS

show :: TransferFailure -> String

showList :: [TransferFailure] -> ShowS

Eq TransferFailure

Defined in Test.Cleveland.Internal.Abstract

Methods

(==) :: TransferFailure -> TransferFailure -> Bool

(/=) :: TransferFailure -> TransferFailure -> Bool

Buildable TransferFailure

Defined in Test.Cleveland.Internal.Abstract

Methods

build :: TransferFailure -> Doc

buildList :: [TransferFailure] -> Doc

data AddressAndAlias

Constructors

forall kind. AddressAndAlias (KindedAddress kind) (Maybe (Alias kind))

Instances

Show AddressAndAlias

Defined in Test.Cleveland.Internal.Abstract

Methods

showsPrec :: Int -> AddressAndAlias -> ShowS

show :: AddressAndAlias -> String

showList :: [AddressAndAlias] -> ShowS

Eq AddressAndAlias

Defined in Test.Cleveland.Internal.Abstract

Methods

(==) :: AddressAndAlias -> AddressAndAlias -> Bool

(/=) :: AddressAndAlias -> AddressAndAlias -> Bool

ToAddress AddressAndAlias

Defined in Test.Cleveland.Internal.Abstract

Methods

toAddress :: AddressAndAlias -> Address

Buildable AddressAndAlias

Defined in Test.Cleveland.Internal.Abstract

Methods

build :: AddressAndAlias -> Doc

buildList :: [AddressAndAlias] -> Doc

data ExpressionOrTypedValue where

Representation of Expression we got from the RPC or a typed value we got from the emulator.

Constructors

EOTVExpression :: Expression -> ExpressionOrTypedValue

EOTVTypedValue :: (SingI t, ConstantScope t) => Value t -> ExpressionOrTypedValue

Instances

Show ExpressionOrTypedValue

Defined in Test.Cleveland.Internal.Abstract

Methods

showsPrec :: Int -> ExpressionOrTypedValue -> ShowS

show :: ExpressionOrTypedValue -> String

showList :: [ExpressionOrTypedValue] -> ShowS

Eq ExpressionOrTypedValue

Defined in Test.Cleveland.Internal.Abstract

Methods

(==) :: ExpressionOrTypedValue -> ExpressionOrTypedValue -> Bool

(/=) :: ExpressionOrTypedValue -> ExpressionOrTypedValue -> Bool

Buildable ExpressionOrTypedValue

Defined in Test.Cleveland.Internal.Abstract

Methods

build :: ExpressionOrTypedValue -> Doc

buildList :: [ExpressionOrTypedValue] -> Doc

newtype ClevelandOpsBatch a

Where the batched operations occur.

Note that this is not a Monad, rather an Applicative - use -XApplicativeDo extension for nicer experience.

Constructors

ClevelandOpsBatch

Fields

• unClevelandOpsBatch :: BatchingM (OperationInfo ClevelandInput) (OperationInfo ClevelandResult) Void a

Instances

Applicative ClevelandOpsBatch

Defined in Test.Cleveland.Internal.Abstract

Methods

pure :: a -> ClevelandOpsBatch a

(<*>) :: ClevelandOpsBatch (a -> b) -> ClevelandOpsBatch a -> ClevelandOpsBatch b

liftA2 :: (a -> b -> c) -> ClevelandOpsBatch a -> ClevelandOpsBatch b -> ClevelandOpsBatch c

(*>) :: ClevelandOpsBatch a -> ClevelandOpsBatch b -> ClevelandOpsBatch b

(<*) :: ClevelandOpsBatch a -> ClevelandOpsBatch b -> ClevelandOpsBatch a

Functor ClevelandOpsBatch

Defined in Test.Cleveland.Internal.Abstract

Methods

fmap :: (a -> b) -> ClevelandOpsBatch a -> ClevelandOpsBatch b

(<$) :: a -> ClevelandOpsBatch b -> ClevelandOpsBatch a

(Bottom, TypeError (((('Text "Attempt to use monad capabilities within a batch" :$$: 'Text "In case you are using a do-block, make sure that") :$$: 'Text "\8226 `ApplicativeDo` extension is enabled") :$$: 'Text "\8226 there is a return statement in the end") :$$: 'Text "\8226 returned value picks variables in the order in which they are defined") :: Constraint) => Monad ClevelandOpsBatch

Defined in Test.Cleveland.Internal.Abstract

Methods

(>>=) :: ClevelandOpsBatch a -> (a -> ClevelandOpsBatch b) -> ClevelandOpsBatch b

(>>) :: ClevelandOpsBatch a -> ClevelandOpsBatch b -> ClevelandOpsBatch b

return :: a -> ClevelandOpsBatch a

MonadOpsInternal ClevelandOpsBatch

Defined in Test.Cleveland.Internal.Actions.MonadOpsInternal

Methods

withOpsCap :: (ClevelandOpsImpl ClevelandOpsBatch -> ClevelandOpsBatch a) -> ClevelandOpsBatch a

(SingI emit, DoTransfer mode, a ~ FTransferResult emit) => TransferFunc mode emit am (ClevelandOpsBatch a)

The terminating case for batched transfer

Defined in Test.Cleveland.Internal.Actions.Transfer

Methods

transfer'r :: GenericTransferData mode -> ClevelandOpsBatch a

TerminatingOFConstraints ct props ClevelandOpsBatch a => OriginateFunc ct props (ClevelandOpsBatch a)

The terminating case for batched transfer.

Defined in Test.Cleveland.Internal.Actions.Originate

Methods

originate'r :: OriginateData (ContractOriginateType ct) (GetLarge props) -> ClevelandOpsBatch a

neExplicitDataDirL :: Lens' NetworkEnv Bool

neMoneybagAliasL :: Lens' NetworkEnv ImplicitAlias

neMorleyClientEnvL :: Lens' NetworkEnv MorleyClientEnv

neSecretKeyL :: Lens' NetworkEnv (Maybe SecretKey)

neVerbosityL :: Lens' NetworkEnv Word

logsL :: Lens' ScenarioLogs MorleyLogs

An alias for slLog with a clearer name

filterLogsByAddrL :: (ToAddress addr, Applicative f) => addr -> (MorleyLogs -> f MorleyLogs) -> ScenarioLogs -> f ScenarioLogs

Lens combinator specified for filtering logs by address from LogsInfo

logsForAddress :: (Each s s ScenarioLogs ScenarioLogs, ToAddress addr) => addr -> s -> [MorleyLogs]

Get logs for a given address from LogsInfo

collectLogs :: LogsInfo -> MorleyLogs

Collect logs produced by all contracts into the single list

runBatched :: (HasCallStack, Functor m) => ClevelandOpsImpl m -> ClevelandOpsBatch a -> m a

Run a series of operations within a batch.

Example:

contract <- runBatched impl $ do
  -- this block is executed within ClevelandOpsBatch
  contract <- runSingleOperation batchedOpsImpl "origination" ...
  for_ [1..3] i ->
    runSingleOperation batchedOpsImpl "transfer" ...
  return contract

See ClevelandOpsBatch for some precautions.

batchedOpsImpl :: ClevelandOpsImpl ClevelandOpsBatch

ClevelandOpsImpl suitable for methods executed within a batch.

runOperationBatchM :: (HasCallStack, Buildable e, Functor m) => Proxy e -> ClevelandOpsImpl m -> BatchingM (OperationInfo ClevelandInput) (OperationInfo ClevelandResult) e a -> m a

Version of coiRunOperationBatch that uses BatchingM.

This is an internal function.

Invariant: all errors described by e must be internal and should not occur in practice (we require e type to be specified explicitly to hinder incorrect usage).

runSingleOperation :: (HasCallStack, Functor m) => ClevelandOpsImpl m -> Text -> OperationInfo ClevelandInput -> (OperationInfo ClevelandResult -> Maybe a) -> m a

Helper that runs a single operation using ClevelandOpsImpl.

buildLastBranchLinear :: CallSequence -> Doc

Build only the last branch of CallSequence as a linear array.

toCallSeq :: Eq k => (a -> ToCallSeqM k (Maybe (k, CallSequenceOp))) -> [a] -> CallSequence

Given a linear list of operations, reconstruct the "call sequence tree".

The function is polymorphic to support both emulated and network operations.

Uses a rather straightforward stack-based algorithm for reconstruction in $O(n)$. However, bear in mind perfect reconstruction is not always possible, so this is merely best-effort.

In the following example Int substitutes for Address for simplicity.

>>> import Morley.Util.Interpolate (i)
>>> :{
aux :: (Int, Int) -> ToCallSeqM Int (Maybe (Int, CallSequenceOp))
aux (caller, callee) =
  Just . (caller,) . CallSequenceOp [i|#{caller} calling #{callee}|] . CallSequence
    <$> popToCallSeq callee
:}

>>> :{
Fmt.pretty $ toCallSeq aux
  [(1, 2), (2, 3), (2, 3), (2, 4), (4, 2), (2, 5), (5, 1), (5, 3), (2, 3), (7, 1)]
:}
- 1 calling 2
  - 2 calling 3
  - 2 calling 3
  - 2 calling 4
    - 4 calling 2
      - 2 calling 5
        - 5 calling 1
        - 5 calling 3
      - 2 calling 3
- 7 calling 1

Note that in this call sequence, it is ambiguous whether the last 2 calling 3 happens from 1 or 4. The algorithm used here will always assume deepest nesting in such cases.

popToCallSeq :: Eq k => k -> ToCallSeqM k [CallSequenceOp]

Helper function for toCallSeq. Pops the top of the stack if key matches the supplied argument.

mapClevelandOpsImplExceptions :: (forall a. HasCallStack => m a -> m a) -> ClevelandOpsImpl m -> ClevelandOpsImpl m

Runs a handler over every action.

mapClevelandMiscImplExceptions :: (forall a. HasCallStack => m a -> m a) -> ClevelandMiscImpl m -> ClevelandMiscImpl m

Runs a handler over every action (except cmiAttempt and cmiThrow), possibly transforming exceptions thrown by those actions.

ccMoneybagL :: forall m. Lens' (ClevelandCaps m) Moneybag

ccSenderL :: forall m. Lens' (ClevelandCaps m) Sender

ecClevelandCapsL :: forall m. Lens' (EmulatedCaps m) (ClevelandCaps m)

type NetworkT m = ReaderT (NetworkCaps m) m

Monad transformer that adds both ClevelandCaps and NetworkCaps capabilities.

type EmulatedT m = ReaderT (EmulatedCaps m) m

Monad transformer that adds both ClevelandCaps and EmulatedCaps capabilities.

type ClevelandT m = ReaderT (ClevelandCaps m) m

Monad transformer that adds only the ClevelandCaps capabilities.

type MonadNetwork caps m = (MonadCleveland caps m, HasNetworkCaps caps)

Constraint for a monad in which we can do cleveland actions that can only be run on a real network. It requires the NetworkCaps capability.

type MonadEmulated caps m = (MonadCleveland caps m, HasEmulatedCaps caps)

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 MonadCleveland caps m = (m ~ ReaderT caps (ClevelandBaseMonad caps), HasClevelandCaps caps)

Constraint for a monad in which we can do cleveland actions.

class HasClevelandCaps caps => HasNetworkCaps caps where

A proof that the given caps record contains the basic cleveland capabilities + the network capabilities.

Methods

getNetworkEnvCap :: caps -> NetworkEnv

Instances

Monad m => HasNetworkCaps (NetworkCaps m)

Defined in Test.Cleveland.Internal.Abstract

Methods

getNetworkEnvCap :: NetworkCaps m -> NetworkEnv

class HasClevelandCaps caps => HasEmulatedCaps caps where

A proof that the given caps record contains the basic cleveland capabilities + the emulator capabilities.

Methods

getEmulatedCap :: caps -> EmulatedImpl (ClevelandBaseMonad caps)

Instances

Monad m => HasEmulatedCaps (EmulatedCaps m)

Defined in Test.Cleveland.Internal.Abstract

Methods

getEmulatedCap :: EmulatedCaps m -> EmulatedImpl (ClevelandBaseMonad (EmulatedCaps m))

class Monad (ClevelandBaseMonad caps) => HasClevelandCaps caps where

A proof that the given caps record contains the basic cleveland capabilities.

Associated Types

type ClevelandBaseMonad caps :: Type -> Type

This will be either PureM or ClientM.

Methods

clevelandCapsL :: Lens' caps (ClevelandCaps (ClevelandBaseMonad caps))

Instances

Monad m => HasClevelandCaps (ClevelandCaps m)

Defined in Test.Cleveland.Internal.Abstract

Associated Types

type ClevelandBaseMonad (ClevelandCaps m) :: Type -> Type

Methods

clevelandCapsL :: Lens' (ClevelandCaps m) (ClevelandCaps (ClevelandBaseMonad (ClevelandCaps m)))

Monad m => HasClevelandCaps (EmulatedCaps m)

Defined in Test.Cleveland.Internal.Abstract

Associated Types

type ClevelandBaseMonad (EmulatedCaps m) :: Type -> Type

Methods

clevelandCapsL :: Lens' (EmulatedCaps m) (ClevelandCaps (ClevelandBaseMonad (EmulatedCaps m)))

Monad m => HasClevelandCaps (NetworkCaps m)

Defined in Test.Cleveland.Internal.Abstract

Associated Types

type ClevelandBaseMonad (NetworkCaps m) :: Type -> Type

Methods

clevelandCapsL :: Lens' (NetworkCaps m) (ClevelandCaps (ClevelandBaseMonad (NetworkCaps m)))

ncClevelandCapsL :: forall m m. Lens (NetworkCaps m) (NetworkCaps m) (ClevelandCaps m) (ClevelandCaps m)

senderL :: HasClevelandCaps caps => Lens' caps Sender

moneybagL :: HasClevelandCaps caps => Lens' caps Moneybag

getMiscCap :: HasClevelandCaps caps => caps -> ClevelandMiscImpl (ClevelandBaseMonad caps)

getOpsCap :: HasClevelandCaps caps => caps -> ClevelandOpsImpl (ClevelandBaseMonad caps)