Michelson.Test.Import

Functions to import contracts to be used in tests.

Read, parse, typecheck

readContract :: forall cp st. Each '[KnownT] [cp, st] => FilePath -> Text -> Either ImportContractError (Contract, Contract cp st)

importContract :: forall cp st. Each '[KnownT] [cp, st] => FilePath -> IO (Contract, Contract cp st)

Import contract from a given file path.

This function reads file, parses and type checks a contract. Within the typechecking we assume that no contracts are originated, otherwise a type checking error will be caused.

This function may throw IOException and ImportContractError.

importUntypedContract :: FilePath -> IO Contract

data ImportContractError

Error type for importContract function.

Constructors

ICEUnexpectedParamType ParameterType Type

ICEUnexpectedStorageType Type Type

ICEParse ParserException

ICETypeCheck TCError

Instances

Eq ImportContractError

Defined in Michelson.Test.Import

Methods

(==) :: ImportContractError -> ImportContractError -> Bool

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

Show ImportContractError

Defined in Michelson.Test.Import

Methods

showsPrec :: Int -> ImportContractError -> ShowS

show :: ImportContractError -> String

showList :: [ImportContractError] -> ShowS

Exception ImportContractError

Defined in Michelson.Test.Import

Methods

toException :: ImportContractError -> SomeException

fromException :: SomeException -> Maybe ImportContractError

displayException :: ImportContractError -> String

Buildable ImportContractError

Defined in Michelson.Test.Import

Methods

build :: ImportContractError -> Builder

Tasty helpers

testTreesWithContract :: (Each '[KnownT] [cp, st], HasCallStack) => FilePath -> ((Contract, Contract cp st) -> IO [TestTree]) -> IO [TestTree]

Import contract and use to create test trees. Both versions of contract are passed to the callback function (untyped and typed).

If contract's import fails, a tree with single failing test will be generated (so test tree will likely be generated unexceptionally, but a failing result will notify about problem).

testTreesWithTypedContract :: (Each '[KnownT] [cp, st], HasCallStack) => FilePath -> (Contract cp st -> IO [TestTree]) -> IO [TestTree]

Like testTreesWithContract but supplies only typed contract.

testTreesWithUntypedContract :: HasCallStack => FilePath -> (Contract -> IO [TestTree]) -> IO [TestTree]

Like testTreesWithContract but supplies only untyped contract.

concatTestTrees :: [IO [TestTree]] -> IO [TestTree]

HSpec helpers

specWithContract :: (Each '[KnownT] [cp, st], HasCallStack) => FilePath -> ((Contract, Contract cp st) -> Spec) -> Spec

Import contract and use it in the spec. Both versions of contract are passed to the callback function (untyped and typed).

If contract's import fails, a spec with single failing expectation will be generated (so tests will likely run unexceptionally, but a failing result will notify about problem).

specWithTypedContract :: (Each '[KnownT] [cp, st], HasCallStack) => FilePath -> (Contract cp st -> Spec) -> Spec

A version of specWithContract which passes only the typed representation of the contract.

specWithUntypedContract :: FilePath -> (Contract -> Spec) -> Spec