jasmine: il callback asincrono non è stato richiamato entro il timeout specificato da jasmine.DEFAULT_TIMEOUT_INTERVAL

Ho un servizio angolare chiamato 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
    };

});

Sto cercando di testare l'unità di questo servizio usando jasmine:

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

Ho letto del supporto asincrono in Jasmine, ma dato che sono piuttosto nuovo ai test unitari con javascript non sono riuscito a farlo funzionare.

Ricevo un errore:

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

e il mio test sta impiegando troppo tempo per essere eseguito (circa 5 secondi).

Qualcuno può aiutarmi a fornire un esempio funzionante del mio codice con qualche spiegazione?

Avere un argomento nella tua itfunzione ( donenel codice seguente) farà provare a una chiamata asincrona a Jasmine.

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

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

Non fa differenza il donenome dell'argomento, la sua esistenza è tutto ciò che conta. Ho riscontrato questo problema da troppa copia / pasta.

I documenti di supporto asincrono Jasmine notano che l'argomento ( donesopra citato) è un callback che può essere chiamato per far sapere a Jasmine quando una funzione asincrona è completa. Se non lo chiami mai, Jasmine non saprà mai che il test è stato eseguito e alla fine scadrà.

Anche per i test asincroni, esiste un timeout che si interrompe in questi casi, è possibile aggirare questo errore aumentando il valore del timeout limite per valutare un callback asincrono di 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

Questo errore può essere causato anche tralasciando l'iniezione durante l'inizializzazione di un servizio / fabbrica o altro. Ad esempio, può essere lanciato in questo modo:

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

Per risolverlo basta avvolgere la funzione con inject per recuperare correttamente il servizio:

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

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

usa fakeAsync

beforeEach(fakeAsync (() => {

//your code

}));



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

È possibile utilizzare il plugin karma-jasmine per impostare l'intervallo di timeout predefinito a livello globale.

Aggiungi questa configurazione in karma.conf.js

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

Questo errore è iniziato all'improvviso per me, su un test che aveva sempre funzionato. Non sono riuscito a trovare alcun suggerimento che mi abbia aiutato fino a quando non ho notato che il mio Macbook funzionava lentamente. Ho notato che la CPU è stata ancorata da un altro processo, che ho ucciso. L'errore asincrono di Jasmine è scomparso e i miei test vanno di nuovo bene.

Non chiedermi perché, non lo so. Ma nelle mie circostanze sembrava essere la mancanza di risorse di sistema in difetto.

Questa è più un'osservazione che una risposta, ma può aiutare gli altri che erano frustrati quanto me.

Ho continuato a ricevere questo errore da due test nella mia suite. Pensavo di aver semplicemente interrotto i test con il refactoring che stavo facendo, quindi dopo il backup delle modifiche non ha funzionato, sono tornato al codice precedente, due volte (due revisioni indietro) pensando che si sarebbe sbarazzato dell'errore. In questo modo non è cambiato nulla. Ho inseguito la coda tutto il giorno ieri e parte di questa mattina senza risolvere il problema.

Sono stato frustrato e ho controllato il codice su un laptop questa mattina. Ha eseguito l'intera suite di test (circa 180 test), senza errori. Quindi gli errori non sono mai stati nel codice o nei test. Sono tornato alla mia casella di sviluppo e lo ho riavviato per cancellare qualsiasi cosa in memoria che potrebbe aver causato il problema. Nessuna modifica, stessi errori negli stessi due test. Quindi ho eliminato la directory dal mio computer e l'ho ricontrollata. Ecco! Nessun errore

Non ho idea di cosa l'abbia causato o di come risolverlo, ma l'eliminazione della directory di lavoro e il suo controllo hanno risolto qualunque cosa fosse.

Spero che questo aiuti qualcuno.

Non usare done, lascia vuota la chiamata di funzione.

Questo errore viene visualizzato anche quando ci si aspetta qualcosa nella beforeAllfunzione!

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

    beforeAll(function () {
        ...

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

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

    }
}

Nel mio caso, questo errore è stato causato dall'uso improprio di "fixture.detectChanges ()" Sembra che questo metodo sia un listener di eventi (asincrono) che risponderà a una richiamata solo quando vengono rilevate modifiche. Se non vengono rilevate modifiche, non verrà richiamato il callback, con conseguente errore di timeout. Spero che questo ti aiuti :)

Funziona dopo aver rimosso il scoperiferimento e gli argomenti della funzione:

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

Come notato da @mastablasta, ma anche per aggiungere che se si chiama l'argomento 'done' o piuttosto il nome è completato , al termine del test è sufficiente chiamare il callback completato ().

// 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;

Mantenere questo nel blocco ha risolto il mio problema.

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

Quello che ho fatto è stato: aggiunto / aggiornato il seguente codice:

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

Invece di

beforeEach(() => {..

uso

beforeEach(fakeAsync(() => {..

Sembra che il test stia aspettando un callback che non arriva mai. È probabile perché il test non viene eseguito con comportamento asincrono.

Per prima cosa, vedi se stai usando fakeAsync nel tuo scenario "it":

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

È inoltre possibile utilizzare flush()per attendere il completamento della coda microTask o tick()per attendere un determinato periodo di tempo.

Se hai un argomento ( done) nella itfunzione prova anche a rimuoverlo, si chiama all'interno della funzione stessa:

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