Как правильно проверить promises с моккой и чаем?

Ответ 1

Проще всего было бы использовать встроенную поддержку обещаний, которую Mocha имеет в последних версиях:

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

Или с современным узлом и async/wait:

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

Поскольку этот подход обещает до конца, его легче тестировать, и вам не придется думать о странных случаях, о которых вы думаете, как о нечетных вызовах done() всем мире.

Это преимущество, которое Моча имеет в отношении других библиотек, таких как Жасмин. Вы также можете проверить Chai As Promised, что сделало бы его еще проще (нет. .then), но лично я предпочитаю ясность и простоту текущей версии

Ответ 2

Как уже указывалось здесь, более новые версии Mocha уже обещаны. Но поскольку ОП специально задал вопрос о Чайе, справедливо отметить пакет chai-as-promised, который обеспечивает чистый синтаксис для тестирования promises:

используя chai-as-обещанный

Здесь вы можете использовать chai-as-обещанный для тестирования случаев resolve и reject для Promise:

var chai = require('chai');
var expect = chai.expect;
var chaiAsPromised = require("chai-as-promised");
chai.use(chaiAsPromised);

...

it('resolves as promised', function() {
    return expect(Promise.resolve('woof')).to.eventually.equal('woof');
});

it('rejects as promised', function() {
    return expect(Promise.reject('caw')).to.be.rejectedWith('caw');
});

без chai-as-обещанного

Чтобы было действительно ясно, что тестируется, здесь тот же пример закодирован без chai-as-обещал:

it('resolves as promised', function() {
    return Promise.resolve("woof")
        .then(function(m) { expect(m).to.equal('woof'); })
        .catch(function(m) { throw new Error('was not supposed to fail'); })
            ;
});

it('rejects as promised', function() {
    return Promise.reject("caw")
        .then(function(m) { throw new Error('was not supposed to succeed'); })
        .catch(function(m) { expect(m).to.equal('caw'); })
            ;
});

Ответ 3

Здесь мое взятие:

• использование async/await
• не нужны дополнительные модули chai
• избегая проблемы с уловами, @TheCrazyProgrammer указал выше

Функция с задержкой обещания, которая терпит неудачу, если задана задержка 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')
})

Положительный тест довольно прост. Неожиданный сбой (симуляция на 500→0) автоматически завершит тест, так как отклоненные обещания будут возрастать.

Отрицательный тест использует идею try-catch. Однако: "жалобы" на нежелательный проход происходит только после предложения catch (таким образом, это не заканчивается в предложении catch(), вызывая дальнейшие, но вводящие в заблуждение ошибки.

Чтобы эта стратегия работала, нужно вернуть тест из предложения catch. Если вы не хотите ничего тестировать, используйте другое() -block.

Ответ 4

Это лучшее решение. Просто верните ошибку с done в блоке 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
  }); 
});

этот тест не пройдёт со следующим сообщением: AssertionError: expected 1 to equal 11