describe("all", (): void => {
		const expectedResponse: TransactionBatch = {
			transactions: [createBasicTransaction(), createBasicTransaction()],
			openingBalance: 0,
			atEnd: false
		};
		let actualResponse: angular.IPromise<TransactionBatch>;

		beforeEach((): void => {
			const fromDate = new Date();

			transactionModel["parse"] = sinon.stub().returnsArg(0);
			$httpBackend.expectGET(new RegExp(`context/transactions\\?as_at=${fromDate.toISOString()}&direction=prev&unreconciled=true`)).respond(200, expectedResponse);
			actualResponse = transactionModel.all("context", fromDate, "prev", true);
			$httpBackend.flush();
		});

		it("should dispatch a GET request to /{context}/transactions?as_at={fromDate}&direction={direction}&unreconciled={unreconciledOnly}", (): null => null);

		it("should parse each transaction returned", (): Chai.Assertion => transactionModel["parse"].should.have.been.calledTwice);

		it("should return a list of transactions", (): void => {
			actualResponse.should.eventually.deep.equal(expectedResponse);
		});
	});

	beforeEach(inject((_$sce_: angular.ISCEService, directiveTest: DirectiveTest, _transactionModel_: TransactionModelMock): void => {
		$sce = _$sce_;
		transactionStatus = directiveTest;
		transactionStatus.configure("transaction-status", "div");
		transactionStatus.scope.model = {account: createAccount({id: 123}), transaction: createBasicTransaction({id: 456})};
		transactionModel = _transactionModel_;
	}));

		beforeEach((): void => {
			transactionModel["invalidateCaches"] = sinon.stub();
			transactionModel["stringify"] = sinon.stub().returnsArg(0);
			transactionModel["parse"] = sinon.stub().returnsArg(0);
			$httpBackend.whenPOST(/transactions$/).respond(200, expectedResponse);
			$httpBackend.whenPATCH(/transactions\/1$/).respond(200, expectedResponse);
			transaction = createBasicTransaction({id: 1});
		});

function *transactions(count: number): Iterable<BasicTransaction> {
	for (let id = 1, daysAgo = count + 1; id < count + 1; id++, daysAgo--) {
		yield createBasicTransaction({
			id,
			amount: id,
			direction: id % 2 ? "outflow" : "inflow",
			transaction_date: subDays(startOfDay(new Date()), daysAgo),
			status: id < 5 ? "Cleared" : ""
		});
	}
}

	describe("findLastTransaction", (): void => {
		const expectedResponse: BasicTransaction = createBasicTransaction();
		let actualResponse: angular.IPromise<Transaction>;

		beforeEach((): void => {
			$httpBackend.expectGET(/securities\/1\/transactions\/last\?account_type=bank$/).respond(200, expectedResponse);
			actualResponse = securityModel.findLastTransaction(1, "bank");
			$httpBackend.flush();
		});

		it("should dispatch a GET request to /securities/{id}/transactions/last?account_type={accountType}", (): null => null);

		it("should return the last transaction for the security", (): void => {
			actualResponse.should.eventually.deep.equal(expectedResponse);
		});
	});

		it("should dispatch a PUT request to /transactions/{id}/flag", (): void => {
			$httpBackend.expectPUT(/transactions\/1\/flag/, {memo: "flag"}).respond(200);
			transactionModel.flag(createBasicTransaction({id: 1, flag: "flag"}));
			$httpBackend.flush();
		});