angularjs - simulacro de servicio angular/promesa en una prueba de karma/jazmín

unit-testing karma-runner

Question

Estoy tratando de escribir una prueba de karma / jazmín y me gustaría recibir algunas explicaciones sobre el funcionamiento de los simulacros en un servicio que está devolviendo una promesa. Te explico mi situación:

Tengo un controlador en el que hago la siguiente llamada:

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

    ...

Así es como mi servicio es:

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

})();

Y finalmente, aquí está mi prueba de unidad:

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

Lo que realmente quiero hacer es tener mi objeto de respuesta ({"elementos: ...}) como el parámetro de datos de la función fillMapDatas. No entiendo cómo simular todas las cosas del servicio (servicio, promesa, entonces)

Answer 1

¿Así que quieres probar, si tu servicio responde como se esperaba? Entonces, esto es algo que preferirías probar en el servicio. Los métodos basados ​​en la promesa de prueba de unidad podrían verse así:

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

Como puede ver, no necesita usar $injector , ya que puede inyectar los servicios necesarios directamente. Si desea utilizar los nombres de servicio correctos a lo largo de sus pruebas, puede inyectarlos con el prefijo y el sufijo "_", inject() es lo suficientemente inteligente como para reconocer a qué servicio se refiere. También configuramos la $httpBackend para cada especificación it() . Y configuramos $q $rootScope para su posterior procesamiento.

Aquí es cómo puede probar que su método de servicio devuelve una promesa:

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

Como una promesa siempre tiene un método .then() , podemos verificar si esta propiedad es una promesa o no (por supuesto, otros objetos también podrían tener este método).

A continuación, puede probar la promesa que obtiene resuelve con el valor adecuado. Puede hacer eso configurando un deferred que resuelva explícitamente.

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

¡Espero que esto ayude!