0

我有一个称为返回承诺的服务，以及一个使用不同参数myHttp调用两次的控制器。myHttp

为了测试控制器，我尝试myHttp使用 Jasmine spyOn 进行模拟，如下所示：

  beforeEach(inject(function($controller, _$rootScope_, _$q_, myHttp) {
    $scope = _$rootScope_.$new();
    $q = _$q_;
    deferred = $q.defer();
    deferred2 = $q.defer();
    spyOn(myHttp, 'call').and.callFake(fake(1)).and.returnValue(deferred.promise);
    spyOn(myHttp, 'call').and.callFake(fake(2)).and.returnValue(deferred2.promise);

wherefake是检索要在myHttp调用中使用的参数的函数。

问题是我不能声明两次相同的模拟函数。我从 Jasmine 收到以下错误：

错误：呼叫已被监视

如何解决这个测试？这是PLUNK

Javascript：

angular.module("mymodule", [])

.service('myHttp', function($http,$q){
    this.call = function(obj) {
        var defer = $q.defer();
        $http({url:obj.url, data:obj.data})
              .then(function (response) {
                  defer.resolve(response);
              });
        return defer.promise;
    };
})

.controller('ctl', function($scope,myHttp) {
      $scope.read = function (id){
          var data = {};
          data.id = id;
          myHttp.call({url:'/getStudent', data:data})
              .then(function(response) {
                  $scope.id = response.id;
                  $scope.name = response.nm;
                  $scope.classId = response.clsid; 

                  var data2 = {};
                  data2.id = $scope.classId;
                  myHttp.call({url:'/getClass', data:data2})
                      .then(function(response) {
                          $scope.className = response.nm;
                  });
              });
     };
});



describe('Testing a Controller that uses a Promise', function () {
  var $scope;
  var $q;
  var deferred;
  var $timeout;

  beforeEach(module('mymodule'));

  beforeEach(inject(function($controller, _$rootScope_, _$q_, myHttp) {
    $scope = _$rootScope_.$new();
    $q = _$q_;
    deferred = $q.defer();
    deferred2 = $q.defer();
    spyOn(myHttp, 'call').and.callFake(fake(1)).and.returnValue(deferred.promise);
    spyOn(myHttp, 'call').and.callFake(fake(2)).and.returnValue(deferred2.promise);

    $controller('ctl', { 
      $scope: $scope, 
      myHttp: myHttp
    });

    $scope.read(1)

  }));

  function fake (option) {
    if (option==1)
       return {url:'/getStudent', data: {id: 1}};
    else
       return {url:'/getClass', data: {id: 10}};
  }

  it('should resolve two promises', function () {

    var student = {
      id: 1,
      nm: "John",
      clsid: 10
    };

    var clazz = {
      id: 10,
      nm: "Math"
    };

    deferred.resolve(student);
    $scope.$apply();

    deferred2.resolve(clazz);
    $scope.$apply();

    expect($scope.id).toBe(student.id);
    expect($scope.name).toBe(student.nm);
    expect($scope.classId).toBe(student.clsid);
    expect($scope.className).toBe(clazz.nm);
  });

});
4

2 回答 2

1

只需监视myHttp.call一次并更改您的假函数调用以接收请求参数并根据请求返回一个对象。

var student = {
  id: 1,
  nm: "John",
  clsid: 10
};

var clazz = {
  id: 10,
  nm: "Math"
};

spyOn(myHttp, 'call').and.callFake(function(obj) {
  if (obj.url == '/getStudent') {
    return $q.when(student);
  } else if (obj.url = '/getClass') {
    return $q.when(clazz);
  }
  return $q.reject('Mock not supported');
});

有关完整的工作示例，请参见plunker。

作为一个方面，你的 http 调用减少到只是

.service('myHttp', function($http,$q){
    this.call = function(obj) {
        return $http({url:obj.url, data:obj.data});
    };
})

因为$http已经返回了一个承诺。

此外，您还可以使用 angular$httpBackend来模拟您的 http 调用，而不是使用 jasmine spyon。请参阅此 plunker，其使用$httpBackend稍作更改myHttp.call。

于 2017-01-18T00:09:45.553 回答
0

非常普遍的答案是您不必在顶层 beforeEach 中创建您的间谍。您可以使用更接近个人规范的 beforeEach ，甚至可以在 it 语句中创建间谍。您还可以检查您的假货中的某些内容，以根据调用假货的参数来查看您想要返回的承诺。

但是，您实际上想要检查什么条件？通常在 promise 解决后应该发生一些事情，而你真的想看看。如果您最终说出您的目标是什么，而不是说出您认为正确的解决方案并询问我们如何实现，那么给您具体的反馈会更容易。

另请参阅$q.defer：你做错了

于 2017-01-17T23:21:35.583 回答