Jasmin: Der asynchrone Rückruf wurde nicht innerhalb des von jasmine.DEFAULT_TIMEOUT_INTERVAL angegebenen Zeitlimits aufgerufen

Ich habe einen Winkelservice namens 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
    };

});

Ich versuche, diesen Dienst mit Jasmin zu testen:

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

Ich habe über die asynchrone Unterstützung in Jasmine gelesen, aber da ich noch nicht mit Unit-Tests mit Javascript vertraut bin, konnte dies nicht funktionieren.

Ich erhalte eine Fehlermeldung:

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

und mein Test dauert zu lange (ca. 5s).

Kann mir jemand helfen, ein funktionierendes Beispiel für meinen Code mit einer Erklärung zu liefern?

Wenn Sie ein Argument in Ihrer itFunktion haben ( doneim folgenden Code), versucht Jasmine einen asynchronen Aufruf.

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

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

Es macht keinen Unterschied, wie das doneArgument benannt wird, seine Existenz ist alles, was zählt. Ich bin auf dieses Problem durch zu viele Kopien / Nudeln gestoßen.

In den Dokumenten zur asynchronen Unterstützung von Jasmine wird darauf hingewiesen, dass das doneoben genannte Argument ein Rückruf ist, der aufgerufen werden kann, um Jasmine über den Abschluss einer asynchronen Funktion zu informieren. Wenn Sie es nie anrufen, wird Jasmine nie wissen, dass Ihr Test abgeschlossen ist, und wird irgendwann eine Zeitüberschreitung haben.

Selbst bei asynchronen Tests tritt in diesem Fall eine Zeitüberschreitung auf. Sie können diesen Fehler umgehen, indem Sie den Wert für die Grenzzeitüberschreitung erhöhen, um einen asynchronen Jasmine-Rückruf auszuwerten

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

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

Dieser Fehler kann auch dadurch verursacht werden, dass beim Initialisieren eines Service / einer Fabrik oder was auch immer die Injektion weggelassen wird. Zum Beispiel kann es folgendermaßen geworfen werden:

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

Um dies zu beheben, schließen Sie die Funktion einfach mit inj ein, um den Dienst ordnungsgemäß abzurufen:

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

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

benutze fakeAsync

beforeEach(fakeAsync (() => {

//your code

}));



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

Sie können Karma-Jasmin verwenden Plugin verwenden, um das Standard-Timeout-Intervall global festzulegen.

Fügen Sie diese Konfiguration in karma.conf.js hinzu

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

Dieser Fehler begann für mich aus heiterem Himmel bei einem Test, der immer funktioniert hatte. Ich konnte keine Vorschläge finden, die mir halfen, bis ich bemerkte, dass mein Macbook nur schleppend lief. Ich bemerkte, dass die CPU an einen anderen Prozess gebunden war, den ich beendet hatte. Der Jasmine-Async-Fehler ist verschwunden und meine Tests sind wieder in Ordnung.

Frag mich nicht warum, ich weiß es nicht. Aber unter meinen Umständen schien es ein Mangel an fehlerhaften Systemressourcen zu sein.

Dies ist eher eine Beobachtung als eine Antwort, aber es kann anderen helfen, die genauso frustriert waren wie ich.

Ich habe diesen Fehler immer wieder von zwei Tests in meiner Suite erhalten. Ich dachte, ich hätte die Tests mit dem von mir durchgeführten Refactoring einfach abgebrochen. Nachdem das Zurücksetzen von Änderungen nicht funktioniert hatte, kehrte ich zweimal (zwei Revisionen zurück) zu früherem Code zurück und dachte, der Fehler würde dadurch behoben. Dies änderte nichts. Ich habe gestern den ganzen Tag meinen Schwanz gejagt und einen Teil dieses Morgens, ohne das Problem zu lösen.

Ich war frustriert und habe heute Morgen den Code auf einem Laptop überprüft. Lief die gesamte Testsuite (ca. 180 Tests), keine Fehler. Die Fehler waren also nie im Code oder in den Tests. Ging zurück zu meiner Entwicklungsbox und startete sie neu, um alles im Speicher zu löschen, was das Problem verursacht haben könnte. Keine Änderung, gleiche Fehler bei den gleichen beiden Tests. Also habe ich das Verzeichnis von meinem Computer gelöscht und es wieder ausgecheckt. Voila! Keine Fehler.

Keine Ahnung, was es verursacht hat oder wie es behoben werden kann, aber das Löschen des Arbeitsverzeichnisses und das erneute Auschecken haben das Problem behoben.

Hoffe das hilft jemandem.

Nicht verwenden done, einfach den Funktionsaufruf leer lassen.

Sie erhalten diesen Fehler auch, wenn Sie etwas in der beforeAllFunktion erwarten !

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

    beforeAll(function () {
        ...

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

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

    }
}

In meinem Fall wurde dieser Fehler durch die missbräuchliche Verwendung von "fixture.detectChanges ()" verursacht. Es scheint, dass diese Methode ein Ereignis-Listener (asynchron) ist, der nur dann auf einen Rückruf reagiert, wenn Änderungen erkannt werden. Wenn keine Änderungen festgestellt werden, wird der Rückruf nicht aufgerufen, was zu einem Timeout-Fehler führt. Hoffe das hilft :)

Funktioniert nach dem Entfernen der scopeReferenz und der Funktionsargumente:

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

Wie von @mastablasta bemerkt, aber um hinzuzufügen, dass Sie, wenn Sie das Argument 'done' aufrufen oder es als abgeschlossen bezeichnen , einfach den Rückruf complete () in Ihrem Test aufrufen, wenn es fertig ist.

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

Dies im Block zu belassen, löste mein Problem.

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

Was ich getan habe war: Den folgenden Code hinzugefügt / aktualisiert:

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

Anstatt

beforeEach(() => {..

verwenden

beforeEach(fakeAsync(() => {..

Es sieht so aus, als würde der Test auf einen Rückruf warten, der niemals kommt. Dies liegt wahrscheinlich daran, dass der Test nicht mit asynchronem Verhalten ausgeführt wird.

Überprüfen Sie zunächst, ob Sie in Ihrem "it" -Szenario nur fakeAsync verwenden:

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

Sie können auch flush()warten, bis die microTask-Warteschlange beendet ist, oder tick()eine bestimmte Zeit warten.

Wenn Sie ein Argument ( done) in der itFunktion haben, versuchen Sie es ebenfalls zu entfernen. Der Aufruf erfolgt innerhalb der Funktion selbst:

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