Contract.Test.Assert

data ContractAssertionFailure

Constructors

• CouldNotGetTxByHash TransactionHash
• CouldNotParseMetadata Label
• TransactionHasNoMetadata TransactionHash (Maybe Label)
• UnexpectedDatumInOutput (Labeled TransactionOutput) (ExpectedActual (Maybe OutputDatum))
• UnexpectedLovelaceDelta (Maybe (Labeled Address)) (ExpectedActual BigInt)
• UnexpectedMetadataValue Label (ExpectedActual String)
• UnexpectedRefScriptInOutput (Labeled TransactionOutput) (ExpectedActual (Maybe ScriptRef))
• UnexpectedTokenDelta (Maybe (Labeled Address)) AssetName (ExpectedActual BigInt)
• FailedToGetExpectedValue String
• MaxExUnitsExceeded (ExpectedActual ExUnits)
• CustomFailure String
• SkippedTest String

Instances

• Eq ContractAssertionFailure
• Generic ContractAssertionFailure _
• Show ContractAssertionFailure

type ContractAssertion (a :: Type) = ReaderT (Ref (List ContractAssertionFailure)) Contract a

Monad allowing for accumulation of assertion failures.

type ContractCheck a = ContractAssertion a -> ContractAssertion ((ContractAssertion a) /\ (ContractAssertion Unit))

A check that can run some initialization code before the Contract is run and check the results afterwards. It is used to implement assertions that require state monitoring, e.g. checking gains at address.

data ExpectedActual (a :: Type)

Constructors

• ExpectedActual a a

Instances

• (Eq a) => Eq (ExpectedActual a)
• (Ord a) => Ord (ExpectedActual a)
• Generic (ExpectedActual a) _
• (Show a) => Show (ExpectedActual a)
• Functor ExpectedActual

type Label = String

data Labeled (a :: Type)

Constructors

• Labeled a (Maybe Label)

Instances

• (Eq a) => Eq (Labeled a)
• (Ord a) => Ord (Labeled a)
• Generic (Labeled a) _
• (Show a) => Show (Labeled a)

assertContract :: ContractAssertionFailure -> Boolean -> ContractAssertion Unit

assertContractEqual :: forall (a :: Type). Eq a => Show a => a -> a -> ContractAssertion Unit

assertContractExpectedActual :: forall (a :: Type). Eq a => (ExpectedActual a -> ContractAssertionFailure) -> a -> a -> ContractAssertion Unit

assertContractMaybe :: forall (a :: Type). ContractAssertionFailure -> Maybe a -> ContractAssertion a

assertNewUtxosAtAddress :: forall (a :: Type). Labeled Address -> TransactionHash -> (Array TransactionOutput -> ContractAssertion a) -> ContractAssertion a

Assert some property of address UTxOs created by a Transaction.

assertNewUtxosInWallet :: forall (a :: Type). TransactionHash -> (Array TransactionOutput -> ContractAssertion a) -> ContractAssertion a

Assert some property of wallet UTxOs created by a Transaction.

assertOutputHasDatum :: Maybe OutputDatum -> Labeled TransactionOutput -> ContractAssertion Unit

Requires that the transaction output contains the specified datum, datum hash or does not contain anything.

assertOutputHasRefScript :: ScriptRef -> Labeled TransactionOutput -> ContractAssertion Unit

Requires that the transaction output contains the specified reference script.

assertTxHasMetadata :: forall (metadata :: Type) (a :: Type). MetadataType metadata => Eq metadata => Show metadata => Label -> TransactionHash -> metadata -> ContractAssertion Unit

assertionToCheck :: forall (a :: Type). String -> (a -> ContractAssertion Unit) -> ContractCheck a

Create a check that simply asserts something about a Contract result.

If a Contract throws an exception, the assertion is never checked, because the result is never computed. In this case, a warning will be printed, containing the given description.

checkExUnitsNotExceed :: forall (a :: Type). ExUnits -> ContractCheck a

Sets a limit on ExUnits budget. All ExUnits values of all submitted transactions are combined. Transactions that are constructed, but not submitted, are not considered. The execution of the Contract will not be interrupted in case the ExUnits limit is reached.

checkGainAtAddress :: forall (a :: Type). Labeled Address -> (Maybe a -> Contract BigInt) -> ContractCheck a

Requires that the computed amount of lovelace was gained at the address by calling the contract.

checkGainAtAddress' :: forall (a :: Type). Labeled Address -> BigInt -> ContractCheck a

Requires that the passed amount of lovelace was gained at the address by calling the contract.

checkGainInWallet :: forall (a :: Type). (Maybe a -> Contract BigInt) -> ContractCheck a

Requires that the computed amount of lovelace was gained in the wallet by calling the contract.

checkGainInWallet' :: forall (a :: Type). BigInt -> ContractCheck a

Requires that the passed amount of lovelace was gained in the wallet by calling the contract.

checkLossAtAddress :: forall (a :: Type). Labeled Address -> (Maybe a -> Contract BigInt) -> ContractCheck a

Requires that the computed amount of lovelace was lost at the address by calling the contract.

checkLossAtAddress' :: forall (a :: Type). Labeled Address -> BigInt -> ContractCheck a

Requires that the passed amount of lovelace was lost at the address by calling the contract.

checkLossInWallet :: forall (a :: Type). (Maybe a -> Contract BigInt) -> ContractCheck a

Requires that the computed amount of lovelace was lost in the wallet by calling the contract.

checkLossInWallet' :: forall (a :: Type). BigInt -> ContractCheck a

Requires that the passed amount of lovelace was lost in the wallet by calling the contract.

checkLovelaceDeltaAtAddress :: forall (a :: Type). Labeled Address -> (Maybe a -> Contract BigInt) -> (BigInt -> BigInt -> Boolean) -> ContractCheck a

checkLovelaceDeltaInWallet :: forall (a :: Type). (Maybe a -> Contract BigInt) -> (BigInt -> BigInt -> Boolean) -> ContractCheck a

checkTokenDeltaAtAddress :: forall (a :: Type). Labeled Address -> (ScriptHash /\ AssetName) -> (Maybe a -> Contract BigInt) -> (BigInt -> BigInt -> Boolean) -> ContractCheck a

checkTokenDeltaInWallet :: forall (a :: Type). (ScriptHash /\ AssetName) -> (Maybe a -> Contract BigInt) -> (BigInt -> BigInt -> Boolean) -> ContractCheck a

checkTokenGainAtAddress :: forall (a :: Type). Labeled Address -> (ScriptHash /\ AssetName) -> (Maybe a -> Contract BigInt) -> ContractCheck a

Requires that the computed number of tokens was gained at the address by calling the contract.

checkTokenGainAtAddress' :: forall (a :: Type). Labeled Address -> (ScriptHash /\ AssetName /\ BigInt) -> ContractCheck a

Requires that the passed number of tokens was gained at the address by calling the contract.

checkTokenGainInWallet :: forall (a :: Type). (ScriptHash /\ AssetName) -> (Maybe a -> Contract BigInt) -> ContractCheck a

Requires that the computed number of tokens was gained in the wallet by calling the contract.

checkTokenGainInWallet' :: forall (a :: Type). (ScriptHash /\ AssetName /\ BigInt) -> ContractCheck a

Requires that the passed number of tokens was gained in the wallet by calling the contract.

checkTokenLossAtAddress :: forall (a :: Type). Labeled Address -> (ScriptHash /\ AssetName) -> (Maybe a -> Contract BigInt) -> ContractCheck a

Requires that the computed number of tokens was lost at the address by calling the contract.

checkTokenLossAtAddress' :: forall (a :: Type). Labeled Address -> (ScriptHash /\ AssetName /\ BigInt) -> ContractCheck a

Requires that the passed number of tokens was lost at the address by calling the contract.

checkTokenLossInWallet :: forall (a :: Type). (ScriptHash /\ AssetName) -> (Maybe a -> Contract BigInt) -> ContractCheck a

Requires that the computed number of tokens was lost in the wallet by calling the contract.

checkTokenLossInWallet' :: forall (a :: Type). (ScriptHash /\ AssetName /\ BigInt) -> ContractCheck a

Requires that the passed number of tokens was lost in the wallet by calling the contract.

checkValueDeltaAtAddress :: forall (a :: Type). Labeled Address -> (Maybe a -> Value -> Value -> ContractAssertion Unit) -> ContractCheck a

Arguments are:

• a labeled address
• a callback that implements the assertion, accepting Contract execution result, and values (before and after). The value may not be computed due to an exception, hence it's wrapped in Maybe.

checkValueDeltaInWallet :: forall (a :: Type). (Maybe a -> Value -> Value -> ContractAssertion Unit) -> ContractCheck a

Accepts a callback that implements the assetion. The result value of type a may not be computed due to an exception, hence it's wrapped in Maybe.

collectAssertionFailures :: forall (a :: Type). Array (ContractCheck a) -> ContractAssertion a -> Contract ((Either Error a) /\ (Array ContractAssertionFailure))

Like runChecks, but does not throw a user-readable report, collecting the exceptions instead.

label :: forall (a :: Type). a -> Label -> Labeled a

noLabel :: forall (a :: Type). a -> Labeled a

printContractAssertionFailure :: ContractAssertionFailure -> String

Pretty printing function that produces a human readable report for a single ContractAssertionFailure

printContractAssertionFailures :: Array ContractAssertionFailure -> String

A pretty-printing function that produces a human-readable report on failures.

printExpectedActual :: forall (a :: Type). Show a => ExpectedActual a -> String

printLabeled :: forall (a :: Type). Show a => Labeled a -> String

runChecks :: forall (a :: Type). Array (ContractCheck a) -> ContractAssertion a -> Contract a

Accepts an array of checks and interprets them into a Contract.

tellFailure :: ContractAssertionFailure -> ContractAssertion Unit

unlabel :: forall (a :: Type). Labeled a -> a