3.4 测试工作流程和编写测试

riyad

3 s" [1 i. A- H9 d3 o; b/ X

我们已经编写了第一个 FunC 合约，并已成功编译。接下来要做什么呢？

在这一课中，我们将学习如何确保我们的合约代码确实能按预期运行。让我提醒你我们对代码的期望：

我们的合约应该在每次收到消息时保存一个发件人地址，并且在调用 getter 方法时返回最新的发件人地址。

很好，但我们如何确保它能正常工作呢？我们可以将它部署到区块链上（我们很快就会在下一课中这样做）， TON 有一些工具，可以让我们在本地模拟某些行为.

这需要借助 sandbox. 这 library 允许您模拟任意的 TON 智能合约，向它们发送消息并运行获取方法，就像它们部署在真实网络上一样。 因为我们有自己的 TypeScript 环境，所以我们可以借助另一个库创建一系列测试 - jest. 这样，我们就有了一个测试套件，可以用不同的输入数据模拟所有重要行为，并检查结果。这是编写、调试和全面测试合约的最佳方法，然后再将它们发布到网络上。

准备测试套件

首先，假设你现在位于项目的根目录，让我们安装 sandbox, jest 以及一个我们需要与 TON 实体交互的库 - ton:

1. yarn add @ton/sandbox jest ts-jest @types/jest @ton/ton --dev
   

复制代码

我们还需要在项目根目录下为 jest 创建一个 jest.config.js 文件，内容如下：

1. module.exports = {
   
2.     preset: 'ts-jest',
   " T4 [; x, y9 e. l+ ]8 p; s
3.     testEnvironment: 'node',
   7 Z  F( F" o5 L# r1 m+ r' |
4. };

复制代码

现在，我们创建一个新文件夹 test，其中包含文件 main.spec.ts：

1. mkdir tests && cd tests && touch main.spec.ts
   

复制代码

我们设置好 main.spec.ts 文件，以便编写第一个测试：

1. describe("main.fc contract tests", () => {
   * W9 ]) v( R4 Z" t# s/ _4 h
2. 
   & @' V0 ~; q% r! c; E
3.   it("our first test", async () => {
   
4. 
   
5.   });
   8 V$ n' X% X# ]) S8 r8 @
6. 
   
7. });

复制代码

如果你从未编写过 TypeScript 测试，你一定要试试这种方法。在编写 TON 智能合约时，你会将一半以上的编程时间花在编写测试上。还记得我们的太空卫星例子吗？在这里也是一样，我们甚至在将合约部署到 testnet 之前，就已经模拟了每一种重要情况。

现在尝试运行命令 yarn jest 的根目录中。如果你已经正确安装了所有程序（跟我一起一步步安装），你应该会看到下面的内容：

1. PASS  tests/main.spec.ts
   
2.   main.fc contract tests
   # e7 s. K& \: _8 v0 A$ p% q
3.     ✓ our first test (1 ms)

复制代码

很好，让我们立即在 package.json 文件中创建另一个脚本运行快捷方式：

7 R# ?3 |# E$ B" ^- y& I; T

1. {
   
2.   ... our previous package.json keys
   4 W  T- s! f& o" d
3.   "scripts": {
   , P" o0 P! N" a$ K
4.     ... previous scripts keys
   
5.     "test": "yarn jest"
   & M$ ~% w9 d; `' y$ O
6.   }
   ! x2 R' ?! F; u" R# [( `
7. }

复制代码

创建合约实例

为了编写第一个测试，我们需要了解如何借助 sandbox.

我们之前讨论过，我们的合约代码在编译后会存储为一个 Cell。在 build/main.compiled.json 文件中，我们有一个 Cell 的十六进制表示法。让我们把它导入我们的测试文件，并从以下文件中导入 Cell 类型 ton-core:

1. import { Cell } from "@ton/core";
   
2. import { hex } from "../build/main.compiled.json";
   
3. 
   
4. describe("main.fc contract tests", () => {
   
5. 
     N) B) H5 ~; l
6.   it("our first test", async () => {
     k/ v* J9 d- J# B9 a5 d" M
7. 
   
8.   });
   
9. 
   
10. });

复制代码

现在，要恢复十六进制并获得真正的 Cell，我们将使用这条命令： const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0].

我们用十六进制字符串创建一个缓冲区，并将其传递给 .fromBoc 方法。

现在让我们来看看 sandbox quick start guide. 我们看到，在获得合约实例之前，我们必须先获得区块链实例。

让我们从 sandbox 库，并调用它的 .create() 方法。

1. import { Cell } from "@ton/core";
     t% j. X( w7 Q. U% p. D4 x( T
2. import { hex } from "../build/main.compiled.json";
   
3. import { Blockchain } from "@ton/sandbox";
   
4. 
   / V  O( L: w/ u- }  f
5. describe("main.fc contract tests", () => {
   
6.   it("our first test", async () => {
   3 G" z+ L9 {; ?+ f, G5 p9 R
7.     const blockchain = await Blockchain.create();
   
8. 
   
9.   });
   ; h- S8 Z6 J; C9 u& Q
10. });

复制代码

现在，让我们准备好获取一个合约实例来进行交互。Sandbox 的文档指出，推荐的使用方法是使用 Contract 从 ton-core

这对我们意味着什么？让我们创建一个新文件夹 wrappers 和一个名为 MainContract.ts 其内. 该文件将实现并导出我们合约的包装器。

1. mkdir wrappers && cd wrappers && touch MainContract.ts
   

复制代码

确保从项目根目录运行此命令序列

打开 MainContract.ts 编辑用. 让我们导入一个 Contract 从 ton-core 库，然后定义并导出一个实现 Contract.

1. import { Contract } from '@ton/core';
   ( z& K$ o  ?" d$ y
2. 
   - h1 D* V  E  K! ^
3. export class MainContract implements Contract {
   / S. L% _8 Q3 q* c2 W7 c( y0 h
4.    
   8 x1 Y* J/ ]  F( G6 N
5. }

复制代码

如果您查看一下 Contract 接口 - 你会看到它需要 address, init 和 abi 参数。 我们只会将 address 和 init 用于我们的目的。 为了使用它们，我们要为我们的 MainContract 类定义一个构造函数。

如果您不知道我们这里所说的类和构造函数是什么意思，那么您最好多读一些关于面向对象编程（Object Oriented Programming）的内容。FunC 并不要求这样做，但为了更好地使用 TypeScript 进行测试，您应该了解这些基本概念。

1. import { Address, Cell, Contract } from "@ton/core";
     k- t- n2 M/ V' u( h2 a1 o
2. 
   9 G# N( ], l3 h! y4 C
3. export class MainContract implements Contract {
   
4.   constructor(
   & s9 [. b- \: _' T. W0 a: c8 I
5.     readonly address: Address,
   * }+ ]$ J: X# \6 G+ r
6.     readonly init?: { code: Cell; data: Cell }
   + @3 W5 N0 f4 O; J  o* X
7.   ) {}
   ( F6 Z, s# u/ A! G
8. }

复制代码

init 属性非常有趣。它具有我们合约的初始状态。代码显然就是合约的代码。数据则更有趣一些。还记得我们在讨论合约的 c4 持续存储吗？ 有了这个 data 在Cell中，我们可以定义一旦我们的合约首次执行，该存储空间中会有哪些内容。这两个值都有 Cell 类型，因为它们在合约生命周期内存储在 TVM 的内存中。相同类型 code 和 data Cell还用于计算我们合同的未来地址。

请注意，我们还导入了 Address 和 Cell 从 @ton/core 库.

在 TON 中，合约的地址是确定的。我们甚至可以在部署合约之前就知道它们。我们将通过几个步骤了解如何做到这一点。

现在，让我们为我们的 MainContract 类 - createFromConfig. 我们暂时不会使用任何配置参数，但今后我们会假设需要输入数据才能创建合约实例。

1. import { Address, beginCell, Cell, Contract, contractAddress } from "@ton/core";
   
2. 
   2 i/ [& ?" j; N* b3 |6 n; R
3. export class MainContract implements Contract {
   * j5 k: [, S  i- X: Q: [  z0 m
4.   constructor(
   
5.     readonly address: Address,
   
6.     readonly init?: { code: Cell; data: Cell }
   : k3 p- J! `4 Y' O" o
7.   ) {}
   # F/ K. H+ v+ u- x3 j
8. 
   
9.   static createFromConfig(config: any, code: Cell, workchain = 0) {
   
10.     const data = beginCell().endCell();
    $ X0 g# B$ {! r
11.     const init = { code, data };
    
12.     const address = contractAddress(workchain, init);
    : a4 P' _$ B6 V  g
13. 
    
14.     return new MainContract(address, init);
    . _" B+ Q  J. a: e9 \9 r
15.   }
    
16. }

复制代码

我们的 createFromConfig 方法接受一个 config 参数（暂时忽略), code 是一个包含我们合约的编译代码的 Cell 和一个 workchain 定义了合约要放置的 TON 工作链。目前，ton 上只有一个工作链 - 0。

为了更好地理解这段代码，让我们从返回的结果开始。我们正在创建 MainContract 类的一个新实例，并按照其构造函数中的定义，我们必须传递其合约的未来 address (如前所述，我们可以计算出）和合约的 init 状态。

我们通过从 @ton/core 库导入的函数计算地址. 通过 workchain 和 init 状态参数，以便获取它。

init 状态只是一个具有 code 和 data 属性的对象.  code 被传入至我们的方法中，而 data 现在只是一个空Cell。我们将学习如何将 config 数据转换成 Cell 格式，以便我们可以使用 config 数据中 init 我们的合约状况。

总而言之 createFromConfig 正在接受一项 config 数据，我们将来会将这些数据存储在合约的持续存储和 code 的实例。作为回报，我们会得到一个合约实例，我们可以借助 sandbox.

让我们回到我们的 tests/main.spec.ts 并执行以下步骤：

• 导入我们的包装器
• 以十六进制形式导入合约的编译代码
• 转换为Cell
• 使用沙盒的 openContract 与我们的新包装器一起，得到一个合约实例，最终我们可以与之交互
  
  ! C  J. }# o/ _) ?

1. import { Cell } from "@ton/core";
   
2. import { hex } from "../build/main.compiled.json";
   + j: I; Y  ~; S; W
3. import { Blockchain } from "@ton/sandbox";
   4 X1 I8 g  D2 Z& n6 C1 Y; l: ]
4. import { MainContract } from "../wrappers/MainContract";
   * ?' v7 }1 }; B! s: Z
5. 
     |+ l2 A2 X% c* f0 u0 A8 R
6. describe("main.fc contract tests", () => {
   , _3 N: a( z, s! |2 e0 }( F# T
7.   it("our first test", async () => {
   
8.     const blockchain = await Blockchain.create();
   2 k/ a8 _6 }$ `4 Q, M
9.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
   4 R/ U6 b4 d" y4 O0 d0 ?% M1 J
10. 
    6 e! N5 V2 M4 h( T6 X+ `: u
11.     const myContract = blockchain.openContract(
    
12.       await MainContract.createFromConfig({}, codeCell)
      _" V" x* A  n! x1 [
13.     );
    ! @* j. W# `1 m- ]# p/ b
14.   });
    2 D4 h: q9 ~. S+ r9 U6 G
15. });

复制代码

至此，我们就有了一个智能合约实例，我们可以通过许多与真实合约类似的方式与之交互，以测试预期行为。

与合约互动

@ton/core 库为我们提供了另一个伟大的组件，名为 Address. 众所周知，TON 区块链上的每个实体都有一个地址。在实际中，如果您想从一个合约（例如钱包合约）向另一个合约发送信息，您需要知道两个合约的地址。

在编写测试时，我们会模拟一个合约，当我们与合约交互时，我们模拟的合约地址是已知的。不过，我们还需要一个钱包，用来部署我们的合约，另一个钱包用来与我们的合约交互。

在 sandbox 这样做的方式是，我们称之为 treasure 方法，并为其提供一个助记词: const senderWallet = await blockchain.treasury("sender");

模仿内部信息

让我们继续编写测试。既然我们已经有了一个合约实例，那就向它发送一条内部信息吧，这样我们的发件人地址就会保存在 c4 存储空间中。我们还记得，要与我们的合约实例交互，我们需要使用包装器。

回到我们的文件 wrappers/MainContract.ts 并在封装器中创建一个名为 sendInternalMessage.

最初看起来是这样的:

1. async sendInternalMessage(
   
2.     provider: ContractProvider,
   
3.     sender: Sender,
     j3 ?# p8 l' e
4.     value: bigint
   - {, Y! P1 }3 N
5.   ){
   " ]0 H2 N# T& g) m: a2 P" L
6.    
   4 q9 h, m2 k% v+ i) D* G. N1 P: y
7. }

复制代码

我们的新方法将接收 ContractProvider 类型的参数、Sender 类型的信息发送者和信息值 value.

通常情况下，使用此方法时我们不必担心传递 ContractProvider，它将作为合约实例内置功能的一部分在底层传递。不过，不要忘了从 ton-core 库中导入这些类型.

让我们在新方法中实现发送内部信息的逻辑。它看起来是这样的:

1. async sendInternalMessage(
     k7 Q( b8 u$ S" j6 m& W
2.     provider: ContractProvider,
   ; [- b7 g0 d: W4 m
3.     sender: Sender,
   ; P' o5 j" c+ f: E' Q. g9 `
4.     value: bigint
   
5.   ) {
   
6.     await provider.internal(sender, {
   4 N, \6 q9 G7 m
7.       value,
   
8.       sendMode: SendMode.PAY_GAS_SEPARATELY,
   
9.       body: beginCell().endCell(),
   
10.     });
    ) a- f* r1 P! C# C. K2 T
11.   }

复制代码

您可以看到，我们正在使用 provider 并调用其名为 internal. 我们通过了 sender 作为第一个参数，然后我们用参数组成一个对象，其中包括:

• value 的信息量（nano格式的TON币数）
• sendMode - 我们使用由 @ton/core, 有关这些模式如何在底层工作的更多信息，请参阅 documentation page 致力于此
• body 这应该是一个包含信息正文的Cell，但我们暂时将其保留为一个空Cell
  
  " ~. \: w; P* T6 S  k. o; D

请不要忘记将我们使用的所有新类型和实体从 @ton/core 库.

因此，wrappers/MainContract.ts 的最终代码如下所示：

5 d$ p5 x7 S3 Z! M. i

1. import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode } from "@ton/core";
   , z( {( S/ a0 v4 ]
2. 
   2 e* R8 _1 N5 P% ^% y
3. export class MainContract implements Contract {
   8 T4 S2 x  g4 {$ F) y0 n+ B+ L, C
4.   constructor(
   * k) b% I5 F2 L4 ]1 X0 u
5.     readonly address: Address,
   8 \, R" y; ^) M2 j' a# r
6.     readonly init?: { code: Cell; data: Cell }
   
7.   ) {}
   * S3 Q! D: d- b: a: ~$ p$ ]
8. 
   
9.   static createFromConfig(config: any, code: Cell, workchain = 0) {
   
10.     const data = beginCell().endCell();
    
11.     const init = { code, data };
    
12.     const address = contractAddress(workchain, init);
    3 J3 c" p/ ?& R/ H7 \
13. 
    : b1 P$ j) Q# j- [5 |
14.     return new MainContract(address, init);
    ! \0 f; Q( X) Z! }: K# _/ L& O
15.   }
    % |% w2 o# X3 P( D/ @  B+ d
16. 
    
17.   async sendInternalMessage(
    0 Q8 y# `2 l* P3 {0 @% e9 Q; Y
18.     provider: ContractProvider,
    
19.     sender: Sender,
    
20.     value: bigint
    
21.   ) {
    ) L* U8 h" y6 s* J: |8 f4 [
22.     await provider.internal(sender, {
    6 e# y9 o" Y& _) y9 n5 R: u/ l2 [
23.       value,
    
24.       sendMode: SendMode.PAY_GAS_SEPARATELY,
    
25.       body: beginCell().endCell(),
    
26.     });
    6 N7 W- [+ x9 U; |# m- ~) C3 Y
27.   }
      |: ?; G$ u* u9 F; l
28. }

复制代码

在我们的 tests/main.spec.ts 中调用该方法会是这样：

1. const senderWallet = await blockchain.treasury("sender");
   
2. myContract.sendInternalMessage(senderWallet.getSender(), toNano("0.05"));

复制代码

请注意我们是如何使用 toNano 辅助函数 @ton/core 库将字符串值转换为nano gram格式。

1 l+ i2 V7 a5 J$ k: A' O6 A$ B( v
9 Y* r! \9 W9 t4 B( b% ?调用 getter 方法

我们需要在合约包装器上再创建一个方法，即 getData 方法，该方法将运行合约的 getter 方法，并返回 c4 存储器中的结果。

这就是我们的 getter 方法：

1. async getData(provider: ContractProvider) {
   
2.     const { stack } = await provider.get("get_the_latest_sender", []);
   
3.     return {
   # k; O$ S5 W0 O- F$ |) x0 S3 {
4.       recent_sender: stack.readAddress(),
   
5.     };
   
6. }

复制代码

就像我们发送内部信息一样，我们使用的是提供发送者及其方法。在本例中，我们使用的是 get 方法。 然后，我们从接收到的 stack 并将其作为结果返回。

编写测试

就是这样。我们已经完成了所有的准备工作，现在要编写实际的测试逻辑。下面是我们的测试场景：

• 我们发送内部信息
• 确保发送成功
• 我们调用合约的获取方法，并确保调用成功。
• 我们将从 getter 接收到的结果与 from 我们在原始内部信息中设置的地址。
  
  ' b4 P5 [0 }8 y9 B5 s6 \

看起来非常简单可行！让我们行动起来吧

沙盒团队又为我们提供了一个神奇的测试工具。我们可以安装额外的 @ton/test-utils 软件包，方法是运行 yarn add @ton/test-utils -D

这将使我们能够使用 .toHaveTransaction 为 jest matcher 添加额外的辅助工具，以方便测试。我们还需要在我们的 tests/main.spec.ts 安装后。

让我们看看基于上述场景的测试代码是怎样的。

1. import { Cell, toNano } from "@ton/core";
   
2. import { hex } from "../build/main.compiled.json";
   ! R$ R5 z# T: c  E- G
3. import { Blockchain } from "@ton/sandbox";
   4 [- |9 y. U& o+ c$ A
4. import { MainContract } from "../wrappers/MainContract";
   
5. import "@ton/test-utils";
   " I  Q! p! Z. N/ m* R. }% s) Z
6. 
   % G# z+ _7 m! t* c3 G: e) s
7. describe("main.fc contract tests", () => {
   ( q/ d- S* d6 H  Q9 a
8.   it("should get the proper most recent sender address", async () => {
   5 y' a0 W( K% Z& g7 @: I
9.     const blockchain = await Blockchain.create();
   9 l  s6 U7 P5 A2 R+ y  Q% z7 U
10.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
    
11. 
    & W5 v4 S' q/ Q; e4 J
12.     const myContract = blockchain.openContract(
    . m2 ?! a2 Z: t) U0 y
13.       await MainContract.createFromConfig({}, codeCell)
    7 e6 @  c# {. i5 J9 n( Y& ]2 Z' u
14.     );
    
15. 
    # O: Q% N5 V/ _1 a( U3 p! m1 s/ j
16.     const senderWallet = await blockchain.treasury("sender");
    
17. 
    
18.     const sentMessageResult = await myContract.sendInternalMessage(
    ( j" B, J6 I+ t  J6 o
19.       senderWallet.getSender(),
    ( _% w! M/ B& a; X% h3 p- {
20.       toNano("0.05")
    
21.     );
    * n1 g7 a1 R* q- J% I
22. 
    
23.     expect(sentMessageResult.transactions).toHaveTransaction({
    
24.       from: senderWallet.address,
    
25.       to: myContract.address,
    . C+ A; K' E' [% ~
26.       success: true,
    1 L- R' U1 j8 d: g9 ~! m7 \
27.     });
    
28. 
    8 h% b; {3 L0 X1 C* H) R
29.     const data = await myContract.getData();
    
30. 
    
31.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    
32.   });
    
33. });

复制代码

我们使用 Jest 功能来确保这一点：

• 内部信息发送成功
• 获取方法成功
• 获取方法返回结果
• 从获取方法返回的地址等于我们在信息中使用的地址  from 地址
  
  / {( S$ D0 m- x. C2 \

我们还将 "我们的第一次测试 "更名为 "应获得正确的最新发件人地址"，因为我们希望测试名称始终可读。

运行测试

瞧！我们已经准备好运行测试了。只需运行我们的命令 yarn test 在终端中，如果你和我一起做了所有的事情，你也会得到类似的结果：

1. PASS  tests/main.spec.ts
   
2.   main.fc contract tests
   
3.     ✓ should get the proper most recent sender address (444 ms)
   ! p0 ]. L+ |3 [' _) U
4. 
   ! }5 F/ C7 t! X  |& H2 y8 i
5. Test Suites: 1 passed, 1 total
   
6. Tests:       1 passed, 1 total
   7 Q* O4 E: D: O4 X2 U$ {
7. Snapshots:   0 total
   
8. Time:        4.13 s, estimated 5 s

复制代码

我们要做的最后一件事是确保每次运行测试时，同时运行编译器脚本。这有助于提高我们的工作效率。大部分开发工作都是编写功能代码，然后运行测试。让我们简化这一切：

更新 package.json 文件，使其看起来像这样：

1. {
   ; d7 |! l" w: M5 |, w! c
2.   ... our previous package.json keys
   
3.   "scripts": {
   0 b5 y3 k5 n& L4 w- ^& x
4.     ... previous scripts keys
   
5.     "test": "yarn compile && yarn jest"
   ; Q( L3 r, f( |
6.   }
     X* t+ |; Q. P
7. }

复制代码

在下一课中，我们将构建部署途径，并学习如何在链上测试真正的部署合同
* y) W3 v1 Q; t4 P6 d1 \4 P
& |  Z* b; U* E  m# p
4 k) {; F, G5 ^( [1 ]4 j