NodeJS UnhandledPromiseRejectionWarning

Então, estou testando um componente que depende de um emissor de evento. Para isso, criei uma solução usando o Promises com Mocha + 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();
  });
});

No console, estou recebendo um 'UnhandledPromiseRejectionWarning', embora a função de rejeição esteja sendo chamada, pois mostra instantaneamente a mensagem 'AssertionError: Promise error'

(nó: 25754) UnhandledPromiseRejectionWarning: rejeição de promessa sem tratamento (ID de rejeição: 2): AssertionError: erro de promessa: esperado {objeto (mensagem, showDiff, ...)} como falso 1) deve fazer a transição com o evento correto

E então, depois de 2 segundos eu recebo

Erro: tempo limite de 2000ms excedido. Verifique se o retorno de chamada done () está sendo chamado neste teste.

O que é ainda mais estranho desde que o retorno de chamada de captura foi executado (acho que, por algum motivo, a falha de declaração impediu o restante da execução)

Agora, o mais engraçado, se eu comentar, assert.isNotOk(error...)o teste será executado sem nenhum aviso no console. Ainda "falha" no sentido em que executa a captura.
Ainda assim, não consigo entender esses erros com promessa. Alguém pode me esclarecer?

O problema é causado por isso:

.catch((error) => {
  assert.isNotOk(error,'Promise error');
  done();
});

Se a asserção falhar, gerará um erro. Este erro fará com que done()nunca seja chamado, porque o código foi exibido antes dele. Isso é o que causa o tempo limite.

A "rejeição de promessa não tratada" também é causada pela falha na declaração, porque se um erro for gerado em um catch()manipulador e não houver um catch()manipulador subsequente , o erro será engolido (conforme explicado neste artigo ). O UnhandledPromiseRejectionWarningaviso está alertando você para esse fato.

Em geral, se você deseja testar o código baseado em promessas no Mocha, deve confiar no fato de que o próprio Mocha já pode lidar com promessas. Você não deve usar done(), mas, em vez disso, retorne uma promessa do seu teste. O Mocha detectará os próprios erros.

Como isso:

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

Eu recebi esse erro ao stubbing com sinon.

A correção é usar o pacote npm sinon como prometido ao resolver ou rejeitar promessas com stubs.

Ao invés de ...

sinon.stub(Database, 'connect').returns(Promise.reject( Error('oops') ))

Usar ...

require('sinon-as-promised');
sinon.stub(Database, 'connect').rejects(Error('oops'));

Há também um método resolve (observe os s no final).

Consulte http://clarkdave.net/2016/09/node-v6-6-and-asynchronously-handled-promise-rejections

As bibliotecas de asserções no Mocha funcionam lançando um erro se a asserção não estiver correta. Lançar um erro resulta em uma promessa rejeitada, mesmo quando lançada na função executora fornecida ao catchmétodo.

.catch((error) => {
  assert.isNotOk(error,'Promise error');
  done();
});

No código acima, a errorobjeção é avaliada para trueque a biblioteca de asserções gere um erro ... que nunca seja detectado. Como resultado do erro, o donemétodo nunca é chamado. O doneretorno de chamada do Mocha aceita esses erros, então você pode simplesmente encerrar todas as cadeias de promessas no Mocha com .then(done,done). Isso garante que o método concluído seja sempre chamado e o erro seja relatado da mesma maneira que quando o Mocha captura o erro da asserção no código síncrono.

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

Dou crédito a este artigo pela idéia de usar .then (concluído, concluído) ao testar promessas no Mocha.

Para quem procura o erro / aviso UnhandledPromiseRejectionWarning fora de um ambiente de teste, pode ser porque provavelmente ninguém no código está cuidando do eventual erro em uma promessa:

Por exemplo, este código mostrará o aviso relatado nesta pergunta:

new Promise((resolve, reject) => {
  return reject('Error reason!');
});

(node:XXXX) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 1): Error: Error reason!

e adicionar .catch()ou manipular o erro deve resolver o aviso / erro

new Promise((resolve, reject) => {
  return reject('Error reason!');
}).catch(() => { /* do whatever you want here */ });

Ou usando o segundo parâmetro na thenfunção

new Promise((resolve, reject) => {
  return reject('Error reason!');
}).then(null, () => { /* do whatever you want here */ });

Eu enfrentei esse problema:

(nó: 1131004) UnhandledPromiseRejectionWarning: rejeição de promessa não tratada (ID de rejeição: 1): TypeError: res.json não é uma função (nó: 1131004) DeprecationWarning: rejeições de promessa não tratadas estão obsoletas. No futuro, as rejeições de promessa que não forem tratadas encerrarão o processo do Node.j com um código de saída diferente de zero.

Foi um erro meu, eu estava substituindo um resobjeto then(function(res), então mudeires para resultar e agora está funcionando.

Errado

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

Correção

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

Código de Serviço:

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
}

Aqui está a minha experiência com o E7 assíncrono / aguardar :

Caso você tenha async helperFunction()recebido uma chamada do seu teste ... (uma explicação com a asyncpalavra-chave ES7 , quero dizer)

→ certifique-se de chamar assim await helperFunction(whateverParams) (bem, sim, naturalmente, depois que você souber ...)

E para que isso funcione (para evitar 'aguardar é uma palavra reservada'), sua função de teste deve ter um marcador assíncrono externo:

it('my test', async () => { ...

Eu tive uma experiência semelhante com o Chai-Webdriver para Selenium. Eu adicionei awaità afirmação e ela corrigiu o problema:

Exemplo usando Cucumberjs:

Then(/I see heading with the text of Tasks/, async function() {
    await chai.expect('h1').dom.to.contain.text('Tasks');
});

Resolvi esse problema depois de desinstalar o webpack (problema do react js).

sudo uninstall webpack