4.2 合同测试

riyad

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

1. import { Cell, toNano } from "ton-core";
   * l- K* G- L+ S% R9 E% J
2. import { hex } from "../build/main.compiled.json";
   % B3 z! z' L- o/ ]8 H
3. import { Blockchain } from "@ton-community/sandbox";
     N0 q0 ^8 X9 c! L0 N8 V
4. import { MainContract } from "../wrappers/MainContract";
   # d" d3 j9 q; N% V* O' X( u
5. import "@ton-community/test-utils";
   $ @3 q" p$ k( I0 y) K% x
6. 
   
7. describe("main.fc contract tests", () => {
   
8.   it("should get the proper most recent sender address", async () => {
   . o/ m  e' z& t" `! P
9.     const blockchain = await Blockchain.create();
   
10.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
    " v3 G* v* q* W% F- m, h. w  e
11. 
    
12.     const myContract = blockchain.openContract(
    " |: t7 D0 ^5 ^
13.       await MainContract.createFromConfig({}, codeCell)
    # `3 {) }$ N* R- H4 N* }
14.     );
    ; C/ [; w5 y: S' ]" b& H
15. 
    , f  K9 {8 s& E% f! G% N5 I: X% r' l
16.     const senderWallet = await blockchain.treasury("sender");
    
17. 
    3 Y9 [/ `2 T, a
18.     const sentMessageResult = await myContract.sendInternalMessage(
    
19.       senderWallet.getSender(),
    ( {4 ]4 R& j0 b; M
20.       toNano("0.05")
    4 _' n( ^' g. f: `
21.     );
    
22. 
    & S+ U6 J# M& C7 J
23.     expect(sentMessageResult.transactions).toHaveTransaction({
    
24.       from: senderWallet.address,
    
25.       to: myContract.address,
    
26.       success: true,
    
27.     });
    # z8 z7 }% O% J2 o: z# B- P
28. 
    
29.     const data = await myContract.getData();
    : ^- O2 l& F8 @! v( v; t, ^
30. 
    
31.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    ! V, X! O0 Z0 ?( g
32.   });
    
33. });

复制代码

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

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

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

1. static createFromConfig(config: any, code: Cell, workchain = 0) {
   
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：

1. const myContract = blockchain.openContract(
   , u+ {+ r$ C. @
2.   await MainContract.createFromConfig({}, codeCell)
   
3. );

复制代码

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

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

1. // ... library imports
   
2. 
   - v) x/ s" k$ Z8 Z2 q+ w  _, J  b
3. export type MainContractConfig = {
   * M% |6 n9 W+ k: m) r
4.   number: number;
   
5.   address: Address;
   2 Q, d3 }- |( I+ ?) e) D. _; k! h) O
6. };

复制代码

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

1. // ... library imports
   8 @; s" K1 _( S$ y
2. 
   
3. // ... MainContractConfig type
   
4. 
   & S' T' {5 l; i6 X7 u; A! A
5. export function mainContractConfigToCell(config: MainContractConfig): Cell {
   * y8 d* O5 I) c2 y* B
6.   return beginCell().storeUint(config.number, 32).storeAddress(config.address).endCell();
   
7. }

复制代码

现在让我们更新同一文件中的 createFromConfig，不过是在 MainContract 类中。现在，它必须使用 mainContractConfigToCell 函数来形成初始状态数据 Cell：
" f2 v# K: m  d! }  H4 }

1. // ... library imports
   ' ~; |( H+ H) @% E' m7 O* y% T1 J
2. // ... MainContractConfig type
   
3. // ... mainContractConfigToCell function
   1 ?) p3 o9 \2 s( n
4. 
   ; ]1 A! h9 I6 ~& I6 l6 }
5. export class MainContract implements Contract {
   
6.   constructor(
   
7.     readonly address: Address,
   
8.     readonly init?: { code: Cell; data: Cell }
   
9.   ) {}
   ! U4 A  F2 g+ d0 e$ R. \, u
10. 
    
11.   static createFromConfig(
    
12.     config: MainContractConfig,
    
13.     code: Cell,
    7 \( J$ Q4 p' M4 r7 k% l
14.     workchain = 0
    
15.   ) {
    
16.     const data = mainContractConfigToCell(config);
    
17.     const init = { code, data };
    ! u1 ^7 R1 X) [! F- g8 K0 A
18.     const address = contractAddress(workchain, init);
    
19. 
    4 O& A2 I. a; `$ s' ]
20.     return new MainContract(address, init);
    8 Y6 v3 t$ H& |. J
21.   }
    4 Z1 i% }1 c% B" ]4 F2 U
22.   
    
23.   // ... rest of the methods
    
24. }

复制代码

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

, [( F# n. ~2 R6 z, p0 j- i

1. // ... library imports
   
2. 
   
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];
   
7. 
   
8.     const initAddress = await blockchain.treasury("initAddress");
   
9. 
   
10.     const myContract = blockchain.openContract(
    
11.       await MainContract.createFromConfig(
    
12.         {
    
13.           number: 0,
    
14.           address: initAddress.address,
    * P- K9 T! s$ J  i, z" J
15.         },
    
16.         codeCell
    / l$ d9 x+ @8 p  O1 c% `
17.       )
    " C3 p2 a; A% g2 ~
18.     );
    7 A0 i% K: a8 y
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(
   : R  n3 h. s# z
2.     provider: ContractProvider,
   
3.     sender: Sender,
   
4.     value: bigint,
   3 W4 P# C1 m; ?" X5 @
5.     increment_by: number
   
6.   ) {
   
7.    
   
8.     const msg_body = beginCell()
   
9.       .storeUint(1, 32) // OP code
   
10.       .storeUint(increment_by, 32) // increment_by value
    / c6 E- W' x9 V% \& ]( ]" }
11.       .endCell();
    
12. 
    
13.     await provider.internal(sender, {
    
14.       value,
    
15.       sendMode: SendMode.PAY_GAS_SEPARATELY,
    ' Q7 [8 r4 T" J. q7 D& H
16.       body: msg_body,
    . t' n" F+ b  i6 O
17.     });
    
18.   }

复制代码

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

1. async getData(provider: ContractProvider) {
   # L2 M9 r6 \. L# j
2.     const { stack } = await provider.get("get_contract_storage_data", []);
   * {9 S, w9 {5 G- I5 c
3.     return {
   
4.       number: stack.readNumber(),
   ; {5 G( `5 a# ^' \' p3 i7 m
5.       recent_sender: stack.readAddress(),
   8 |. ?5 L+ \: A* y! M9 X
6.     };
   
7.   }

复制代码

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

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

1. // ... library imports
   
2. 
   
3. describe("main.fc contract tests", () => {
   
4.   it("should successfully increase counter in contract and get the proper most recent sender address", async () => {
   ; y1 w: J8 t# i' ]+ {  |& Z1 E
5.     const blockchain = await Blockchain.create();
   5 A- k/ _) U/ |. n; j$ ?
6.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
   / g* }" V, X: \; p0 @
7. 
   
8.     const initAddress = await blockchain.treasury("initAddress");
   
9. 
   
10.     const myContract = blockchain.openContract(
    ! _3 J9 @4 z( b, Z- }6 U6 u1 {
11.       await MainContract.createFromConfig(
    , y: ^0 e: v8 f% Y3 J  p- p
12.         {
    + i+ M  A0 X1 q2 t" J
13.           number: 0,
    
14.           address: initAddress.address,
    % b3 y: Q! g8 R
15.         },
    
16.         codeCell
    # H4 {+ v9 J& }: V% K, E
17.       )
    $ c+ l$ d. Z8 B* \4 K
18.     );
    
19. 
    
20.     const senderWallet = await blockchain.treasury("sender");
    
21. 
    
22.     const sentMessageResult = await myContract.sendIncrement(
    
23.       senderWallet.getSender(),
    
24.       toNano("0.05"),
    - m( H6 {$ @8 D* n, X) R7 t% F
25.       1
    
26.     );
    
27. 
    
28.     expect(sentMessageResult.transactions).toHaveTransaction({
    
29.       from: senderWallet.address,
    - P% Z: W9 G6 k& W( X
30.       to: myContract.address,
    
31.       success: true,
    & w9 d2 _2 J0 L8 p
32.     });
      ^4 {6 a1 Z% K: p* _
33. 
    $ r1 E% [' H7 J$ {' w
34.     const data = await myContract.getData();
    $ _1 A0 z$ K/ q% a. C: S0 @0 t: x
35. 
      H7 ^# J5 H; @
36.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    
37.     expect(data.number).toEqual(1);
    
38.   });
    
39. });

复制代码

我们在这里更新了什么？

• 现在，我们向 sendIncrement 方法传递了一个数字 - 1，因此结果值必须递增 1.
• 我们为 recent_sender 和 number 价值观
  
  6 z' x' ~, C. ?& A

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

1. PASS  tests/main.spec.ts
   3 d! l" t% T% M1 t" v9 c
2.   main.fc contract tests
   
3.     ✓ should successfully increase counter in contract and get the proper most recent sender address (452 ms)
   $ o+ F% m3 h! A+ O! s
4. 
   ) C3 @( A) L+ r4 _6 N% ?- q* S# y7 W
5. Test Suites: 1 passed, 1 total
   
6. Tests:       1 passed, 1 total
   6 K; P, h- x; Z9 D; R0 b: A% a
7. Snapshots:   0 total
   
8. Time:        4.339 s, estimated 5 s

复制代码

7 B* _$ Z0 X" [
! {% d: J/ y; y, X2 s3 g+ r; u  g+ N1 H