4.2 合同测试

riyad

正如我之前提到的，编写测试将是 FunC 合约编程中非常重要的一部分。让我们回顾一下上一课创建的测试：

. x; B& a9 ^& _$ J/ z, q' H

1. import { Cell, toNano } from "ton-core";
   3 n8 g: _6 _1 J5 X# N3 R% T
2. import { hex } from "../build/main.compiled.json";
   4 R0 \6 c$ v0 ]0 W
3. import { Blockchain } from "@ton-community/sandbox";
   
4. import { MainContract } from "../wrappers/MainContract";
   $ ?3 v- ~! O& ~' Y
5. import "@ton-community/test-utils";
   
6. 
   ) P) R6 Z' N( [; n# W
7. describe("main.fc contract tests", () => {
   
8.   it("should get the proper most recent sender address", async () => {
     s" Q1 ?8 n  k+ m
9.     const blockchain = await Blockchain.create();
   
10.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
    
11. 
      ^; L1 w9 g5 `
12.     const myContract = blockchain.openContract(
    0 F0 v. z% W; ?; T0 y( Y& w" @
13.       await MainContract.createFromConfig({}, codeCell)
    
14.     );
    & P( P: a1 i* B7 H; y
15. 
    7 d+ ^# V0 L( P( H8 d4 e
16.     const senderWallet = await blockchain.treasury("sender");
    $ f# c2 L( x  d  h
17. 
    
18.     const sentMessageResult = await myContract.sendInternalMessage(
    
19.       senderWallet.getSender(),
    $ `, {! b7 t8 B1 F& B: @* y* C
20.       toNano("0.05")
    & ]) W7 `; n6 g! B& w7 p5 y! j
21.     );
    ! s, G5 t0 o; m" z& _+ ]8 D: v2 `: k
22. 
    
23.     expect(sentMessageResult.transactions).toHaveTransaction({
    
24.       from: senderWallet.address,
    ' A, {; l- F5 @8 e7 `1 V
25.       to: myContract.address,
    3 F& B  U' g  Y  M9 L2 ?/ f; x( W
26.       success: true,
    $ A. }+ `( j  R# ^6 H
27.     });
    # _' j5 e+ p& }  s& @: S6 P
28. 
    + c( T) J4 u  ^8 r
29.     const data = await myContract.getData();
    + R: [& y' z% |/ X8 V
30. 
    7 G" x8 D8 C! b
31.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    
32.   });
    * W0 Q0 _3 ~+ S! O/ Q& V  I
33. });

复制代码

值得一提的是，如果我们现在运行 yarn 测试，它将无法工作，因为我们的代码发生了很大变化。为了解决这个问题，我们需要做的如下：

• 我们需要提供适当的初始状态数据，因此我们的 c4 存储空间已经预填充了一些数据。我们将提供 0 作为计数器值，zeroAddress 作为最新的发件人地址（根据合约的新逻辑)。
• 我们需要在发送给合约的信息正文中传递一个特定的操作命令。
  
  

让我们来处理初始数据。正如你所记得的，我们使用 createFromConfig 方法来初始化我们的合约，并通过以下方式将合约的初始状态数据设置为简单的空Cell：

1. static createFromConfig(config: any, code: Cell, workchain = 0) {
   * Z" j- H' Z6 j
2.     const data = beginCell().endCell();
   
3.     const init = { code, data };
   
4.     const address = contractAddress(workchain, init);
   
5. 
   
6.     return new MainContract(address, init);
   
7. }

复制代码

然后在 main.spec.ts 中调用 createFromConfig：

5 m; P8 R: o$ A

1. const myContract = blockchain.openContract(
   $ B( x' G. F1 e7 P
2.   await MainContract.createFromConfig({}, codeCell)
   9 ?! z; n5 i; ^; q3 V
3. );

复制代码

到目前为止，我们传递的是一个空对象作为配置，但现在我们可以传递一些值，这些值实际上是我们初始化合约的适当数据所需要的。

让我们定义一下我们的 config 应该是什么样子。在 wrappers/MainContract.ts 中导入后，我们将定义一个名为 MainContractConfig 的新类型。

1. // ... library imports
   " G( {- m+ U; v6 ^* f. X/ u# d
2. 
   # E! {0 V; G. Q! p$ _
3. export type MainContractConfig = {
   - s, E  i1 t; m+ U' f5 G$ n
4.   number: number;
   
5.   address: Address;
   
6. };

复制代码

我们将在同一封装文件中实现的另一个很酷的辅助函数是 mainContractConfigToCell.它将接收 MainContractConfig 类型的对象，将这些参数正确打包到Cell中并返回.我们需要这样做，因为你还记得，c4 存储空间是一个存储Cell：
1 z6 h- P3 \1 I- ~$ ~0 u

1. // ... library imports
   
2. 
   2 K. r1 M5 M* ?
3. // ... MainContractConfig type
   6 b& t" S6 ~( y$ k9 [; L+ Z
4. 
   # V) j% L0 i4 q' h
5. export function mainContractConfigToCell(config: MainContractConfig): Cell {
   
6.   return beginCell().storeUint(config.number, 32).storeAddress(config.address).endCell();
   
7. }

复制代码

现在让我们更新同一文件中的 createFromConfig，不过是在 MainContract 类中。现在，它必须使用 mainContractConfigToCell 函数来形成初始状态数据 Cell：

1. // ... library imports
   6 I' {3 L2 U) y/ E7 \- B
2. // ... MainContractConfig type
   / _6 Z  O2 ^4 n, F6 B1 v
3. // ... mainContractConfigToCell function
   
4. 
   
5. export class MainContract implements Contract {
   ! T& `( Z$ Z( o4 ^, K5 ^+ N4 n; k
6.   constructor(
   % K, x3 ?; p0 P8 A) ^1 f
7.     readonly address: Address,
   
8.     readonly init?: { code: Cell; data: Cell }
   
9.   ) {}
   
10. 
    ) ]$ K3 w/ h8 H% r
11.   static createFromConfig(
    
12.     config: MainContractConfig,
    ) z$ O$ C" M, s$ D  c
13.     code: Cell,
    9 d6 u% w; P9 v
14.     workchain = 0
    
15.   ) {
    
16.     const data = mainContractConfigToCell(config);
    
17.     const init = { code, data };
    
18.     const address = contractAddress(workchain, init);
    5 n/ L1 _7 S9 b7 N9 e# d/ R
19. 
    
20.     return new MainContract(address, init);
    
21.   }
    8 |! k& m! `3 r# b5 J, @  y) g9 M
22.   
    
23.   // ... rest of the methods
    
24. }

复制代码

现在，我们的 createFromConfig 方法已经准备就绪，让我们更新一下如何在 tests/main.spec.ts 文件中使用该方法：

1 r  g; w- b0 T+ O0 ?

1. // ... library imports
   7 F% C. V& J( p1 T
2. 
   
3. describe("main.fc contract tests", () => {
   2 t6 r  H4 x. Q( K" D8 }) h) n! c$ |: W
4.   it("should get the proper most recent sender address", async () => {
   : {: e8 N- D) a8 |( `/ q; l
5.     const blockchain = await Blockchain.create();
   
6.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
   
7. 
   
8.     const initAddress = await blockchain.treasury("initAddress");
   
9. 
   
10.     const myContract = blockchain.openContract(
    
11.       await MainContract.createFromConfig(
    ; o6 g' i8 j" |+ W+ r3 i* K
12.         {
    
13.           number: 0,
    
14.           address: initAddress.address,
    
15.         },
    ) {6 G# f% L3 i% G' s
16.         codeCell
    0 w! L& `; x% E2 H: D) g: n
17.       )
    : \2 c2 P4 C# M% l& c7 s
18.     );
    
19.    
    
20.     // ... the rest of old tests logic
    
21.    
    
22. }

复制代码

请注意我们是如何从助记词 "initAddress "中创建 initAddress 钱包（金库），并将其地址传递到 createFromConfig 我们的 MainContract.

至此，我们成功地初始化了我们的合约！祝贺您 :）

由于我们现在还要在消息正文中发送特定数据--让我们更新方法 sendInternalMessage 在我们的 wrappers/MainContract.ts.

我们将把它重命名为 sendIncrement，现在它还将接受一个值-increment_by。这将是当前合约存储值递增的一个数字。

我们还要记住，这是我们的合约为获取操作码而解析的同一个正文。因此，我们不要忘记首先存储一个 32 位整数（如合约代码所示，1 表示递增），然后再存储一个 32 位整数的递增值：

1. async sendIncrement(
   7 g, x$ h. f$ u& {  x  J
2.     provider: ContractProvider,
   " U7 p2 f& A# y( d% V
3.     sender: Sender,
   
4.     value: bigint,
   
5.     increment_by: number
   
6.   ) {
   / h, @& n. o7 _1 d
7.    
   9 G1 `( a+ k0 e4 D9 a
8.     const msg_body = beginCell()
   9 ~/ {! w1 p$ n: S8 C, L
9.       .storeUint(1, 32) // OP code
   , V! E, X- C8 G( B% `/ C
10.       .storeUint(increment_by, 32) // increment_by value
    3 ]. \7 K( P! _. g% s
11.       .endCell();
    
12. 
    
13.     await provider.internal(sender, {
    
14.       value,
    ; [, j$ F3 O$ m; c! E$ N; t! M
15.       sendMode: SendMode.PAY_GAS_SEPARATELY,
    
16.       body: msg_body,
    ! S% ^% H0 D/ l
17.     });
    
18.   }

复制代码

我们还需要更新封装器中的一个方法-getData。正如你所记得的，我们重新命名了 getter 方法，而且它现在返回两个值。让我们调整一下 wrapper 方法：
  k1 G9 Q2 h* S' k

1. async getData(provider: ContractProvider) {
   ' p6 n' [7 L3 i1 D# }4 L+ W* z
2.     const { stack } = await provider.get("get_contract_storage_data", []);
   4 h9 b; |+ ]3 n( Y+ W+ U; Q, f
3.     return {
   , {# e9 E  J8 Y3 C1 ~5 \
4.       number: stack.readNumber(),
   % v- g& O: f& {7 G6 |; A
5.       recent_sender: stack.readAddress(),
   # f9 X9 s: d/ A/ }( f
6.     };
   
7.   }

复制代码

请注意，我们是如何读取 getter 方法的堆栈结果的。我们使用 readNumber() 读取当前值的整数。

现在，我们可以返回 tests/main.spec.ts，继续完成测试。以下是测试的更新代码：

1. // ... library imports
   - O4 K; E# J) L* Z# t2 i% M
2. 
   1 @& h" c$ _% a
3. describe("main.fc contract tests", () => {
   / Y" r7 d4 g* Q$ E
4.   it("should successfully increase counter in contract and get the proper most recent sender address", async () => {
   ) D" m3 E3 L* f$ U' E. a+ z4 T% n
5.     const blockchain = await Blockchain.create();
   ' Y5 {* Y2 G& F! k7 R! x
6.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
   . _# R3 H4 ?4 ]0 k
7. 
   " O% v) Z" m# s  R, X% D* X
8.     const initAddress = await blockchain.treasury("initAddress");
   
9. 
   , R% F2 g/ G" B; G: M& |9 V
10.     const myContract = blockchain.openContract(
    , H3 [- e- E9 N; T
11.       await MainContract.createFromConfig(
    ! V4 N# R- g3 f; @
12.         {
    8 X! T& C) T  e- t
13.           number: 0,
    
14.           address: initAddress.address,
    
15.         },
    
16.         codeCell
    $ y- w0 ]; N; L% Z
17.       )
    
18.     );
    
19. 
    1 s3 a, n. v! U2 S0 d1 N  _+ N
20.     const senderWallet = await blockchain.treasury("sender");
      v4 G# d. Y$ i2 \1 e, j
21. 
    
22.     const sentMessageResult = await myContract.sendIncrement(
    
23.       senderWallet.getSender(),
    
24.       toNano("0.05"),
    
25.       1
    / B( Z5 G5 B* n
26.     );
    1 n& {$ |1 Q& ~: q2 u: o% O' n, ^
27. 
    
28.     expect(sentMessageResult.transactions).toHaveTransaction({
    
29.       from: senderWallet.address,
    / E/ I5 U6 c: f$ I0 G% E' S
30.       to: myContract.address,
    / {- x* M* n, h8 [- Z
31.       success: true,
    
32.     });
    ( {% O( Z: d7 L5 L
33. 
    . ^5 l8 f9 N3 `* P$ ]
34.     const data = await myContract.getData();
    2 g0 s6 |1 w9 R7 y
35. 
    ! Y. C" r" ~. z. f5 ~9 F+ W
36.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    - |  j) L, z+ p  X1 A0 w2 b
37.     expect(data.number).toEqual(1);
    
38.   });
    : c- o& ~5 y; ~2 H' o
39. });

复制代码

我们在这里更新了什么？

• 现在，我们向 sendIncrement 方法传递了一个数字 - 1，因此结果值必须递增 1.
• 我们为 recent_sender 和 number 价值观
  
  

现在我们可以使用 yarn test 命令。如果一切操作正确，你将在终端中看到以下内容:

1. PASS  tests/main.spec.ts
   1 P7 {. H+ F9 G9 H
2.   main.fc contract tests
   % U$ i8 B7 M& }# _
3.     ✓ should successfully increase counter in contract and get the proper most recent sender address (452 ms)
   
4. 
   
5. Test Suites: 1 passed, 1 total
   ( U. b5 @4 _2 R6 \! t
6. Tests:       1 passed, 1 total
   
7. Snapshots:   0 total
   
8. Time:        4.339 s, estimated 5 s

复制代码

: C. @" F% C6 B& ~4 T
( n$ o5 n& e: X+ z