jazmín: no se invocó la devolución de llamada asíncrona dentro del tiempo de espera especificado por jasmine.DEFAULT_TIMEOUT_INTERVAL

Tengo un servicio angular llamado 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
    };

});

Estoy tratando de probar este servicio con jazmín:

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

Leí sobre el soporte asíncrono en Jasmine, pero como soy bastante nuevo en las pruebas unitarias con javascript no pude hacerlo funcionar.

Estoy recibiendo un error:

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

y mi prueba está tardando demasiado en ejecutarse (aproximadamente 5 segundos).

¿Alguien puede ayudarme a proporcionar un ejemplo funcional de mi código con alguna explicación?

Tener un argumento en su itfunción ( doneen el código a continuación) hará que Jasmine intente una llamada asincrónica.

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

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

No importa cómo donese llame el argumento, su existencia es todo lo que importa. Me encontré con este problema por demasiada copia / pasta.

Los documentos de Jasmine Asynchronous Support observan que el argumento (mencionado doneanteriormente) es una devolución de llamada que se puede invocar para que Jasmine sepa cuándo se completa una función asincrónica. Si nunca lo llama, Jasmine nunca sabrá que su prueba está hecha y eventualmente se agotará.

Incluso para las pruebas asíncronas, hay un tiempo de espera que se dispara en estos casos. Puede evitar este error aumentando el valor del tiempo límite límite para evaluar una devolución de llamada asincrónica de 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();
            }
        });
    });
});

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

Este error también puede ser causado por dejar de inyectar al inicializar un servicio / fábrica o lo que sea. Por ejemplo, se puede lanzar haciendo esto:

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

Para solucionarlo, simplemente envuelva la función con inyectar para recuperar correctamente el servicio:

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

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

usar fakeAsync

beforeEach(fakeAsync (() => {

//your code

}));



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

Puedes usar karma-jazmín complemento para establecer el intervalo de tiempo de espera predeterminado globalmente.

Agregue esta configuración en karma.conf.js

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

Este error comenzó de la nada para mí, en una prueba que siempre había funcionado. No pude encontrar ninguna sugerencia que me ayudó hasta que noté que mi Macbook se estaba ejecutando lentamente. Noté que la CPU estaba vinculada por otro proceso, que maté. El error asincrónico de Jasmine desapareció y mis pruebas están bien una vez más.

No me preguntes por qué, no lo sé. Pero en mi circunstancia parecía ser la falta de recursos del sistema la culpa.

Esto es más una observación que una respuesta, pero puede ayudar a otros que estaban tan frustrados como yo.

Seguí recibiendo este error de dos pruebas en mi suite. Pensé que simplemente había roto las pruebas con la refactorización que estaba haciendo, por lo que después de retroceder los cambios no funcionó, volví al código anterior, dos veces (dos revisiones anteriores) pensando que eliminaría el error. Hacerlo no cambió nada. Ayer perseguí mi cola todo el día y parte de esta mañana sin resolver el problema.

Me frustré y revisé el código en una computadora portátil esta mañana. Ejecuté todo el conjunto de pruebas (alrededor de 180 pruebas), sin errores. Entonces los errores nunca estuvieron en el código o en las pruebas. Volví a mi cuadro de desarrollo y lo reinicié para borrar cualquier cosa en la memoria que podría haber estado causando el problema. Sin cambios, los mismos errores en las mismas dos pruebas. Así que eliminé el directorio de mi máquina y lo revisé nuevamente. Voila! Sin errores.

No tengo idea de qué lo causó o cómo solucionarlo, pero eliminar el directorio de trabajo y volver a verificarlo solucionó lo que sea.

Espero que esto ayude a alguien.

No lo use done, solo deje la llamada de función vacía.

¡También obtiene este error cuando espera algo en la beforeAllfunción!

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

    beforeAll(function () {
        ...

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

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

    }
}

En mi caso, este error fue causado por el uso incorrecto de "fixture.detectChanges ()" Parece que este método es un detector de eventos (asíncrono) que solo responderá una devolución de llamada cuando se detecten cambios. Si no se detectan cambios, no invocará la devolución de llamada, lo que provocará un error de tiempo de espera. Espero que esto ayude :)

Funciona después de eliminar la scopereferencia y los argumentos de la función:

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

Como señaló @mastablasta, pero también para agregar que si llama al argumento 'hecho' o más bien lo nombra completado , simplemente llame a la devolución de llamada completada () en su prueba cuando esté hecho.

// 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(){
  //...
});

jazmín.DEFAULT_TIMEOUT_INTERVAL = 100000;

Mantener esto en el bloque resolvió mi problema.

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

Lo que hice fue: Agregué / actualicé el siguiente código:

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

En vez de

beforeEach(() => {..

utilizar

beforeEach(fakeAsync(() => {..

Parece que la prueba está esperando alguna devolución de llamada que nunca llega. Es probable porque la prueba no se ejecuta con un comportamiento asincrónico.

Primero, vea si solo usa fakeAsync en su escenario "it":

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

También puede usar flush()para esperar a que finalice la cola de microTask o tick()para esperar una cantidad de tiempo específica.

Si tiene un argumento ( done) en la itfunción, intente eliminarlo también, se llama dentro de la función en sí:

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