public void RemoveTransaction_ShouldCallStatementModelRemove_GivenATransaction()
{
this.testData = new StatementModelTestHarness();
this.testData.LoadTransactions(StatementModelTestData.TestData2().Transactions);
Arrange();
Transaction transaction = this.testData.Transactions.Skip(1).First();
this.subject.RemoveTransaction(transaction);
Assert.AreEqual(1, ((StatementModelTestHarness)this.testData).RemoveTransactionWasCalled);
}
public async Task ImportAndMergeBankStatement_ShouldCallStatementRepo_GivenStorageKeyAndAccount()
{
this.mockStatementRepo
.Setup(m => m.ImportBankStatementAsync(It.IsAny <string>(), It.IsAny <Engine.BankAccount.Account>()))
.Returns(Task.FromResult(StatementModelTestData.TestData3()))
.Verifiable();
await this.subject.ImportAndMergeBankStatementAsync("Sticky Bag.csv", StatementModelTestData.ChequeAccount);
this.mockStatementRepo.Verify();
}
public void TestInitialise()
{
Statement = StatementModelTestData.TestData2();
// Mocking out the Calculator means we dont need the LedgerBook
LedgerBook = new LedgerBookTestHarness(new Mock <IReconciliationBuilder>().Object);
SetLedgerBalancesFakeDataSomeOverspentBuckets();
Subject = new OverspentWarning();
Act();
}
public void Reconcile_ShouldNotCreateTasksForUserTransfersOfBudgetedAmounts_GivenTestData5AndPaymentFromDifferentAccount()
{
// Modify a InsHome payment transaction, originally coming out of the Savings account where the ledger is stored, to the Cheque account.
this.testDataStatement = StatementModelTestData.TestData5();
var insHomePayment = this.testDataStatement.AllTransactions.Single(t => t.BudgetBucket == StatementModelTestData.InsHomeBucket && t.Amount == -1000M);
insHomePayment.Account = StatementModelTestData.ChequeAccount;
ActOnTestData5(this.testDataStatement);
OutputToDoList();
// Given the test data 5 set, there should only be one transfer task.
Assert.AreEqual(2, this.testDataToDoList.OfType <TransferTask>().Count());
}
public async Task ImportAndMergeBankStatement_ShouldMergeTheModel_GivenStorageKeyAndAccount()
{
this.testData = new StatementModelTestHarness();
this.testData.LoadTransactions(new List <Transaction>());
Arrange();
this.mockStatementRepo
.Setup(m => m.ImportBankStatementAsync(It.IsAny <string>(), It.IsAny <Engine.BankAccount.Account>()))
.Returns(Task.FromResult(StatementModelTestData.TestData2()))
.Verifiable();
await this.subject.ImportAndMergeBankStatementAsync("Sticky Bag.csv", StatementModelTestData.ChequeAccount);
Assert.AreEqual(1, ((StatementModelTestHarness)this.testData).MergeWasCalled);
}
public void Reconcile_ShouldThrowWhenAutoMatchingTransactionAreMissingFromStatement_GivenTestData5()
{
try
{
ActOnTestData5(StatementModelTestData.TestData4());
}
catch (ValidationWarningException ex)
{
if (ex.Source == "1")
{
return;
}
}
Assert.Fail();
}
public void Reconcile_ShouldAutoMatchTransactionsAndLinkIdToStatementTransaction_GivenTestData5()
{
// The automatched credit ledger transaction from last month should be linked to the statement transaction.
this.testDataStatement = StatementModelTestData.TestData5();
List <Transaction> statementTransactions = this.testDataStatement.AllTransactions.Where(t => t.Reference1 == "agkT9kC").ToList();
Debug.Assert(statementTransactions.Count() == 2);
ActOnTestData5(this.testDataStatement);
var previousMonthLine =
this.subject.Reconciliations.Single(line => line.Date == new DateTime(2013, 08, 15)).Entries.Single(e => e.LedgerBucket.BudgetBucket == StatementModelTestData.InsHomeBucket);
var previousLedgerTxn = previousMonthLine.Transactions.OfType <BudgetCreditLedgerTransaction>().Single();
// Assert last month's ledger transaction has been linked to the credit 16/8/13
Assert.AreEqual(statementTransactions.Single(t => t.Amount > 0).Id, previousLedgerTxn.Id);
}
public async Task ImportAndMergeBankStatement_ShouldThrow_GivenAlreadyImported()
{
this.testData = new StatementModelBuilder()
.TestData2()
.Build();
Arrange();
this.mockStatementRepo
.Setup(m => m.ImportBankStatementAsync(It.IsAny <string>(), It.IsAny <Engine.BankAccount.Account>()))
.Returns(Task.FromResult(StatementModelTestData.TestData2()))
.Verifiable();
await this.subject.ImportAndMergeBankStatementAsync("Sticky Bag.csv", StatementModelTestData.ChequeAccount);
Assert.Fail();
}
private void ActOnTestData5(StatementModel statementModelTestData = null)
{
this.subject = LedgerBookTestData.TestData5();
this.testDataBudget = BudgetModelTestData.CreateTestData5();
this.testDataStatement = statementModelTestData ?? StatementModelTestData.TestData5();
Console.WriteLine("********************** BEFORE RUNNING RECONCILIATION *******************************");
this.testDataStatement.Output(ReconcileDate.AddMonths(-1));
this.subject.Output(true);
var result = Act(bankBalances: new[] { new BankBalance(StatementModelTestData.ChequeAccount, 1850.5M), new BankBalance(StatementModelTestData.SavingsAccount, 1200M) });
this.testDataToDoList = result.Tasks.ToList();
Console.WriteLine();
Console.WriteLine("********************** AFTER RUNNING RECONCILIATION *******************************");
this.subject.Output(true);
}
private void ActOnTestData5(StatementModel statementModelTestData = null, bool ignoreWarnings = false)
{
this.testDataLedgerBook = LedgerBookTestData.TestData5(() => new LedgerBookTestHarness(new Mock <IReconciliationBuilder>().Object));
this.testDataBudgets = new BudgetCollection(new[] { BudgetModelTestData.CreateTestData5() });
this.testDataBudgetContext = new BudgetCurrencyContext(this.testDataBudgets, this.testDataBudgets.CurrentActiveBudget);
this.testDataStatement = statementModelTestData ?? StatementModelTestData.TestData5();
Console.WriteLine("********************** BEFORE RUNNING RECONCILIATION *******************************");
this.testDataStatement.Output(ReconcileDate.AddMonths(-1));
this.testDataLedgerBook.Output(true);
Act(bankBalances: new[] { new BankBalance(StatementModelTestData.ChequeAccount, 1850.5M), new BankBalance(StatementModelTestData.SavingsAccount, 1200M) },
ignoreWarnings: ignoreWarnings);
Console.WriteLine();
Console.WriteLine("********************** AFTER RUNNING RECONCILIATION *******************************");
this.testDataLedgerBook.Output(true);
}
public void TestInit()
{
PrivateAccessor.SetProperty(this.testAppDb, "StatementModelStorageKey", @"Foo.csv");
PrivateAccessor.SetProperty(this.testAppDb, "FileName", @"C:\AppDb.bax");
this.testData = StatementModelTestData.TestData2();
this.mockBudgetBucketRepo = new Mock <IBudgetBucketRepository>();
this.mockStatementRepo = new Mock <IStatementRepository>();
this.mockStatementRepo.Setup(m => m.LoadAsync(It.IsAny <string>(), It.IsAny <bool>()))
.Returns(Task.FromResult(this.testData))
.Verifiable();
this.mockBudgetBucketRepo
.Setup(m => m.Buckets)
.Returns(BudgetBucketTestData.BudgetModelTestData1Buckets);
this.budgetBucketRepo = this.mockBudgetBucketRepo.Object;
Arrange();
}
public async Task Save_ShouldThrow_GivenMappingDoesNotMapAllTransactions()
{
var mapper = new Mock <IDtoMapper <TransactionSetDto, StatementModel> >();
var subject = ArrangeWithMockMappers(mapper.Object);
var model = StatementModelTestData.TestData2();
model.Filter(new GlobalFilterCriteria {
BeginDate = new DateTime(2013, 07, 20), EndDate = new DateTime(2013, 08, 19)
});
mapper.Setup(m => m.ToDto(model)).Returns(
new TransactionSetDto
{
StorageKey = "Foo.bar",
LastImport = new DateTime(2013, 07, 20),
Transactions = TransactionSetDtoTestData.TestData2().Transactions.Take(2).ToList()
});
await subject.SaveAsync(model, "Foo.bar", false);
Assert.Fail();
}
public void CalculateOverSpentLedgersShouldReturnEmptyGivenNoLedgerLineForGivenDate()
{
IEnumerable <ReportTransaction> result = Subject.CalculateOverspentLedgers(StatementModelTestData.TestData1(), TestData, new DateTime(2014, 07, 01));
Assert.IsTrue(result.Count() == 0);
}
public void TestInitialise()
{
this.testDataBudget = BudgetModelTestData.CreateTestData1();
this.testDataStatement = StatementModelTestData.TestData1();
this.subject = LedgerBookTestData.TestData1();
}
public void CalculateOverSpentLedgersShouldThrowGivenNullLedger()
{
Subject.CalculateOverspentLedgers(StatementModelTestData.TestData1(), null, new DateTime(2014, 07, 01));
Assert.Fail();
}
public void CalculateOverSpentLedgersShouldReturnOverdrawnTransactionsGivenStatementTransactionsSpendMoreThanLedgerBalance()
{
TestData.Output(true);
IEnumerable <ReportTransaction> result = Subject.CalculateOverspentLedgers(StatementModelTestData.TestData2(), TestData, new DateTime(2013, 08, 15));
foreach (ReportTransaction txn in result)
{
Console.WriteLine("{0} {1} {2}", txn.Date, txn.Narrative, txn.Amount);
}
Assert.AreEqual(-40.41M, result.Sum(t => t.Amount));
}
public void CalculateOverSpentLedgersShouldReturnEmptyGivenNoLedgersWereOverdrawn()
{
TestData.Output(true);
IEnumerable <ReportTransaction> result = Subject.CalculateOverspentLedgers(StatementModelTestData.TestData3(), TestData, new DateTime(2013, 08, 15));
foreach (ReportTransaction txn in result)
{
Console.WriteLine("{0} {1} {2}", txn.Date, txn.Narrative, txn.Amount);
}
Assert.IsTrue(result.Count() == 0);
}
private TransactionGroupedByBucket Arrange()
{
StatementModel statementModel = StatementModelTestData.TestData1();
return(new TransactionGroupedByBucket(statementModel.AllTransactions, StatementModelTestData.PowerBucket));
}
