如何正确测试Node.js异步进程触发的多个EventEmitter事件

这个问题的核心原因非常直接：EventEmitter普通事件回调中抛出的错误，不会自动进入你await的Promise链，也不会被Mocha这类测试框架的测试上下文自动捕获：

1. 事件回调的执行上下文和await asyncLib.start()的Promise链是完全割裂的。库内部触发event事件时，不会把用户传入的回调抛出的错误冒泡到外层start()返回的Promise上，你await等不到这个错误。
2. 如果断言错误是在start()已经执行完成、Mocha已经把测试标记为通过之后才抛出，框架自然不会回头修改测试结果。
3. 原生Node.js脚本场景下，异步回调里抛出的未被捕获的错误如果发生在主流程执行完成后，Node.js不会默认把它当成致命错误终止进程，就会出现退出码为0的假通过情况。

Mocha 测试场景正确写法 #

写法1：收集错误统一校验（最稳妥） #

思路是单独用变量存储事件回调中捕获的所有错误，等整个异步流程跑完后再把错误抛给Mocha，同时可以收集所有事件数据做额外校验：

require('mocha');
const { expect } = require('chai');
const { AsyncLib } = require('async-lib');

describe('Test suite', () => {
  it('test 1', async () => {
    const asyncLib = new AsyncLib();
    // 存储事件回调、库运行抛出的错误
    let testError = null;
    // 存储所有收到的事件数据，用于后续额外校验
    const receivedEvents = [];

    const onDataHandler = (data) => {
      try {
        // 所有断言必须包裹在try/catch中，不能直接抛错
        expect(data.foo).to.exist;
        expect(data.bar).to.exist;
        expect(data.bar.length).to.be.greaterThan(0);
        receivedEvents.push(data);
      } catch (err) {
        testError = err;
      }
    };

    const onErrorHandler = (err) => {
      testError = err;
    };

    asyncLib.on('event', onDataHandler);
    asyncLib.on('error', onErrorHandler);

    try {
      await asyncLib.start();
      await asyncLib.close();
    } finally {
      // 必须移除监听器，避免污染其他测试用例
      asyncLib.off('event', onDataHandler);
      asyncLib.off('error', onErrorHandler);
    }

    // 流程结束后先校验是否有错误，有则直接抛给Mocha标记失败
    if (testError) throw testError;

    // 可选：校验事件触发次数、数据顺序等逻辑，避免测试空跑
    expect(receivedEvents.length).to.be.greaterThan(0);
  });
});

写法2：出错立刻终止测试 #

如果不想等整个流程跑完，想一出现断言错误就立刻标记测试失败，可以用Promise.race做错误监听：

require('mocha');
const { expect } = require('chai');
const { AsyncLib } = require('async-lib');

describe('Test suite', () => {
  it('test 1', async () => {
    const asyncLib = new AsyncLib();
    let rejectTest;
    // 构造一个仅用于报错的Promise，事件回调出错就立刻reject
    const errorPromise = new Promise((_, reject) => {
      rejectTest = reject;
    });

    const onDataHandler = (data) => {
      try {
        expect(data.foo).to.exist;
        expect(data.bar).to.exist;
        expect(data.bar.length).to.be.greaterThan(0);
      } catch (err) {
        rejectTest(err);
      }
    };

    asyncLib.on('event', onDataHandler);
    asyncLib.on('error', rejectTest);

    try {
      // 竞速：正常流程跑完/事件报错任意一个先发生就结束等待
      await Promise.race([
        asyncLib.start().then(() => asyncLib.close()),
        errorPromise
      ]);
    } finally {
      asyncLib.off('event', onDataHandler);
      asyncLib.off('error', rejectTest);
    }
  });
});

done回调的正确写法 #

如果你习惯用done回调，只需要把捕获到的错误主动传给done即可：

require('mocha');
const { expect } = require('chai');
const { AsyncLib } = require('async-lib');

describe('Test suite', () => {
  it('test 1', (done) => {
    const asyncLib = new AsyncLib();

    const onDataHandler = (data) => {
      try {
        expect(data.foo).to.exist;
        expect(data.bar).to.exist;
        expect(data.bar.length).to.be.greaterThan(0);
      } catch (err) {
        // 出错直接调用done并传入错误，标记测试失败
        done(err);
      }
    };

    asyncLib.on('event', onDataHandler);
    asyncLib.on('error', done);

    asyncLib.start()
      .then(() => asyncLib.close())
      .then(() => done())
      .catch(done);
  });
});

原生Node.js assert脚本正确写法 #

核心逻辑和Mocha场景一致，主动收集所有错误，进程退出前根据是否有错误设置正确的退出码：

const { strict: assert } = require('assert');
const { AsyncLib } = require('async-lib');

(async () => {
  let testError = null;
  const asyncLib = new AsyncLib();

  const onDataHandler = (data) => {
    try {
      assert.ok(data.foo != null);
      assert.ok(data.bar != null);
      assert.ok(data.bar.length > 0);
    } catch (err) {
      testError = err;
      // 出错可提前终止库运行
      asyncLib.close().catch(() => {});
    }
  };

  const onErrorHandler = (err) => {
    testError = err;
  };

  asyncLib.on('event', onDataHandler);
  asyncLib.on('error', onErrorHandler);

  // 全局捕获漏网的异步错误
  process.on('uncaughtException', (err) => { testError = err; });
  process.on('unhandledRejection', (err) => { testError = err; });

  try {
    await asyncLib.start();
    await asyncLib.close();
  } catch (err) {
    testError = err;
  } finally {
    asyncLib.off('event', onDataHandler);
    asyncLib.off('error', onErrorHandler);
  }

  if (testError) {
    console.error('Test failed:', testError);
    process.exit(1);
  }
  console.log('Test passed');
  process.exit(0);
})();

• 永远不要直接把裸断言作为EventEmitter的回调函数，所有事件回调内的断言必须用try/catch包裹，否则错误很容易逃逸出测试捕获范围
• 测试执行完成后必须主动移除绑定的事件监听器，否则多个测试用例运行时，上一个用例的监听器会残留到下一个用例，导致测试结果混乱
• 建议把所有收到的事件数据存入数组，流程结束后除了校验单条数据格式，还可以校验事件触发次数、数据顺序等逻辑，避免出现事件根本没触发、测试空跑通过的问题
• 如果被测库暴露了error事件，一定要加监听，库本身运行抛出的错误也需要作为测试失败的判定依据

内容的提问来源于stack exchange，提问作者revy