Bagaimana cara mengejek layanan yang mengembalikan janji dalam uji unit AngularJS Jasmine?

saya sudah myService kegunaan itu myOtherService, yang membuat panggilan jarak jauh, mengembalikan janji:

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

      return {
        makeRemoteCall: makeRemoteCall
      };      
    }
  ])

Untuk membuat unit test myService saya perlu mengejek myOtherService, sehingga makeRemoteCallReturningPromisemetodenya memberikan janji. Beginilah cara saya melakukannya:

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

Seperti yang dapat Anda lihat di atas, definisi mock saya tergantung pada $q , yang harus saya muat menggunakan inject(). Selanjutnya, menyuntikkan mock harus terjadi module(), yang harusnya terjadi sebelumnya inject(). Namun, nilai untuk mock tidak diperbarui setelah saya mengubahnya.

Apa cara yang tepat untuk melakukan ini?

Saya tidak yakin mengapa cara Anda melakukannya tidak berhasil, tetapi saya biasanya melakukannya dengan spyOnfungsi. Sesuatu seperti ini:

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

Ingat juga bahwa Anda perlu membuat $digestpanggilan agar thenfungsi dipanggil. Lihat Pengujian bagian dari dokumentasi $ q .

------ EDIT ------

Setelah melihat lebih dekat apa yang Anda lakukan, saya pikir saya melihat masalah dalam kode Anda. Dalam beforeEach, Anda mengatur myOtherServiceMockke objek yang sama sekali baru. Tidak $provideakan pernah melihat referensi ini. Anda hanya perlu memperbarui referensi yang ada:

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

Kita juga bisa menulis implementasi jasmine untuk mengembalikan janji secara langsung oleh mata-mata.

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

Untuk Jasmine 2:

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

(disalin dari komentar, terima kasih kepada 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();  
    });
});

Anda dapat menggunakan pustaka mematikan seperti sinon untuk mengejek layanan Anda. Anda kemudian dapat mengembalikan $ q.when () sebagai janji Anda. Jika nilai objek lingkup Anda berasal dari hasil yang dijanjikan, Anda perlu memanggil lingkup. $ 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);


    });

menggunakan sinon:

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

Diketahui itu, httpPromisebisa berupa:

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

Jujur .. Anda melakukan ini dengan cara yang salah dengan mengandalkan inject untuk mengejek layanan, bukan modul. Juga, memanggil suntikan di beforeEach adalah anti-pola karena membuat mengejek sulit berdasarkan uji.

Inilah cara saya akan melakukan ini ...

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

Sekarang ketika Anda menyuntikkan layanan Anda, itu akan memiliki metode ejekan yang benar untuk penggunaan.

Saya menemukan bahwa fungsi layanan menusuk yang bermanfaat sebagai sinon.stub (). Mengembalikan ($ 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 );

pengontrol:

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

dan uji

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

this.scope.$digest();

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

Cuplikan kode:

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

Dapat ditulis dalam bentuk yang lebih ringkas:

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