4.2 合同测试

riyad

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

1. import { Cell, toNano } from "ton-core";
   
2. import { hex } from "../build/main.compiled.json";
   & u, g$ O" q$ [3 p" C" \
3. import { Blockchain } from "@ton-community/sandbox";
   
4. import { MainContract } from "../wrappers/MainContract";
   4 x+ s7 |  I& M( ?
5. import "@ton-community/test-utils";
   , M6 m0 z% K4 G" `: h2 y
6. 
   
7. describe("main.fc contract tests", () => {
   # W) e' N) p- m" X- @; ~! B) {
8.   it("should get the proper most recent sender address", async () => {
   5 F! ]! ^. p6 ~- C( K: I
9.     const blockchain = await Blockchain.create();
   0 Z" k/ t( I: D3 ]$ U
10.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
    5 x1 [3 `4 B, R9 i4 B. U4 ~
11. 
      {; h. I$ m2 Q- D# W7 X4 s  N
12.     const myContract = blockchain.openContract(
    / R; w& G7 V/ d! ?! [' e: t
13.       await MainContract.createFromConfig({}, codeCell)
    : a+ ?2 H  g4 H4 v  R- C
14.     );
    
15. 
    . y  A. H/ M* e* o3 M* X/ q/ n6 p  r- {
16.     const senderWallet = await blockchain.treasury("sender");
    , U) ?- W% N8 p1 P
17. 
    
18.     const sentMessageResult = await myContract.sendInternalMessage(
    
19.       senderWallet.getSender(),
    
20.       toNano("0.05")
    , j8 g2 D2 i* G: V: t
21.     );
    3 |4 b- T2 C" z
22. 
    ) f" s& i+ t0 y, D) A
23.     expect(sentMessageResult.transactions).toHaveTransaction({
    
24.       from: senderWallet.address,
    
25.       to: myContract.address,
    - k1 V$ b( w  a, ~; c' J0 y8 y
26.       success: true,
    
27.     });
    
28. 
    1 _9 F/ A( R; n3 w, C
29.     const data = await myContract.getData();
    $ r. ~! R  N0 x, Z
30. 
    5 n8 ]' ^: E, K" x
31.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    
32.   });
    
33. });

复制代码

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

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

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

1. static createFromConfig(config: any, code: Cell, workchain = 0) {
   
2.     const data = beginCell().endCell();
   
3.     const init = { code, data };
   5 ]) o4 ?) w6 z5 D8 J& `
4.     const address = contractAddress(workchain, init);
   ) H- H, g9 e* Q& x  w
5. 
   
6.     return new MainContract(address, init);
   ; V& i! ?( N! A, [9 m2 D* H3 \; P
7. }

复制代码

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

1. const myContract = blockchain.openContract(
   2 G' F8 ~( Y4 z0 o
2.   await MainContract.createFromConfig({}, codeCell)
   
3. );

复制代码

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

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

1. // ... library imports
   * i: o4 x5 |2 j  C% x
2. 
   8 k1 Y8 E/ d$ v, w6 `( R7 ^
3. export type MainContractConfig = {
   
4.   number: number;
   
5.   address: Address;
   
6. };

复制代码

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

1. // ... library imports
   / e: ~* H& a% `! d
2. 
   
3. // ... MainContractConfig type
   
4. 
   
5. export function mainContractConfigToCell(config: MainContractConfig): Cell {
   
6.   return beginCell().storeUint(config.number, 32).storeAddress(config.address).endCell();
   . T* G' o( }$ A7 }' B; N$ f4 ]& w, t
7. }

复制代码

现在让我们更新同一文件中的 createFromConfig，不过是在 MainContract 类中。现在，它必须使用 mainContractConfigToCell 函数来形成初始状态数据 Cell：
+ I  j# m) R" F7 A  J% X$ v

1. // ... library imports
   7 M- _, w5 R6 w8 f9 _4 m
2. // ... MainContractConfig type
   
3. // ... mainContractConfigToCell function
   & B& @9 T4 y# G  F1 \$ K1 ~+ V
4. 
   
5. export class MainContract implements Contract {
   * V3 {  P& }; y! V; Y. ~
6.   constructor(
   
7.     readonly address: Address,
   
8.     readonly init?: { code: Cell; data: Cell }
   
9.   ) {}
   
10. 
    
11.   static createFromConfig(
    
12.     config: MainContractConfig,
    
13.     code: Cell,
    : @  s4 U7 v9 `# i
14.     workchain = 0
    
15.   ) {
    8 J- x9 f; W" |
16.     const data = mainContractConfigToCell(config);
    + R# U7 n8 T2 W: u
17.     const init = { code, data };
    5 b* ~/ p$ U4 N
18.     const address = contractAddress(workchain, init);
    
19. 
    5 H& G' g8 Z1 S! _: Y4 A+ V+ p& t) R
20.     return new MainContract(address, init);
    0 J) E: h5 l& e# p& B
21.   }
    
22.   
    8 o8 N3 C) C; z0 c6 f% O9 Z
23.   // ... rest of the methods
    
24. }

复制代码

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

$ B9 D, L# z% e; n7 D

1. // ... library imports
   : a7 b4 L) K: K: l  B& U
2. 
   , j) p. o7 u+ F3 ^) ?
3. describe("main.fc contract tests", () => {
   
4.   it("should get the proper most recent sender address", async () => {
   % e( J& z( n6 k% c, W/ l, M7 {
5.     const blockchain = await Blockchain.create();
   : I6 f0 p1 G" O/ M
6.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
   - R+ _- O+ B$ C9 P
7. 
   3 Q$ @3 p, w" N  i* b+ d! b  Q3 F
8.     const initAddress = await blockchain.treasury("initAddress");
   : K7 S) B4 y) {5 Q3 g: N" A! A
9. 
   + y5 c+ A: C" s, Z: A% k9 A0 V
10.     const myContract = blockchain.openContract(
    
11.       await MainContract.createFromConfig(
    8 ]7 R" f* ], y5 r! A
12.         {
    ) ^$ q0 ^" O( t0 C- ]9 F# c
13.           number: 0,
    " i) T' R4 t/ b9 j) `& N# Y8 r
14.           address: initAddress.address,
    ; ]3 a2 {4 n: J  j" S) N
15.         },
    
16.         codeCell
    . ]" s# x- j! i9 Q4 Y: n
17.       )
    
18.     );
    
19.    
    
20.     // ... the rest of old tests logic
    - J. x8 f  j. D+ w, u  j
21.    
    
22. }

复制代码

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

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

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

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

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

1. async sendIncrement(
   
2.     provider: ContractProvider,
   ! l  i; z/ R# R! E4 _3 x/ h, F+ x( w' i
3.     sender: Sender,
   
4.     value: bigint,
   5 l+ r& z: |+ ?" H+ [1 \+ D/ D
5.     increment_by: number
   ) g2 p, B+ t$ t% u0 ~
6.   ) {
   ; r5 S1 p# m0 t
7.    
   
8.     const msg_body = beginCell()
   
9.       .storeUint(1, 32) // OP code
   ( v' t0 h) P2 z
10.       .storeUint(increment_by, 32) // increment_by value
    
11.       .endCell();
    8 L( C- f; o4 s7 d7 z( q
12. 
    
13.     await provider.internal(sender, {
    4 w. Z5 r) H( e8 b# H9 B
14.       value,
    
15.       sendMode: SendMode.PAY_GAS_SEPARATELY,
    * ?. t2 G$ f+ n& C: J0 z
16.       body: msg_body,
    6 D5 Z( Y2 z8 G% }" A; Y) ?; D, f
17.     });
    % f3 Y9 {: }) {" j, ]
18.   }

复制代码

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

1. async getData(provider: ContractProvider) {
   ; }. M4 G9 i2 u. J' S
2.     const { stack } = await provider.get("get_contract_storage_data", []);
   ; \- N* Y7 y1 N5 y  V8 ?2 K9 ^9 d
3.     return {
   
4.       number: stack.readNumber(),
   
5.       recent_sender: stack.readAddress(),
   
6.     };
   1 K& p/ _5 L, U9 ^, s* B
7.   }

复制代码

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

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

1. // ... library imports
   6 Z, z( \8 _. a5 p' `
2. 
   6 d0 {% J& u8 P
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();
   9 d+ A  i% h4 n9 }* v
6.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
   4 O' i1 E2 G- Z: h
7. 
   
8.     const initAddress = await blockchain.treasury("initAddress");
   & u: J' y. U7 ], m, j! h
9. 
   $ _7 @$ D1 d6 @. v8 D: m* @+ a
10.     const myContract = blockchain.openContract(
    4 P8 _; W; r( I  d$ W1 R* N
11.       await MainContract.createFromConfig(
    , ^; p0 {7 u% _4 n2 C
12.         {
    
13.           number: 0,
    * y* X6 c+ e. O
14.           address: initAddress.address,
    
15.         },
    
16.         codeCell
    
17.       )
    * p  F$ z5 a% R, p3 o, i# |! z" ?
18.     );
    / j* G, v/ M! v5 H% Q4 r& L
19. 
    
20.     const senderWallet = await blockchain.treasury("sender");
    9 A& Q( G9 }+ i& _/ {' S
21. 
    - N1 i+ t  N! I, b7 C2 T/ Q5 g
22.     const sentMessageResult = await myContract.sendIncrement(
    - f9 o; K' X0 Y$ ^- u
23.       senderWallet.getSender(),
    1 M# L8 q5 @% i4 n1 h
24.       toNano("0.05"),
    3 x4 X  F0 \# R) x7 K
25.       1
    
26.     );
    
27. 
    
28.     expect(sentMessageResult.transactions).toHaveTransaction({
    
29.       from: senderWallet.address,
    
30.       to: myContract.address,
    
31.       success: true,
    
32.     });
    
33. 
    
34.     const data = await myContract.getData();
    
35. 
    
36.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    
37.     expect(data.number).toEqual(1);
    ) f5 L, g5 q" P: h+ V: ?
38.   });
    
39. });

复制代码

我们在这里更新了什么？

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

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

1. PASS  tests/main.spec.ts
   * e* j0 b4 P. g8 T
2.   main.fc contract tests
   
3.     ✓ should successfully increase counter in contract and get the proper most recent sender address (452 ms)
   
4. 
   , W8 H* Z! P. `8 j% c. a4 F
5. Test Suites: 1 passed, 1 total
   
6. Tests:       1 passed, 1 total
   
7. Snapshots:   0 total
   6 m0 |! `/ G9 ^: I& D6 w
8. Time:        4.339 s, estimated 5 s

复制代码

. l9 U& f7 m: f; W  [7 P  R