public void Create_ShouldReturnViewWithModel()
{
var assetAccount1 = new AssetAccount();
var assetAccount2 = new AssetAccount();
var liabilityAccount1 = new LiabilityAccount();
var liabilityAccount2 = new LiabilityAccount();
var accounts = new Account[] { assetAccount1, assetAccount2, liabilityAccount1, liabilityAccount2 };
_repository.Stub(x => x.Get<Account>()).Return(accounts);
var controller = GetController();
var result = (ViewResult)controller.Create();
Assert.That(result.ViewName, Is.EqualTo("Create"));
var viewModel = (CreateModel)result.Model;
Assert.That(viewModel.AssetAndLiabilityAccounts.Count(), Is.EqualTo(4));
Assert.That(viewModel.AssetAndLiabilityAccounts.Any(x => x.Id == assetAccount1.Id), Is.True);
Assert.That(viewModel.AssetAndLiabilityAccounts.Any(x => x.Id == assetAccount2.Id), Is.True);
Assert.That(viewModel.AssetAndLiabilityAccounts.Any(x => x.Id == liabilityAccount1.Id), Is.True);
Assert.That(viewModel.AssetAndLiabilityAccounts.Any(x => x.Id == liabilityAccount2.Id), Is.True);
Assert.That(viewModel.SelectedFromAccountId, Is.EqualTo(assetAccount1.Id));
Assert.That(viewModel.SelectedToAccountId, Is.EqualTo(assetAccount2.Id));
Assert.That(viewModel.Date, Is.EqualTo(DateTime.Today));
Assert.That(viewModel.Amount, Is.EqualTo(0));
Assert.That(viewModel.Comments, Is.Null);
}
public void Execute_WillGetBalanceForOnlyAssetAndLiabilityAccounts()
{
var repository = MockRepository.GenerateMock<IRepository>();
var getAccountBalanceForDateCommand = MockRepository.GenerateMock<IGetAccountBalanceForDateCommand>();
var date = DateTime.Today.AddDays(1);
const decimal assetAccountBalance = 100;
const decimal liabilityAccountBalance = 20;
var assetAccount = new AssetAccount { Name = "some asset account" };
var liabilityAccount = new LiabilityAccount { Name = "some liability account" };
var expenseAccount = new ExpenseAccount { Name = "some expense account" };
var incomeAccount = new IncomeAccount { Name = "some income account" };
var accounts = new List<Account> { assetAccount, liabilityAccount, expenseAccount, incomeAccount };
repository.Stub(x => x.Get<Account>()).Return(accounts);
getAccountBalanceForDateCommand.Stub(x => x.Execute(assetAccount.Id, date)).Return(assetAccountBalance);
getAccountBalanceForDateCommand.Stub(x => x.Execute(liabilityAccount.Id, date)).Return(liabilityAccountBalance);
var command = new GetAccountBalancesCommand(repository, getAccountBalanceForDateCommand);
var result = command.Execute(date);
Assert.That(result.Count(), Is.EqualTo(2));
Assert.That(result.Any(x => (x.AccountName == assetAccount.Name) && (x.Balance == assetAccountBalance)), Is.True);
Assert.That(result.Any(x => (x.AccountName == liabilityAccount.Name) && (x.Balance == liabilityAccountBalance)), Is.True);
}
public void Create_ShouldSaveTransactionToRepository()
{
const decimal amount = 100;
var date = DateTime.Today.AddDays(1);
const string comments = "something";
var assetAccount1 = new ExpenseAccount();
var assetAccount2 = new AssetAccount();
var model = new CreateModel();
model.Amount = amount;
model.Date = date;
model.Comments = comments;
model.SelectedFromAccountId = assetAccount1.Id;
model.SelectedToAccountId = assetAccount2.Id;
_repository.Stub(x => x.Find<Account>(assetAccount1.Id)).Return(assetAccount1);
_repository.Stub(x => x.Find<Account>(assetAccount2.Id)).Return(assetAccount2);
_repository.Expect(x => x.Save(Arg<TransferTransaction>.Matches(
y =>
(y.Date == date) &&
(y.Comments == comments) &&
(y.Entries.Count == 2) &&
(y.Entries.Any(z => (z.Account.Id == assetAccount1.Id) && (z.Amount == amount) && (z.Type == EntryType.Credit))) &&
(y.Entries.Any(z => (z.Account.Id == assetAccount2.Id) && (z.Amount == amount) && (z.Type == EntryType.Debit)))))).Return(null);
var controller = GetController();
controller.Create(model);
_repository.VerifyAllExpectations();
}
public void Account_ShouldSetAndGet()
{
var account = new AssetAccount();
var entry = new Entry();
Assert.That(entry.Account, Is.Null);
entry.Account = account;
Assert.That(entry.Account, Is.EqualTo(account));
}
public void Name_ShouldSetAndGet()
{
var name = "some account name";
var account = new AssetAccount();
Assert.That(account.Name, Is.Null);
account.Name = name;
Assert.That(account.Name, Is.EqualTo(name));
}
public void Create_ShouldReturnRedirectToIndex()
{
const AccountType type = AccountType.Asset;
var account = new AssetAccount();
_accountFactory.Stub(x => x.Create(type)).Return(account);
var controller = GetController();
var result = (RedirectToRouteResult)controller.Create(new CreateModel { AccountType = type });
Assert.That(result.RouteValues["action"], Is.EqualTo("Index"));
}
public void Create_ShouldReturnRedirectToIndex()
{
var assetAccount1 = new ExpenseAccount();
var assetAccount2 = new AssetAccount();
var model = new CreateModel();
model.SelectedFromAccountId = assetAccount1.Id;
model.SelectedToAccountId = assetAccount2.Id;
_repository.Stub(x => x.Find<Account>(assetAccount1.Id)).Return(assetAccount1);
_repository.Stub(x => x.Find<Account>(assetAccount2.Id)).Return(assetAccount2);
var controller = GetController();
var result = (RedirectToRouteResult)controller.Create(model);
Assert.That(result.RouteValues["action"], Is.EqualTo("Index"));
Assert.That(result.RouteValues["controller"], Is.EqualTo("Transaction"));
}
public void Create_ShouldGetAccountFromFactoryAndSaveToRepository()
{
const string name = "some name";
const AccountType type = AccountType.Asset;
var account = new AssetAccount();
_accountFactory.Expect(x => x.Create(type)).Return(account);
_repository.Expect(x => x.Save(
Arg<Account>.Matches(y =>
(y.Name == name) &&
(y.AccountType == type)
)));
var controller = GetController();
controller.Create(new CreateModel { Name = name, AccountType = type });
_accountFactory.VerifyAllExpectations();
_repository.VerifyAllExpectations();
}
public void Configure_ShouldSetPropertiesAsExpected()
{
const decimal amount = 100;
var date = DateTime.Today.AddDays(1);
const string comments = "something";
var assetAccount = new AssetAccount();
var liabilityAccount = new LiabilityAccount();
var transaction = new TransferTransaction();
transaction.Configure(amount)
.ForDate(date)
.WithComments(comments)
.FromAccount(assetAccount)
.ToAccount(liabilityAccount);
Assert.That(transaction.Date, Is.EqualTo(date));
Assert.That(transaction.Comments, Is.EqualTo(comments));
Assert.That(transaction.Entries.Count, Is.EqualTo(2));
Assert.That(transaction.Entries.Any(x => (x.Amount == amount) && (x.Type == EntryType.Credit) && (x.Account == assetAccount)), Is.True);
Assert.That(transaction.Entries.Any(x => (x.Amount == amount) && (x.Type == EntryType.Debit) && (x.Account == liabilityAccount)), Is.True);
}
public Account Create(AccountType type)
{
Account account = null;
switch (type)
{
case AccountType.Asset:
account = new AssetAccount();
break;
case AccountType.Income:
account = new IncomeAccount();
break;
case AccountType.Expense:
account = new ExpenseAccount();
break;
case AccountType.Liability:
account = new LiabilityAccount();
break;
}
return account;
}
public void AccountType_ShouldReturnAsset()
{
var account = new AssetAccount();
Assert.That(account.AccountType, Is.EqualTo(AccountType.Asset));
}
public void Edit_ShouldReturnViewWithModel()
{
var assetAccount1 = new AssetAccount();
var assetAccount2 = new AssetAccount();
var liabilityAccount1 = new LiabilityAccount();
var liabilityAccount2 = new LiabilityAccount();
var accounts = new Account[] { assetAccount1, assetAccount2, liabilityAccount1, liabilityAccount2 };
const string comments = "something";
const decimal amount = 100;
var date = DateTime.Today.AddDays(1);
var TransferTransaction = new TransferTransaction();
TransferTransaction.Configure(amount)
.ForDate(date)
.WithComments(comments)
.FromAccount(assetAccount1)
.ToAccount(assetAccount2);
_repository.Stub(x => x.Find<TransferTransaction>(TransferTransaction.Id)).Return(TransferTransaction);
_repository.Stub(x => x.Get<Account>()).Return(accounts);
var controller = GetController();
var result = (ViewResult)controller.Edit(TransferTransaction.Id);
Assert.That(result.ViewName, Is.EqualTo("Edit"));
var viewModel = (EditModel)result.Model;
Assert.That(viewModel.Id, Is.EqualTo(TransferTransaction.Id));
Assert.That(viewModel.AssetAndLiabilityAccounts.Count(), Is.EqualTo(4));
Assert.That(viewModel.AssetAndLiabilityAccounts.Any(x => x.Id == assetAccount1.Id), Is.True);
Assert.That(viewModel.AssetAndLiabilityAccounts.Any(x => x.Id == assetAccount2.Id), Is.True);
Assert.That(viewModel.AssetAndLiabilityAccounts.Any(x => x.Id == liabilityAccount1.Id), Is.True);
Assert.That(viewModel.AssetAndLiabilityAccounts.Any(x => x.Id == liabilityAccount2.Id), Is.True);
Assert.That(viewModel.SelectedFromAccountId, Is.EqualTo(assetAccount1.Id));
Assert.That(viewModel.SelectedToAccountId, Is.EqualTo(assetAccount2.Id));
Assert.That(viewModel.Date, Is.EqualTo(date));
Assert.That(viewModel.Amount, Is.EqualTo(amount));
Assert.That(viewModel.Comments, Is.EqualTo(comments));
}
public void Edit_ShouldSaveTransactionToRepository()
{
const decimal amount = 100;
var date = DateTime.Today.AddDays(1);
const string comments = "something";
var expenseAccount = new ExpenseAccount();
var assetAccount = new AssetAccount();
var expenseTransaction = new ExpenseTransaction();
var model = new EditModel();
model.Id = expenseTransaction.Id;
model.Amount = amount;
model.Date = date;
model.Comments = comments;
model.SelectedExpenseAccountId = expenseAccount.Id;
model.SelectedAssetOrLiabilityAccountId = assetAccount.Id;
_repository.Stub(x => x.Find<ExpenseTransaction>(expenseTransaction.Id)).Return(expenseTransaction);
_repository.Stub(x => x.Find<Account>(expenseAccount.Id)).Return(expenseAccount);
_repository.Stub(x => x.Find<Account>(assetAccount.Id)).Return(assetAccount);
_repository.Expect(x => x.Save(Arg<ExpenseTransaction>.Matches(
y =>
(y.Date == date) &&
(y.Comments == comments) &&
(y.Entries.Count == 2) &&
(y.Entries.Any(z => (z.Account.Id == expenseAccount.Id) && (z.Amount == amount) && (z.Type == EntryType.Debit))) &&
(y.Entries.Any(z => (z.Account.Id == assetAccount.Id) && (z.Amount == amount) && (z.Type == EntryType.Credit)))))).Return(null);
var controller = GetController();
controller.Edit(model);
_repository.VerifyAllExpectations();
}
public void Edit_ShouldReturnViewWithModel()
{
var expenseAccount1 = new ExpenseAccount();
var expenseAccount2 = new ExpenseAccount();
var assetAccount = new AssetAccount();
var liabilityAccount = new LiabilityAccount();
var accounts = new Account[] { expenseAccount1, expenseAccount2, assetAccount, liabilityAccount };
const string comments = "something";
const decimal amount = 100;
var date = DateTime.Today.AddDays(1);
var expenseTransaction = new ExpenseTransaction();
expenseTransaction.Configure(amount)
.ForDate(date)
.WithComments(comments)
.ExpenseAccount(expenseAccount2)
.AccountToCredit(liabilityAccount);
_repository.Stub(x => x.Find<ExpenseTransaction>(expenseTransaction.Id)).Return(expenseTransaction);
_repository.Stub(x => x.Get<Account>()).Repeat.Times(2).Return(accounts);
var controller = GetController();
var result = (ViewResult)controller.Edit(expenseTransaction.Id);
Assert.That(result.ViewName, Is.EqualTo("Edit"));
var viewModel = (EditModel)result.Model;
Assert.That(viewModel.Id, Is.EqualTo(expenseTransaction.Id));
Assert.That(viewModel.ExpenseAccounts.Count(), Is.EqualTo(2));
Assert.That(viewModel.ExpenseAccounts.Any(x => x.Id == expenseAccount1.Id), Is.True);
Assert.That(viewModel.ExpenseAccounts.Any(x => x.Id == expenseAccount2.Id), Is.True);
Assert.That(viewModel.SelectedExpenseAccountId, Is.EqualTo(expenseAccount2.Id));
Assert.That(viewModel.AssetAndLiabilityAccounts.Count(), Is.EqualTo(2));
Assert.That(viewModel.AssetAndLiabilityAccounts.Any(x => x.Id == assetAccount.Id), Is.True);
Assert.That(viewModel.AssetAndLiabilityAccounts.Any(x => x.Id == liabilityAccount.Id), Is.True);
Assert.That(viewModel.SelectedAssetOrLiabilityAccountId, Is.EqualTo(liabilityAccount.Id));
Assert.That(viewModel.Date, Is.EqualTo(date));
Assert.That(viewModel.Amount, Is.EqualTo(amount));
Assert.That(viewModel.Comments, Is.EqualTo(comments));
}
public void Edit_ShouldReturnViewWithModel()
{
const string accountName = "some account";
var id = Guid.NewGuid();
var account = new AssetAccount { Name = accountName };
_repository.Stub(x => x.Find<Account>(id)).Return(account);
var controller = GetController();
var result = (ViewResult)controller.Edit(id);
Assert.That(result.ViewName, Is.EqualTo("Edit"));
Assert.That(((EditModel)result.Model).Id, Is.EqualTo(id));
Assert.That(((EditModel)result.Model).Name, Is.EqualTo(accountName));
Assert.That(((EditModel)result.Model).AccountType, Is.EqualTo(account.AccountType));
}
public void Edit_ShouldReturnViewWithModel()
{
var incomeAccount1 = new IncomeAccount();
var incomeAccount2 = new IncomeAccount();
var assetAccount1 = new AssetAccount();
var assetAccount2 = new AssetAccount();
var accounts = new Account[] { incomeAccount1, incomeAccount2, assetAccount1, assetAccount2 };
const string comments = "something";
const decimal amount = 100;
var date = DateTime.Today.AddDays(1);
var IncomeTransaction = new IncomeTransaction();
IncomeTransaction.Configure(amount)
.ForDate(date)
.WithComments(comments)
.IncomeAccount(incomeAccount2)
.AccountToDebit(assetAccount2);
_repository.Stub(x => x.Find<IncomeTransaction>(IncomeTransaction.Id)).Return(IncomeTransaction);
_repository.Stub(x => x.Get<Account>()).Repeat.Times(2).Return(accounts);
var controller = GetController();
var result = (ViewResult)controller.Edit(IncomeTransaction.Id);
Assert.That(result.ViewName, Is.EqualTo("Edit"));
var viewModel = (EditModel)result.Model;
Assert.That(viewModel.Id, Is.EqualTo(IncomeTransaction.Id));
Assert.That(viewModel.IncomeAccounts.Count(), Is.EqualTo(2));
Assert.That(viewModel.IncomeAccounts.Any(x => x.Id == incomeAccount1.Id), Is.True);
Assert.That(viewModel.IncomeAccounts.Any(x => x.Id == incomeAccount2.Id), Is.True);
Assert.That(viewModel.SelectedIncomeAccountId, Is.EqualTo(incomeAccount2.Id));
Assert.That(viewModel.AssetAccounts.Count(), Is.EqualTo(2));
Assert.That(viewModel.AssetAccounts.Any(x => x.Id == assetAccount1.Id), Is.True);
Assert.That(viewModel.AssetAccounts.Any(x => x.Id == assetAccount2.Id), Is.True);
Assert.That(viewModel.SelectedAssetAccountId, Is.EqualTo(assetAccount2.Id));
Assert.That(viewModel.Date, Is.EqualTo(date));
Assert.That(viewModel.Amount, Is.EqualTo(amount));
Assert.That(viewModel.Comments, Is.EqualTo(comments));
}
