Version: 0.23.0

Test

Important: The Test module is only available inside the ligo test command. See also Testing LIGO.

type michelson_program
A type for code that's compiled to Michelson.
type test_exec_error = ["Rejected", michelson_program, address] | ["Other"]
A test error.
type test_exec_result = ["Success"] | ["Fail", test_exec_error]
A test execution result.
type typed_address <'p, 's>
A type for an address of a contract with parameter `'p` and storage `'s`.
let to_contract = (account: typed_address <'p, 's>) => contract <'p>

Get the contract corresponding to the default entrypoint of a typed address: the contract parameter in the result will be the type of the default entrypoint (generally 'p, but this might differ if 'p includes a "default" entrypoint).

let to_entrypoint = (entrypoint: string, account: typed_address <'p, 's>) => contract <'e>

Get the contract corresponding to an entrypoint of a typed address: the contract parameter in the result will be the type of the entrypoint, it needs to be annotated, entrypoint string should omit the prefix "%".

let originate_from_file = (filepath: string, entrypoint: string, init: michelson_program, balance: tez) => [address, michelson_program, int]

Originate a contract with an entrypoint, initial storage and initial balance.

let [addr, program, size] = Test.originate_from_file(testme_test,"main", init_storage, 0 as tez);
let originate = (contract: ('parameter, 'storage) => (list <operation>, 'storage), init: 'storage, balance: tez) => [typed_address <'parameter, 'storage>, michelson_program, int]

Originate a contract with an entrypoint function, initial storage and initial balance.

let set_now = (now: timestamp) => unit
Set the timestamp of the predecessor block.
let set_source = (source: address) => unit
Set the source for `Test.transfer` and `Test.originate`.
let set_baker = (source: address) => unit
Force the baker for `Test.transfer` and `Test.originate`. By default, the first bootstrapped account.
let transfer = (addr: address, parameter: michelson_program, amount: tez) => test_exec_result
Bake a transaction by sending an amount of tez with a parameter from the current source to another account.
let transfer_exn = (addr: address, parameter: michelson_program, amount: tez) => unit
Similar as `Test.transfer`, but fails when anything goes wrong.
let transfer_to_contract = (addr: contract<'p>, parameter: 'p, amount: tez) => test_exec_result
Bake a transaction by sending an amount of tez with a parameter from the current source to a contract.
let transfer_to_contract_exn = (addr: contract<'p>, parameter: 'p, amount: tez) => unit
Similar as `Test.transfer_to_contract`, but fails when anything goes wrong.
let get_storage_of_address = (account: address) => michelson_program
Get the storage of an account in `michelson_program`.
let get_storage = (account: typed_address <'p, 's>) => 's
Get the storage of a typed account.
let get_balance = (account: address) => tez
Get the balance of an account in tez.
let michelson_equal = (a: michelson_program, b: michelson_program) => bool
Compare two Michelson values.
let log = (a: 'a) => unit
Log a value.
let reset_state = (no_of_accounts: nat, amount: list<nat>) => unit
Generate a number of random bootstrapped accounts with a default amount of 4000000 tez. The passed list can be used to overwrite the amount. By default, the state only has two bootstrapped accounts.
let nth_bootstrap_account = (nth: int) => address
Returns the address of the nth bootstrapped account.
let nth_bootstrap_contract = (nth: nat) => address
Returns the address corresponding to the nth bootstrapped contract.
let bootstrap_contract = (balance: tez, contract: ('parameter, 'storage) => (list <operation>, 'storage), init: 'storage) => unit

Setup a bootstrap contract with an entrypoint function, initial storage and initial balance. Bootstrap contracts will be loaded in order, and they will be available only after reset.

let nth_bootstrap_typed_address = (nth: int) => typed_address <'p, 's>
Returns the typed address corresponding to the nth bootstrapped contract currently loaded. The types are inferred from those contracts loaded with `Test.bootstrap_contract` (before reset).
let last_originations = (_: unit) => map<address , address list>
Returns addresses of orginated accounts in the last transfer. It is given in the form of a map binding the address of the source of the origination operation to the addresses of newly originated accounts.
let compile_value = (value: 'a) => michelson_program
Compile a LIGO value to Michelson.
let eval = (value: 'a) => michelson_program
Compile a LIGO value to Michelson. Currently it is a renaming of `compile_value`.
let run = (func: ('a => 'b), value: 'a) => michelson_program

Run a function on an input, all in Michelson. More concretely: a) compiles the function argument to Michelson f_mich; b) compiles the value argument (which was evaluated already) to Michelson v_mich; c) runs the Michelson interpreter on the code f_mich with starting stack [ v_mich ].

type some_r = [@layout:comb] { one : int , two : nat , three : string , four : bytes , five : unit };
let f = (x:some_r) : int => x.one;
let test_example =
Test.run (((x : [int, nat, string, bytes, unit]) => f ({ one : x[0] , two : x[1] , three : x[2] , four : x[3] , five : x[4] })),
[1 + 3 + 2, ((1 as nat) + (2 as nat)), ("a" + "b"), 0xFF00, unit]);
let mutate_value : (index: nat, value: 'a) => option <['a, mutation]>

Mutates a value using a natural number as an index for the available mutations, returns an option for indicating whether mutation was successful or not.

let mutation_test : (value: 'a, tester: ('a -> 'b)) => option <['b, mutation]>

Given a value to mutate (first argument), it will try all the mutations available of it, passing each one to the function (second argument). On the first case of non failure when running the function on a mutation, the value and mutation involved will be returned.

let mutation_test_all : (value: 'a, tester: ('a -> 'b)) => list <['b, mutation]>

Given a value to mutate (first argument), it will try all the mutations of it, passing each one to the function (second argument). In case no failure arises when running the function on a mutation, the failure and mutation involved will be added to the list to be returned.