AngularJS $q promise resolved flag

gistfile1.js

'use strict';

angular.module('testQDecorator', [])
    .config(function($provide) {
        $provide.decorator('$q', function($delegate) {
            function decoratePromise(promise) {
                var then = promise.then;
                promise.resolved = false;
                promise.finally(function() {
                    promise.resolved = true;
                });
                promise.then = function() {
                    var p = then.apply(this, arguments);
                    return decoratePromise(p);
                };
                return promise;
            }

            var defer = $delegate.defer,
                when = $delegate.when,
                reject = $delegate.reject,
                all = $delegate.all;
            $delegate.defer = function() {
                var deferred = defer();
                decoratePromise(deferred.promise);
                return deferred;
            };
            $delegate.when = function() {
                var p = when.apply(this, arguments);
                return decoratePromise(p);
            };
            $delegate.reject = function() {
                var p = reject.apply(this, arguments);
                return decoratePromise(p);
            };
            $delegate.all = function() {
                var p = all.apply(this, arguments);
                return decoratePromise(p);
            };

            return $delegate;
        });
    }).run();

describe('Promise resolved test', function() {

    beforeEach(module('testQDecorator'));
    var $rootScope,
        $q;

    beforeEach(inject(function($injector) {
        $q = $injector.get('$q');
        $rootScope = $injector.get('$rootScope');
    }));

    describe('$q promises', function() {

        it('should have resolved property', function() {
            var deferred = $q.defer(),
                p = deferred.promise;
            expect(p.resolved).toBe(false);
            deferred.resolve(true);
            $rootScope.$apply();
            expect(p.resolved).toBe(true);
        });

        it('promise.then should have resolved property', function() {
            var deferred = $q.defer(),
                p = deferred.promise.then(function() {});
            expect(p.resolved).toBe(false);
            deferred.resolve(true);
            $rootScope.$apply();
            expect(p.resolved).toBe(true);
        });

        it('promise.catch should have resolved property', function() {
            var deferred = $q.defer(),
                p = deferred.promise.catch(function() {});
            expect(p.resolved).toBe(false);
            deferred.resolve(true);
            $rootScope.$apply();
            expect(p.resolved).toBe(true);
        });

        it('promise.finally should have resolved property', function() {
            var deferred = $q.defer(),
                p = deferred.promise.finally(function() {});
            expect(p.resolved).toBe(false);
            deferred.resolve(true);
            $rootScope.$apply();
            expect(p.resolved).toBe(true);
        });
    });


    describe('$http promises', function() {
        var $http,
            $httpBackend;

        beforeEach(inject(function($injector) {
            $http = $injector.get('$http');
            $httpBackend = $injector.get('$httpBackend');
        }));

        afterEach(function() {
            $httpBackend.verifyNoOutstandingExpectation();
            $httpBackend.verifyNoOutstandingRequest();
        });

        it('should have resolved property', function() {
            var p;
            $httpBackend.expectPOST('/test/1').respond(200);
            p = $http({
                method: 'post',
                url: '/test/1'
            });
            expect(p.resolved).toBe(false);
            $httpBackend.flush();
            expect(p.resolved).toBe(true);
        });

        it('promise.then() should have resolved property', function() {
            var p;
            $httpBackend.expectPOST('/test/1').respond(200);
            p = $http({
                method: 'post',
                url: '/test/1'
            }).then(function() {});
            expect(p.resolved).toBe(false);
            $httpBackend.flush();
            expect(p.resolved).toBe(true);
        });

        it('promise.finally() should have resolved property', function() {
            var p;
            $httpBackend.expectPOST('/test/1').respond(200);
            p = $http({
                method: 'post',
                url: '/test/1'
            }).finally(function() {});
            expect(p.resolved).toBe(false);
            $httpBackend.flush();
            expect(p.resolved).toBe(true);
        });

        it('promise.catch() should have resolved property', function() {
            var p;
            $httpBackend.expectPOST('/test/1').respond(200);
            p = $http({
                method: 'post',
                url: '/test/1'
            }).catch(function() {});
            expect(p.resolved).toBe(false);
            $httpBackend.flush();
            expect(p.resolved).toBe(true);
        });

    });
});