jasmine: o retorno de chamada assíncrona não foi chamado dentro do tempo limite especificado por jasmine.DEFAULT_TIMEOUT_INTERVAL

Eu tenho um serviço angular chamado requestNotificationChannel:

app.factory("requestNotificationChannel", function($rootScope) {

    var _DELETE_MESSAGE_ = "_DELETE_MESSAGE_";

    function deleteMessage(id, index) {
        $rootScope.$broadcast(_DELETE_MESSAGE_, { id: id, index: index });
    };

    return {
       deleteMessage: deleteMessage
    };

});

Eu estou tentando testar este serviço usando o jasmim:

"use strict";

describe("Request Notification Channel", function() {
    var requestNotificationChannel, rootScope, scope;

    beforeEach(function(_requestNotificationChannel_) {
        module("messageAppModule");

        inject(function($injector, _requestNotificationChannel_) {
            rootScope = $injector.get("$rootScope");
            scope = rootScope.$new();
            requestNotificationChannel = _requestNotificationChannel_;
        })

        spyOn(rootScope, '$broadcast');
    });


    it("should broadcast delete message notification", function(done) {

        requestNotificationChannel.deleteMessage(1, 4);
        expect(rootScope.$broadcast).toHaveBeenCalledWith("_DELETE_MESSAGE_", { id: 1, index: 4 });
        done();       
    });
});

Eu li sobre o Suporte assíncrono no Jasmine, mas como eu sou novo no teste de unidade com javascript, não poderia fazê-lo funcionar.

Estou recebendo um erro:

Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL

e meu teste está demorando muito para ser executado (cerca de 5s).

Alguém pode me ajudar a fornecer um exemplo prático do meu código com alguma explicação?

Ter um argumento em sua itfunção ( doneno código abaixo) fará com que o Jasmine tente uma chamada assíncrona.

//this block signature will trigger async behavior.
it("should work", function(done){
  //...
});

//this block signature will run synchronously
it("should work", function(){
  //...
});

Não faz diferença o que o done argumento, sua existência é tudo o que importa. Corri para esta questão de muita cópia / massas.

Os documentos do Jasmine Asynchronous Support observam que o argumento (mencionado doneacima) é um retorno de chamada que pode ser chamado para informar o Jasmine quando uma função assíncrona for concluída. Se você nunca ligar, o Jasmine nunca saberá que seu teste está concluído e, eventualmente, atingirá o tempo limite.

Mesmo para testes assíncronos, há um tempo limite que é desativado nesses casos. Você pode solucionar esse erro aumentando o valor do tempo limite para avaliar um retorno de chamada assíncrono do Jasmine

describe('Helper', function () {
    var originalTimeout;

    beforeEach(function() {
        originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
        jasmine.DEFAULT_TIMEOUT_INTERVAL = 1000000;
    });

    afterEach(function() {
      jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
    });

    it('Template advance', function(doneFn) {
        $.ajax({
            url: 'public/your-end-point.mock.json',
            dataType: 'json',
            success: function (data, response) {
                // Here your expected using data
                expect(1).toBe(1)
                doneFn();
            },
            error: function (data, response) {
                // Here your expected using data
                expect(1).toBe(1)
                doneFn();
            }
        });
    });
});

Fonte: http://jasmine.github.io/2.0/introduction.html#section-42

Este erro também pode ser causado por deixar de fora a injeção ao inicializar um serviço / fábrica ou qualquer outra coisa. Por exemplo, ele pode ser lançado ao fazer o seguinte:

var service;
beforeEach(function(_TestService_) {
    service = _TestService_;
});

Para corrigi-lo, basta enrolar a função com injetar para recuperar adequadamente o serviço:

var service;
beforeEach(inject(function(_TestService_) {
    service = _TestService_;
}));

import { fakeAsync, ComponentFixture, TestBed } from '@angular/core/testing';

use fakeAsync

beforeEach(fakeAsync (() => {

//your code

}));



describe('Intilalize', () => {
        it('should have a defined component', fakeAsync(() => {
            createComponent();
            expect(_AddComponent.ngOnInit).toBeDefined();
        }));
    });

Você pode usar karma-jasmim plugin para definir o intervalo de tempo limite padrão globalmente.

Adicione esta configuração em karma.conf.js

module.exports = function(config) {
  config.set({
    client: {
      jasmine: {
        timeoutInterval: 10000
      }
    }
  })
}

Esse erro começou do nada para mim, em um teste que sempre funcionou. Não consegui encontrar nenhuma sugestão que ajudasse até perceber que meu Macbook estava rodando devagar. Percebi que a CPU estava atrelada a outro processo, que matei. O erro assíncrono do Jasmine desapareceu e meus testes estão bem mais uma vez.

Não me pergunte por que, eu não sei. Mas, na minha circunstância, parecia haver falta de recursos do sistema.

Isso é mais uma observação do que uma resposta, mas pode ajudar outras pessoas que ficaram tão frustradas quanto eu.

Eu continuei recebendo esse erro de dois testes na minha suíte. Eu pensei que tinha simplesmente quebrado os testes com a refatoração que estava fazendo, então, depois de fazer o backup das alterações não funcionarem, voltei ao código anterior, duas vezes (duas revisões anteriores) pensando que isso iria livrar-se do erro. Fazer isso não mudou nada. Ontem persegui meu rabo o dia todo e parte desta manhã sem resolver o problema.

Fiquei frustrado e verifiquei o código em um laptop esta manhã. Executou todo o conjunto de testes (cerca de 180 testes), sem erros. Portanto, os erros nunca estavam no código ou nos testes. Voltei para minha caixa de desenvolvimento e a reinicializei para limpar qualquer coisa na memória que pudesse estar causando o problema. Nenhuma mudança, os mesmos erros nos mesmos dois testes. Então eu apaguei o diretório da minha máquina e verifiquei novamente. Voila! Sem erros.

Não faço ideia do que o causou ou como corrigi-lo, mas excluir o diretório de trabalho e verificar novamente o que foi corrigido.

Espero que isso ajude alguém.

Não use done, apenas deixe a chamada de função vazia.

Você também recebe esse erro ao esperar algo na beforeAllfunção!

describe('...', function () {

    beforeAll(function () {
        ...

        expect(element(by.css('[id="title"]')).isDisplayed()).toBe(true);
    });

    it('should successfully ...', function () {

    }
}

No meu caso, esse erro foi causado pelo uso inadequado de "fixture.detectChanges ()" Parece que esse método é um ouvinte de eventos (assíncrono) que responde apenas a um retorno de chamada quando alterações são detectadas. Se nenhuma alteração for detectada, ele não chamará o retorno de chamada, resultando em um erro de tempo limite. Espero que isto ajude :)

Funciona após remover a scopereferência e os argumentos da função:

"use strict";

describe("Request Notification Channel", function() {
    var requestNotificationChannel, rootScope;

    beforeEach(function() {
        module("messageAppModule");

        inject(function($injector, _requestNotificationChannel_) {
            rootScope = $injector.get("$rootScope");
            requestNotificationChannel = _requestNotificationChannel_;
        })
        spyOn(rootScope, "$broadcast");
    });


    it("should broadcast delete message notification with provided params", function() {
        requestNotificationChannel.deleteMessage(1, 4);
        expect(rootScope.$broadcast).toHaveBeenCalledWith("_DELETE_MESSAGE_", { id: 1, index: 4} );
    });
});

Conforme observado por @mastablasta, mas também para adicionar que, se você chamar o argumento 'concluído' ou melhor, nomeá-lo como concluído, basta chamar o retorno de chamada como concluído () em seu teste quando terminar.

// this block signature will trigger async behavior.
it("should work", function(done){
  // do stuff and then call done...
  done();
});

// this block signature will run synchronously
it("should work", function(){
  //...
});

jasmine.DEFAULT_TIMEOUT_INTERVAL = 100000;

Manter isso no bloco resolveu meu problema.

it('', () => {
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 100000;
});

O que fiz foi: Adicionado / atualizado o seguinte código:

framework: 'jasmine',
jasmineNodeOpts: 
{
    // Jasmine default timeout
    defaultTimeoutInterval: 60000,
    expectationResultHandler(passed, assertion) 
    {
      // do something
    },
}

Ao invés de

beforeEach(() => {..

usar

beforeEach(fakeAsync(() => {..

Parece que o teste está aguardando um retorno de chamada que nunca chega. É provável que o teste não seja executado com comportamento assíncrono.

Primeiro, veja se apenas usando fakeAsync no seu cenário "it":

it('should do something', fakeAsync(() => {

Você também pode usar flush()para aguardar o término da fila da microTask ou tick()para aguardar um período especificado.

Se você tem um argumento ( done) na itfunção, tente removê-lo também, é chamado dentro da própria função:

it("should broadcast delete message notification", function(/*done -> YOU SHOULD REMOVE IT */) {

    requestNotificationChannel.deleteMessage(1, 4);
    expect(rootScope.$broadcast).toHaveBeenCalledWith("_DELETE_MESSAGE_", { id: 1, index: 4 });
    // done(); -> YOU SHOULD REMOVE IT        
});