web-dev-qa-db-fra.com

Testez si une promesse est résolue ou rejetée avec Jasmine dans Nodejs

Je sais comment le faire à Mocha mais je veux savoir comment le faire avec Jasmine. J'ai essayé

describe('test promise with jasmine', function() {
    it('expects a rejected promise', function() {
        var promise = getRejectedPromise();

        // return expect(promise).toBe('rejected');
        return expect(promise.inspect().state).toBe('rejected');
    });
});

Cependant, l'état est toujours pending et, bien sûr, le test échoue. Je n'ai trouvé aucun exemple en ligne que je pourrais faire fonctionner.

Quelqu'un pourrait m'aider avec ça?

Merci.

javascriptnode.jsjasminepromise
26
chepukha

Pour tester du code asynchrone avec du jasmin, vous devez utiliser sa syntaxe asynchrone , par exemple:

describe('test promise with jasmine', function(done) {
    var promise = getRejectedPromise();

    promise.then(function() {
      // Promise is resolved
      done(new Error('Promise should not be resolved'));
    }, function(reason) {
      // Promise is rejected
      // You could check rejection reason if you want to
      done(); // Success
    });
});
38
Leonid Beschastny

Vous pouvez utiliser le bloc finally pour tester l'état de la promesse:

it('should resolve if auth succeed', (done)=>{
    var p = server.login('user', 'password');
    p.finally(()=>{
        expect(p.isFulfilled()).toBeTruthy();
        done();
    });
});

Vous pouvez utiliser isFulfilled pour vérifier si la promesse a été tenue et la méthode value pour vérifier la valeur de réalisation. Les méthodes de rejet correspondantes sont isRejected et reason.

5
SET

jasmine 2.7 prend en charge les promesses de retour et verrait son état rempli testé.

Pour tester le rejet:

it('test promise with jasmine', async () => {
    try {
        await getRejectedPromise();
    } catch (err) {
        return;
    }

    throw new Error('Promise should not be resolved');
});

ou encore:

it('test promise with jasmine', async () => {
    await getRejectedPromise()
        .then(
            () => Promise.reject(new Error('Promise should not be resolved')), 
            () => {});
});

Pour vérifier le message réel, en plus de la fonction instanceof/toBe() habituelle, placez à l'intérieur du catch:

expect(() => { throw err }).toThrow(new MyCustomError('Custom error message'));

L'avantage de cette approche est d'avoir un message d'échec plus agréable sur la sortie de test.

Fonction attendue pour lancer MyCustomError: Message d'erreur personnalisé, mais il a lancé un autre message d'erreur.

Un peu mieux que la sortie habituelle.

Pour tester pour résolu (ne peut pas être plus simple):

it('test promise with jasmine', async () => {
    await getRejectedPromise();
});
5
André Werlang

vous pouvez maintenant utiliser expectAsync()

Attendre le succès:

it('expect result', async () => {
   ...
   await expectAsync(someAsyncFunction(goodInput)).toBeResolved(expectedResponse)
})

Attente d'un échec:

it('expect result', async () => {
   ...
   await expectAsync(someAsyncFunction(badInput)).toBeRejectedWith(expectedResponse)
})
1
nxmohamad

@ La réponse de Leonid est correcte, mais vous pouvez simplifier ainsi et n'utiliser que des promesses:

it('test promise with jasmine', function() {

    return getRejectedPromise().then(function() {
      // Promise should not be resolved, so we reject it
      return Promise.reject(new Error('Promise should not be resolved'));
    })
    .catch(function(err){
       if(!/Promise should not be resolved/.test(err && err.message)){
          return Promise.reject(err);
       }
    })
})
0
Alexander Mills