NodeJS UnhandledPromiseRejectionWarning

Donc, je vais tester un composant qui s'appuie sur un événement de l'émetteur. Pour ce faire, je suis venu avec une solution à l'aide de Promesses avec Moka+Chai:

it('should transition with the correct event', (done) => {
  const cFSM = new CharacterFSM({}, emitter, transitions);
  let timeout = null;
  let resolved = false;
  new Promise((resolve, reject) => {
    emitter.once('action', resolve);
    emitter.emit('done', {});
    timeout = setTimeout(() => {
    if (!resolved) {
      reject('Timedout!');
    }
    clearTimeout(timeout);
  }, 100);
}).then(((state) => {
      resolved = true;
      assert(state.action === 'DONE', 'should change state');
      done();
    }))
    .catch((error) => {
      assert.isNotOk(error,'Promise error');
      done();
    });
  });
});

Sur la console j'obtiens un "UnhandledPromiseRejectionWarning" même si la rejeter fonction est appelé, car il montre instantanément le message "AssertionError: la Promesse d'erreur'

(noeud:25754) UnhandledPromiseRejectionWarning: non Gérée promesse
rejet (rejet de l'id: 2): AssertionError: la Promesse d'erreur: attendu
{ Objet (message, showDiff, ...) } pour être falsy
1) si la transition avec l'événement correct

Et puis, au bout de 2 sec je obtenir

Erreur: délai d'attente de 2000ms dépassé. Assurer la done() rappel est
appelé dans ce test.

Qui est encore plus étrange depuis la capture de rappel a été exécuté.(Je pense que pour certaines raison de l'affirmer échec empêché le reste de l'exécution)

Maintenant le plus drôle, si j'en commentaire le assert.isNotOk(error...) le test se passe bien avec tout d'avertissement dans la console. Il stills "échoue", dans le sens qu'elle exécute l'attraper.

Mais encore, je ne peux pas comprendre ces erreurs avec la promesse. Quelqu'un peut-il m'éclairer?

Je pense que vous avez un jeu supplémentaire de l'accolade de fermeture et de parens, à la dernière ligne. Supprimez-les et essayez à nouveau.
C'est trop cool, le nouveau non gérée rejet d'avertissement trouve des bugs dans la vraie vie et sauve des gens de temps. Tellement gagner ici. Sans cet avertissement, vos tests aurait expiré sans aucune explication.

InformationsquelleAutor Jzop | 2016-09-27

132

Le problème est causé par ceci:
```
.catch((error) => {
  assert.isNotOk(error,'Promise error');
  done();
});
```
Si l'assertion échoue, il renvoie une erreur. Cette erreur entraîne done() jamais appelé, parce que le code d'erreur avant. Qu'est ce qui cause le délai d'attente.

La "non Gérée promesse de rejet" est aussi causée par l'échec de l'assertion, parce que si une erreur est renvoyée dans un catch() gestionnaire, et il n'y a pas une ultérieure catch() gestionnaire, l'erreur sera d'être avalé (comme expliqué dans cet article). Le UnhandledPromiseRejectionWarning avertissement est pour vous en avertir.

En général, si vous voulez tester la promesse code de Moka, vous devez compter sur le fait que Moka lui-même peut gérer promet déjà. Vous ne devriez pas utiliser done(), mais au lieu de cela, de retour d'une promesse de votre test. Moka sera alors intercepter les erreurs lui-même.

Comme ceci:
```
it('should transition with the correct event', () => {
  ...
  return new Promise((resolve, reject) => {
    ...
  }).then((state) => {
    assert(state.action === 'DONE', 'should change state');
  })
  .catch((error) => {
    assert.isNotOk(error,'Promise error');
  });
});
```
- Pour quiconque est curieux, c'est également vrai pour le jasmin.
- Ne prends pas seront appelés pour toute erreur et pas seulement celui que vous êtes enceinte? Je pense que ce style ne fonctionnera pas si vous essayez de faire valoir des échecs.
- le catch gestionnaire doit probablement être passé en second argument de then. Cependant, je ne suis pas entièrement assurez-vous que l'intention de l'OP, donc j'ai laissé comme ça.
- Et aussi pour tous ceux curieux de connaître le jasmin, l'utilisation done.fail('msg') dans ce cas.
- pouvez-vous donner plein d'exemple de cas où le code principal vs affirmations devrait aller, n'est pas si clair ici.....surtout si vous l'affirmation d'une valeur de service original/promesse d'appel dans notre code. Est-ce la promesse de notre code d'aller dans cet autre "moka promesse" ??
- peut-être que ça aide si examiner votre cas de test comme un .then gestionnaire: vous revenez d'une promesse de la chaîne d'elle, et, en général, que la chaîne commence avec la fonction en cours de test, suivi par un .then où vous pourrez vous affirmer que la valeur de(s) retourné sont corrects. Voir ce gist.
InformationsquelleAutor robertklep
9

J'ai eu cette erreur lors de l'écrasant avec sinon.

La solution est d'utiliser npm paquet sinon comme promis lors de la résolution ou de rejet de promesses avec talons.

Au lieu de ...
```
sinon.stub(Database, 'connect').returns(Promise.reject( Error('oops') ))
```
Utiliser ...
```
require('sinon-as-promised');
sinon.stub(Database, 'connect').rejects(Error('oops'));
```
Il y a aussi une méthode résout (notez le s à la fin).

Voir http://clarkdave.net/2016/09/node-v6-6-and-asynchronously-handled-promise-rejections
- Sinon, comprend maintenant les méthodes de "résoudre" et "rejette" pour talons de la version 2. Voir npmjs.com/package/sinon-as-promised. J'ai encore +1 ed la réponse, même si je ne le savais pas à ce sujet.
InformationsquelleAutor danday74
8

L'affirmation bibliothèques Moka le travail en lançant un message d'erreur si l'affirmation n'était pas correcte. Jeter une erreur se produit dans le refus de la promesse, même quand jeté à l'exécuteur fonction de la catch méthode.
```
.catch((error) => {
  assert.isNotOk(error,'Promise error');
  done();
});
```
Dans le code ci-dessus la error opposé évalue à true donc l'affirmation de la bibliothèque renvoie une erreur... qui n'est jamais pris. Comme un résultat de l'erreur de la done méthode n'est jamais appelé. Moka est done rappel accepte de ces erreurs, alors vous pouvez tout simplement fin à toute promesse de chaînes de Moka avec .then(done,done). Cela garantit que la méthode est toujours appelé et l'erreur doit être signalé de la même manière que lorsque Moka captures de l'affirmation de l'erreur dans le code synchrone.
```
it('should transition with the correct event', (done) => {
  const cFSM = new CharacterFSM({}, emitter, transitions);
  let timeout = null;
  let resolved = false;
  new Promise((resolve, reject) => {
    emitter.once('action', resolve);
    emitter.emit('done', {});
    timeout = setTimeout(() => {
      if (!resolved) {
        reject('Timedout!');
      }
      clearTimeout(timeout);
    }, 100);
  }).then(((state) => {
    resolved = true;
    assert(state.action === 'DONE', 'should change state');
  })).then(done,done);
});
```
Je donne crédit à cet article pour l'idée de l'aide .ensuite(en fait,en fait) lors de l'essai de promesses de Moka.

InformationsquelleAutor Matthew Orlando
5

Pour ceux qui sont à la recherche de l'erreur/avertissement UnhandledPromiseRejectionWarning en dehors d'un environnement de test, Il pourrait être probablement parce que personne, dans le code, c'est prendre soin de l'éventuelle erreur dans une promesse:

Par exemple, ce code va afficher l'avertissement signalé dans cette question:
```
new Promise((resolve, reject) => {
  return reject('Error reason!');
});
```
(node:XXXX) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 1): Error: Error reason!

et en ajoutant le .catch() ou de la manipulation de l'erreur doit résoudre l'avertissement/erreur
```
new Promise((resolve, reject) => {
  return reject('Error reason!');
}).catch(() => { /* do whatever you want here */ });
```
Ou à l'aide de la deuxième paramètre dans la then fonction
```
new Promise((resolve, reject) => {
  return reject('Error reason!');
}).then(null, () => { /* do whatever you want here */ });
```
- Bien sûr, mais je pense que dans la vie réelle nous avons l'habitude de ne pas utiliser juste new Promise((resolve, reject) => { return reject('Error reason!'); }) mais en fonction function test() { return new Promise((resolve, reject) => { return reject('Error reason!'); });} donc à l'intérieur de la fonction nous n'avons pas besoin d'utiliser .catch() mais pour réussir à gérer les erreurs, il suffit d'utiliser lors de l'appel de cette fonction test().catch(e => console.log(e)) ou async/await version try { await test() } catch (e) { console.log(e) }
InformationsquelleAutor gsalgadotoledo
1

Voici mon prendre de l'expérience avec E7 async/await:

Dans le cas où vous avez un async helperFunction() appelés à partir de votre test... (un explicilty avec l'ES7 async mot-clé, je veux dire)

→ assurez-vous, vous appelez ça comme await helperFunction(whateverParams) (eh bien, oui, naturellement, une fois que vous savez...)

Et pour que cela fonctionne (à éviter l ‘ " attendre est un mot réservé), votre test de fonction doit avoir un extérieur async marqueur:
```
it('my test', async () => { ...
```
- Vous n'avez pas pour pour l'appeler comme await helperFunction(...). Un async fonction renvoie une promesse. Vous pouvez simplement gérer le retour de la promesse, comme vous le feriez sur une fonction qui ne sont pas marqués async qui arrive à retourner une promesse. Le point est de traiter la promesse, de la période. Si la fonction est async ou pas n'a pas d'importance. await est simplement un parmi les multiples façons de gérer la promesse.
- Vrai. Mais puis-je investir lignes sur la capture... ou mes tests passent comme des faux positifs, et tout défaut de promesses vont unoticed (en termes de lanceur de résultats). Alors attends ressemble de moins en moins de lignes&effort pour moi. – De toute façon, en oubliant attendent a été, ce qui a causé que UnhandledPromiseRejectionWarning pour moi... donc cette réponse.
InformationsquelleAutor Frank Nocke

J'ai été confronté à ce problème:

(noeud:1131004) UnhandledPromiseRejectionWarning: non Gérée promesse de rejet (re
jection id: 1): TypeError: res.json n'est pas une fonction
(node:1131004) DeprecationWarning: non Gérée promesse de rejets sont obsolètes.
Dans l'avenir, promesse de rejets qui ne sont pas gérées prendra fin le Nœud.j
s avec un code de sortie non nulle.

C'était mon erreur, j'étais remplaçant res objet dans then(function(res), tellement changé res de suite et maintenant, il est de travail.

Mauvais

module.exports.update = function(req, res){
        return Services.User.update(req.body)
                .then(function(res){//issue was here, res overwrite
                    return res.json(res);
                }, function(error){
                    return res.json({error:error.message});
                }).catch(function () {
                   console.log("Promise Rejected");
              });

Correction

module.exports.update = function(req, res){
        return Services.User.update(req.body)
                .then(function(result){//res replaced with result
                    return res.json(result);
                }, function(error){
                    return res.json({error:error.message});
                }).catch(function () {
                   console.log("Promise Rejected");
              });

Code de Service:

function update(data){
   var id = new require('mongodb').ObjectID(data._id);
        userData = {
                    name:data.name,
                    email:data.email,
                    phone: data.phone
                };
 return collection.findAndModify(
          {_id:id}, //query
          [['_id','asc']],  //sort order
          {$set: userData}, //replacement
          { "new": true }
          ).then(function(doc) {
                if(!doc)
                    throw new Error('Record not updated.');
                return doc.value;   
          });
    }

module.exports = {
        update:update
}

InformationsquelleAutor Muhammad Shahzad

0

J'ai résolu ce problème après la désinstallation webpack (réaction de js problème ).
```
sudo uninstall webpack
```
InformationsquelleAutor Mr Fun

Vous devez vous connecter pour publier un commentaire.

Voici mon prendre de l'expérience avec E7 async/await:

Mauvais

Correction