Unit testing 直接用块菌测试以太坊事件的稳定性

在使用javascript测试truffle中的事件日志时，我发现了以下问题：

---

但块菌也支持直接以稳定的形式编写测试。然而，我找不到任何关于如何在solidity中测试事件日志的文档。有人能帮我吗？

事件是存储在区块链中的日志。要想获得一项赛事，你需要观看比赛。

固体块菌测试是合同。而合同只是存储代码的以太坊账户。该代码在该帐户收到事务时执行。以太坊合同无法查看链以获取事件日志。因此，稳固性不支持获取事件。

一般说明：

请注意，智能合约无法访问事件。根据设计，活动只能从智能合约外部访问。它们不是直接存储在区块链中。这意味着您将无法使用纯固体进行测试

无法从合同中访问日志及其事件数据（甚至不能从创建它们的合同中访问）。 资料来源：

使用truffle works测试事件，只需执行以下步骤：

1） 创建发出事件的简单约定（contracts/EventEmitter.sol）：

2） 创建测试合同（test/testanventemitter.sol）：

3） 创建测试代码（Test/testaventemitter.js）：

4） 运行测试：

$ truffle test
Using network 'development'.


Compiling your contracts...
===========================
> Compiling ./test/TestAnEventEmitter.sol



  Contract: EventEmitter
    1.1 Basic
        contract => 0xeD62E72c2d04Aa385ec764c743219a93ae49e796
      ✓ 1.1.1 has been created (56ms)
        owner => 0xbD004d9048C9b9e5C4B5109c68dd569A65c47CF9
      ✓ 1.1.2 should emit ConstructorDone event (63ms)
    1.2 Check calls of increment()
      ✓ 1.2.1 first call should increase the counts correctly (142ms)
      ✓ 1.2.2 second call should increase the counts correctly (160ms)
      ✓ 1.2.3 third call should increase the counts correctly (156ms)

完整来源（带有package.json等）：

有关事件和监视的更多信息：

---

（免责声明：我是这个项目和博客的作者）

考虑使用OpenZeppelin测试助手

以施工期间发出的事件为例：

合同：

//SPDX许可证标识符：MIT
pragma-solidity^0.8.3；
合同测试{
向公众所有人致辞；
事件创建（）；
构造函数（）{
所有者=msg.sender；
emit ContractCreated（）；
}
}

块菌试验：

const{expectEvent}=require（'@openzeppelin/testhelpers'）；
const TestContract=artifacts.require（'Test'）；
合同（“测试”、职能（账户）{
const[所有者]=账户；
const txParams={from:owner}；
beforeach（异步函数（）{
this.testContract=等待testContract.new（txParams）；
});
描述（‘结构’、功能（）{
它（'初始状态'，异步函数（）{
expect（等待这个.testContract.owner（））.to.equal（owner）；
等待expectEvent.inConstruction（this.testContract，“ContractCreated”）；
});
});
});

---

package.json

{
..
“依赖性”：{
“@openzeppelin/test helpers”：“^0.5.10”
}
..
}

您可以在测试中使用Web3。

pragma solidity 0.5.12;

import "truffle/Assert.sol";
import "../contracts/EventEmitter.sol";

contract TestAnEventEmitter {

    EventEmitter private eventEmitter;

    uint eContracts = 0;

    address private owner;

    function assertCount() private {
        Assert.equal(eventEmitter.getCount(), eContracts, "Unexpected count of created contracts");
    }

    constructor() public{
        eventEmitter = new EventEmitter();
        owner = address(this);
    }

}

const EventEmitter = artifacts.require("EventEmitter");
const truffleAssert = require('truffle-assertions');

/** Expected number of counter */
var eCount = 0;

/** The Contract's instance */
var eventEmitter;

global.CONTRACT_ADDRESS = '';

async function assertContractCount() {
    assert.equal(await eventEmitter.getCount.call(), eCount, "Wrong number of created contracts");
}

contract('EventEmitter', async () => {

    before(async () => {
        eventEmitter = await EventEmitter.new();
    });

    describe("1.1 Basic", function () {

        it("1.1.1 has been created", async () => {
            global.CONTRACT_ADDRESS = eventEmitter.address;
            console.log('        contract => ' + global.CONTRACT_ADDRESS);
            await assertContractCount();
        });

        it("1.1.2 should emit ConstructorDone event", async () => {
            // Get the hash of the deployment transaction
            let txHash = eventEmitter.transactionHash;

            // Get the transaction result using truffleAssert
            let result = await truffleAssert.createTransactionResult(eventEmitter, txHash);

            // Check event
            truffleAssert.eventEmitted(result, 'ConstructorDone', (ev) => {
                console.log('        owner => ' + ev.owner);
                return true;
            });
        });
    });

    describe("1.2 Check calls of increment()", function () {

        it("1.2.1 first call should increase the counts correctly", async () => {
            // Pre-Conditions
            await assertContractCount();

            // Creation
            let tx = await eventEmitter.increment();
            eCount++;

            // Expected Event
            truffleAssert.eventEmitted(tx, 'Counter', (ev) => {
                return parseInt(ev.count) === eCount;
            });

            // Post-Conditions
            await assertContractCount();
        });

        it("1.2.2 second call should increase the counts correctly", async () => {
            // Pre-Conditions
            await assertContractCount();

            // Creation
            let tx = await eventEmitter.increment();
            eCount++;

            // Expected Event
            truffleAssert.eventEmitted(tx, 'Counter', (ev) => {
                return parseInt(ev.count) === eCount;
            });

            // Post-Conditions
            await assertContractCount();
        });

        it("1.2.3 third call should increase the counts correctly", async () => {
            // Pre-Conditions
            await assertContractCount();

            // Creation
            let tx = await eventEmitter.increment();
            eCount++;

            // Expected Event
            truffleAssert.eventEmitted(tx, 'Counter', (ev) => {
                return parseInt(ev.count) === eCount;
            });

            // Post-Conditions
            await assertContractCount();
        });
    });
});

$ truffle test
Using network 'development'.


Compiling your contracts...
===========================
> Compiling ./test/TestAnEventEmitter.sol



  Contract: EventEmitter
    1.1 Basic
        contract => 0xeD62E72c2d04Aa385ec764c743219a93ae49e796
      ✓ 1.1.1 has been created (56ms)
        owner => 0xbD004d9048C9b9e5C4B5109c68dd569A65c47CF9
      ✓ 1.1.2 should emit ConstructorDone event (63ms)
    1.2 Check calls of increment()
      ✓ 1.2.1 first call should increase the counts correctly (142ms)
      ✓ 1.2.2 second call should increase the counts correctly (160ms)
      ✓ 1.2.3 third call should increase the counts correctly (156ms)