Lorentz.Test.Integrational

Mirrors Integrational module in a Lorentz way.

Re-exports

data TxData

Data associated with a particular transaction.

Constructors

TxData

Fields

• tdSenderAddress :: Address
• tdParameter :: Value
• tdEntrypoint :: EpName
• tdAmount :: Mutez

Instances

Eq TxData

Defined in Michelson.Runtime.TxData

Methods

(==) :: TxData -> TxData -> Bool

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

Show TxData

Defined in Michelson.Runtime.TxData

Methods

showsPrec :: Int -> TxData -> ShowS

show :: TxData -> String

showList :: [TxData] -> ShowS

genesisAddresses :: NonEmpty Address

Initially these addresses have a lot of money.

genesisAddress :: Address

One of genesis addresses.

More genesis addresses which can be used in tests

genesisAddress1 :: Address

More genesis addresses

We know size of genesisAddresses, so it is safe to use !!

genesisAddress2 :: Address

More genesis addresses

We know size of genesisAddresses, so it is safe to use !!

genesisAddress3 :: Address

More genesis addresses

We know size of genesisAddresses, so it is safe to use !!

genesisAddress4 :: Address

genesisAddress5 :: Address

genesisAddress6 :: Address

Testing engine for bare Typed primitives

tOriginate :: (ParameterScope cp, StorageScope st) => FullContract cp st -> Text -> Value st -> Mutez -> IntegrationalScenarioM Address

Like originate, but for typed contract and value.

tTransfer :: forall arg. ParameterScope arg => ("from" :! Address) -> ("to" :! Address) -> Mutez -> EpName -> Value arg -> IntegrationalScenarioM ()

Similar to transfer, for typed values. Note that it works with untyped Address and does not check that entrypoint with given name is present and has the expected type. Passed value must correspond to the entrypoint argument type, not the parameter type of the contract (and must be unit for implicit accounts).

tExpectStorageConst :: forall st. StorageScope st => Address -> Value st -> SuccessValidator

Similar to expectStorageConst, for typed stuff.

Testing engine

type IntegrationalValidator = Either (ExecutorError -> Bool) SuccessValidator

Validator for integrational testing. If an error is expected, it should be Left with validator for errors. Otherwise it should check final global state and its updates.

type SuccessValidator = InternalState -> GState -> [GStateUpdate] -> Either ValidationError ()

Validator for integrational testing that expects successful execution.

type IntegrationalScenarioM = StateT InternalState (Except ScenarioError)

A monad inside which integrational tests can be described using do-notation.

type IntegrationalScenario = IntegrationalScenarioM Validated

data ValidationError

Constructors

UnexpectedExecutorError IntegrationalExecutorError

UnexpectedTypeCheckError TCError

ExpectingInterpreterToFail

IncorrectUpdates ValidationError [GStateUpdate]

IncorrectStorageUpdate AddressName Text

InvalidStorage AddressName ExpectedStorage Text

StoragePredicateMismatch AddressName Text

InvalidBalance AddressName ExpectedBalance Text

UnexpectedUpdates (NonEmpty GStateUpdate)

CustomValidationError Text

Instances

Show ValidationError

Defined in Michelson.Test.Integrational

Methods

showsPrec :: Int -> ValidationError -> ShowS

show :: ValidationError -> String

showList :: [ValidationError] -> ShowS

Exception ValidationError

Defined in Michelson.Test.Integrational

Methods

toException :: ValidationError -> SomeException

fromException :: SomeException -> Maybe ValidationError

displayException :: ValidationError -> String

Buildable ValidationError

Defined in Michelson.Test.Integrational

Methods

build :: ValidationError -> Builder

integrationalTestExpectation :: HasCallStack => IntegrationalScenario -> Expectation

Integrational test that executes given operations and validates them using given validator. It can fail using Expectation capability. It starts with initGState and some reasonable dummy values for gas limit and current timestamp. You can update blockchain state by performing some operations.

integrationalTestProperty :: IntegrationalScenario -> Property

Integrational test similar to integrationalTestExpectation. It can fail using Property capability. It can be used with QuickCheck's forAll to make a property-based test with arbitrary data.

lOriginate :: forall cp st. (NiceParameterFull cp, NiceStorage st) => Contract cp st -> Text -> st -> Mutez -> IntegrationalScenarioM (TAddress cp)

Like originate, but for Lorentz contracts.

lOriginateEmpty :: (NiceParameterFull cp, NiceStorage st, Default st) => Contract cp st -> Text -> IntegrationalScenarioM (TAddress cp)

Originate a contract with empty balance and default storage.

lTransfer :: forall cp epRef epArg addr. (HasEntryPointArg cp epRef epArg, IsoValue epArg, ToTAddress cp addr) => ("from" :! Address) -> ("to" :! addr) -> Mutez -> epRef -> epArg -> IntegrationalScenarioM ()

Similar to transfer, for Lorentz values.

lCall :: forall cp defEpName addr. (HasDefEntryPointArg cp defEpName cp, IsoValue cp, ToTAddress cp addr) => addr -> cp -> IntegrationalScenarioM ()

Deprecated: lCall will likely be replaced with lCallEP in future version

Legacy version of lCallEP function. Calls default entrypoint of a contract assuming its argument is the same as contract parameter (which is equivalent to absence of explicit default entrypoint).

This function is DEPRECATED and exists only for backwards compatibility.

lCallEP :: forall cp epRef epArg addr. (HasEntryPointArg cp epRef epArg, IsoValue epArg, ToTAddress cp addr) => addr -> epRef -> epArg -> IntegrationalScenarioM ()

Call an entrypoint of a contract without caring about the source address. Transfers 0 mutez.

data EntryPointRef (mname :: Maybe Symbol) where

Which entrypoint to call.

We intentionally distinguish default and non-default cases because this makes API more details-agnostic.

Constructors

CallDefault :: EntryPointRef Nothing

Call the default entrypoint, or root if no explicit default is assigned.

Call :: NiceEntryPointName name => EntryPointRef (Just name)

Call the given entrypoint; calling default is not treated specially. You have to provide entrypoint name via passing it as type argument.

Unfortunatelly, here we cannot accept a label because in most cases our entrypoints begin from capital letter (being derived from constructor name), while labels must start from a lower-case letter, and there is no way to make a conversion at type-level.

Instances

(GetEntryPointArgCustom cp mname ~ arg, ParameterDeclaresEntryPoints cp) => HasEntryPointArg (cp :: Type) (EntryPointRef mname) arg

Defined in Lorentz.EntryPoints.Core

Methods

useHasEntryPointArg :: EntryPointRef mname -> (Dict (ParameterScope (ToT arg)), EpName)

lCallDef :: forall cp defEpName defArg addr. (HasDefEntryPointArg cp defEpName defArg, IsoValue defArg, ToTAddress cp addr) => addr -> defArg -> IntegrationalScenarioM ()

lCallEP for default entrypoint.

validate :: IntegrationalValidator -> IntegrationalScenario

Validate the execution result.

integrationalFail :: ValidationError -> IntegrationalScenarioM anything

Just fail with given error.

setMaxSteps :: RemainingSteps -> IntegrationalScenarioM ()

Make all further interpreter calls (which are triggered by the validate function) use given gas limit.

setNow :: Timestamp -> IntegrationalScenarioM ()

Make all further interpreter calls (which are triggered by the validate function) use given timestamp as the current one.

rewindTime :: Integer -> IntegrationalScenarioM ()

Increase current time by the given number of seconds.

withSender :: Address -> IntegrationalScenarioM a -> IntegrationalScenarioM a

Pretend that given address initiates all the transfers within the code block (i.e. SENDER instruction will return this address).

setChainId :: ChainId -> IntegrationalScenarioM ()

Make all further interpreter calls (which are triggered by the validate function) use given chain id.

branchout :: HasCallStack => [(Text, IntegrationalScenario)] -> IntegrationalScenario

Execute multiple testing scenarios independently, basing them on scenario built till this point.

The following property holds for this function:

pre >> branchout [a, b, c] = branchout [pre >> a, pre >> b, pre >> c] .

In case of property failure in one of the branches no following branch is executed.

Providing empty list of scenarios to this function causes error; we do not require NonEmpty here though for convenience.

(?-) :: Text -> a -> (Text, a) infixr 0

Make a tuple with name without extra syntactic noise.

offshoot :: Text -> IntegrationalScenario -> IntegrationalScenarioM ()

Test given scenario with the state gathered till this moment; if this scenario passes, go on as if it never happened.

Validators

composeValidators :: SuccessValidator -> SuccessValidator -> SuccessValidator

Compose two success validators.

For example:

expectBalance bal addr composeValidators expectStorageUpdateConst addr2 ValueUnit

composeValidatorsList :: [SuccessValidator] -> SuccessValidator

Compose a list of success validators.

expectAnySuccess :: SuccessValidator

SuccessValidator that always passes.

expectNoUpdates :: SuccessValidator

Check that there were no updates.

expectNoStorageUpdates :: SuccessValidator

Check that there were no storage updates.

lExpectStorageUpdate :: forall st addr. (NiceStorage st, ToAddress addr, HasCallStack) => addr -> (st -> Either ValidationError ()) -> SuccessValidator

Similar to expectStorageUpdate, but for Lorentz values.

lExpectBalance :: ToAddress addr => addr -> Mutez -> SuccessValidator

Like expectBalance, for Lorentz values.

lExpectStorage :: forall st addr. (NiceStorage st, ToAddress addr, HasCallStack) => addr -> (st -> Either ValidationError ()) -> SuccessValidator

Similar to expectStorage, but for Lorentz values.

lExpectStorageConst :: forall st addr. (NiceStorage st, ToAddress addr) => addr -> st -> SuccessValidator

Similar to expectStorageConst, for Lorentz values.

Errors

lExpectMichelsonFailed :: forall addr. ToAddress addr => (MichelsonFailed -> Bool) -> addr -> ExecutorError -> Bool

Expect that interpretation of contract with given address ended with [FAILED].

lExpectFailWith :: forall e. (Typeable (ToT e), IsoValue e) => (e -> Bool) -> ExecutorError -> Bool

Expect contract to fail with FAILWITH instruction and provided value to match against the given predicate.

lExpectError :: forall e. IsError e => (e -> Bool) -> ExecutorError -> Bool

Expect contract to fail with given error.

lExpectErrorNumeric :: forall e. IsError e => ErrorTagMap -> (e -> Bool) -> ExecutorError -> Bool

Version of lExpectError for the case when numeric representation of errors is used.

lExpectCustomError :: forall tag arg. (IsError (CustomError tag), arg ~ ErrorArg tag, Eq arg) => Label tag -> arg -> ExecutorError -> Bool

Expect contract to fail with given CustomError.

lExpectCustomErrorNumeric :: forall tag arg. (IsError (CustomError tag), arg ~ ErrorArg tag, Eq arg) => ErrorTagMap -> Label tag -> arg -> ExecutorError -> Bool

Version of lExpectCustomError for the case when numeric representation of errors is used.

lExpectCustomError_ :: forall tag. (IsError (CustomError tag), ErrorArg tag ~ ()) => Label tag -> ExecutorError -> Bool

Specialization of lExpectCustomError for non-arg error case.

lExpectCustomErrorNumeric_ :: forall tag. (IsError (CustomError tag), ErrorArg tag ~ ()) => ErrorTagMap -> Label tag -> ExecutorError -> Bool

Version of lExpectCustomError_ for the case when numeric representation of errors is used.

Consumer

lExpectConsumerStorage :: forall cp st addr. (st ~ [cp], NiceStorage st, ToTAddress cp addr) => addr -> (st -> Either ValidationError ()) -> SuccessValidator

Version of lExpectStorageUpdate specialized to "consumer" contract (see contractConsumer).

lExpectViewConsumerStorage :: (st ~ [cp], Eq cp, Buildable cp, NiceStorage st, ToTAddress cp addr) => addr -> [cp] -> SuccessValidator

Assuming that "consumer" contract receives a value from View, expect this view return value to be the given one.

Despite consumer stores parameters it was called with in reversed order, this function cares about it, so you should provide a list of expected values in the same order in which the corresponding events were happenning.