beforeEach(inject((_accountModel_: AccountModel, _$httpBackend_: angular.IHttpBackendService, _$http_: angular.IHttpService, _$cacheFactory_: CacheFactoryMock, _ogLruCacheFactory_: OgLruCacheFactoryMock, _account_: Account): void => {
		accountModel = _accountModel_;
		$httpBackend = _$httpBackend_;
		$http = _$http_;
		account = _account_;

		const	$cacheFactory: CacheFactoryMock = _$cacheFactory_,
					ogLruCacheFactory: OgLruCacheFactoryMock = _ogLruCacheFactory_;

		$cache = $cacheFactory();
		ogLruCache = ogLruCacheFactory.new();
	}));

	beforeEach(inject((_securityModel_: SecurityModel, _$httpBackend_: angular.IHttpBackendService, _$http_: angular.IHttpService, $cacheFactory: CacheFactoryMock, ogLruCacheFactory: OgLruCacheFactoryMock): void => {
		securityModel = _securityModel_;

		$httpBackend = _$httpBackend_;
		$http = _$http_;

		$cache = $cacheFactory();
		ogLruCache = ogLruCacheFactory.new();

		security = createSecurity({id: 1});
	}));

	beforeEach(inject((_payeeModel_: PayeeModel, _$httpBackend_: angular.IHttpBackendService, _$http_: angular.IHttpService, $cacheFactory: CacheFactoryMock, ogLruCacheFactory: OgLruCacheFactoryMock): void => {
		payeeModel = _payeeModel_;

		$httpBackend = _$httpBackend_;
		$http = _$http_;

		$cache = $cacheFactory();
		ogLruCache = ogLruCacheFactory.new();

		payee = createPayee({id: 1});
	}));

	beforeEach(inject((_authenticationModel_: AuthenticationModel, _$httpBackend_: angular.IHttpBackendService, _$http_: angular.IHttpService, _$cacheFactory_: CacheFactoryMock, _$window_: WindowMock): void => {
		authenticationModel = _authenticationModel_;

		$httpBackend = _$httpBackend_;
		$http = _$http_;

		$cacheFactory = _$cacheFactory_;
		$cache = $cacheFactory();

		$window = _$window_;
	}));

describe("authenticationModel", (): void => {
	let	authenticationModel: AuthenticationModel,
			$httpBackend: angular.IHttpBackendService,
			$http: angular.IHttpService,
			$cacheFactory: CacheFactoryMock,
			$cache: angular.ICacheObject,
			$window: WindowMock;

	// Load the modules
	beforeEach(angular.mock.module("lootMocks", "lootAuthentication", (mockDependenciesProvider: MockDependenciesProvider): void => mockDependenciesProvider.load(["$cacheFactory", "$window"])));

	// Inject the object under test and the $httpBackend
	beforeEach(inject((_authenticationModel_: AuthenticationModel, _$httpBackend_: angular.IHttpBackendService, _$http_: angular.IHttpService, _$cacheFactory_: CacheFactoryMock, _$window_: WindowMock): void => {
		authenticationModel = _authenticationModel_;

		$httpBackend = _$httpBackend_;
		$http = _$http_;

		$cacheFactory = _$cacheFactory_;
		$cache = $cacheFactory();

		$window = _$window_;
	}));

	// After each spec, verify that there are no outstanding http expectations or requests
	afterEach((): void => {
		$httpBackend.verifyNoOutstandingExpectation();
		$httpBackend.verifyNoOutstandingRequest();
	});

	describe("SESSION_STORAGE_KEY", (): void => {
		it("should be 'lootAuthenticationKey'", (): Chai.Assertion => authenticationModel["SESSION_STORAGE_KEY"].should.equal("lootAuthenticationKey"));
	});

	describe("isAuthenticated", (): void => {
		let isAuthenticated: boolean;

		it("should fetch the authentication key from sessionStorage", (): void => {
			({isAuthenticated} = authenticationModel);
			$window.sessionStorage.getItem.should.have.been.calledWith("lootAuthenticationKey");
		});

		describe("when authenticated", (): void => {
			beforeEach((): SinonStub => $window.sessionStorage.getItem.returns("authentication key"));

			it("should set the default $http Authorization header", (): void => {
				$http.defaults = {};
				({isAuthenticated} = authenticationModel);
				($http.defaults.headers as angular.IHttpRequestConfigHeaders).common.Authorization.should.equal("Basic authentication key");
			});

			it("should update the default $http Authorization header", (): void => {
				$http.defaults.headers = {common: {Authorization: ""}};
				({isAuthenticated} = authenticationModel);
				$http.defaults.headers.common.Authorization.should.equal("Basic authentication key");
			});

			it("should be true", (): void => {
				({isAuthenticated} = authenticationModel);
				isAuthenticated.should.be.true;
			});
		});

		describe("when not authenticated", (): void => {
			it("should be false", (): Chai.Assertion => authenticationModel.isAuthenticated.should.be.false);
		});
	});

	describe("login", (): void => {
		beforeEach((): void => {
			$httpBackend.expectPOST(/logins/, "", (headers: angular.IHttpRequestConfigHeaders): boolean => "Basic base64 encoded" === headers.Authorization).respond(200, "authentication key");
			authenticationModel.login("username", "password");
			$httpBackend.flush();
		});

		it("should dispatch a POST request to /logins, containing an Authorization header", (): null => null);

		it("should save the authentication key to sessionStorage", (): Chai.Assertion => $window.sessionStorage.setItem.should.have.been.calledWith("lootAuthenticationKey", "base64 encoded"));

		it("should set the default $http Authorization header", (): Chai.Assertion => ($http.defaults.headers as angular.IHttpRequestConfigHeaders).common.Authorization.should.equal("Basic base64 encoded"));
	});

	describe("logout", (): void => {
		beforeEach((): void => authenticationModel.logout());

		it("should remove the authentication key from sessionStorage", (): Chai.Assertion => $window.sessionStorage.removeItem.should.have.been.calledWith("lootAuthenticationKey"));

		it("should clear the default $http Authorization header", (): Chai.Assertion => ($http.defaults.headers as angular.IHttpRequestConfigHeaders).common.Authorization.should.equal("Basic "));

		it("should clear all $http caches except the template cache", (): void => {
			$cache.removeAll.should.have.been.called;
			($cacheFactory.get as SinonStub)("templates").removeAll.should.not.have.been.called;
		});
	});
});