Come posso prendere in giro un servizio che restituisce risultati promettenti nel test unitario di AngularJS Jasmine?

Ho myServiceche usi myOtherService, che effettua una chiamata remota, restituendo promessa:

angular.module('app.myService', ['app.myOtherService'])
  .factory('myService', [
    myOtherService,
    function(myOtherService) {
      function makeRemoteCall() {
        return myOtherService.makeRemoteCallReturningPromise();
      }

      return {
        makeRemoteCall: makeRemoteCall
      };      
    }
  ])

Per fare un test di unità per il myServiceHo bisogno di prendere in giro myOtherService, in modo tale che il suo makeRemoteCallReturningPromisemetodo restituisce una promessa. Ecco come lo faccio:

describe('Testing remote call returning promise', function() {
  var myService;
  var myOtherServiceMock = {};

  beforeEach(module('app.myService'));

  // I have to inject mock when calling module(),
  // and module() should come before any inject()
  beforeEach(module(function ($provide) {
    $provide.value('myOtherService', myOtherServiceMock);
  }));

  // However, in order to properly construct my mock
  // I need $q, which can give me a promise
  beforeEach(inject(function(_myService_, $q){
    myService = _myService_;
    myOtherServiceMock = {
      makeRemoteCallReturningPromise: function() {
        var deferred = $q.defer();

        deferred.resolve('Remote call result');

        return deferred.promise;
      }    
    };
  }

  // Here the value of myOtherServiceMock is not
  // updated, and it is still {}
  it('can do remote call', inject(function() {
    myService.makeRemoteCall() // Error: makeRemoteCall() is not defined on {}
      .then(function() {
        console.log('Success');
      });    
  }));  

Come puoi vedere da quanto sopra, la definizione del mio mock dipende da $q, che devo caricare usando inject(). Inoltre, l'iniezione del finto dovrebbe avvenire in module(), che dovrebbe venire prima inject(). Tuttavia, il valore per il mock non viene aggiornato dopo averlo modificato.

Qual è il modo corretto per farlo?

Non sono sicuro del perché il modo in cui lo hai fatto non funziona, ma di solito lo faccio con la spyOnfunzione. Qualcosa come questo:

describe('Testing remote call returning promise', function() {
  var myService;

  beforeEach(module('app.myService'));

  beforeEach(inject( function(_myService_, myOtherService, $q){
    myService = _myService_;
    spyOn(myOtherService, "makeRemoteCallReturningPromise").and.callFake(function() {
        var deferred = $q.defer();
        deferred.resolve('Remote call result');
        return deferred.promise;
    });
  }

  it('can do remote call', inject(function() {
    myService.makeRemoteCall()
      .then(function() {
        console.log('Success');
      });    
  }));

Ricorda inoltre che dovrai effettuare una $digestchiamata per chiamare la thenfunzione. Vedi la sezione Test della documentazione $ q .

------MODIFICARE------

Dopo aver esaminato più da vicino quello che stai facendo, penso di vedere il problema nel tuo codice. Nel beforeEach, stai impostando myOtherServiceMockun oggetto completamente nuovo. Non $providevedrà mai questo riferimento. Hai solo bisogno di aggiornare il riferimento esistente:

beforeEach(inject( function(_myService_, $q){
    myService = _myService_;
    myOtherServiceMock.makeRemoteCallReturningPromise = function() {
        var deferred = $q.defer();
        deferred.resolve('Remote call result');
        return deferred.promise;   
    };
  }

Possiamo anche scrivere l'implementazione del gelsomino della promessa di ritorno direttamente dalla spia.

spyOn(myOtherService, "makeRemoteCallReturningPromise").andReturn($q.when({}));

Per Jasmine 2:

spyOn(myOtherService, "makeRemoteCallReturningPromise").and.returnValue($q.when({}));

(copiato dai commenti, grazie a ccnokes)

describe('testing a method() on a service', function () {    

    var mock, service

    function init(){
         return angular.mock.inject(function ($injector,, _serviceUnderTest_) {
                mock = $injector.get('service_that_is_being_mocked');;                    
                service = __serviceUnderTest_;
            });
    }

    beforeEach(module('yourApp'));
    beforeEach(init());

    it('that has a then', function () {
       //arrange                   
        var spy= spyOn(mock, 'actionBeingCalled').and.callFake(function () {
            return {
                then: function (callback) {
                    return callback({'foo' : "bar"});
                }
            };
        });

        //act                
        var result = service.actionUnderTest(); // does cleverness

        //assert 
        expect(spy).toHaveBeenCalled();  
    });
});

Puoi usare una biblioteca di stub come Sinon per deridere il tuo servizio. È quindi possibile restituire $ q.when () come promessa. Se il valore dell'oggetto scope deriva dal risultato della promessa, dovrai chiamare scope. $ Root. $ Digest ().

var scope, controller, datacontextMock, customer;
  beforeEach(function () {
        module('app');
        inject(function ($rootScope, $controller,common, datacontext) {
            scope = $rootScope.$new();
            var $q = common.$q;
            datacontextMock = sinon.stub(datacontext);
            customer = {id:1};
           datacontextMock.customer.returns($q.when(customer));

            controller = $controller('Index', { $scope: scope });

        })
    });


    it('customer id to be 1.', function () {


            scope.$root.$digest();
            expect(controller.customer.id).toBe(1);


    });

utilizzando sinon:

const mockAction = sinon.stub(MyService.prototype,'actionBeingCalled')
                     .returns(httpPromise(200));

Noto che, httpPromisepuò essere:

const httpPromise = (code) => new Promise((resolve, reject) =>
  (code >= 200 && code <= 299) ? resolve({ code }) : reject({ code, error:true })
);

Onestamente ... stai andando in questo modo nel modo sbagliato facendo affidamento sull'iniezione per deridere un servizio invece del modulo. Inoltre, chiamare inject in beforeEach è un anti-pattern in quanto rende difficile il deridere in base al test.

Ecco come lo farei ...

module(function ($provide) {
  // By using a decorator we can access $q and stub our method with a promise.
  $provide.decorator('myOtherService', function ($delegate, $q) {

    $delegate.makeRemoteCallReturningPromise = function () {
      var dfd = $q.defer();
      dfd.resolve('some value');
      return dfd.promise;
    };
  });
});

Ora, quando inietterai il tuo servizio, avrà un metodo deriso per l'uso.

Ho scoperto che il servizio utile e accoltellato funziona come sinon.stub (). Returns ($ q.when ({})):

this.myService = {
   myFunction: sinon.stub().returns( $q.when( {} ) )
};

this.scope = $rootScope.$new();
this.angularStubs = {
    myService: this.myService,
    $scope: this.scope
};
this.ctrl = $controller( require( 'app/bla/bla.controller' ), this.angularStubs );

Controller:

this.someMethod = function(someObj) {
   myService.myFunction( someObj ).then( function() {
        someObj.loaded = 'bla-bla';
   }, function() {
        // failure
   } );   
};

e prova

const obj = {
    field: 'value'
};
this.ctrl.someMethod( obj );

this.scope.$digest();

expect( this.myService.myFunction ).toHaveBeenCalled();
expect( obj.loaded ).toEqual( 'bla-bla' );

Lo snippet di codice:

spyOn(myOtherService, "makeRemoteCallReturningPromise").and.callFake(function() {
    var deferred = $q.defer();
    deferred.resolve('Remote call result');
    return deferred.promise;
});

Può essere scritto in una forma più concisa:

spyOn(myOtherService, "makeRemoteCallReturningPromise").and.returnValue(function() {
    return $q.resolve('Remote call result');
});