Каков наилучший способ модульного тестирования события, испускаемого в Nodejs?

Question

Я пишу кучу мокко-тестов, и я бы хотел проверить, что определенные события испускаются. В настоящее время я делаю это:

it('should emit an some_event', function(done){ 
    myObj.on('some_event',function(){ 
     assert(true); 
     done(); 
    }); 
    }); 

Однако, если событие не излучает, он выходит из строя тестового набора, а не недостаток, что один тест.

Каков наилучший способ проверить это?

Answer 1

Если вы можете гарантировать, что событие должно срабатывать в течение определенного промежутка времени, просто установите таймаут.

it('should emit an some_event', function(done){ 
    this.timeout(1000); //timeout with an error if done() isn't called within one second 

    myObj.on('some_event',function(){ 
    // perform any other assertions you want here 
    done(); 
    }); 

    // execute some code which should trigger 'some_event' on myObj 
}); 

Если вы не можете гарантировать, что событие будет срабатывать, возможно, это не будет хорошим кандидатом для модульного тестирования.

Answer 2

Edit 30 сентября:

Я вижу, что мой ответ принимается как правильный ответ, но техника Брета Коупленда (см ответ ниже) просто лучше, потому что это быстрее, если проверка прошла успешно, который будет иметь место чаще всего вы запускаете тест как часть набора тестов.

---

Техника Брет Коупленд правильная. Вы также можете сделать это немного по-другому:

it('should emit an some_event', function(done){ 
    var eventFired = false 
    setTimeout(function() { 
     assert(eventFired, 'Event did not fire in 1000 ms.'); 
     done(); 
    }, 1000); //timeout with an error in one second 
    myObj.on('some_event',function(){ 
     eventFired = true 
    }); 
    // do something that should trigger the event 
    }); 

Это может быть немного короче, с помощью Sinon.js.

it('should emit an some_event', function(done){ 
    var eventSpy = sinon.spy() 
    setTimeout(function() { 
     assert(eventSpy.called, 'Event did not fire in 1000ms.'); 
     assert(eventSpy.calledOnce, 'Event fired more than once'); 
     done(); 
    }, 1000); //timeout with an error in one second 
    myObj.on('some_event',eventSpy); 
    // do something that should trigger the event 
    }); 

Здесь мы проверить, что не только событие уволят, но если если событие уволен только один раз в течение периода времени ожидания.

Sinon также поддерживает calledWith и calledOn, чтобы проверить, какие аргументы и контекст функции были использованы.

Обратите внимание, что если вы ожидаете, что событие будет запущено синхронно с операцией, вызвавшей событие (без асинхронных вызовов между ними), вы можете сделать это с нулевым временем. Тайм-аут 1000 мс необходим только тогда, когда вы выполняете асинхронные вызовы, между которыми требуется много времени. Скорее всего, не так.

На самом деле, когда событие гарантированно срабатывает синхронно с операцией, вызвавшей его, можно упростить код

it('should emit an some_event', function() { 
    eventSpy = sinon.spy() 
    myObj.on('some_event',eventSpy); 
    // do something that should trigger the event 
    assert(eventSpy.called, 'Event did not fire.'); 
    assert(eventSpy.calledOnce, 'Event fired more than once'); 
    }); 

В противном случае метод Брета Коупленда всегда быстрее в «успех» дела (надеюсь общий случай), так как он может немедленно позвонить done, если событие инициировано.

Answer 3

Просто придерживайтесь:

this.timeout(<time ms>); 

в верхней части вашего ИТ заявления:

it('should emit an some_event', function(done){ 
    this.timeout(1000); 
    myObj.on('some_event',function(){ 
     assert(true); 
     done(); 
    });`enter code here` 
    }); 

Answer 4

Late к партии, но я столкнулся именно с этой проблемой и пришел к другому решению. Принимаемый ответ Брет - хороший, но я обнаружил, что он повредил при запуске моего полного набора тестов для мокко, выбросив ошибку done() called multiple times, и я в конечном итоге отказался от попытки устранения неполадок.Ответ Meryl поставил меня на пути к моему собственному решению, которое также использует sinon, но не требует использования тайм-аута. Путем простого обнуления метода emit() вы можете проверить, что он вызывается и проверяет его аргументы. Это предполагает, что ваш объект наследуется от класса EventEmitter от Node. Имя метода emit может отличаться в вашем случае.

var sinon = require('sinon'); 

// ... 

describe("#someMethod", function(){ 
    it("should emit `some_event`", function(done){ 
     var myObj = new MyObj({/* some params */}) 

     // This assumes your object inherits from Node's EventEmitter 
     // The name of your `emit` method may be different, eg `trigger` 
     var eventStub = sinon.stub(myObj, 'emit') 

     myObj.someMethod(); 
     eventStub.calledWith("some_event").should.eql(true); 
     eventStub.restore(); 
     done(); 
    }) 
}) 

Answer 5

Этот метод обеспечивает минимальное время ожидания, но максимальную возможность, установленную тайм-аутом набора, и довольно чистая.

it('should emit an some_event', function(done){ 
    myObj.on('some_event', done); 
    }); 

Можно также использовать его для функций CPS стиле ...

it('should call back when done', function(done){ 
    myAsyncFunction(options, done); 
    }); 

Идея также может быть расширена, чтобы проверить больше деталей - например, аргументы и this - поставив обертку Arround done. Например, благодаря this answer я могу сделать ...

it('asynchronously emits finish after logging is complete', function(done){ 
    const EE = require('events'); 
    const testEmitter = new EE(); 

    var cb = sinon.spy(completed); 

    process.nextTick(() => testEmitter.emit('finish')); 

    testEmitter.on('finish', cb.bind(null)); 

    process.nextTick(() => testEmitter.emit('finish')); 

    function completed() { 

     if(cb.callCount < 2) 
      return; 

     expect(cb).to.have.been.calledTwice; 
     expect(cb).to.have.been.calledOn(null); 
     expect(cb).to.have.been.calledWithExactly(); 

     done() 
    } 

}); 

Answer 6

Лучше решение вместо sinon.timers является использование ES6 - Обещания:

//Simple EventEmitter 
let emitEvent = (eventType, callback) => callback(eventType) 

//Test case 
it('Try to test ASYNC event emitter',() => { 
    let mySpy = sinon.spy() //callback 
    return expect(new Promise(resolve => { 
    //event happends in 300 ms 
    setTimeout(() => { emitEvent('Event is fired!', (...args) => resolve(mySpy(...args))) }, 300) //call wrapped callback 
    }) 
    .then(() => mySpy.args)).to.eventually.be.deep.equal([['Event is fired!']]) //ok 
}) 

Как вы можете видеть, ключ заключается в том, чтобы обернуть calback с разрешением: (... args) => resolve (mySpy (... args)).

Таким образом, PROMIS новый Promise(). Затем() разрешен ТОЛЬКО после будет называться обратным вызовом.

Но как только был вызван обратный вызов, вы уже можете проверить, что вы ожидали от него.

Преимущества:

• нам не нужно угадать таймаут ждать, пока событие не срабатывает (в случае многих описывает() и его()), а не в зависимости от Perfomance компьютера
• и тесты будут проходить быстрее