Event Emission Testing

/**
 * Assert that an event was emitted in a transaction receipt
 * @param {TransactionReceipt} receipt - Transaction receipt to check
 * @param {string} eventName - Name of the event to look for
 * @param {object} eventArgs - Optional object with expected event parameters
 * @returns {object} - The matching event object
 */
function expectEvent(receipt, eventName, eventArgs = {});

const { expectEvent } = require('@openzeppelin/test-helpers');

// Basic event assertion
const receipt = await token.transfer(recipient, amount);
expectEvent(receipt, 'Transfer');

// Event with parameter validation
expectEvent(receipt, 'Transfer', {
  from: sender,
  to: recipient,
  value: amount,
});

// Partial parameter matching
expectEvent(receipt, 'Approval', {
  owner: owner,
  // spender and value not checked
});

/**
 * Assert that an event was emitted during contract construction
 * @param {ContractInstance} contract - Truffle contract instance
 * @param {string} eventName - Name of the event to look for
 * @param {object} eventArgs - Optional object with expected event parameters
 * @returns {Promise<object>} - The matching event object
 */
async function expectEvent.inConstruction(contract, eventName, eventArgs = {});

// Check event emitted in constructor
const myContract = await MyContract.new(initialValue);
await expectEvent.inConstruction(myContract, 'Initialized', {
  value: initialValue,
});

/**
 * Assert that an event was emitted in a transaction by hash
 * @param {string} txHash - Transaction hash to check
 * @param {ContractInstance} emitter - Contract that should have emitted the event
 * @param {string} eventName - Name of the event to look for
 * @param {object} eventArgs - Optional object with expected event parameters
 * @returns {Promise<object>} - The matching event object
 */
async function expectEvent.inTransaction(txHash, emitter, eventName, eventArgs = {});

// Check event in external transaction
const tx = await web3.eth.sendTransaction({
  from: sender,
  to: contract.address,
  data: encodedData,
});

await expectEvent.inTransaction(tx.transactionHash, contract, 'DataReceived', {
  sender: sender,
  data: expectedData,
});

/**
 * Assert that an event was NOT emitted in a transaction receipt
 * @param {TransactionReceipt} receipt - Transaction receipt to check
 * @param {string} eventName - Name of the event that should not be present
 * @returns {void}
 */
function expectEvent.notEmitted(receipt, eventName);

// Ensure event was not emitted
const receipt = await token.approve(spender, 0);
expectEvent.notEmitted(receipt, 'Transfer');

/**
 * Assert that an event was NOT emitted during contract construction
 * @param {ContractInstance} contract - Truffle contract instance
 * @param {string} eventName - Name of the event that should not be present
 * @returns {Promise<void>}
 */
async function expectEvent.notEmitted.inConstruction(contract, eventName);

/**
 * Assert that an event was NOT emitted in a transaction by hash
 * @param {string} txHash - Transaction hash to check
 * @param {ContractInstance} emitter - Contract to check for events
 * @param {string} eventName - Name of the event that should not be present
 * @returns {Promise<void>}
 */
async function expectEvent.notEmitted.inTransaction(txHash, emitter, eventName);

{
  logs: [
    {
      event: 'Transfer',
      args: { from: '0x...', to: '0x...', value: BN }
    }
  ]
}

{
  events: {
    'Transfer': {
      returnValues: { from: '0x...', to: '0x...', value: '1000' }
    }
  }
}

// Big Number parameter matching
expectEvent(receipt, 'Transfer', {
  value: new BN('1000000000000000000'), // 1 ether in wei
});

// Null parameter checking
expectEvent(receipt, 'Approval', {
  spender: constants.ZERO_ADDRESS,
  value: null, // explicitly check for null
});

// When event not found:
// AssertionError: No 'Transfer' events found

// When parameters don't match:
// AssertionError: expected event argument 'value' to have value 1000 but got 500