4.2 合同测试

riyad

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

1. import { Cell, toNano } from "ton-core";
   - @' g' q$ S3 A# t
2. import { hex } from "../build/main.compiled.json";
   
3. import { Blockchain } from "@ton-community/sandbox";
   8 R+ A" o" ]7 ?1 S+ O- A
4. import { MainContract } from "../wrappers/MainContract";
   
5. import "@ton-community/test-utils";
   + Y+ I8 Y) |5 v' d. s
6. 
   
7. describe("main.fc contract tests", () => {
   
8.   it("should get the proper most recent sender address", async () => {
   
9.     const blockchain = await Blockchain.create();
   5 |8 P5 Y$ N9 Z4 Q  m3 y$ T; n: K
10.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
    
11. 
    
12.     const myContract = blockchain.openContract(
    6 G2 Y# o% N2 k; ]- L/ r* h7 p
13.       await MainContract.createFromConfig({}, codeCell)
    / ~! q: A+ h; J2 ]  Q% h+ V
14.     );
    ) t  X: k3 J9 X$ l# r
15. 
    
16.     const senderWallet = await blockchain.treasury("sender");
    
17. 
    
18.     const sentMessageResult = await myContract.sendInternalMessage(
    ) t/ r: D, S% g( |4 H. ]
19.       senderWallet.getSender(),
    
20.       toNano("0.05")
    
21.     );
    
22. 
    , R# s( A: o2 C3 {8 \8 M
23.     expect(sentMessageResult.transactions).toHaveTransaction({
    
24.       from: senderWallet.address,
    
25.       to: myContract.address,
    
26.       success: true,
    5 z9 C+ e2 y: y3 K2 k$ y) k
27.     });
    
28. 
    ; c4 Z$ q- U) U
29.     const data = await myContract.getData();
    
30. 
    
31.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    / r# D  Z- {- j
32.   });
    
33. });

复制代码

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

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

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

1. static createFromConfig(config: any, code: Cell, workchain = 0) {
   0 E: j  q; a# q% g, H' o
2.     const data = beginCell().endCell();
   
3.     const init = { code, data };
   
4.     const address = contractAddress(workchain, init);
   
5. 
   6 I4 ]% }- d/ q1 w: E
6.     return new MainContract(address, init);
   
7. }

复制代码

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

1 Z  J6 i& J/ b1 w/ t& U# q

1. const myContract = blockchain.openContract(
   
2.   await MainContract.createFromConfig({}, codeCell)
   
3. );

复制代码

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

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

1. // ... library imports
   
2. 
   1 E, N4 w" O$ Y1 D. ^# f* o+ b
3. export type MainContractConfig = {
   % t# t; k# o' G  d
4.   number: number;
   
5.   address: Address;
   
6. };

复制代码

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

1. // ... library imports
   
2. 
   
3. // ... MainContractConfig type
   9 O3 G8 v/ V( y
4. 
   8 m  a0 i$ f+ b5 N! d6 `
5. export function mainContractConfigToCell(config: MainContractConfig): Cell {
   ) G# P3 r5 e; |! ?4 Q
6.   return beginCell().storeUint(config.number, 32).storeAddress(config.address).endCell();
   * |5 T2 |' Z( ?
7. }

复制代码

现在让我们更新同一文件中的 createFromConfig，不过是在 MainContract 类中。现在，它必须使用 mainContractConfigToCell 函数来形成初始状态数据 Cell：
: Q: }: X! g$ T% K8 I; l2 G

1. // ... library imports
   ( F4 j& ]3 h) U- `. w, P
2. // ... MainContractConfig type
   1 o/ v; ~. j+ @/ e# m4 D
3. // ... mainContractConfigToCell function
   
4. 
   
5. export class MainContract implements Contract {
   
6.   constructor(
   0 b9 a: p5 T8 Y( |' N
7.     readonly address: Address,
   9 g; E5 ~+ [/ z0 ^
8.     readonly init?: { code: Cell; data: Cell }
   
9.   ) {}
   
10. 
    
11.   static createFromConfig(
    
12.     config: MainContractConfig,
    
13.     code: Cell,
    " m+ C8 w0 D0 b4 k* a+ K, o
14.     workchain = 0
    
15.   ) {
    
16.     const data = mainContractConfigToCell(config);
    
17.     const init = { code, data };
    
18.     const address = contractAddress(workchain, init);
    
19. 
    . H+ g: E8 [: T! R, [, k1 j, B% f2 u2 D
20.     return new MainContract(address, init);
    . M& O" U# Z/ ^9 e
21.   }
    
22.   
    
23.   // ... rest of the methods
    ! l7 T$ z2 t% h. i
24. }

复制代码

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

$ n, d8 H+ D" C

1. // ... library imports
   
2. 
   4 B6 l  B' O' d8 C! p
3. describe("main.fc contract tests", () => {
   
4.   it("should get the proper most recent sender address", async () => {
   
5.     const blockchain = await Blockchain.create();
   
6.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
   # S9 J2 f" D! I: \4 @) p/ P
7. 
   
8.     const initAddress = await blockchain.treasury("initAddress");
   ) [$ d7 _$ S# R0 s
9. 
   
10.     const myContract = blockchain.openContract(
    0 b: b7 c! K4 N3 x% ^& Y/ I% A
11.       await MainContract.createFromConfig(
    " K; I2 {# d7 u2 g
12.         {
    1 w$ x2 G7 x$ B6 T0 q7 D6 j
13.           number: 0,
    0 g" S+ A+ M3 V0 T! \/ ?
14.           address: initAddress.address,
    
15.         },
    
16.         codeCell
    + X* K% m- r, \' j) I% a" R0 I
17.       )
    % z0 {* |. L+ Q3 u) p( `
18.     );
    
19.    
    8 h# v; N) q4 x
20.     // ... the rest of old tests logic
    5 F/ X4 p$ L; ]( @# }$ v  N
21.    
    6 l# T% k4 H* N& B
22. }

复制代码

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

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

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

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

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

1. async sendIncrement(
   
2.     provider: ContractProvider,
   # s0 d' {+ f% k' z: x9 i
3.     sender: Sender,
   
4.     value: bigint,
   & T7 a: B* u- U8 o
5.     increment_by: number
   
6.   ) {
   
7.    
   
8.     const msg_body = beginCell()
   0 k2 Y7 C1 g6 m* i" w
9.       .storeUint(1, 32) // OP code
   
10.       .storeUint(increment_by, 32) // increment_by value
    
11.       .endCell();
    
12. 
    ! i5 E, {( T6 n& T2 Y
13.     await provider.internal(sender, {
    $ D- l' x/ h8 u) n
14.       value,
    
15.       sendMode: SendMode.PAY_GAS_SEPARATELY,
    : M! d4 H7 G& f: c, R
16.       body: msg_body,
    
17.     });
    
18.   }

复制代码

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

1. async getData(provider: ContractProvider) {
   
2.     const { stack } = await provider.get("get_contract_storage_data", []);
   # m0 N  S1 p# @$ Q! c0 d
3.     return {
   
4.       number: stack.readNumber(),
   
5.       recent_sender: stack.readAddress(),
   3 D' w2 {& }/ f
6.     };
   ; d1 \/ L$ b( H9 i; {) Z3 i* G
7.   }

复制代码

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

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

1. // ... library imports
   
2. 
   - n- y1 Y( F) D5 T! Z' L3 x
3. describe("main.fc contract tests", () => {
   - S% K8 b3 d9 D+ t" |* d) a
4.   it("should successfully increase counter in contract and get the proper most recent sender address", async () => {
   & t2 w5 T8 v8 s& H
5.     const blockchain = await Blockchain.create();
   8 X1 u4 {/ t% G$ Q9 G7 E+ k" I
6.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
   
7. 
   
8.     const initAddress = await blockchain.treasury("initAddress");
   ( _: U$ h# d  O% }9 Z( H1 T
9. 
   
10.     const myContract = blockchain.openContract(
    
11.       await MainContract.createFromConfig(
    
12.         {
    : C* D7 P. ~+ k: e5 w5 @
13.           number: 0,
    
14.           address: initAddress.address,
    
15.         },
    
16.         codeCell
    5 P' A* ]* y8 r' B
17.       )
    ; G, `1 Q  ]7 T; b, ~
18.     );
    
19. 
    9 X( @/ j( D: J/ b
20.     const senderWallet = await blockchain.treasury("sender");
    
21. 
    & B# C/ K1 g* I7 f3 j
22.     const sentMessageResult = await myContract.sendIncrement(
    
23.       senderWallet.getSender(),
    
24.       toNano("0.05"),
    0 s9 ~" ~. o% ~* ~! b. n6 E0 \
25.       1
    : ]1 k2 A, `( ~% i0 E8 Z
26.     );
    ' ^9 I% Y; }7 S5 Z+ ?
27. 
    
28.     expect(sentMessageResult.transactions).toHaveTransaction({
    9 I, B5 F! C9 Z8 f
29.       from: senderWallet.address,
    
30.       to: myContract.address,
    ) ]* W) S5 X0 o
31.       success: true,
    
32.     });
    
33. 
    
34.     const data = await myContract.getData();
    # T/ _9 i: b  U! [& |
35. 
    4 W0 L# y* [& G
36.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    
37.     expect(data.number).toEqual(1);
    3 r. ~6 d$ N8 S! G8 c* f0 C7 V$ O
38.   });
    
39. });

复制代码

我们在这里更新了什么？

• 现在，我们向 sendIncrement 方法传递了一个数字 - 1，因此结果值必须递增 1.
• 我们为 recent_sender 和 number 价值观
  
  7 V. }( M' f: i. \; f! \, A  B

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

1. PASS  tests/main.spec.ts
   ) w. `5 O: P1 \1 V! z' ?
2.   main.fc contract tests
   ; E; I! `' ]: B' K- @4 L- @# T
3.     ✓ should successfully increase counter in contract and get the proper most recent sender address (452 ms)
   6 L" I" E1 a6 i) x* |5 H
4. 
   
5. Test Suites: 1 passed, 1 total
   : v* \/ Z: T" {- l4 Q/ _: b
6. Tests:       1 passed, 1 total
     n; u1 m3 ]2 q
7. Snapshots:   0 total
   - |2 t, X9 ]0 p% s
8. Time:        4.339 s, estimated 5 s

复制代码