單元測試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

編輯9月30日：

我看到我的回答被接受爲正確的答案，但佈雷特Copeland的技術（見下面的回答）僅僅是更好，因爲它是在測試是成功的更快，這會是這樣大多數情況下，您會將測試作爲測試套件的一部分進行測試

---

Bret Copeland的技術是正確的。你也可以做到這一點有點不同：

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 ms。最有可能不是這種情況。

實際上，當事件被保證能與導致它的操作同步閃光，您可以將代碼簡化爲

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'); 
    }); 

否則，佈雷特Copeland的技術總是快於「成功」的情況下（有希望常見的情況），因爲如果事件被觸發，它能夠立即呼叫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

遲到了這裏，但我確切地面對這個問題，並與其他解決方案上來。佈雷特接受的答案是一個很好的答案，但我發現在運行我的全套摩卡測試套件時發生了嚴重破壞，拋出了錯誤done() called multiple times，我最終放棄嘗試排除故障。梅麗爾的回答讓我走上了我自己的解決方案，它也使用sinon，但不需要使用超時。通過簡單地存根emit()方法，您可以測試它被調用並驗證其參數。這假定你的對象繼承自Node的EventEmitter類。您的情況下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 - 通過把一個包裝以防萬一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 
}) 

正如你所看到的，關鍵是用解析包裝回調：（... args）=>解析（mySpy（... args））。

因此，PROMIS 新無極（）。然後，（）只有之後調用回調解決。

但是一旦調用回調函數，您就可以測試，您對他的期望是什麼。

優點：

• 我們不需要去猜測超時​​等待，直到事件被觸發（在許多介紹情況（）和（）），不依賴於計算機的性能比較
• 並且測試將更快通過