public void TestBudgetEditViewModelOK()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
Entities.Currency usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account savingsAccountEntity =
accountFactory.Create(AccountPrefab.Savings, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account rentExpenseAccountEntity =
accountFactory.Create(AccountPrefab.RentExpense, usdCurrencyEntity);
Entities.Account groceriesPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesPrepayment, usdCurrencyEntity);
Entities.Account groceriesExpenseAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesExpense, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, savingsAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentExpenseAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesExpenseAccountEntity);
var checkingToRentPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var checkingToGroceriesPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = groceriesPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var rentPrepaymentToExpenseRelationship = new Entities.AccountRelationship
{
SourceAccount = rentPrepaymentAccountEntity,
DestinationAccount = rentExpenseAccountEntity,
Type = AccountRelationshipType.PrepaymentToExpense
};
var groceriesPrepaymentToExpenseRelationship = new Entities.AccountRelationship
{
SourceAccount = groceriesPrepaymentAccountEntity,
DestinationAccount = groceriesExpenseAccountEntity,
Type = AccountRelationshipType.PrepaymentToExpense
};
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToRentPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToGroceriesPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(rentPrepaymentToExpenseRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(groceriesPrepaymentToExpenseRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
var budget = new Entities.Budget
{
Name = "Budget",
Period = BudgetPeriod.Fortnightly
};
sqliteMemoryWrapper.DbContext.Budgets.Add(budget);
sqliteMemoryWrapper.DbContext.SaveChanges();
var initialTransaction = new Entities.BudgetTransaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 200m,
IsInitial = true,
Budget = budget
};
var rentTransaction = new Entities.BudgetTransaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 100m,
Budget = budget
};
var groceriesTransaction = new Entities.BudgetTransaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = groceriesPrepaymentAccountEntity,
Amount = 50m,
Budget = budget
};
var surplusTransaction = new Entities.BudgetTransaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = groceriesPrepaymentAccountEntity,
IsSurplus = true,
Budget = budget
};
sqliteMemoryWrapper.DbContext.BudgetTransactions.Add(initialTransaction);
sqliteMemoryWrapper.DbContext.BudgetTransactions.Add(rentTransaction);
sqliteMemoryWrapper.DbContext.BudgetTransactions.Add(groceriesTransaction);
sqliteMemoryWrapper.DbContext.BudgetTransactions.Add(surplusTransaction);
sqliteMemoryWrapper.DbContext.SaveChanges();
var accountService = new AccountService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
var budgetService = new BudgetService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
var mockTransactionItemViewModelFactory = new Mock <IBudgetTransactionItemViewModelFactory>();
mockTransactionItemViewModelFactory
.Setup(f => f.Create(
It.IsAny <ObservableCollection <IAccountLinkViewModel> >(),
It.IsAny <BudgetTransaction>(),
It.IsAny <BudgetTransactionType>()))
.Returns(
(ObservableCollection <IAccountLinkViewModel> accountLinks,
BudgetTransaction budgetTransaction,
BudgetTransactionType type) =>
{
return(new BudgetTransactionItemViewModel(
loggerFactory,
accountLinks,
budgetTransaction,
type));
});
var mockTransactionListViewModelFactory = new Mock <IBudgetTransactionListViewModelFactory>();
mockTransactionListViewModelFactory
.Setup(f => f.Create(It.IsAny <int>()))
.Returns((int budgetId) =>
{
return(new BudgetTransactionListViewModel(
loggerFactory,
accountService,
budgetService,
new Concrete.StubAccountLinkViewModelFactory(),
mockTransactionItemViewModelFactory.Object,
new Mock <IDeleteConfirmationViewService>().Object,
budgetId
));
});
var viewModel = new BudgetEditViewModel(
loggerFactory,
budgetService,
mockTransactionListViewModelFactory.Object,
budget.BudgetId
);
viewModel.Name = "My First Budget";
viewModel.SelectedPeriod = BudgetPeriod.Monthly;
viewModel.OKCommand.Execute(this);
List <Budget> budgets = budgetService.GetAll().ToList();
Assert.AreEqual(1, budgets.Count);
Assert.AreEqual(viewModel.Name, budgets[0].Name);
Assert.AreEqual(viewModel.SelectedPeriod, budgets[0].Period);
Assert.AreEqual(initialTransaction.CreditAccountId, budgets[0].InitialTransaction.CreditAccount.AccountId);
Assert.AreEqual(initialTransaction.DebitAccountId, budgets[0].InitialTransaction.DebitAccount.AccountId);
Assert.AreEqual(initialTransaction.Amount, budgets[0].InitialTransaction.Amount);
Assert.AreEqual(surplusTransaction.CreditAccountId, budgets[0].SurplusTransaction.CreditAccount.AccountId);
Assert.AreEqual(surplusTransaction.DebitAccountId, budgets[0].SurplusTransaction.DebitAccount.AccountId);
Assert.AreEqual(surplusTransaction.Amount, budgets[0].SurplusTransaction.Amount);
Assert.AreEqual(2, budgets[0].Transactions.Count());
}
}
public void TestReloadTransaction()
{
const string path = "TestData/TransactionReload.xml";
ILoggerFactory loggerFactory = new LoggerFactory();
var currencyFactory = new CurrencyFactory();
Entities.Currency usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
var accountFactory = new AccountFactory();
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
var accountRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var transaction = new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
Amount = 10m,
DebitAccount = rentPrepaymentAccountEntity,
At = new DateTime(2018, 1, 1, 8, 30, 0)
};
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(accountRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
sqliteMemoryWrapper.DbContext.Transactions.Add(transaction);
sqliteMemoryWrapper.DbContext.SaveChanges();
var service = new DatabaseSerializationXmlService(loggerFactory, sqliteMemoryWrapper.DbContext);
service.Save(path);
}
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var service = new DatabaseSerializationXmlService(loggerFactory, sqliteMemoryWrapper.DbContext);
service.Load(path);
List <Entities.Account> accounts = sqliteMemoryWrapper.DbContext.Accounts.ToList();
List <Entities.AccountRelationship> accountRelationships = sqliteMemoryWrapper.DbContext.AccountRelationships.ToList();
List <Entities.Currency> currencies = sqliteMemoryWrapper.DbContext.Currencies.ToList();
List <Entities.Transaction> transactions = sqliteMemoryWrapper.DbContext.Transactions.ToList();
Assert.AreEqual(2, accounts.Count);
Assert.AreEqual(1, accountRelationships.Count);
Assert.AreEqual(1, currencies.Count);
Assert.AreEqual(1, transactions.Count);
Assert.AreEqual(checkingAccountEntity.Name, transactions[0].CreditAccount.Name);
Assert.AreEqual(transaction.Amount, transactions[0].Amount);
Assert.AreEqual(rentPrepaymentAccountEntity.Name, transactions[0].DebitAccount.Name);
Assert.AreEqual(transaction.At, transactions[0].At);
}
}
public void TestReloadBudget()
{
const string path = "TestData/BudgetReload.xml";
ILoggerFactory loggerFactory = new LoggerFactory();
var currencyFactory = new CurrencyFactory();
Entities.Currency usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account savingsAccountEntity =
accountFactory.Create(AccountPrefab.Savings, usdCurrencyEntity);
var accountRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var budget = new Entities.Budget
{
Name = "The Budget",
Period = BudgetPeriod.Fortnightly,
Transactions = new List <Entities.BudgetTransaction>
{
new Entities.BudgetTransaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
IsInitial = true
},
new Entities.BudgetTransaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 80m,
},
new Entities.BudgetTransaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = savingsAccountEntity,
Amount = 100m,
IsSurplus = true
}
}
};
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, savingsAccountEntity);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(accountRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
sqliteMemoryWrapper.DbContext.Budgets.Add(budget);
sqliteMemoryWrapper.DbContext.SaveChanges();
var service = new DatabaseSerializationXmlService(loggerFactory, sqliteMemoryWrapper.DbContext);
service.Save(path);
}
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var service = new DatabaseSerializationXmlService(loggerFactory, sqliteMemoryWrapper.DbContext);
service.Load(path);
List <Entities.Account> accounts = sqliteMemoryWrapper.DbContext.Accounts.ToList();
List <Entities.AccountRelationship> accountRelationships = sqliteMemoryWrapper.DbContext.AccountRelationships.ToList();
List <Entities.Budget> budgets = sqliteMemoryWrapper.DbContext.Budgets.ToList();
List <Entities.BudgetTransaction> budgetTransactions = sqliteMemoryWrapper.DbContext.BudgetTransactions.ToList();
List <Entities.Currency> currencies = sqliteMemoryWrapper.DbContext.Currencies.ToList();
List <Entities.Transaction> transactions = sqliteMemoryWrapper.DbContext.Transactions.ToList();
Assert.AreEqual(4, accounts.Count);
Assert.AreEqual(1, accountRelationships.Count);
Assert.AreEqual(1, budgets.Count);
Assert.AreEqual(3, budgetTransactions.Count);
Assert.AreEqual(1, currencies.Count);
Assert.AreEqual(0, transactions.Count);
Assert.AreEqual(budget.Name, budgets[0].Name);
Assert.AreEqual(budget.Period, budgets[0].Period);
Entities.BudgetTransaction initialTransaction = budgetTransactions.First(bt => bt.IsInitial && !bt.IsSurplus);
Entities.BudgetTransaction regularTransaction = budgetTransactions.First(bt => !bt.IsInitial && !bt.IsSurplus);
Entities.BudgetTransaction surplusTransaction = budgetTransactions.First(bt => !bt.IsInitial && bt.IsSurplus);
Assert.AreEqual(budget.Transactions[0].DebitAccount.Name, initialTransaction.DebitAccount.Name);
Assert.AreEqual(budget.Transactions[0].CreditAccount.Name, initialTransaction.CreditAccount.Name);
Assert.AreEqual(budget.Transactions[0].Amount, initialTransaction.Amount);
Assert.AreEqual(budget.Transactions[0].IsInitial, initialTransaction.IsInitial);
Assert.AreEqual(budget.Transactions[0].IsSurplus, initialTransaction.IsSurplus);
Assert.AreEqual(budget.Transactions[1].DebitAccount.Name, regularTransaction.DebitAccount.Name);
Assert.AreEqual(budget.Transactions[1].CreditAccount.Name, regularTransaction.CreditAccount.Name);
Assert.AreEqual(budget.Transactions[1].Amount, regularTransaction.Amount);
Assert.AreEqual(budget.Transactions[1].IsInitial, regularTransaction.IsInitial);
Assert.AreEqual(budget.Transactions[1].IsSurplus, regularTransaction.IsSurplus);
Assert.AreEqual(budget.Transactions[2].DebitAccount.Name, surplusTransaction.DebitAccount.Name);
Assert.AreEqual(budget.Transactions[2].CreditAccount.Name, surplusTransaction.CreditAccount.Name);
Assert.AreEqual(budget.Transactions[2].Amount, surplusTransaction.Amount);
Assert.AreEqual(budget.Transactions[2].IsInitial, surplusTransaction.IsInitial);
Assert.AreEqual(budget.Transactions[2].IsSurplus, surplusTransaction.IsSurplus);
}
}
public void TestGetPendingCreditCardTransactionsOneResult()
{
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
Entities.Currency usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account rentExpenseAccountEntity =
accountFactory.Create(AccountPrefab.RentExpense, usdCurrencyEntity);
Entities.Account creditCardAccountEntity =
accountFactory.Create(AccountPrefab.CreditCard, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentExpenseAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, creditCardAccountEntity);
var checkingToRentPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var rentPrepaymentToExpenseRelationship = new Entities.AccountRelationship
{
SourceAccount = rentPrepaymentAccountEntity,
DestinationAccount = rentExpenseAccountEntity,
Type = AccountRelationshipType.PrepaymentToExpense
};
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToRentPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(rentPrepaymentToExpenseRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
var transactionsToAdd = new Entities.Transaction[4]
{
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 1, 8, 30, 1)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 50m,
At = new DateTime(2018, 1, 1, 8, 30, 2)
},
new Entities.Transaction
{
CreditAccount = creditCardAccountEntity,
DebitAccount = rentExpenseAccountEntity,
Amount = 20m,
At = new DateTime(2018, 1, 1, 8, 30, 3)
},
new Entities.Transaction
{
CreditAccount = rentPrepaymentAccountEntity,
DebitAccount = creditCardAccountEntity,
Amount = 20m,
At = new DateTime(2018, 1, 1, 8, 30, 4)
}
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactionsToAdd);
sqliteMemoryWrapper.DbContext.SaveChanges();
ILoggerFactory loggerFactory = new LoggerFactory();
TransactionService transactionService = new TransactionService(loggerFactory, sqliteMemoryWrapper.DbContext);
List <Payment> pendingPayments =
transactionService.GetPendingCreditCardPayments(creditCardAccountEntity.AccountId).ToList();
Assert.AreEqual(1, pendingPayments.Count);
Assert.AreEqual(creditCardAccountEntity.AccountId, pendingPayments[0].OriginalTransaction.CreditAccount.AccountId);
Assert.AreEqual(rentExpenseAccountEntity.AccountId, pendingPayments[0].OriginalTransaction.DebitAccount.AccountId);
Assert.AreEqual(transactionsToAdd[2].Amount, pendingPayments[0].OriginalTransaction.Amount);
Assert.AreEqual(rentPrepaymentAccountEntity.AccountId, pendingPayments[0].PaymentTransaction.CreditAccount.AccountId);
Assert.AreEqual(creditCardAccountEntity.AccountId, pendingPayments[0].PaymentTransaction.DebitAccount.AccountId);
Assert.AreEqual(transactionsToAdd[2].Amount, pendingPayments[0].PaymentTransaction.Amount);
}
}
public void TestAccountTransactionListViewModelAccountWithLogicalsAndTransactions()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
var usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account groceriesPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesPrepayment, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesPrepaymentAccountEntity);
var transactionEntities = new Entities.Transaction[]
{
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 1, 8, 30, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 60m,
At = new DateTime(2018, 1, 1, 8, 31, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = groceriesPrepaymentAccountEntity,
Amount = 10m,
At = new DateTime(2018, 1, 1, 8, 32, 0)
}
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactionEntities);
sqliteMemoryWrapper.DbContext.SaveChanges();
var checkingToRentPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var checkingToGroceriesPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = groceriesPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToRentPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToGroceriesPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
var accountService = new AccountService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
var transactionService = new TransactionService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
IAccountTransactionItemViewModelFactory accountTransactionViewModelFactory =
new Concrete.StubAccountTransactionItemViewModelFactory();
var viewModel = new AccountTransactionListViewModel(
loggerFactory,
accountService,
transactionService,
accountTransactionViewModelFactory,
new Mock <IDeleteConfirmationViewService>().Object,
new Mock <ITransactionCreateViewService>().Object,
new Mock <ITransactionEditViewService>().Object,
new Mock <IReconcileBalanceViewService>().Object,
checkingAccountEntity.AccountId);
Assert.AreEqual(true, viewModel.HasLogicalAcounts);
Assert.AreEqual(3, viewModel.Transactions.Count);
Assert.AreEqual(100m, viewModel.Transactions[0].Balance);
Assert.AreEqual(100m, viewModel.Transactions[1].Balance);
Assert.AreEqual(100m, viewModel.Transactions[2].Balance);
}
}
public void TestGetAllTransactionsFilteredByAccountAndDateRange()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
var usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account groceriesPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesPrepayment, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesPrepaymentAccountEntity);
var transactionEntities = new Entities.Transaction[]
{
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 1, 8, 30, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 60m,
At = new DateTime(2018, 1, 1, 8, 35, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 10m,
At = new DateTime(2018, 1, 1, 9, 45, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 10m,
At = new DateTime(2018, 1, 1, 11, 15, 0)
}
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactionEntities);
sqliteMemoryWrapper.DbContext.SaveChanges();
var checkingToRentPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var checkingToGroceriesPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = groceriesPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToRentPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToGroceriesPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
var transactionService = new TransactionService(loggerFactory, sqliteMemoryWrapper.DbContext);
int[] accountIds = new int[1] {
rentPrepaymentAccountEntity.AccountId
};
List <Transaction> transactions = transactionService
.GetAll(
accountIds,
new DateTime(2018, 1, 1, 8, 35, 0),
new DateTime(2018, 1, 1, 10, 0, 0)
)
.ToList();
Assert.AreEqual(2, transactions.Count);
Assert.AreEqual(2, transactions[0].TransactionId);
Assert.AreEqual(checkingAccountEntity.AccountId, transactions[0].CreditAccount.AccountId);
Assert.AreEqual(rentPrepaymentAccountEntity.AccountId, transactions[0].DebitAccount.AccountId);
Assert.AreEqual(transactionEntities[1].Amount, transactions[0].Amount);
Assert.AreEqual(transactionEntities[1].At, transactions[0].At);
Assert.AreEqual(checkingAccountEntity.AccountId, transactions[1].CreditAccount.AccountId);
Assert.AreEqual(rentPrepaymentAccountEntity.AccountId, transactions[1].DebitAccount.AccountId);
Assert.AreEqual(transactionEntities[2].Amount, transactions[1].Amount);
Assert.AreEqual(transactionEntities[2].At, transactions[1].At);
}
}
public void TestGenerateCashflowStatementMultiplePeriodsMultipleAccounts()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
var usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account creditCardAccountEntity =
accountFactory.Create(AccountPrefab.CreditCard, usdCurrencyEntity);
Entities.Account rentExpenseAccountEntity =
accountFactory.Create(AccountPrefab.RentExpense, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account groceriesExpenseAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesExpense, usdCurrencyEntity);
Entities.Account groceriesPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesPrepayment, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, creditCardAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentExpenseAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesExpenseAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesPrepaymentAccountEntity);
var transactionEntities = new Entities.Transaction[]
{
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 1, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 50m,
At = new DateTime(2018, 1, 2, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = groceriesPrepaymentAccountEntity,
Amount = 20m,
At = new DateTime(2018, 1, 3, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = creditCardAccountEntity,
DebitAccount = groceriesExpenseAccountEntity,
Amount = 5m,
At = new DateTime(2018, 1, 4, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = creditCardAccountEntity,
DebitAccount = groceriesExpenseAccountEntity,
Amount = 8m,
At = new DateTime(2018, 1, 5, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = creditCardAccountEntity,
DebitAccount = groceriesExpenseAccountEntity,
Amount = 3m,
At = new DateTime(2018, 1, 6, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = groceriesPrepaymentAccountEntity,
DebitAccount = creditCardAccountEntity,
Amount = 5m,
At = new DateTime(2018, 1, 7, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = groceriesPrepaymentAccountEntity,
DebitAccount = creditCardAccountEntity,
Amount = 8m,
At = new DateTime(2018, 1, 8, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = groceriesPrepaymentAccountEntity,
DebitAccount = creditCardAccountEntity,
Amount = 3m,
At = new DateTime(2018, 1, 9, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 80m,
At = new DateTime(2018, 1, 14, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 50m,
At = new DateTime(2018, 1, 15, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = groceriesPrepaymentAccountEntity,
Amount = 20m,
At = new DateTime(2018, 1, 16, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = creditCardAccountEntity,
DebitAccount = groceriesExpenseAccountEntity,
Amount = 3m,
At = new DateTime(2018, 1, 17, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = creditCardAccountEntity,
DebitAccount = groceriesExpenseAccountEntity,
Amount = 7m,
At = new DateTime(2018, 1, 18, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = creditCardAccountEntity,
DebitAccount = groceriesExpenseAccountEntity,
Amount = 12m,
At = new DateTime(2018, 1, 19, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = groceriesPrepaymentAccountEntity,
DebitAccount = creditCardAccountEntity,
Amount = 3m,
At = new DateTime(2018, 1, 20, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = groceriesPrepaymentAccountEntity,
DebitAccount = creditCardAccountEntity,
Amount = 7m,
At = new DateTime(2018, 1, 21, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = groceriesPrepaymentAccountEntity,
DebitAccount = creditCardAccountEntity,
Amount = 12m,
At = new DateTime(2018, 1, 22, 9, 0, 0)
},
new Entities.Transaction
{
CreditAccount = rentPrepaymentAccountEntity,
DebitAccount = rentExpenseAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 27, 9, 0, 0)
},
new Entities.Transaction // this should be excluded from the report
{
CreditAccount = creditCardAccountEntity,
DebitAccount = groceriesExpenseAccountEntity,
Amount = 7m,
At = new DateTime(2018, 1, 31, 9, 0, 0)
}
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactionEntities);
sqliteMemoryWrapper.DbContext.SaveChanges();
var accountRelationshipEntities = new Entities.AccountRelationship[]
{
new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
},
new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = groceriesPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
},
new Entities.AccountRelationship
{
SourceAccount = rentPrepaymentAccountEntity,
DestinationAccount = rentExpenseAccountEntity,
Type = AccountRelationshipType.PrepaymentToExpense
},
new Entities.AccountRelationship
{
SourceAccount = groceriesPrepaymentAccountEntity,
DestinationAccount = groceriesExpenseAccountEntity,
Type = AccountRelationshipType.PrepaymentToExpense
}
};
sqliteMemoryWrapper.DbContext.AccountRelationships.AddRange(accountRelationshipEntities);
sqliteMemoryWrapper.DbContext.SaveChanges();
var accountRelationshipService = new AccountRelationshipService(
loggerFactory,
sqliteMemoryWrapper.DbContext
);
var accountService = new AccountService(
loggerFactory,
sqliteMemoryWrapper.DbContext
);
var currencyService = new CurrencyService(
loggerFactory,
sqliteMemoryWrapper.DbContext
);
var transactionService = new TransactionService(
loggerFactory,
sqliteMemoryWrapper.DbContext
);
var cashflowService = new CashflowService(
loggerFactory,
accountRelationshipService,
accountService,
currencyService,
transactionService
);
CashflowStatement cashflowStatement =
cashflowService.Generate(CashflowPeriod.Fortnightly, new DateTime(2018, 1, 1), new DateTime(2018, 1, 28));
List <CashflowAccount> cashflowAccounts =
cashflowStatement
.Accounts
.OrderBy(i => i.Name)
.ToList();
Assert.AreEqual(2, cashflowAccounts.Count);
Assert.AreEqual("Groceries", cashflowAccounts[0].Name);
Assert.AreEqual(2, cashflowAccounts[0].Periods.Count());
Assert.AreEqual(20m, cashflowAccounts[0].Periods.ElementAt(0).Inflow);
Assert.AreEqual(16m, cashflowAccounts[0].Periods.ElementAt(0).Outflow);
Assert.AreEqual(4m, cashflowAccounts[0].Periods.ElementAt(0).Cashflow);
Assert.AreEqual(20m, cashflowAccounts[0].Periods.ElementAt(1).Inflow);
Assert.AreEqual(22m, cashflowAccounts[0].Periods.ElementAt(1).Outflow);
Assert.AreEqual(-2m, cashflowAccounts[0].Periods.ElementAt(1).Cashflow);
Assert.AreEqual(40m, cashflowAccounts[0].Inflow);
Assert.AreEqual(38m, cashflowAccounts[0].Outflow);
Assert.AreEqual(2m, cashflowAccounts[0].Cashflow);
Assert.AreEqual("Rent", cashflowAccounts[1].Name);
Assert.AreEqual(2, cashflowAccounts[1].Periods.Count());
Assert.AreEqual(50m, cashflowAccounts[1].Periods.ElementAt(0).Inflow);
Assert.AreEqual(0m, cashflowAccounts[1].Periods.ElementAt(0).Outflow);
Assert.AreEqual(50m, cashflowAccounts[1].Periods.ElementAt(0).Cashflow);
Assert.AreEqual(50m, cashflowAccounts[1].Periods.ElementAt(1).Inflow);
Assert.AreEqual(100m, cashflowAccounts[1].Periods.ElementAt(1).Outflow);
Assert.AreEqual(-50m, cashflowAccounts[1].Periods.ElementAt(1).Cashflow);
Assert.AreEqual(100m, cashflowAccounts[1].Inflow);
Assert.AreEqual(100m, cashflowAccounts[1].Outflow);
Assert.AreEqual(0m, cashflowAccounts[1].Cashflow);
}
}
public void TestCreateTransactionRelationship()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
var usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account rentExpenseAccountEntity =
accountFactory.Create(AccountPrefab.RentExpense, usdCurrencyEntity);
Entities.Account creditCardAccountEntity =
accountFactory.Create(AccountPrefab.CreditCard, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentExpenseAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, creditCardAccountEntity);
var transactionEntities = new Entities.Transaction[]
{
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 60m,
At = new DateTime(2018, 1, 1, 8, 31, 0)
},
new Entities.Transaction
{
CreditAccount = creditCardAccountEntity,
DebitAccount = rentExpenseAccountEntity,
Amount = 10m,
At = new DateTime(2018, 1, 1, 8, 32, 0)
},
new Entities.Transaction
{
CreditAccount = rentPrepaymentAccountEntity,
DebitAccount = creditCardAccountEntity,
Amount = 10m,
At = new DateTime(2018, 1, 1, 8, 33, 0)
}
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactionEntities);
sqliteMemoryWrapper.DbContext.SaveChanges();
var checkingToRentPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var checkingToGroceriesPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = rentPrepaymentAccountEntity,
DestinationAccount = rentExpenseAccountEntity,
Type = AccountRelationshipType.PrepaymentToExpense
};
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToRentPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToGroceriesPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
var transactionService = new TransactionService(
loggerFactory,
sqliteMemoryWrapper.DbContext
);
var transactionRelationshipService = new TransactionRelationshipService(
loggerFactory,
sqliteMemoryWrapper.DbContext
);
Transaction creditCardToExpenseTransaction = transactionService.Get(transactionEntities[1].TransactionId);
Transaction prepaymentToCreditCardTransaction = transactionService.Get(transactionEntities[2].TransactionId);
var newTransactionRelationship = new TransactionRelationship
{
SourceTransaction = creditCardToExpenseTransaction,
DestinationTransaction = prepaymentToCreditCardTransaction,
Type = TransactionRelationshipType.CreditCardPayment
};
transactionRelationshipService.Create(newTransactionRelationship);
List <Entities.TransactionRelationship> transactionRelationshipEntities =
sqliteMemoryWrapper.DbContext.TransactionRelationships.ToList();
Assert.AreEqual(1, transactionRelationshipEntities.Count);
Assert.AreEqual(newTransactionRelationship.TransactionRelationshipId, transactionRelationshipEntities[0].TransactionRelationshipId);
Assert.AreEqual(newTransactionRelationship.SourceTransaction.TransactionId, transactionRelationshipEntities[0].SourceTransaction.TransactionId);
Assert.AreEqual(newTransactionRelationship.DestinationTransaction.TransactionId, transactionRelationshipEntities[0].DestinationTransaction.TransactionId);
Assert.AreEqual(newTransactionRelationship.Type, transactionRelationshipEntities[0].Type);
}
}
public void TestAccountRelationshipListViewModel()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
var usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account groceriesPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesPrepayment, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
var checkingToGroceriesPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = groceriesPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var checkingToRentPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToGroceriesPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToRentPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
var accountRelationshipService = new AccountRelationshipService(
loggerFactory,
sqliteMemoryWrapper.DbContext
);
var accountService = new AccountService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
var transactionService = new TransactionService(
loggerFactory,
sqliteMemoryWrapper.DbContext);
var viewModel = new AccountRelationshipListViewModel(
loggerFactory,
accountRelationshipService,
new Concrete.StubAccountRelationshipItemViewModelFactory(),
new Mock <IAccountRelationshipCreateViewService>().Object,
new Mock <IAccountRelationshipEditViewService>().Object,
new Mock <IDeleteConfirmationViewService>().Object
);
Assert.AreEqual(2, viewModel.AccountRelationships.Count);
}
}
public void TestBalanceSheetWithLogicalAccounts()
{
ILoggerFactory loggerFactory = new LoggerFactory();
using (var sqliteMemoryWrapper = new SqliteMemoryWrapper())
{
var currencyFactory = new CurrencyFactory();
var usdCurrencyEntity = currencyFactory.Create(CurrencyPrefab.Usd, true);
currencyFactory.Add(sqliteMemoryWrapper.DbContext, usdCurrencyEntity);
var accountFactory = new AccountFactory();
Entities.Account incomeAccountEntity =
accountFactory.Create(AccountPrefab.Income, usdCurrencyEntity);
Entities.Account checkingAccountEntity =
accountFactory.Create(AccountPrefab.Checking, usdCurrencyEntity);
Entities.Account rentPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.RentPrepayment, usdCurrencyEntity);
Entities.Account groceriesPrepaymentAccountEntity =
accountFactory.Create(AccountPrefab.GroceriesPrepayment, usdCurrencyEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, incomeAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, checkingAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, rentPrepaymentAccountEntity);
accountFactory.Add(sqliteMemoryWrapper.DbContext, groceriesPrepaymentAccountEntity);
var checkingToRentPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = rentPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
var checkingToGroceriesPrepaymentRelationship = new Entities.AccountRelationship
{
SourceAccount = checkingAccountEntity,
DestinationAccount = groceriesPrepaymentAccountEntity,
Type = AccountRelationshipType.PhysicalToLogical
};
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToRentPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.AccountRelationships.Add(checkingToGroceriesPrepaymentRelationship);
sqliteMemoryWrapper.DbContext.SaveChanges();
var transactions = new Entities.Transaction[]
{
new Entities.Transaction
{
CreditAccount = incomeAccountEntity,
DebitAccount = checkingAccountEntity,
Amount = 100m,
At = new DateTime(2018, 1, 1)
},// income=100CR,checking=100DR
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = rentPrepaymentAccountEntity,
Amount = 40m,
At = new DateTime(2018, 1, 1)
},// income=100CR,(checking=60DR,rent-prepayment=40DR)=100DR
new Entities.Transaction
{
CreditAccount = checkingAccountEntity,
DebitAccount = groceriesPrepaymentAccountEntity,
Amount = 20m,
At = new DateTime(2018, 1, 1)
}// income=100CR,(checking=40DR,rent-prepayment=40DR,groceries-prepayment=20DR)=100DR
};
sqliteMemoryWrapper.DbContext.Transactions.AddRange(transactions);
sqliteMemoryWrapper.DbContext.SaveChanges();
var accountService = new AccountService(
loggerFactory,
sqliteMemoryWrapper.DbContext
);
var currencyService = new CurrencyService(
loggerFactory,
sqliteMemoryWrapper.DbContext
);
var balanceSheetService = new BalanceSheetService(
loggerFactory,
sqliteMemoryWrapper.DbContext
);
BalanceSheet balanceSheet = balanceSheetService.Generate(new DateTime(2018, 1, 1));
List <BalanceSheetItem> balanceSheetAssets = balanceSheet.Assets.ToList();
List <BalanceSheetItem> balanceSheetLiabilities = balanceSheet.Liabilities.ToList();
Assert.AreEqual(usdCurrencyEntity.Symbol, balanceSheet.CurrencySymbol);
Assert.AreEqual(100, balanceSheet.TotalAssets);
Assert.AreEqual(0, balanceSheet.TotalLiabilities);
Assert.AreEqual(100, balanceSheet.NetWorth);
Assert.AreEqual(1, balanceSheetAssets.Count);
Assert.AreEqual(0, balanceSheetLiabilities.Count);
Assert.AreEqual(checkingAccountEntity.Name, balanceSheetAssets[0].Name);
Assert.AreEqual(100, balanceSheetAssets[0].Balance);
}
}
