public async Task SavingAndLoading_ShouldProduceTheSameCheckSum()
{
var subject1 = CreateSubject();
await subject1.SaveAsync(LedgerBookTestData.TestData2(), "Foo2.xml", false);
var serialisedData = subject1.SerialisedData;
Debug.WriteLine("Saved / Serialised Xml:");
Debug.WriteLine(serialisedData);
LedgerBookDto bookDto;
var subject2 = CreateSubject();
subject2.FileExistsOverride = f => true;
subject2.LoadXamlFromDiskFromEmbeddedResources = false;
this.mockReaderWriter.Setup(m => m.LoadFromDiskAsync(It.IsAny <string>())).ReturnsAsync(serialisedData);
await subject2.LoadAsync("foo", false);
bookDto = subject2.LedgerBookDto;
int checksumPosition = serialisedData.IndexOf("CheckSum=\"", StringComparison.OrdinalIgnoreCase);
int checksumLength = serialisedData.IndexOf('"', checksumPosition + 11) - checksumPosition;
string serialisedCheckSum = serialisedData.Substring(checksumPosition + 10, checksumLength - 10);
Assert.AreEqual(double.Parse(serialisedCheckSum), bookDto.Checksum);
}
public void TestIntialise()
{
this.mockRuleService = new Mock <ITransactionRuleService>(MockBehavior.Strict);
this.mockReconciliationConsistency = new Mock <IReconciliationConsistency>();
this.bucketRepo = new BucketBucketRepoAlwaysFind();
this.testDataBudgets = BudgetModelTestData.CreateCollectionWith1And2();
this.testDataBudgetContext = new BudgetCurrencyContext(this.testDataBudgets, this.testDataBudgets.CurrentActiveBudget);
this.testDataStatement = new StatementModelBuilder()
.TestData5()
.AppendTransaction(new Transaction
{
Account = StatementModelTestData.ChequeAccount,
Amount = -23.56M,
BudgetBucket = StatementModelTestData.RegoBucket,
Date = ReconcileDate.Date.AddDays(-1),
TransactionType = new NamedTransaction("Foo"),
Description = "Last transaction"
})
.Build();
this.testDataToDoList = new List <ToDoTask>();
this.subject = new ReconciliationCreationManager(this.mockRuleService.Object, this.mockReconciliationConsistency.Object, new FakeLogger());
this.testDataLedgerBook = LedgerBookTestData.TestData5(() => new LedgerBookTestHarness(new Mock <IReconciliationBuilder>().Object));
this.mockReconciliationConsistency.Setup(m => m.EnsureConsistency(It.IsAny <LedgerBook>())).Returns(new Mock <IDisposable>().Object);
}
public async Task Load_ShouldCreateBookWithSameName()
{
XamlOnDiskLedgerBookRepository subject = CreateSubject();
var book = await subject.LoadAsync(LoadFileName, false);
var testData2 = LedgerBookTestData.TestData2();
Assert.AreEqual(testData2.Name, book.Name);
}
public async Task Load_ShouldCreateBookWithSameNumberOfReconciliations()
{
XamlOnDiskLedgerBookRepository subject = CreateSubject();
var book = await subject.LoadAsync(LoadFileName, false);
var testData2 = LedgerBookTestData.TestData2();
Assert.AreEqual(testData2.Reconciliations.Count(), book.Reconciliations.Count());
}
public void TestInitialise()
{
Subject = new BurnDownChartAnalyser(new LedgerCalculation(), new FakeLogger());
Budget = BudgetModelTestData.CreateTestData2();
LedgerBook = LedgerBookTestData.TestData2();
StatementModel = StatementModelTestData.TestData3();
Act();
}
public async Task Load_Output()
{
XamlOnDiskLedgerBookRepository subject = CreateSubject();
var book = await subject.LoadAsync(LoadFileName, false);
// Visual compare these two - should be the same
LedgerBookTestData.TestData2().Output();
book.Output();
}
public async Task Load_ShouldCreateBookWithFirstLineEqualBankBalances()
{
XamlOnDiskLedgerBookRepository subject = CreateSubject();
var book = await subject.LoadAsync(LoadFileName, false);
var testData2 = LedgerBookTestData.TestData2();
var line = book.Reconciliations.First();
Assert.AreEqual(testData2.Reconciliations.First().TotalBankBalance, line.TotalBankBalance);
}
public async Task Save_ShouldSaveTheXmlFile()
{
var fileName = @"CompleteSmellyFoo.xml";
XamlOnDiskLedgerBookRepository subject = CreateSubject();
var testData = LedgerBookTestData.TestData2();
await subject.SaveAsync(testData, fileName, false);
this.mockReaderWriter.Verify(m => m.WriteToDiskAsync(It.IsAny <string>(), It.IsAny <string>()));
}
public void TestInitialise()
{
var accountRepo = new InMemoryAccountTypeRepository();
var subject = new Mapper_LedgerEntryDto_LedgerEntry(new LedgerBucketFactory(new BucketBucketRepoAlwaysFind(), accountRepo), new LedgerTransactionFactory(), accountRepo);
Result = subject.ToModel(TestData);
LedgerBook book = LedgerBookTestData.TestData2();
Control = book.Reconciliations.First(l => l.Date == new DateTime(2013, 08, 15)).Entries.First(e => e.LedgerBucket.BudgetBucket.Code == TestDataConstants.PowerBucketCode);
}
public async Task SerialiseTestData2ToEnsureItMatches_Load_ShouldLoadTheXmlFile_xml()
{
var subject = CreateSubject();
await subject.SaveAsync(LedgerBookTestData.TestData2(), "Leonard Nimoy.xml", false);
var serialisedData = subject.SerialisedData;
Console.WriteLine(serialisedData);
Assert.IsTrue(serialisedData.Length > 100);
}
public async Task SaveAsync_ShouldHaveACheckSumOf8435_GivenLedgerBookTestData2()
{
var subject = CreateSubject();
await subject.SaveAsync(LedgerBookTestData.TestData2(), "Foo.xml", false);
var serialisedData = subject.SerialisedData;
int checksumPosition = serialisedData.IndexOf("CheckSum=\"", StringComparison.OrdinalIgnoreCase);
int checksumLength = serialisedData.IndexOf('"', checksumPosition + 11) - checksumPosition;
string serialisedCheckSum = serialisedData.Substring(checksumPosition + 10, checksumLength - 10);
Assert.AreEqual(8435.06, double.Parse(serialisedCheckSum));
}
public async Task Load_ShouldCreateBookWithFirstLineEqualSurplus()
{
XamlOnDiskLedgerBookRepository subject = CreateSubject();
var book = await subject.LoadAsync(LoadFileName, false);
book.Output();
var testData2 = LedgerBookTestData.TestData2();
testData2.Output();
var line = book.Reconciliations.First();
Assert.AreEqual(testData2.Reconciliations.First().CalculatedSurplus, line.CalculatedSurplus);
}
public void TestIntialise()
{
this.mockBucketRepo = new Mock <IBudgetBucketRepository>();
this.mockRuleService = new Mock <ITransactionRuleService>();
this.mockReconciliationConsistency = new Mock <IReconciliationConsistency>();
this.subject = new ReconciliationCreationManager(this.mockRuleService.Object, this.mockReconciliationConsistency.Object, new FakeLogger());
this.testDataLedgerBook = LedgerBookTestData.TestData5(() => new LedgerBookTestHarness(new Mock <IReconciliationBuilder>().Object));
this.testDataEntryLine = this.testDataLedgerBook.Reconciliations.First();
this.testDataEntryLine.Unlock();
this.surplusChqLedger = new SurplusLedger {
StoredInAccount = StatementModelTestData.ChequeAccount
};
this.insHomeSavLedger = this.testDataLedgerBook.Ledgers.Single(l => l.BudgetBucket == StatementModelTestData.InsHomeBucket);
this.phNetChqLedger = this.testDataLedgerBook.Ledgers.Single(l => l.BudgetBucket == StatementModelTestData.PhoneBucket);
}
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);
}
public void Reconcile_WithPaymentFromWrongAccountShouldUpdateLedgerBalance_GivenTestData5()
{
this.testDataBudget = BudgetModelTestData.CreateTestData5();
this.subject = LedgerBookTestData.TestData5();
var testTransaction = this.testDataStatement.AllTransactions.Last();
testTransaction.BudgetBucket = LedgerBookTestData.HouseInsLedgerSavingsAccount.BudgetBucket;
testTransaction.Account = StatementModelTestData.ChequeAccount;
testTransaction.Amount = -1250;
this.testDataStatement.Output(DateTime.MinValue);
this.subject.Output();
var reconResult = Act(bankBalances: new[] { new BankBalance(StatementModelTestData.ChequeAccount, 1850.5M), new BankBalance(StatementModelTestData.SavingsAccount, 1000M) });
this.subject.Output(true);
Assert.AreEqual(300M, reconResult.Reconciliation.Entries.Single(e => e.LedgerBucket == LedgerBookTestData.HouseInsLedgerSavingsAccount).Balance);
}
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 Reconcile_WithPaymentFromWrongAccountShouldCreateBalanceAdjustment_GivenTestData5()
{
this.testDataBudget.Output();
this.subject = LedgerBookTestData.TestData5();
var testTransaction = this.testDataStatement.AllTransactions.Last();
testTransaction.BudgetBucket = LedgerBookTestData.HouseInsLedgerSavingsAccount.BudgetBucket;
testTransaction.Account = StatementModelTestData.ChequeAccount;
this.testDataStatement.Output(DateTime.MinValue);
this.subject.Output();
var reconResult = Act(bankBalances: new[] { new BankBalance(StatementModelTestData.ChequeAccount, 1850.5M), new BankBalance(StatementModelTestData.SavingsAccount, 1000M) });
this.subject.Output(true);
var savingsBal = reconResult.Reconciliation.BankBalances.Single(b => b.Account == LedgerBookTestData.SavingsAccount).Balance
+ reconResult.Reconciliation.BankBalanceAdjustments.Where(b => b.BankAccount == LedgerBookTestData.SavingsAccount).Sum(b => b.Amount);
var chqBal = reconResult.Reconciliation.BankBalances.Single(b => b.Account == LedgerBookTestData.ChequeAccount).Balance
+ reconResult.Reconciliation.BankBalanceAdjustments.Where(b => b.BankAccount == LedgerBookTestData.ChequeAccount).Sum(b => b.Amount);
Assert.AreEqual(650M, savingsBal, "Savings should be decreased because savings still has the funds and needs to payback the Cheque account.");
Assert.AreEqual(2200.50M, chqBal, "Chq should be increased after it has been paid back from savings.");
Assert.AreEqual(0M, reconResult.Reconciliation.TotalBalanceAdjustments);
}
public void TestInitialise()
{
this.testDataBudget = BudgetModelTestData.CreateTestData1();
this.testDataStatement = StatementModelTestData.TestData1();
this.subject = LedgerBookTestData.TestData1();
}
private LedgerBook ArrangeAndAct()
{
return(LedgerBookTestData.TestData1());
}
private LedgerEntryLine CreateSubject()
{
return(LedgerBookTestData.TestData5().Reconciliations.First());
}
public void UsingTestData2_Output()
{
var book = LedgerBookTestData.TestData2();
book.Output();
}
public void TestInitialise()
{
TestData = LedgerBookTestData.TestData2();
}
public void TestInitialise()
{
Subject = new LedgerCalculation();
TestData = LedgerBookTestData.TestData1();
}
public void OutputTestData5()
{
LedgerBookTestData.TestData5().Output(true);
}
