Angular Promise Example and UT

angular-promise-implement.js

require('1.3.0/angular.min.js');
require('1.3.0/angular-ivpusic-cookie.min.js');
require('django-angular/django-angular.min.js');

(function (angular) {
    var app = angular.module('present-ylly-api-token', ['ipCookie', 'djng.urls']);

    app.factory('present-token-interceptor', ['$injector', '$q', function ($injector, $q) {
        var interceptor = {
            getAuthorizationHeader: function () {
                var ipCookie = $injector.get('ipCookie'),
                    tokenCookieName = $injector.get('API_TOKEN_COOKIE_NAME'),
                    token = ipCookie(tokenCookieName),
                    $http = $injector.get('$http'),
                    yllyTokenRefreshUrl = $injector.get('djangoUrl').reverse('refresh-ylly-api-token');

                if (token) {
                    return "Bearer " + token;
                } else {
                    return $http.get(yllyTokenRefreshUrl, {
                        headers: {
                            "Authorization": undefined
                        }
                    });
                }

            },
            request: function (config) {
                var self = interceptor,
                    deferred = $q.defer(),
                    header;

                config.headers = config.headers || {};
                if (config.headers.hasOwnProperty("Authorization")) {
                    return config;
                }

                header = self.getAuthorizationHeader();

                if (!header.then) {
                    config.headers.Authorization = header;
                    return config;
                }

                header.then(function () {
                    config.headers.Authorization = self.getAuthorizationHeader();
                    deferred.resolve(config);
                }, function () {
                    deferred.resolve(config);
                });

                return deferred.promise;
            },
            responseError: function(response) {
                var error = response.data && response.data.error,
                    $window = $injector.get('$window');

                if (401 === response.status && error && 'NotAuthenticated' === error.code) {
                    $window.location.href = $injector.get('djangoUrl').reverse('core:logout');
                }
            }
        };

        return interceptor;
    }]);
    app.config(['$httpProvider', function ($httpProvider) {
        $httpProvider.interceptors.push('present-token-interceptor');
    }]);
})(angular);

angular-promise-ut.js

require('1.3.0/angular.min.js');
require('1.3.0/angular-mocks.js');
require('./provider.js');

describe('present-token-interceptor Spec', function () {
    var $httpProvider,
        $provide,
        interceptor,
        $http,
        djangoUrl,
        $q,
        $rootScope;

    beforeEach(function () {
        angular.mock.module(function ($injector) {
            $httpProvider = $injector.get('$httpProvider');
            spyOn($httpProvider.interceptors, 'push');
        });
        angular.mock.module('present-ylly-api-token', function (_$provide_) {
            $provide = _$provide_;
        });
        inject(function ($injector) {
            interceptor = $injector.get('present-token-interceptor');
            $http = $injector.get('$http');
            djangoUrl = $injector.get('djangoUrl');
            $q = $injector.get('$q');
            $rootScope = $injector.get('$rootScope');
        });
    });

    it('test config', function () {
        expect($httpProvider.interceptors.push).toHaveBeenCalledWith('present-token-interceptor');
    });

    it('test getAuthorizationHeader when token exist in cookie', function () {
        var ipCookieInstanceSpy = jasmine.createSpy('ipCookie instance spy').and.returnValue('fake_token'),
            ipCookieSpy = jasmine.createSpy('ipCookie spy').and.returnValue(ipCookieInstanceSpy);

        $provide.service('ipCookie', ipCookieSpy);
        $provide.constant('API_TOKEN_COOKIE_NAME', 'fake_token_cookie_name');
        expect(interceptor.getAuthorizationHeader()).toBe('Bearer fake_token');
        expect(ipCookieSpy).toHaveBeenCalled();
        expect(ipCookieInstanceSpy).toHaveBeenCalledWith('fake_token_cookie_name');
    });

    it('test getAuthorizationHeader when token not exist in cookie', function () {
        var ipCookieInstanceSpy = jasmine.createSpy('ipCookie instance spy').and.returnValue(undefined),
            ipCookieSpy = jasmine.createSpy('ipCookie spy').and.returnValue(ipCookieInstanceSpy);

        spyOn($http, 'get').and.returnValue('http get promise');
        spyOn(djangoUrl, 'reverse').and.returnValue('fake_refresh_url');

        $provide.service('ipCookie', ipCookieSpy);
        $provide.constant('API_TOKEN_COOKIE_NAME', 'fake_token_cookie_name');
        expect(interceptor.getAuthorizationHeader()).toBe('http get promise');
        expect(ipCookieSpy).toHaveBeenCalled();
        expect(ipCookieInstanceSpy).toHaveBeenCalledWith('fake_token_cookie_name');
        expect(djangoUrl.reverse).toHaveBeenCalledWith('refresh-ylly-api-token');
        expect($http.get).toHaveBeenCalledWith('fake_refresh_url', {
            headers: {
                "Authorization": undefined
            }
        });
    });

    it('test request when headers exist Authorization', function () {
        var mockConfig = {
            headers: {
                Authorization: undefined
            }
        };

        expect(interceptor.request(mockConfig)).toBe(mockConfig);
    });

    it('test request when headers not exist Authorization but token exist in cookie', function () {
        var mockConfig = {
            headers: {}
        };

        spyOn(interceptor, 'getAuthorizationHeader').and.returnValue('fake token header');
        expect(interceptor.request(mockConfig)).toEqual({
            headers: {
                Authorization: 'fake token header'
            }
        });
    });

    it('test request when request token from server success', function () {
        var mockConfig = {
            headers: {}
        },
            httpDeferred = $q.defer(),
            requestPromise;

        spyOn(interceptor, 'getAuthorizationHeader').and.returnValues(httpDeferred.promise, 'fake token header');

        requestPromise = interceptor.request(mockConfig);
        expect(typeof requestPromise).toBe(typeof httpDeferred.promise);

        httpDeferred.resolve();
        $rootScope.$apply();

        expect(mockConfig).toEqual({
            headers: {
                Authorization: 'fake token header'
            }
        });
    });

    it('test request when request token from server failed', function () {
        var mockConfig = {
            headers: {}
        },
            httpDeferred = $q.defer(),
            requestPromise;

        spyOn(interceptor, 'getAuthorizationHeader').and.returnValues(httpDeferred.promise, 'fake token header');

        requestPromise = interceptor.request(mockConfig);
        expect(typeof requestPromise).toBe(typeof httpDeferred.promise);

        httpDeferred.reject();
        $rootScope.$apply();

        expect(mockConfig).toEqual({
            headers: {}
        });
    });

    it('test responseError', function () {
        var mockError = {
            status: 401,
            data: {
                error: {
                    code: 'NotAuthenticated'
                }
            }
        },
            mockWindow = {
                location: {
                    href: '/'
                }
            };

        spyOn(djangoUrl, 'reverse').and.returnValue('login_page_url');
        $provide.constant('$window', mockWindow);
        interceptor.responseError(mockError);

        expect(djangoUrl.reverse).toHaveBeenCalledWith('core:logout');
        expect(mockWindow.location.href).toBe('login_page_url');
    });
});