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";
   
4. import { MainContract } from "../wrappers/MainContract";
   / W5 S7 N3 H3 E2 o4 G9 P* L
5. import "@ton-community/test-utils";
   
6. 
   
7. describe("main.fc contract tests", () => {
   , q3 y" b/ W6 H
8.   it("should get the proper most recent sender address", async () => {
   
9.     const blockchain = await Blockchain.create();
   0 q) X0 T1 \* `7 L+ ?+ M+ e- r9 M; A
10.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
    4 n5 y1 Y. {& _, Z
11. 
    
12.     const myContract = blockchain.openContract(
    
13.       await MainContract.createFromConfig({}, codeCell)
    
14.     );
    
15. 
    
16.     const senderWallet = await blockchain.treasury("sender");
    9 V1 E& c2 D" U  q# i9 M
17. 
    
18.     const sentMessageResult = await myContract.sendInternalMessage(
    $ ]: n$ Q7 ]$ F) m
19.       senderWallet.getSender(),
    
20.       toNano("0.05")
    $ q* ]+ J  u! X& W" j( Z
21.     );
    
22. 
    
23.     expect(sentMessageResult.transactions).toHaveTransaction({
    
24.       from: senderWallet.address,
    6 b8 `6 w1 L! P8 q# t
25.       to: myContract.address,
    9 Q7 v, [! v9 W& L( o$ n# X% Q3 K
26.       success: true,
    
27.     });
    / Q. \# Y$ z8 K: H
28. 
    
29.     const data = await myContract.getData();
    
30. 
    9 X6 R0 u4 w5 b  x8 H9 A
31.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    
32.   });
    
33. });

复制代码

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

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

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

1. static createFromConfig(config: any, code: Cell, workchain = 0) {
   
2.     const data = beginCell().endCell();
   : X1 e. @' r" l2 I0 G, t8 f
3.     const init = { code, data };
   - l- u& g2 Q0 D
4.     const address = contractAddress(workchain, init);
   
5. 
   
6.     return new MainContract(address, init);
   ) Q- a! ~/ I8 g0 z8 t
7. }

复制代码

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

1 n# e2 b0 I' B4 [. x" }

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

复制代码

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

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

1. // ... library imports
   0 w6 ?9 f" w% I& k: B) X. a# C
2. 
   
3. export type MainContractConfig = {
   5 w1 K  N- j* l" I5 Z6 W
4.   number: number;
   3 {$ n. u: _: f* n, `. Y
5.   address: Address;
   % E" \: b9 M$ V0 w, Z. `, x
6. };

复制代码

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

1. // ... library imports
   $ A8 k8 P+ B9 y5 I8 }. C1 K
2. 
   " `' U6 b0 o' E, i
3. // ... MainContractConfig type
   
4. 
   
5. export function mainContractConfigToCell(config: MainContractConfig): Cell {
   7 X* H4 n9 y0 V" n; f: {: k; p
6.   return beginCell().storeUint(config.number, 32).storeAddress(config.address).endCell();
   
7. }

复制代码

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

1. // ... library imports
   
2. // ... MainContractConfig type
   5 T5 Z! E$ t$ R' |/ a- J; F! q
3. // ... mainContractConfigToCell function
   # P6 C  @5 c: x$ e" `
4. 
   $ o2 w3 i! u3 M$ @* \, k! d( S
5. export class MainContract implements Contract {
   
6.   constructor(
   
7.     readonly address: Address,
   
8.     readonly init?: { code: Cell; data: Cell }
   
9.   ) {}
   1 P) Y' {. U: ^& K% b! f
10. 
    
11.   static createFromConfig(
      {/ N; t. x. c/ P
12.     config: MainContractConfig,
    ! v9 o- d$ }  S4 A# B  v; S( B5 R
13.     code: Cell,
    
14.     workchain = 0
    
15.   ) {
    1 L9 Q, x0 W* f$ K
16.     const data = mainContractConfigToCell(config);
    
17.     const init = { code, data };
    ( t0 g; \. |9 G% S  i# _
18.     const address = contractAddress(workchain, init);
    
19. 
      x4 d  H' H6 k! c* P
20.     return new MainContract(address, init);
    # Z) B( j4 {2 L5 R5 F- M
21.   }
    
22.   
    
23.   // ... rest of the methods
    
24. }

复制代码

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

! g3 l+ ^* Y3 v4 Q7 k( L  i

1. // ... library imports
   
2. 
   
3. describe("main.fc contract tests", () => {
   
4.   it("should get the proper most recent sender address", async () => {
   % D  `' Y+ t+ |6 ^$ [
5.     const blockchain = await Blockchain.create();
   4 J' d: O2 k0 l, v. g# I% L
6.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
   
7. 
   5 g( t9 V, ~9 P& M& h( Q
8.     const initAddress = await blockchain.treasury("initAddress");
   # J0 o# Z  I% r: |# j+ U
9. 
   
10.     const myContract = blockchain.openContract(
    & h+ E; b2 ^  c) Y( X( C3 B  x3 h
11.       await MainContract.createFromConfig(
    ' n7 s4 D& O/ X# L- b( o: Q
12.         {
    0 Q% J$ S: p$ \& o5 x4 P0 s2 V
13.           number: 0,
    $ G0 `+ t# @7 e. S; i4 Z
14.           address: initAddress.address,
    ! a% K  C+ `2 z1 ]" U
15.         },
    # h/ H; O+ E8 W: e! [% T4 f- b
16.         codeCell
    
17.       )
    
18.     );
    
19.    
    & O% E6 W" E& V% b3 R. b' N
20.     // ... the rest of old tests logic
    
21.    
    ( u1 u6 A6 V% _+ t. x  r9 d
22. }

复制代码

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

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

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

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

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

1. async sendIncrement(
   / J. z2 I( }7 L$ {" P  H1 c. D
2.     provider: ContractProvider,
   . Y' O/ a, G6 r( v' \, ~2 T
3.     sender: Sender,
   ) N% u7 Y$ I; H
4.     value: bigint,
   
5.     increment_by: number
   ( n/ _, K0 Y( A6 b# k
6.   ) {
   
7.    
   
8.     const msg_body = beginCell()
   
9.       .storeUint(1, 32) // OP code
   / A5 ^+ j9 G, o, z" S1 I# h. ~
10.       .storeUint(increment_by, 32) // increment_by value
    
11.       .endCell();
    & C6 T0 Y/ ?( \' o
12. 
    
13.     await provider.internal(sender, {
    5 X7 r0 r; r2 j3 X. d- t7 ^
14.       value,
    ! o# d8 m0 O& ?( Y- |
15.       sendMode: SendMode.PAY_GAS_SEPARATELY,
    8 {" k0 r- N4 ], D+ ?
16.       body: msg_body,
    
17.     });
    
18.   }

复制代码

我们还需要更新封装器中的一个方法-getData。正如你所记得的，我们重新命名了 getter 方法，而且它现在返回两个值。让我们调整一下 wrapper 方法：
% q) Q5 u# G/ K' w; s$ C- R+ H

1. async getData(provider: ContractProvider) {
   ; a) E  h6 H) T3 E+ l- B) K' `; o
2.     const { stack } = await provider.get("get_contract_storage_data", []);
   
3.     return {
   5 p& t: {" J! m; t4 S4 h) V( Y
4.       number: stack.readNumber(),
   ) E: J9 J9 T- t; g$ O  z
5.       recent_sender: stack.readAddress(),
   
6.     };
   
7.   }

复制代码

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

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

1. // ... library imports
   
2. 
   & l+ ]; e5 O5 I6 P, j) t: G
3. describe("main.fc contract tests", () => {
   $ s- T& a( q: M- ^) `, j& G
4.   it("should successfully increase counter in contract and get the proper most recent sender address", async () => {
   & }' G" T2 O6 f2 x$ X# n& f2 N
5.     const blockchain = await Blockchain.create();
   
6.     const codeCell = Cell.fromBoc(Buffer.from(hex, "hex"))[0];
   
7. 
     _' j. ]/ |1 O( _9 V
8.     const initAddress = await blockchain.treasury("initAddress");
   
9. 
   
10.     const myContract = blockchain.openContract(
    1 m7 {' Z, u" Z: F4 Z; O# L
11.       await MainContract.createFromConfig(
    
12.         {
    
13.           number: 0,
    6 s5 S# S" r; O" i
14.           address: initAddress.address,
    
15.         },
    
16.         codeCell
    
17.       )
    % C; T1 k' g+ Q6 a4 u- ?$ o
18.     );
    
19. 
    3 R$ T, U+ L& f. r; n
20.     const senderWallet = await blockchain.treasury("sender");
    
21. 
    
22.     const sentMessageResult = await myContract.sendIncrement(
    0 h1 s. f* u- W& Y; w
23.       senderWallet.getSender(),
    1 v' Z' b$ v. U2 I1 T2 e4 N
24.       toNano("0.05"),
    
25.       1
    5 m  X0 O+ {5 J3 i1 T0 t- I
26.     );
    
27. 
    5 M$ i0 ?1 M! K5 S
28.     expect(sentMessageResult.transactions).toHaveTransaction({
    
29.       from: senderWallet.address,
    
30.       to: myContract.address,
    ! J8 ~/ N' \3 ?' [: N
31.       success: true,
    
32.     });
    
33. 
    
34.     const data = await myContract.getData();
    
35. 
    
36.     expect(data.recent_sender.toString()).toBe(senderWallet.address.toString());
    6 ]4 j; Z0 U% n7 [8 l& P; c' A
37.     expect(data.number).toEqual(1);
    , K% h, M" H. r9 t
38.   });
    
39. });

复制代码

我们在这里更新了什么？

• 现在，我们向 sendIncrement 方法传递了一个数字 - 1，因此结果值必须递增 1.
• 我们为 recent_sender 和 number 价值观
  
  * h6 w" N* ~9 Y' n

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

1. PASS  tests/main.spec.ts
   
2.   main.fc contract tests
   
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
   - T/ G4 Y2 F0 x& p
6. Tests:       1 passed, 1 total
   
7. Snapshots:   0 total
   + I% R% i2 P! c- A8 E- p) L
8. Time:        4.339 s, estimated 5 s

复制代码

2 V. v  V3 p6 h0 {2 f) ]' O