Javascript promise的角茉莉花单元测试

我想写一个单元测试，它只显示创建两个承诺的行为，用$q.all将它们包装成一个，然后测试这两个承诺是否同时得到解决

  describe("Application controller", function() {
    var scope;
    var controller;

    beforeEach(module('my.namespace'));
//this suite can be removed.
    describe("Application ", function() {
        beforeEach(
            inject(function ($rootScope, $controller,$q) {
                scope = $rootScope.$new();
                controller = $controller('Application', {
                    '$scope': scope
                });
            }));


        it("should package two promises into one", function (done) {
            inject(function ($rootScope) {
                setTimeout(function () {
                    $rootScope.$apply(function () {
                        var promiseOne = $q.defer(),
                            //promiseOneData;
                            promiseTwo = $q.defer();
                            //promiseTwoData
                        promiseOne.then(function(data){
                            promiseOne.resolve('promiseOne');
                            expect(1).toBe(1);
                        });
                        promiseTwo.then(function(data){
                            promiseTwoData.resolve('promiseTwo');
                        })
                        var allPromises = $q.all([promiseOne,promiseTwo]);
                        allPromises.then(function(data){
                            //data should contain an array of two empty elements for each promise
                            expect(data.length).toBe(2);
                        });
                        done();
                    });
                }, 1000);


    })
});

---

这样我就得到了错误：

error:Timeout-异步回调没有在jasmine指定的超时内调用。默认的\u Timeout\u INTERVAL。

我不想在这里实际使用get请求，我只需要解决两个承诺，然后移到一个包含这两个承诺的承诺中。我怎样才能用Angular和jasmine做到这一点呢？

你想要的可能是一个间谍，看看它是否被叫来了

describe('test $q', function() {
  var
    $scope;
    $controller;
    $httpBackend;

  beforeEach(function() {
    module('myModule');
    inject(function(_$rootScope_, _$controller_) {
        $scope = _$rootScope_.$new();
        $controller = _$controller_;
        $controller ('MyCtrl', {
          $scope: $scope
        });
    });

  it('should test that $q.all calls callback when dependent promises are resolved', function() {
    var deferOne = $q.defer(),
        deferTwo = $q.defer();
        combinedSpy = jasmine.createSpy('combined');    

    $q.all([deferOne.promise, deferTwo.promise]).then(combinedSpy);

    expect(combinedSpy).toNotHaveBeenCalled();
    deferOne.resolve();
    deferTwo.resolve();
    $scope.apply();
    expect(combinedSpy).toHaveBeenCalled();
  });

这个测试标题很混乱，你不是在模拟承诺。你在考验一个承诺。你不必这么做，Angular本身已经有$q的测试，所以你没有必要为此编写测试

用$q.all将它们包装成一个

这创造了第三个承诺。第三个承诺在承诺A和承诺B都已解决时解决

测试承诺是否同时得到解决

JavaScript是单线程的，不能同时解析它们。第三个承诺是由$q.all（）创建的，将在第一个和第二个承诺都已解决时解决。时间可能会在A和B之间流逝

---

假设A已解决，一小时后B已解决。然后，C（$q.all）将在下一个摘要周期中解析（通过$scope.apply（））。

这是他们粘贴到问题中的OP的答案：

it("Should simulate promise",inject(function($q, $rootScope){
            var deferred = $q.defer();
            var promise = deferred.promise;
            var resolvedValue;
            promise.then(function(value){
                resolvedValue  = value;
            });
            //made no promises yet
            expect(resolvedValue).toBeUndefined();
            var application = {
                id: '123',
                name: 'suebalu',
                database: '234',
                folder: 'c:',
                version: '1.2',
                file: 'previewPubFile',
                date: '2009-01-01'
            };

            deferred.resolve({
                id: '123',
                name: 'suebalu',
                database: '234',
                folder: 'c:',
                version: '1.2',
                file: 'previewPubFile',
                date: '2009-01-01'
            });
            $rootScope.$apply();
            expect(resolvedValue).toEqual(application);
        }));

---

这个答案中有很多是有用的，因为它告诉人们什么是不应该做的；但是这个测试应该是什么样的呢？这才是真正有用的答案，向人们展示他们应该做什么。好吧，他想做的事情是做不到的，那么测试会是什么样子呢？在JS中可以同时做两件事的前提是不正确的。此外，问题还不清楚他真正想要什么，问题也没有改善。测试承诺是否得到了解决通常最好是通过间谍来完成，见这个问题。