node.js - unit - test nodejs mocha




Como faço para testar adequadamente as promessas com mocha e chai? (3)

O seguinte teste está se comportando de maneira estranha:

it('Should return the exchange rates for btc_ltc', function(done) {
    var pair = 'btc_ltc';

    shapeshift.getRate(pair)
        .then(function(data){
            expect(data.pair).to.equal(pair);
            expect(data.rate).to.have.length(400);
            done();
        })
        .catch(function(err){
            //this should really be `.catch` for a failed request, but
            //instead it looks like chai is picking this up when a test fails
            done(err);
        })
});

Como devo lidar adequadamente com uma promessa rejeitada (e testá-la)?

Como devo lidar adequadamente com um teste que falhou (por exemplo: expect(data.rate).to.have.length(400);

Aqui está a implementação que estou testando:

var requestp = require('request-promise');
var shapeshift = module.exports = {};
var url = 'http://shapeshift.io';

shapeshift.getRate = function(pair){
    return requestp({
        url: url + '/rate/' + pair,
        json: true
    });
};

Aqui está a minha opinião:

  • usando async/await
  • não precisando de módulos chai extras
  • evitando o problema de captura, @TheCrazyProgrammer apontado acima

Uma função de promessa atrasada, que falha, se receber um atraso de 0:

const timeoutPromise = (time) => {
    return new Promise((resolve, reject) => {
        if (time === 0)
            reject({ 'message': 'invalid time 0' })
        setTimeout(() => resolve('done', time))
    })
}

//                     ↓ ↓ ↓
it('promise selftest', async () => {

    // positive test
    let r = await timeoutPromise(500)
    assert.equal(r, 'done')

    // negative test
    try {
        await timeoutPromise(0)
        // a failing assert here is a bad idea, since it would lead into the catch clause…
    } catch (err) {
        // optional, check for specific error (or error.type, error. message to contain …)
        assert.deepEqual(err, { 'message': 'invalid time 0' })
        return  // this is important
    }
    assert.isOk(false, 'timeOut must throw')
    log('last')
})

Teste positivo é bastante simples. Falhas inesperadas (simuladas com 500→0 ) serão reprovadas no teste automaticamente, à medida que a promessa rejeitada aumenta.

O teste negativo usa a ideia de tentar pegar. No entanto: 'reclamar' de um passe indesejado ocorre apenas após a cláusula catch (dessa forma, ele não termina na cláusula catch (), desencadeando erros adicionais, porém enganosos.

Para que essa estratégia funcione, é preciso retornar o teste da cláusula catch. Se você não quiser testar mais nada, use outro bloco it () -.


A coisa mais fácil a se fazer seria usar o suporte incorporado às promessas do Mocha nas versões recentes:

it('Should return the exchange rates for btc_ltc', function() { // no done
    var pair = 'btc_ltc';
    // note the return
    return shapeshift.getRate(pair).then(function(data){
        expect(data.pair).to.equal(pair);
        expect(data.rate).to.have.length(400);
    });// no catch, it'll figure it out since the promise is rejected
});

Ou com o Node moderno e assíncrono / espera:

it('Should return the exchange rates for btc_ltc', async () => { // no done
    const pair = 'btc_ltc';
    const data = await shapeshift.getRate(pair);
    expect(data.pair).to.equal(pair);
    expect(data.rate).to.have.length(400);
});

Como essa abordagem é promissora de ponta a ponta, é mais fácil testar e você não terá que pensar nos casos estranhos em que está pensando, como as chamadas ímpares done() todos os lugares.

Essa é uma vantagem do Mocha sobre outras bibliotecas como o Jasmine no momento. Você também pode verificar o Chai As Promised, o que tornaria ainda mais fácil (não. .then ), mas pessoalmente eu prefiro a clareza e simplicidade da versão atual


Há uma solução melhor. Basta retornar o erro com done em um bloco catch.

// ...

it('fail', (done) => {
  // any async call that will return a Promise 
  ajaxJson({})
  .then((req) => {
    expect(1).to.equal(11); //this will throw a error
    done(); //this will resove the test if there is no error
  }).catch((e) => {
    done(e); //this will catch the thrown error
  }); 
});

este teste falhará com a seguinte mensagem: AssertionError: expected 1 to equal 11





chai