存根ES6 EventEmitter类函数

Question

I have a dependency class that extends EventEmitter and I need to test how a function that uses this dependency will react based on the events that it fires. How do you stub a function of a EventEmitter class?

Dependency Class

const EventEmitter = require('events');

class FooBar extends EventEmitter {

  constructor() {
    super();

    this.doingSomething = false;
  }

  doSomething() {
    if (this.doingSomething === false) {
      this.doingSomething = true;
      this.emit('startedDoingSomething');
    }
    else {
      this.emit('alreadyDoingSomething');
    }
  }
}

module.exports = FooBar;

Dependent Module Under Test

let Foobar = require('FooBar');
let fooBar = new FooBar();

exports.myFunction = () => {
  // Set up listeners
  fooBar.once('startedDoingSomething', () => {
    fooBar.removeAllListeners();
    // Some functionality
    console.log('Started Doing Something');
  });

  fooBar.once('alreadyDoingSomething', () => {
    fooBar.removeAllListeners();
    // Some functionality
    console.log('Already Doing Something');
  });

  // Call the event-emitting function
  fooBar.doSomething();
};

// Other functions that use fooBar

I'm using Sinon in order to create a stub, but I haven't been able to stub the class functions that emit events effectively. I modeled my test off of [Feature request] stub emits but had to make some modifications since the event emitter dependency being stubbed is a class.

Test

let chai = require('chai');
let sinon = require('sinon');
let FooBar = require('FooBar');
let dependentModule = require('./dependentModule');

describe('Dependent Module', () => {
  it('alreadyDoingSomething', () => {
    sinon.stub(FooBar.prototype, 'pause', () => {
      FooBar.prototype.emit('alreadyDoingSomething');
    });

    // Assertion statements here
    expect(dependentModule.myFunction()).to...
  });
});

This approach does not actually emit an event even though the stub function is being called.

Answer 1

Line 13 in Test, it calls dependentModule.myFunction()

Then it jumps to line 5 in Dependent Module Under Test

Then in line 19 in Dependent Module Under Test, it calls fooBar.doSomething()

Then it jumps to line 12 in Dependency Class, there this.doingSomething is false, so it emits startedDoingSomething .

Then it jumps to line 7 in Dependent Module Under Test, it calls fooBar.removeAllListeners(); , which means the event handler registered at line 34 of the same file is also removed.

Is this inteded?

Now assume fooBar.removeAllListeners in line 7 Dependent Module Under Test is commented out.

And after line 13 in Test, it calls FooBar.prototype.pause which in turn calls FooBar.prototype.emit('alreadyDoingSomething');

The problem is that when FooBar.prototype.emit is called, this in the context is not equal to fooBar declared in line 2 in Dependent Module Under Test. (It is equal to FooBar.prototype )

So FooBar.prototype.emit('alreadyDoingSomething'); won't trigger event handler defined in line 12 in Dependent Module Under Test.

We will need to find a way to call fooBar.emit('alreadyDoingSomething') .

But that's impossible, because fooBar is never exported, unless some library like rewire is used.

Now assume we add exports.fooBar = fooBar; to the end of Dependent Module Under Test.

And we also change line 9 in Test to this.emit('alreadyDoingSomething') This is important, because we need the context when emit is called needs to be the instance, in our case fooBar .

And now in Test, when dependentModule.fooBar.pause() is called, that triggers a alreadyDoingSomething.

Now you should see Already Doing Something in your console.