JS Testing API Reference

1
import {getAccountAddress} from "@onflow/flow-js-testing"
2

3
const main = async () => {
4
  const Alice = await getAccountAddress("Alice")
5
  console.log({Alice})
6
}
7

8
main()

1
import path from "path";
2
import { init, emulator, deployContractByName } from "@onflow/flow-js-testing";
3

4
const main = async () => {
5
  const basePath = path.resolve(__dirname, "../cadence");
6

7
  await init(basePath);
8
  await emulator.start();
9

10
  // We will deploy our contract to the address that corresponds to "Alice" alias
11
  const to = await getAccountAddress("Alice");
12

13
  // We assume there is a file on "../cadence/contracts/Wallet.cdc" path
14
  const name = "Wallet";
15

16
  // Arguments will be processed and type matched in the same order as they are specified
17
  // inside of a contract template
18
  const args = [1337, "Hello", { name: "Alice" }];
19

20
  const [deploymentResult, err] = await deployContractByName({ to, name });
21
  console.log({ deploymentResult }, { err });
22
  }
23

24
  await emulator.stop();
25
};
26

27
main();

1
import path from "path"
2
import {
3
  init,
4
  emulator,
5
  getAccountAddress,
6
  deployContract,
7
  executeScript,
8
} from "@onflow/flow-js-testing"
9
;(async () => {
10
  const basePath = path.resolve(__dirname, "../cadence")
11

12
  await init(basePath)
13
  await emulator.start()
14

15
  // We can specify, which account will hold the contract
16
  const to = await getAccountAddress("Alice")
17

18
  const name = "Wallet"
19
  const code = `
20
        pub contract Wallet{
21
            pub let balance: UInt
22
            init(balance: UInt){
23
              self.balance = balance
24
            }
25
        }
26
    `
27
  const args = [1337]
28

29
  await deployContract({to, name, code, args})
30

31
  const [balance, err] = await executeScript({
32
    code: `
33
      import Wallet from 0x01
34
      pub fun main(): UInt{
35
        return Wallet.balance
36
      }
37
    `,
38
  })
39
  console.log({balance}, {err})
40

41
  await emulator.stop()
42
})()

1
import path from "path"
2
import {init, emulator, deployContractByName, getContractAddress} from "../src"
3
;(async () => {
4
  const basePath = path.resolve(__dirname, "./cadence")
5

6
  await init(basePath)
7
  await emulator.start()
8

9
  // if we omit "to" it will be deployed to Service Account
10
  // but let's pretend we don't know where it will be deployed :)
11
  await deployContractByName({name: "Hello"})
12

13
  const contractAddress = await getContractAddress("Hello")
14
  console.log({contractAddress})
15

16
  await emulator.stop()
17
})()

1
import {pubFlowKey}
2

3
const key = {
4
  privateKey: "a1b2c3" // private key as hex string
5
  hashAlgorithm: HashAlgorithm.SHA3_256
6
  signatureAlgorithm: SignatureAlgorithm.ECDSA_P256
7
  weight: 1000
8
}
9

10
const pubKey = await pubFlowKey(key) // public key generated from keyObject provided
11
const genericPubKey = await pubFlowKey() // public key generated from universal private key/service key

1
import {signUserMessage, getAccountAddress} from "@onflow/flow-js-testing"
2

3
const Alice = await getAccountAddress("Alice")
4
const msgHex = "a1b2c3"
5

6
const signature = await generateUserSignature(msgHex, Alice)

1
import {
2
  signUserMessage,
3
  verifyUserSignatures,
4
  getAccountAddress,
5
} from "@onflow/flow-js-testing"
6

7
const Alice = await getAccountAddress("Alice")
8
const msgHex = "a1b2c3"
9

10
const signature = await generateUserSignature(msgHex, Alice)
11

12
console.log(await verifyUserSignatures(msgHex, Alice)) // true
13

14
const Bob = await getAccountAddress("Bob")
15
console.log(await verifyUserSignatures(msgHex, Bob)) // false

1
import path from "path"
2
import {emulator, init} from "../src"
3
;(async () => {
4
  const basePath = path.resolve(__dirname, "../cadence")
5

6
  await init(basePath)
7

8
  // Start emulator instance on port 8080
9
  await emulator.start()
10
  console.log("emulator is working")
11

12
  // Stop running emulator
13
  await emulator.stop()
14
  console.log("emulator has been stopped")
15
})()

1
import {emulator, init} from "@onflow/flow-js-testing"
2

3
describe("test setup", () => {
4
  // Instantiate emulator and path to Cadence files
5
  beforeEach(async () => {
6
    const basePath = path.resolve(__dirname, "../cadence")
7

8
    await init(basePath)
9
    await emulator.start()
10
  })
11

12
  // Stop emulator, so it could be restarted
13
  afterEach(async () => {
14
    await emulator.stop()
15
  })
16
})

1
import path from "path"
2
import {emulator, init} from "@onflow/flow-js-testing"
3

4
describe("test setup", () => {
5
  // Instantiate emulator and path to Cadence files
6
  beforeEach(async () => {
7
    const basePath = path.resolve(__dirname, "../cadence")
8

9
    await init(basePath)
10
    await emulator.start()
11
  })
12

13
  // Stop emulator, so it could be restarted
14
  afterEach(async () => {
15
    await emulator.stop()
16
  })
17

18
  test("basic test", async () => {
19
    // Turn on logging from begining
20
    emulator.setLogging(true)
21
    // some asserts and interactions
22

23
    // Turn off logging for later calls
24
    emulator.setLogging(false)
25
    // more asserts and interactions here
26
  })
27
})

1
import {
2
  init,
3
  emulator,
4
  getAccountAddress,
5
  getFlowBalance,
6
} from "@onflow/flow-js-testing"
7

8
const main = async () => {
9
  const basePath = path.resolve(__dirname, "../cadence")
10

11
  await init(basePath)
12
  await emulator.start()
13

14
  const Alice = await getAccountAddress("Alice")
15

16
  const [result, error] = await getFlowBalance(Alice)
17
  console.log({result}, {error})
18

19
  await emulator.stop()
20
}
21

22
main()

1
import path from "path"
2
import {
3
  init,
4
  emulator,
5
  getAccountAddress,
6
  getFlowBalance,
7
  mintFlow,
8
} from "../src"
9
;(async () => {
10
  const basePath = path.resolve(__dirname, "./cadence")
11

12
  await init(basePath)
13
  await emulator.start()
14

15
  // Get address for account with alias "Alice"
16
  const Alice = await getAccountAddress("Alice")
17

18
  // Get initial balance
19
  const [initialBalance] = await getFlowBalance(Alice)
20
  console.log(initialBalance)
21

22
  // Add 1.0 FLOW tokens to Alice account
23
  await mintFlow(Alice, "1.0")
24

25
  // Check updated balance
26
  const updatedBalance = await getFlowBalance(Alice)
27
  console.log({updatedBalance})
28

29
  await emulator.stop()
30
})()

1
import path from "path"
2
import {init} from "@onflow/flow-js-testing"
3

4
describe("test setup", () => {
5
  beforeEach(async () => {
6
    const basePath = path.resolve(__dirname, "../cadence")
7
    await init(basePath)
8

9
    // alternatively you can pass specific port
10
    // await init(basePath, {port: 8085})
11
  })
12
})

1
import path from "path"
2
import {init, emulator, getBlockOffset} from "@onflow/flow-js-testing"
3

4
const main = async () => {
5
  const basePath = path.resolve(__dirname, "../cadence")
6

7
  init(basePath)
8
  await emulator.start()
9

10
  const [blockOffset, err] = await getBlockOffset()
11
  console.log({blockOffset}, {err})
12

13
  await emulator.stop()
14
}
15

16
main()

1
import path from "path"
2
import {
3
  init,
4
  emulator,
5
  executeScript,
6
  getBlockOffset,
7
  setBlockOffset,
8
  sendTransaction,
9
} from "@onflow/flow-js-testing"
10

11
const main = async () => {
12
  const basePath = path.resolve(__dirname, "../cadence")
13

14
  init(basePath)
15
  await emulator.start()
16

17
  // Offset current block height by 42
18
  await setBlockOffset(42)
19

20
  const [blockOffset, err] = await getBlockOffset()
21
  console.log({blockOffset}, {err})
22

23
  // "getCurrentBlock().height" in your Cadence code will be replaced by Manager to a mocked value
24
  const code = `
25
    pub fun main(): UInt64 {
26
      return getCurrentBlock().height
27
    }
28
  `
29

30
  const [result, error] = await executeScript({code})
31
  console.log({result}, {error})
32

33
  await emulator.stop()
34
}
35

36
main()

1
import path from "path"
2
import {init, emulator, getTimestampOffset} from "@onflow/flow-js-testing"
3

4
const main = async () => {
5
  const basePath = path.resolve(__dirname, "../cadence")
6

7
  init(basePath)
8
  await emulator.start()
9

10
  const [timestampOffset, err] = await getTimestampOffset()
11
  console.log({timestampOffset}, {err})
12

13
  await emulator.stop()
14
}
15

16
main()

1
import path from "path"
2
import {
3
  init,
4
  emulator,
5
  executeScript,
6
  getTimestampOffset,
7
  setTimestampOffset,
8
  sendTransaction,
9
} from "@onflow/flow-js-testing"
10

11
const main = async () => {
12
  const basePath = path.resolve(__dirname, "../cadence")
13

14
  init(basePath)
15
  await emulator.start()
16

17
  // Offset current timestamp by 10s
18
  await setTimestampOffset(10)
19

20
  const [timestampOffset, err] = await getTimestampOffset()
21
  console.log({timestampOffset}, {err})
22

23
  // "getCurrentBlock().timestamp" in your Cadence code will be replaced by Manager to a mocked value
24
  const code = `
25
    pub fun main(): UInt64 {
26
      return getCurrentBlock().timestamp
27
    }
28
  `
29

30
  const [result, error] = await executeScript({code})
31
  console.log({result}, {error})
32

33
  await emulator.stop()
34
}
35

36
main()

1
import path from "path"
2
import {
3
  init,
4
  emulator,
5
  shallPass,
6
  sendTransaction,
7
  getAccountAddress,
8
} from "js-testing-framework"
9

10
// We need to set timeout for a higher number, cause some interactions might need more time
11
jest.setTimeout(10000)
12

13
describe("interactions - sendTransaction", () => {
14
  // Instantiate emulator and path to Cadence files
15
  beforeEach(async () => {
16
    const basePath = path.resolve(__dirname, "./cadence")
17
    await init(basePath)
18
    return emulator.start()
19
  })
20

21
  // Stop emulator, so it could be restarted
22
  afterEach(async () => {
23
    return emulator.stop()
24
  })
25

26
  test("basic transaction", async () => {
27
    const code = `
28
      transaction(message: String){
29
        prepare(singer: AuthAccount){
30
          log(message)
31
        }
32
      }
33
    `
34
    const Alice = await getAccountAddress("Alice")
35
    const signers = [Alice]
36
    const args = ["Hello, Cadence"]
37

38
    const [txResult, error] = await shallPass(
39
      sendTransaction({
40
        code,
41
        signers,
42
        args,
43
      })
44
    )
45

46
    // Transaction result will hold status, events and error message
47
    console.log({txResult}, {error})
48
  })
49
})

1
import path from "path"
2
import {
3
  init,
4
  emulator,
5
  shallPass,
6
  sendTransaction,
7
  getAccountAddress,
8
} from "js-testing-framework"
9

10
// We need to set timeout for a higher number, cause some interactions might need more time
11
jest.setTimeout(10000)
12

13
describe("interactions - sendTransaction", () => {
14
  // Instantiate emulator and path to Cadence files
15
  beforeEach(async () => {
16
    const basePath = path.resolve(__dirname, "./cadence")
17
    await init(basePath)
18
    return emulator.start()
19
  })
20

21
  // Stop emulator, so it could be restarted
22
  afterEach(async () => {
23
    return emulator.stop()
24
  })
25

26
  test("basic transaction", async () => {
27
    const code = `
28
      transaction(message: String){
29
        prepare(singer: AuthAccount){
30
          panic("You shall not pass!")
31
        }
32
      }
33
    `
34
    const Alice = await getAccountAddress("Alice")
35
    const signers = [Alice]
36
    const args = ["Hello, Cadence"]
37

38
    // Catch any cadence error
39
    let [txResult, error] = await shallRevert(
40
      sendTransaction({
41
        code,
42
        signers,
43
        args,
44
      })
45
    )
46

47
    // Catch only specific panic message
48
    let [txResult, error] = await shallRevert(
49
      sendTransaction({
50
        code,
51
        signers,
52
        args,
53
      }),
54
      "You shall not pass!"
55
    )
56

57
    // Transaction result will hold status, events and error message
58
    console.log({txResult}, {error})
59
  })
60
})

1
import path from "path"
2
import {init, emulator, shallPass, executeScript} from "js-testing-framework"
3

4
// We need to set timeout for a higher number, cause some interactions might need more time
5
jest.setTimeout(10000)
6

7
describe("interactions - sendTransaction", () => {
8
  // Instantiate emulator and path to Cadence files
9
  beforeEach(async () => {
10
    const basePath = path.resolve(__dirname, "./cadence")
11
    await init(basePath)
12
    return emulator.start()
13
  })
14

15
  // Stop emulator, so it could be restarted
16
  afterEach(async () => {
17
    return emulator.stop()
18
  })
19

20
  test("basic script", async () => {
21
    const code = `
22
      pub fun main():Int{
23
        return 42
24
      }
25
    `
26

27
    const [result, error] = await shallResolve(
28
      executeScript({
29
        code,
30
      })
31
    )
32

33
    expect(result).toBe(42)
34
    expect(error).toBe(null)
35
  })
36
})

1
import path from "path"
2
import {init, emulator, executeScript} from "@onflow/flow-js-testing"
3

4
const main = async () => {
5
  const basePath = path.resolve(__dirname, "../cadence")
6

7
  // Init framework
8
  init(basePath)
9
  // Start emulator
10
  await emulator.start()
11

12
  // Define code and arguments we want to pass
13
  const code = `
14
    pub fun main(message: String): Int{
15
      log(message)
16

17
      return 42
18
    }
19
  `
20
  const args = ["Hello, from Cadence"]
21

22
  const [result, error, logs] = await executeScript({code, args})
23
  console.log({result}, {error}, {logs})
24

25
  // Stop emulator instance
26
  await emulator.stop()
27
}
28

29
main()

1
import path from "path"
2
import {init, emulator, executeScript} from "@onflow/flow-js-testing"
3

4
const main = async () => {
5
  const basePath = path.resolve(__dirname, "../cadence")
6

7
  // Init framework
8
  init(basePath)
9
  // Start emulator
10
  await emulator.start()
11

12
  // Define arguments we want to pass
13
  const args = ["Hello, from Cadence"]
14

15
  // We assume there is a file `scripts/log-message.cdc` under base path
16
  const [result, error, logs] = await executeScript("log-message", args)
17
  console.log({result}, {error}, {logs})
18

19
  await emulator.stop()
20
}
21

22
main()

1
import path from "path"
2
import {
3
  init,
4
  emulator,
5
  sendTransaction,
6
  getAccountAddress,
7
} from "@onflow/flow-js-testing"
8

9
const main = async () => {
10
  const basePath = path.resolve(__dirname, "../cadence")
11

12
  // Init framework
13
  await init(basePath)
14
  // Start emulator
15
  await emulator.start()
16

17
  // Define code and arguments we want to pass
18
  const code = `
19
    transaction(message: String){
20
      prepare(signer: AuthAccount){
21
        log(message)
22
      }
23
    }
24
  `
25
  const args = ["Hello, from Cadence"]
26
  const Alice = await getAccountAddress("Alice")
27
  const signers = [Alice]
28

29
  const [result, error, logs] = await sendTransaction({code, args, signers})
30
  console.log({result}, {error}, {logs})
31

32
  // Stop emulator instance
33
  await emulator.stop()
34
}
35

36
main()

1
import path from "path"
2
import {
3
  init,
4
  emulator,
5
  sendTransaction,
6
  shallPass,
7
} from "@onflow/flow-js-testing"
8

9
const main = async () => {
10
  const basePath = path.resolve(__dirname, "../cadence")
11

12
  // Init framework
13
  await init(basePath)
14
  // Start emulator
15
  await emulator.start()
16

17
  // Define arguments we want to pass
18
  const args = ["Hello, Cadence"]
19

20
  const [result, error, logs] = await shallPass(
21
    sendTransaction("log-message", [], args)
22
  )
23
  console.log({result}, {error}, {logs})
24

25
  // Stop the emulator instance
26
  await emulator.stop()
27
}
28

29
main()

1
import path from "path"
2
import {init, getTemplate} from "@onflow/flow-js-testing"
3

4
const main = async () => {
5
  const basePath = path.resolve(__dirname, "../cadence")
6
  await init(basePath)
7

8
  const template = await getTemplate("../cadence/scripts/get-name.cdc")
9
  console.log({template})
10
}
11

12
main()