Testing codice sincrono

Question

ho una sezione di codice che utilizza node-sync in questo modo:

function funcA() { 
    return new Promise(function(resolve, reject) { 
    Sync(function() { 
     return funcB.sync(); 
    }, function (err, result) { 
     if(err) { 
     reject(err); 
     } else { 
     resolve(result); 
     } 
    }); 
} 

Questo codice viene testato con moka + chai:

it("should return array", function() { 
    return funcA().then(function(result) { 
    expect(result).to.be.an.instanceof(Array); 
    }); 
}); 

Ha funzionato paio bene di mesi fa , ma ora questo test sempre timeout:

Error: timeout of 2000ms exceeded. Ensure the done() callback is being called in this test.

quello che ho provato finora:

• utilizzando done() invece di restituire una promessa
• sostituzione node-sync con synchronize.js
• aumentando timeout

Quello che ho scoperto, è che expect(... parte di questo test è, infatti, essere chiamato , ma solo dopo che la moka ha ucciso il test. Indipendentemente dall'intervallo di timeout attualmente impostato, expect(.. viene chiamato sempre ~ 20 millisecondi dopo che ho ricevuto il messaggio Error: timeout.

Ho risolto il problema aggiungendo setInterval(function(){}, 10) nella parte superiore del file di test. Mi piacerebbe sapere perché questo ha funzionato e se c'è un modo migliore per risolvere questo?

[MODIFICA] Sembra che questo sia un problema specifico della versione del nodo. Il test fallisce su 0.12.4 ma funziona correttamente su 0.10.38.

[EDIT] Il codice attuale è disponibile here.

Answer 1

Si può solo mancare il done() callback:

it("should return array", function(done) { 
    funcA().then(function(result) { 
     expect(result).to.be.an.instanceof(Array); 
     done(); 
    }); 
}); 

http://mochajs.org/#asynchronous-code

Answer 2

Sulla base della sua code, io parto dal presupposto che la funzione funcB è in esecuzione il codice in modo sincrono .

Così quando creo funcB in questo modo:

function funcB() { 
    return [1, 2, 3]; 
} 

ed eseguire il test, Mocha mostra un errore:

Error: timeout of 2000ms exceeded. Ensure the done() callback is being called in this test.

Ma se converto il funcB in funzione asincrono come questo :

Mocha esegue il test senza alcun problema:

✓ should return an array

---

Quindi il mio codice completo che corre ok (il funcB commentato è quello che causerà l'errore) è questo:

// install dependencies 
// npm install promise 
// npm install sync 
var Promise = require('promise'); 
var assert = require('assert'); 
var Sync = require('sync'); 

function funcA() { 
    return new Promise(function (resolve, reject) { 
    Sync(function() { 
     return funcB.sync(); 
    }, function (err, result) { 
     if (err) { 
     reject(err); 
     } else { 
     resolve(result); 
     } 
    }); 
    }); 
} 

// function funcB() { 
// return [1, 2, 3]; 
// } 

function funcB(cb) { 
    process.nextTick(function() { 
    cb(null, [1, 2, 3]); 
    }); 
} 

it("should return an array", function(done) { 
    return funcA().then(
    function (result) { 
     console.log(result); 
     assert.equal(Array.isArray(result), true); 
     done(); 
    } 
); 
}); 

Così sto parere, credo che l'abuso di il sync method (utilizzandolo su funzioni sincrone) creato dalla libreria di sincronizzazione è quello che sta causando questo problema.

Answer 3

È possibile utilizzare un parametro di timeout per l'eseguibile di mocha.

Ad esempio, se si desidera un timeout di 500 millisecondi, basta cambiare la tua package.json a:

"scripts": { 
    "test": "mocha specs --timeout 500 --require specs/helpers/chai.js" 
}, 

E forse la promessa viene respinta, quindi bisogna chiamare done utilizzando catch metodo.

it("should return array", function(done) { 
    return funcA().then(function(result) { 
     expect(result).to.be.an.instanceof(Array); 
     done(); 
    }).catch(done); 
}); 

Ciò consentirebbe anche di eseguire il debug di eventuali errori che potrebbero verificarsi nel codice di promessa.