Testowanie jednostki Usługa kątowa korzystająca z opcji Timeout z Jockine Mock Clock

Question

Mam funkcję wewnątrz jednej z moich usług kątowych, którą chciałbym wywoływać wielokrotnie w regularnych odstępach czasu. Chciałbym to zrobić za pomocą $ timeout. Wygląda to mniej więcej tak:

var interval = 1000; // Or something 

var _tick = function() { 
    $timeout(function() { 
     doStuff(); 
     _tick(); 
    }, interval); 
}; 

_tick(); 

jestem zakłopotany, jak ten z testów jednostkowych Jasmine w tej chwili - jak to zrobić? Jeśli używam $timeout.flush(), wywołania funkcji pojawiają się w nieskończoność. Jeśli użyję fałszywego zegara Jasmine, to wydaje się, że nie ma to wpływu na $timeout. Zasadniczo, jeśli mogę dostać tej pracy, powinien być dobry, aby przejść:

describe("ANGULAR Manually ticking the Jasmine Mock Clock", function() { 
    var timerCallback, $timeout; 

    beforeEach(inject(function($injector) { 
     $timeout = $injector.get('$timeout'); 
     timerCallback = jasmine.createSpy('timerCallback'); 
     jasmine.Clock.useMock(); 
    })); 

    it("causes a timeout to be called synchronously", function() { 
     $timeout(function() { 
      timerCallback(); 
     }, 100); 
     expect(timerCallback).not.toHaveBeenCalled(); 
     jasmine.Clock.tick(101); 
     expect(timerCallback).toHaveBeenCalled(); 
    }); 
}); 

Te dwa warianty pracy, ale nie może mi pomóc:

describe("Manually ticking the Jasmine Mock Clock", function() { 
    var timerCallback; 

    beforeEach(function() { 
     timerCallback = jasmine.createSpy('timerCallback'); 
     jasmine.Clock.useMock(); 
    }); 

    it("causes a timeout to be called synchronously", function() { 
     setTimeout(function() { 
      timerCallback(); 
     }, 100); 
     expect(timerCallback).not.toHaveBeenCalled(); 
     jasmine.Clock.tick(101); 
     expect(timerCallback).toHaveBeenCalled(); 
    }); 
}); 

describe("ANGULAR Manually flushing $timeout", function() { 
    var timerCallback, $timeout; 

    beforeEach(inject(function($injector) { 
     $timeout = $injector.get('$timeout'); 
     timerCallback = jasmine.createSpy('timerCallback'); 
    })); 

    it("causes a timeout to be called synchronously", function() { 
     $timeout(function() { 
      timerCallback(); 
     }, 100); 
     expect(timerCallback).not.toHaveBeenCalled(); 
     $timeout.flush(); 
     expect(timerCallback).toHaveBeenCalled(); 
    }); 
}); 

Z góry dzięki!

Answer 1

Nie twórz testu Async używając zegara Jasmine. Zamiast tego użyj $timeout.flush(), aby synchronicznie utrzymać przepływ testu. Konfiguracja może być nieco trudna, ale gdy ją zdobędziesz, twoje testy będą szybsze i bardziej kontrolowane.

Oto przykład testu, który robi to za pomocą tego podejścia: https://github.com/angular/angular.js/blob/master/test/ngAnimate/animateSpec.js#L618

Answer 2

@ odpowiedź matsko doprowadził mnie w dół właściwą drogę. Pomyślałem, że opublikuję moje "kompletne" rozwiązanie, aby ułatwić znalezienie odpowiedzi.

Rzecz przetestować

angular.module("app").service("MyService", function() { 
    return { 
     methodThatHasTimeoutAndReturnsAPromise: function($q, $timeout) { 
      var deferred = $q.defer(); 
      $timeout(function() { 
       deferred.resolve(5); 
      }, 2000); 
      return deferred.promise; 
     } 
    }; 
}); 

Test

describe("MyService", function() { 
    var target, 
     $timeout; 
    beforeEach(inject(function(_$timeout_, MyService) { 
     $timeout = _$timeout_; 
     target = MyService; 
    })); 
    beforeEach(function(done) { 
     done(); 
    }); 
    it("equals 5", function(done) { 
     target.methodThatHasTimeoutAndReturnsAPromise().then(function(value) { 
      expect(value).toBe(5); 
      done(); 
     }); 
     $timeout.flush(); 
    }); 
});