So testen Sie das getan und scheitern Deferred-Objekt mit Jasmin

Wir tatsächlich lief in das gleiche problem, versuchen zu testen, Latente Objekte AJAXed Vorlage scripts für on-the-fly-templating. Unser Test-Lösung umfasst die Verwendung der Jasmin-Ajax Bibliothek in Verbindung mit Jasmin selbst.

Also wahrscheinlich wird es so etwas wie dieses:

describe('When Submit button handler fired', function () {
  jasmine.Ajax.useMock();

  describe('if the message is empty', function () {

    beforeEach(function() {
      spyOn(backendController, 'submitForm').andCallThrough();
      //replace with wherever your callbacks are defined
      spyOn(this, 'onSuccess');
      spyOn(this, 'onFailure');
      this.view.$el.find('#message').text('');
      this.view.$el.find('form').submit();
    });

    it('backendController.submitForm and fail Deferred Object should be called', function () {
      expect(backendController.submitForm).toHaveBeenCalledWith('');
      mostRecentAjaxRequest().response({
        status: 500, //or whatever response code you want
        responseText: ''
      });

      expect( this.onSuccess ).not.toHaveBeenCalled();
      expect( this.onFailure ).toHaveBeenCalled();
    });
});

Andere Sache, wenn Sie können, versuchen Sie brechen die Funktionalität, so dass Sie nicht die Prüfung der gesamten DOM-zu-Antwort-callback-Pfad in einem test. Wenn Sie granular genug sind, können Sie tatsächlich testen asynchronen Latente Auflösungen durch Verwendung der Zurückgestellten Objekte, die sich in Ihren tests!

Der Schlüssel ist, um tatsächlich Latente Objekte in Ihre tests selbst, so dass der Anwendungsbereich der expect Anruf noch innerhalb Ihrer it Funktion blockieren.

describe('loadTemplate', function() {
  it('passes back the response text', function() {
    jasmine.Ajax.mock();
    loadTemplate('template-request').done(function(response) {
      expect(response).toBe('foobar');
    });
    mostRecentAjaxRequest().response({ status:200, responseText:'foobar' });
  });
});

InformationsquelleAutor Aintaer

Wäre es viel einfacher zu testen, wenn Sie hatte eine var mit dem ajax-request promise-Objekt. In diesem Fall können Sie tun:

 it('should do an async thing', function() {     
   var mutex = 1;
   var promF = jasmine.createSpy('prF');

   runs( function() {
     var promise1 = $.ajax();
     promise1.always(function(){
       mutex--;
     });
     promise1.fail(function(){
       promF();
     });
   });

   waitsFor(function(){
     return !mutex;
   }, 'Fetch should end', 10000);

   runs( function() {
      expect(promF).toHaveBeenCalled();
   });
 });

Unten poste ich noch ungetestete code, der möglicherweise zu Ihnen passen. Ich nehme an, dass der ajax-Aufruf initialisiert .submit() der Klasse? Vielleicht sollten Sie die Initialisierung der ajax-request von einem läuft () - block und nicht von beforeEach(), aber Sie sollten versuchen, mit den man arbeitet.

describe('When Submit button handler fired and city is defined', function () {
    var ajaxRequestSpy,
        failSpy, successSpy, alwaysSpy,
        mutex;
    beforeEach(function () {
        ajaxRequestSpy = spyOn(backendController, 'ajaxRequest').andCallThrough();
        failSpy = spyOn(ajaxRequestSpy(), 'fail').andCallThrough()
        successSpy = spyOn(ajaxRequestSpy(), 'success').andCallThrough();
        mutex = 1; //num of expected ajax queries
        alwaysSpy =  spyOn(ajaxRequestSpy(), 'always').andCallFake(function() {
             mutex--;
        });
        this.view = new MyView({
            el: $('<div><form>' +
                '<input type="submit" value="Submit" />' +
                '<input type="text" name="city">' +
                '</form></div>')
        });
        this.view.$el.find('form').submit();
    });
    it('backendController.ajaxRequest should be called', function () {
        runs( function() {
            //maybe init ajax here ?   
        });

        waitsFor( function() {
            return !mutex;
        }, 'ajax request should happen', 5000);

        runs( function() {
            expect(ajaxRequestSpy).toHaveBeenCalled(); //true
            expect(failSpy).toHaveBeenCalled(); //Error: Expected spy fail 
                                            //to have been called.
        });

    });
});

Aber ich bin nicht sicher, dass die Zeile

failSpy = spyOn(ajaxRequestSpy(), 'fail').andCallThrough();

tut, was Sie wollen. Ist es möglich, Spion auf einem anderen Spion? Und wenn ja, warum fordern Sie die spy ? Vielleicht sollten Sie versuchen,

failSpy = spyOn(ajaxRequestSpy, 'fail').andCallThrough();

InformationsquelleAutor basos