mock angular service/Versprechen in ein karma/Jasmin-test

Ich bin versucht, zu schreiben, dass das karma/Jasmin-test, und ich möchte einige Erklärungen darüber, wie mocks arbeiten an einem Dienst, die Rückkehr ist ein Versprechen. Ich meine situation erklären :

Ich habe einen controller, in dem ich den folgenden Aufruf : 

mapService.getMapByUuid(mapUUID, isEditor).then(function(datas){
    fillMapDatas(datas);
});

function fillMapDatas(datas){
    if($scope.elements === undefined){
        $scope.elements = [];
    }
 //Here while debugging my unit test, 'datas' contain the promise javascript object instead //of my real reponse.
   debugger;
    var allOfThem = _.union($scope.elements, datas.elements);

    ...

Hier ist, wie mein service ist :

(function () {
'use strict';

var serviceId = 'mapService';

angular.module('onmap.map-module.services').factory(serviceId, [
    '$resource',
    'appContext',
    'restHello',
    'restMap',
    serviceFunc]);

function serviceFunc($resource, appContext, restHello, restMap) {

    var Maps = $resource(appContext+restMap, {uuid: '@uuid', editor: '@editor'});

    return{          
        getMapByUuid: function (uuid, modeEditor) {
            var maps = Maps.get({'uuid' : uuid, 'editor': modeEditor});
            return maps.$promise;
        }
    };
}

})();

Und schließlich, hier ist mein unit-test : 

describe('Map controller', function() {
var $scope, $rootScope, $httpBackend, $timeout, createController, MapService, $resource;

beforeEach(module('onmapApp'));

beforeEach(inject(function($injector) {
    $httpBackend = $injector.get('$httpBackend');
    $rootScope = $injector.get('$rootScope');
    $scope = $rootScope.$new();

    var $controller = $injector.get('$controller');

    createController = function() {
        return $controller('maps.ctrl', {
            '$scope': $scope
        });
    };
}));

afterEach(function() {
    $httpBackend.verifyNoOutstandingExpectation();
    $httpBackend.verifyNoOutstandingRequest();
});

var response = {"elements":[1,2,3]};

it('should allow user to get a map', function() {

    var controller = createController();
    $httpBackend.expect('GET', '/onmap/rest/map/MY-UUID?editor=true')
        .respond({
            "success": response
        });


//hope to call /onmap/rest/map/MY-UUID?editor=true url and hope to have response as the fillMapDatas parameter
    $scope.getMapByUUID('MY-UUID', true); 

    $httpBackend.flush();
});
});

Was ich wirklich tun möchte, ist meine Antwort-Objekt ( {"Elemente:...}), die Daten-parameter der fillMapDatas Funktion. Ich verstehe nicht, wie Sie zu verspotten, alle service Sachen (service, Versprechen, dann)

InformationsquelleAutor der Frage clement | 2014-06-02

  1. 24

    So, das Sie testen möchten, ob Ihre Antworten der Dienste den Erwartungen? Dann ist dies etwas, was Sie lieber test auf den service. Unit-test Versprechen basierte Verfahren könnte wie folgt Aussehen:

    var mapService, $httpBackend, $q, $rootScope;

beforeEach(inject(function (_mapService_, _$httpBackend_, _$q_, _$rootScope_) {
  mapService = mapService;
  $httpBackend = _$httpBackend_;
  $q = _$q_;
  $rootScope = _$rootScope_;

  //expect the actual request
  $httpBackend.expect('GET', '/onmap/rest/map/uuid?editor=true');

  //react on that request
  $httpBackend.whenGET('/onmap/rest/map/uuid?editor=true').respond({
    success: {
      elements: [1, 2, 3]
    }
  });
}));

    Wie Sie sehen können, Sie brauchen nicht zu verwenden $injectorda kann man Spritzen Sie Ihre benötigten services direkt. Wenn Sie wollen, verwenden Sie die richtigen service-Namen, die während Ihres tests können Sie injizieren Sie mit dem Präfix und dem Suffix "_", inject() ist intelligent genug, um zu erkennen, welchen service du meinst. Wir sind auch einrichten die $httpBackend mock für jeden it() spec. Und wir $q und $rootScope für die spätere Verarbeitung.

    Hier, wie Sie das testen könnten, dass Ihre service-Methode gibt ein Versprechen:

    it('should return a promise', function () {
  expect(mapService.getMapUuid('uuid', true).then).toBeDefined();
});

    Seit ein Versprechen hat immer eine .then() Methode können wir überprüfen für Sie diese Eigenschaft zu sehen, ob es ein Versprechen oder nicht (natürlich anderen Objekten haben könnte, diese Methode zu).

    Nächsten test die Versprechen, die Sie bekommen, löst sich mit dem richtigen Wert. Sie können tun, dass das einrichten einer deferred dass Sie explizit lösen.

    it('should resolve with [something]', function () {
  var data;

  //set up a deferred
  var deferred = $q.defer();
  //get promise reference
  var promise = deferred.promise;

  //set up promise resolve callback
  promise.then(function (response) {
    data = response.success;
  });

  mapService.getMapUuid('uuid', true).then(function(response) {
    //resolve our deferred with the response when it returns
    deferred.resolve(response);
  });

  //force `$digest` to resolve/reject deferreds
  $rootScope.$digest();

  //make your actual test
  expect(data).toEqual([something]);
});

    Hoffe, das hilft!

    InformationsquelleAutor der Antwort Pascal Precht

Schreibe einen Kommentar