Jest Helpers

In order to simplify the process even further we've created several Jest-based methods, which will help you to catch thrown errors and ensure your code works as intended.

`shallPass(ix)`

Ensure transaction did not throw and was sealed.

Arguments

Name	Type	Description
`ix`	Interaction	interaction, either in form of a Promise or function

Returns

Type	Description
ResponseObject	Transaction result

Usage

import path from "path"
import {
  init,
  emulator,
  shallPass,
  sendTransaction,
  getAccountAddress,
} from "@onflow/flow-js-testing"
// We need to set timeout for a higher number, because some transactions might take up some time
jest.setTimeout(10000)
describe("interactions - sendTransaction", () => {
  // Instantiate emulator and path to Cadence files
  beforeEach(async () => {
    const basePath = path.resolve(__dirname, "./cadence")
    await init(basePath)
    return emulator.start()
  })
  // Stop emulator, so it could be restarted
  afterEach(async () => {
    return emulator.stop()
  })
  test("basic transaction", async () => {
    const code = `
      transaction(message: String){
        prepare(singer: AuthAccount){
          log(message)
        }
      }
    `
    const Alice = await getAccountAddress("Alice")
    const signers = [Alice]
    const args = ["Hello, Cadence"]
    const [txResult, error] = await shallPass(
      sendTransaction({
        code,
        signers,
        args,
      })
    )
    // Transaction result will hold status, events and error message
    console.log(txResult, error)
  })
})

shallRevert(ix, message)

Ensure interaction throws an error. Can test for specific error messages or catch any error message if message is not provided. Returns Promise, which contains result, when resolved.

Arguments

Name	Type	Description
`ix`	Interaction	transaction, either in form of a Promise or function
`message` (optional)	`string` or `RegExp`	expected error message provided as either a string equality or regular expression to match, matches any error by default

Returns

Type	Description
ResponseObject	Transaction result

Usage

import path from "path"
import {
  init,
  emulator,
  shallPass,
  sendTransaction,
  getAccountAddress,
} from "js-testing-framework"
// We need to set timeout for a higher number, cause some interactions might need more time
jest.setTimeout(10000)
describe("interactions - sendTransaction", () => {
  // Instantiate emulator and path to Cadence files
  beforeEach(async () => {
    const basePath = path.resolve(__dirname, "./cadence")
    await init(basePath)
    return emulator.start()
  })
  // Stop emulator, so it could be restarted
  afterEach(async () => {
    return emulator.stop()
  })
  test("basic transaction", async () => {
    const code = `
      transaction(message: String){
        prepare(singer: AuthAccount){
          panic("You shall not pass!")
        }
      }
    `
    const Alice = await getAccountAddress("Alice")
    const signers = [Alice]
    const args = ["Hello, Cadence"]
    const [txResult, error] = await shallRevert(
      sendTransaction({
        code,
        signers,
        args,
      })
    )
    // Transaction result will hold status, events and error message
    console.log(txResult, error)
  })
})

shallResolve(ix)

Ensure interaction resolves without throwing errors.

Arguments

Name	Type	Description
`ix`	Interaction	interaction, either in form of a Promise or function

Returns

Type	Description
ResponseObject	Transaction result

Usage

import path from "path"
import {init, emulator, shallPass, executeScript} from "js-testing-framework"
// We need to set timeout for a higher number, cause some interactions might need more time
jest.setTimeout(10000)
describe("interactions - sendTransaction", () => {
  // Instantiate emulator and path to Cadence files
  beforeEach(async () => {
    const basePath = path.resolve(__dirname, "./cadence")
    await init(basePath)
    return emulator.start()
  })
  // Stop emulator, so it could be restarted
  afterEach(async () => {
    return emulator.stop()
  })
  test("basic script", async () => {
    const code = `
      pub fun main():Int{
        return 42
      }
    `
    const [result, error] = await shallResolve(
      executeScript({
        code,
      })
    )
    expect(result).toBe(42)
    expect(error).toBe(null)
  })
})

shallHavePath(account, path)

Asserts that the given account has the given path enabled.

Arguments

Name	Type	Description
`account`	`string`	The address or name of the account to check for the path.
`path`	`string`	The path to check for.

Returns

Type	Description
`Promise<void>`	A Promise that resolves when the assertion is complete, or rejects with an error if it fails.

Usage

import path from "path"
import {init, emulator, shallPass, executeScript} from "js-testing-framework"
// We need to set timeout for a higher number, cause some interactions might need more time
jest.setTimeout(10000)
describe("interactions - sendTransaction", () => {
  // Instantiate emulator and path to Cadence files
  beforeEach(async () => {
    const basePath = path.resolve(__dirname, "./cadence")
    await init(basePath)
    return emulator.start()
  })
  // Stop emulator, so it could be restarted
  afterEach(async () => {
    return emulator.stop()
  })
  describe("check path with Jest helper", () => {
    test("pass account address", async () => {
      const Alice = await getAccountAddress("Alice")
      await shallHavePath(Alice, "/storage/flowTokenVault")
    })
    test("pass account name", async () => {
      await shallHavePath("Alice", "/storage/flowTokenVault")
    })
  })
})

shallHaveStorageValue(account, params)

Asserts that the given account has the expected storage value at the given path.

Arguments

Name	Type	Description
`account`	`string`	The address or name of the account to check for the storage value.
`params`	`{pathName: string, key?: string, expect: any}`	An object containing the path name, optional key, and expected value of the storage at the given path.
`params.pathName`	`string`	The path of the storage value to retrieve.
`params.key`	`string` (optional)	The key of the value to retrieve from the storage at the given path, if applicable.
`expect`	`any`	The expected value of the storage at the given path and key (if applicable).

Returns

Type	Description
`Promise<void>`	A Promise that resolves when the assertion is complete, or rejects with an error if it fails.

shallPass(ix)​

Arguments​

Returns​

Usage​

shallRevert(ix, message)​

Arguments​

Returns​

Usage​

shallResolve(ix)​

Arguments​

Returns​

Usage​

shallHavePath(account, path)​

Arguments​

Returns​

Usage​

shallHaveStorageValue(account, params)​

Arguments​

Returns​

`shallPass(ix)`

Arguments

Returns

Usage

shallRevert(ix, message)

Arguments

Returns

Usage

shallResolve(ix)

Arguments

Returns

Usage

shallHavePath(account, path)

Arguments

Returns

Usage

shallHaveStorageValue(account, params)

Arguments

Returns