4.2 合同测试

riyad

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

1. import { Cell, toNano } from "ton-core";
   
2. import { hex } from "../build/main.compiled.json";
   
3. import { Blockchain } from "@ton-community/sandbox";
   2 d- Z8 [& I5 N( I
4. import { MainContract } from "../wrappers/MainContract";
   : J+ h" v/ c& p7 ]* [: [
5. import "@ton-community/test-utils";
   
6. 
   
7. describe("main.fc contract tests", () => {
   
8.   it("should get the proper most recent sender address", async () => {
   ' x( ?+ T5 x: H6 O
9.     const blockchain = await Blockchain.create();
   % M5 E2 }) H* C9 `, _1 j
10.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
    
11. 
    
12.     const myContract = blockchain.openContract(
    8 S% P6 ?1 @% Y! @+ o: G" c' k" @2 j
13.       await MainContract.createFromConfig({}, codeCell)
    
14.     );
    
15. 
    6 k" l: H9 t, _! x3 i# l8 `- \
16.     const senderWallet = await blockchain.treasury("sender");
    " r. e$ z0 c$ Z
17. 
    6 ~1 b7 s1 F' V0 ~
18.     const sentMessageResult = await myContract.sendInternalMessage(
    
19.       senderWallet.getSender(),
    / r. Q. ?+ E" {& W
20.       toNano("0.05")
    
21.     );
      ?- j6 q9 @, L( s/ W5 B
22. 
    
23.     expect(sentMessageResult.transactions).toHaveTransaction({
    
24.       from: senderWallet.address,
    
25.       to: myContract.address,
    1 C! Y& C, g) t& |- c
26.       success: true,
    
27.     });
    ) c, e( B0 Q8 ?, {/ G$ r# s
28. 
    5 l! F3 F3 F; U) B. k7 |' E$ X
29.     const data = await myContract.getData();
    
30. 
    
31.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    " y1 ]& u% @; G. h* O9 m4 w
32.   });
    
33. });

复制代码

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

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

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

1. static createFromConfig(config: any, code: Cell, workchain = 0) {
   
2.     const data = beginCell().endCell();
   
3.     const init = { code, data };
   - z5 q) O0 q9 @6 A! C% Y
4.     const address = contractAddress(workchain, init);
   
5. 
   
6.     return new MainContract(address, init);
   
7. }

复制代码

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

4 Y/ c3 q: r* I4 i: g4 V

1. const myContract = blockchain.openContract(
   
2.   await MainContract.createFromConfig({}, codeCell)
   / O7 G6 j8 Y2 O6 C/ Q: `+ y3 p; t
3. );

复制代码

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

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

1. // ... library imports
   % W! H2 Q& T4 A( ^
2. 
   
3. export type MainContractConfig = {
   
4.   number: number;
   7 I, u" e' p; m& d- P. |1 q/ |' ^
5.   address: Address;
   4 ^# @& n! V0 p0 N% x+ ?" [# K
6. };

复制代码

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

1. // ... library imports
   ! R! G7 N6 n+ @" X+ o6 `- n% [
2. 
   
3. // ... MainContractConfig type
   
4. 
   
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
   
2. // ... MainContractConfig type
   
3. // ... mainContractConfigToCell function
   0 }+ ~9 A' k2 _  l) e/ v. p8 B: y# G
4. 
   
5. export class MainContract implements Contract {
   8 u6 T9 X7 x5 H& x+ m9 A9 C$ [
6.   constructor(
   + @$ U' N2 e: {+ n) Y3 f
7.     readonly address: Address,
   
8.     readonly init?: { code: Cell; data: Cell }
   
9.   ) {}
   
10. 
    $ G4 i( v) k! O: t; ?4 R8 H$ x* Q+ F
11.   static createFromConfig(
    
12.     config: MainContractConfig,
    
13.     code: Cell,
    / y4 h# T$ [, Q! u
14.     workchain = 0
    
15.   ) {
    2 K: r  R+ W0 g% f
16.     const data = mainContractConfigToCell(config);
    
17.     const init = { code, data };
    0 I) Y! A. F$ T# s1 y# }
18.     const address = contractAddress(workchain, init);
    . D/ v6 b* Y9 D+ k! |4 E- S3 A, H! d) d
19. 
    6 G: h- P2 g" v  W5 i
20.     return new MainContract(address, init);
    
21.   }
    1 J2 ^1 O  P, v9 B; `; K
22.   
    * D  l" e# b2 v. u. w& K
23.   // ... rest of the methods
    
24. }

复制代码

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

& x# u* T8 M+ q) }2 A& s

1. // ... library imports
   7 e" H1 x$ D4 ?% V8 K0 B: J; z
2. 
   2 \# Y" b+ e5 s0 v
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. 
   ; l- d* X. L7 \3 n6 Y5 n+ G
8.     const initAddress = await blockchain.treasury("initAddress");
   9 l& c: T' H) m  X% |  |7 L0 n0 }5 l
9. 
   8 t6 c( t+ U0 `: ]$ M
10.     const myContract = blockchain.openContract(
    . N# o% v! m4 F  j6 @' D
11.       await MainContract.createFromConfig(
    
12.         {
    9 N: z3 f6 M/ K. r
13.           number: 0,
    ( }! _5 V" A  X( p5 ?
14.           address: initAddress.address,
    
15.         },
    - B: M( y( i" I" L
16.         codeCell
    1 h& n2 m! Q0 E$ a! b: n- C& ~
17.       )
    
18.     );
    
19.    
    
20.     // ... the rest of old tests logic
    7 \; _) W- a4 Z& N9 R/ C+ S# P
21.    
    2 e3 ~  \! R- J0 O
22. }

复制代码

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

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

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

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

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

1. async sendIncrement(
   
2.     provider: ContractProvider,
     N) W  Z5 o. G+ F9 {& {) y7 B
3.     sender: Sender,
   
4.     value: bigint,
   : N5 m% x, B! Z, R* E+ I/ X
5.     increment_by: number
   8 e  Y) k! r" W9 s6 J
6.   ) {
   6 h! P& O/ O8 R% Z* n2 i1 {9 a
7.    
   
8.     const msg_body = beginCell()
   ; O  F' `+ [% F: b/ s/ w
9.       .storeUint(1, 32) // OP code
   
10.       .storeUint(increment_by, 32) // increment_by value
    
11.       .endCell();
    0 L6 l( U" C  @* j, Z- v) A" j
12. 
    $ X1 t* U0 `. @- n; W. m
13.     await provider.internal(sender, {
    " i, H. F; e8 |# T! l2 o  n3 c
14.       value,
    
15.       sendMode: SendMode.PAY_GAS_SEPARATELY,
    
16.       body: msg_body,
    # }1 R1 B! X1 i/ z1 O2 V& K
17.     });
    
18.   }

复制代码

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

1. async getData(provider: ContractProvider) {
   8 l: u( V7 G1 x4 ~$ L* I: z6 q$ f" p/ `
2.     const { stack } = await provider.get("get_contract_storage_data", []);
   1 u# T1 F  h/ y* h+ H& `6 [
3.     return {
   
4.       number: stack.readNumber(),
   . o- L# T# G  k  M5 T. N: |" U
5.       recent_sender: stack.readAddress(),
   
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 () => {
   
5.     const blockchain = await Blockchain.create();
   7 p! ], J$ N1 W! j" U" Y$ A% o
6.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
   3 @1 D) `: ^7 T" b" J
7. 
   
8.     const initAddress = await blockchain.treasury("initAddress");
   
9. 
   
10.     const myContract = blockchain.openContract(
    
11.       await MainContract.createFromConfig(
    
12.         {
    & x0 I. R6 g" S4 Y. k
13.           number: 0,
    
14.           address: initAddress.address,
    
15.         },
    ! h8 Y( Q: R. g3 ^5 r) s
16.         codeCell
    / O! ^" u% n& [& l) l# f
17.       )
    , t  i' Z, N  m9 y$ O
18.     );
    : R8 w+ g6 n% n, t
19. 
    
20.     const senderWallet = await blockchain.treasury("sender");
    
21. 
    - n, p1 l2 C- Y' b7 [# u
22.     const sentMessageResult = await myContract.sendIncrement(
    
23.       senderWallet.getSender(),
    
24.       toNano("0.05"),
    2 b' S4 Z: }: Q
25.       1
    
26.     );
    
27. 
    
28.     expect(sentMessageResult.transactions).toHaveTransaction({
    
29.       from: senderWallet.address,
    
30.       to: myContract.address,
    ( I+ J4 h0 b; y) U
31.       success: true,
    
32.     });
    ( U7 Q5 U) \% c1 W4 G8 h6 ~
33. 
    5 {9 j. g2 L& w3 Q
34.     const data = await myContract.getData();
    
35. 
    2 a6 i5 {4 Q3 |. _6 @$ R
36.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    
37.     expect(data.number).toEqual(1);
    / Z- K2 b7 x4 Y4 `
38.   });
    2 J( V* g( X) k$ j/ z- I1 s' o
39. });

复制代码

我们在这里更新了什么？

• 现在，我们向 sendIncrement 方法传递了一个数字 - 1，因此结果值必须递增 1.
• 我们为 recent_sender 和 number 价值观
  
  " u4 D* i5 G3 y, {8 ^

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

1. PASS  tests/main.spec.ts
   
2.   main.fc contract tests
   , ^( v; p' f  N7 w
3.     ✓ should successfully increase counter in contract and get the proper most recent sender address (452 ms)
   ' `/ H0 f4 I  z5 |# o( h- C& @
4. 
   3 _, {6 t3 l# b9 g9 a
5. Test Suites: 1 passed, 1 total
   7 X, Z' B) U* u5 ]( o
6. Tests:       1 passed, 1 total
   
7. Snapshots:   0 total
   + m" v0 _+ w& m2 _/ H) i$ N4 a
8. Time:        4.339 s, estimated 5 s

复制代码

$ X! z" [# M% c7 y