public void Update()
{
//Arrange
var card = new Card()
{
Id = 1
};
var iRepositoryCard = new MockIRepository <Card>()
.MockUpdate(card);
var iRepositoryAccount = new MockIRepository <Account>();
var cardRepository = new MockCardRepository();
var accountRepository = new MockAccountRepository();
var cardService = new CardService(
cardRepository.Object,
accountRepository.Object,
new EncryptionService(),
iRepositoryAccount.Object,
iRepositoryCard.Object);
//Act
var createdCard = cardService.Update(card);
//Assert
Assert.IsNotNull(createdCard);
}
public void WithdrawMoney_InsufficientFundsTest()
{
var accountId = Guid.NewGuid();
var user = new User {
Id = Guid.NewGuid(), Name = "User", Email = ""
};
var account = new Account {
Id = accountId, Balance = 0, User = user
};
IAccountRepository accounts = new MockAccountRepository();
accounts.Add(account);
var notificationService = new MockNotificationService();
WithdrawMoney withdrawMoneyFeature = new WithdrawMoney(accounts, notificationService);
try
{
withdrawMoneyFeature.Execute(accountId, 100);
}
catch (InvalidOperationException ex)
{
if (ex.Message == "Insufficient funds to make transfer")
{
return;
}
}
Assert.Fail();
}
public void GetByNumber()
{
//Arrange
var card = new Card()
{
CardNumber = "1"
};
var iRepositoryCard = new MockIRepository <Card>();
var iRepositoryAccount = new MockIRepository <Account>();
var cardRepository = new MockCardRepository()
.MockGetByNumber(card);
var accountRepository = new MockAccountRepository();
var cardService = new CardService(
cardRepository.Object,
accountRepository.Object,
new EncryptionService(),
iRepositoryAccount.Object,
iRepositoryCard.Object);
//Act
var cardByNumber = cardService.GetByNumber(card.CardNumber);
//Assert
Assert.IsNotNull(cardByNumber);
}
public void Get()
{
//Arrange
var cards = new List <Card>()
{
new Card()
{
Id = 1
}
};
var iRepositoryCard = new MockIRepository <Card>()
.MockGet(cards);
var iRepositoryAccount = new MockIRepository <Account>();
var cardRepository = new MockCardRepository();
var accountRepository = new MockAccountRepository();
var cardService = new CardService(
cardRepository.Object,
accountRepository.Object,
new EncryptionService(),
iRepositoryAccount.Object,
iRepositoryCard.Object);
//Act
var getCards = cardService.Get();
//Assert
Assert.IsNotNull(getCards);
}
public void TransferMoney_SufficientFunds_UnderPayInLimit()
{
var fromAccountId = Guid.NewGuid();
var toAccountId = Guid.NewGuid();
var user = new User {
Id = Guid.NewGuid(), Name = "User", Email = ""
};
var fromAccount = new Account {
Id = fromAccountId, Balance = 100, User = user
};
var toAccount = new Account {
Id = toAccountId, Balance = 0, User = user
};
IAccountRepository accounts = new MockAccountRepository();
accounts.Add(fromAccount);
accounts.Add(toAccount);
var notificationService = new MockNotificationService();
TransferMoney transferMoneyFeature = new TransferMoney(accounts, notificationService);
transferMoneyFeature.Execute(fromAccountId, toAccountId, 100);
fromAccount = accounts.GetAccountById(fromAccountId);
toAccount = accounts.GetAccountById(toAccountId);
Assert.AreEqual(0, fromAccount.Balance);
Assert.AreEqual(-100, fromAccount.Withdrawn);
Assert.AreEqual(100, toAccount.Balance);
Assert.AreEqual(100, toAccount.PaidIn);
}
public void Get()
{
//Arrange
var accounts = new List <Account>()
{
new Account()
{
Id = 1
}
};
var iRepository = new MockIRepository <Account>()
.MockGet(accounts);
var accountRepository = new MockAccountRepository();
var cardRepository = new MockCardRepository();
var accountService = new AccountService(
accountRepository.Object,
new EncryptionService(),
iRepository.Object,
cardRepository.Object);
//Act
var gotAccounts = accountService.Get();
//Assert
Assert.IsNotNull(gotAccounts);
}
public async Task ItShouldReturnAnAccountForEachItemInResponseIfFound()
{
var accountDetailModels = new List <Core.Models.Account>
{
new Core.Models.Account
{
AccountId = 123,
OwnerEmail = "*****@*****.**",
HashedAccountId = "ABC78"
},
new Core.Models.Account
{
AccountId = 124,
OwnerEmail = "*****@*****.**",
HashedAccountId = "DEF12"
}
};
MockAccountRepository.Setup(r => r.FindAllDetails(10, 1)).ReturnsAsync(accountDetailModels);
var actual = await Unit.FindAllAccounts(10, 1);
Assert.IsNotNull(actual);
Assert.AreEqual(2, actual.Count());
}
public void CanLoadAllAccounts()
{
var repo = new MockAccountRepository();
var accounts = repo.ListAccounts();
Assert.AreEqual(3, accounts.Count);
}
public void CanLoadSpecificAccount(int accountNumber, string expected)
{
var repo = new MockAccountRepository();
var account = repo.LoadAccount(accountNumber);
Assert.AreEqual(expected, account.Name);
}
public void WithdrawMoney_SufficientFundsTest()
{
var accountId = Guid.NewGuid();
var user = new User {
Id = Guid.NewGuid(), Name = "User", Email = ""
};
var account = new Account {
Id = accountId, Balance = 100, User = user
};
IAccountRepository accounts = new MockAccountRepository();
accounts.Add(account);
var notificationService = new MockNotificationService();
WithdrawMoney withdrawMoneyFeature = new WithdrawMoney(accounts, notificationService);
withdrawMoneyFeature.Execute(accountId, 100);
account = accounts.GetAccountById(accountId);
Assert.AreEqual(0, account.Balance);
Assert.AreEqual(-100, account.Withdrawn);
}
public void TransferMoney_Should_ThrowMoneyNotEnoughException_When_TotalBalanceIsLessThanAmoutToTransfer()
{
var sender = "NL95INGB1938035321";
var payee = "NL13ABNA7035378898";
var dto = new TransferMoneyDto
{
payee_iban_number = payee,
sender_iban_number = sender,
amount = 2000
};
Account senderInstance = new Account();
Account payeeInstance = new Account();
MockAccountRepository.Setup(x => x.GetByIBanNumber(sender)).Returns(Task.FromResult(senderInstance));
MockAccountRepository.Setup(x => x.GetByIBanNumber(payee)).Returns(Task.FromResult(payeeInstance));
IEnumerable <Statement> statements = new List <Statement>
{
new Statement {
Amount = 100
},
new Statement {
Amount = 1000
}
};
MockStatementRepository.Setup(x => x.GetByAccountId(It.IsAny <int>())).Returns(Task.FromResult(statements));
Assert.ThrowsAsync <MoneyNotEnoughException>(() => _testService.TransferMoney(dto));
}
public async Task ItShouldReturnNoAccountInTheResponseIfNotFoundInFindFinance()
{
MockAccountRepository.Setup(x => x.Get(Id, AccountFieldsSelection.Finance))
.ReturnsAsync(null as Core.Models.Account);
var actual = await Unit.FindFinance(Id);
Assert.AreEqual(SearchResponseCodes.NoSearchResultsFound, actual.StatusCode);
}
public void Test_TransferMoney_MoneyIsNotEnough()
{
MockAccountRepository.Setup(m => m.GetAccount(123))
.Returns(new Account(123, 100, new List <TransferHistory>()));
MockAccountRepository.Setup(m => m.GetAccount(456))
.Returns(new Account(456, 500, new List <TransferHistory>()));
Assert.Throws <NotSupportedException>(()
=>
{ TransferService.TransferMoney(456, 123, 200); });
}
public async Task ItShouldReturnAnEmptyCollectionIfNotFound()
{
var accountDetailModels = new List <Core.Models.Account>();
MockAccountRepository.Setup(r => r.FindAllDetails(10, 1)).ReturnsAsync(accountDetailModels);
var actual = await Unit.FindAllAccounts(10, 1);
Assert.IsNotNull(actual);
Assert.AreEqual(0, actual.Count());
}
public void Test_TransferMoney_MoneyIsEnough()
{
var s = MockAccountRepository.Setup(m => m.GetAccount(123))
.Returns(new Account(123, 100, new List <TransferHistory>()));
MockAccountRepository.Setup(m => m.GetAccount(456))
.Returns(new Account(456, 500, new List <TransferHistory>()));
Assert.DoesNotThrow(()
=>
{ TransferService.TransferMoney(456, 123, 50); });
}
public void Deposit_Should_ThrowValidationException_When_IbanNumberAlreadyExists()
{
var dto = new StatementDepositDto
{
iban_number = "NL13ABNA7035378898",
amount = 100
};
MockAccountRepository.Setup(x => x.HasAccount(It.IsAny <string>())).Returns(Task.FromResult(false));
Assert.ThrowsAsync <ValidationException>(() => _testService.Deposit(dto));
}
public void Register_Should_ThrowValidationException_When_AccontNameIsInvalid(string accountName)
{
var dto = new AccountRegisterDto
{
iban_number = "NL13ABNA7035378898",
acccount_name = accountName
};
MockAccountRepository.Setup(x => x.IsUniqueIbanNumber(It.IsAny <string>())).Returns(Task.FromResult(true));
Assert.ThrowsAsync <ValidationException>(() => _testService.Register(dto));
}
public void Register_Should_ThrowValidationException_When_IbanNumberAlreadyExists()
{
var dto = new AccountRegisterDto
{
iban_number = "NL13ABNA7035378898",
acccount_name = "My name is Hero"
};
MockAccountRepository.Setup(x => x.IsUniqueIbanNumber(It.IsAny <string>())).Returns(Task.FromResult(false));
Assert.ThrowsAsync <ValidationException>(() => _testService.Register(dto));
}
public void Register_Should_Success_When_DtoIsValid()
{
var dto = new AccountRegisterDto
{
iban_number = "NL13ABNA7035378898",
acccount_name = "My name is Hero"
};
MockAccountRepository.Setup(x => x.IsUniqueIbanNumber(It.IsAny <string>())).Returns(Task.FromResult(true));
MockAccountRepository.Setup(x => x.Add(It.IsAny <Account>())).Returns(Task.FromResult(new Account()));
var result = _testService.Register(dto).Result;
Assert.IsNotNull(result);
}
public void Deposit_Should_Success_When_DtoIsValid()
{
var dto = new StatementDepositDto
{
iban_number = "NL13ABNA7035378898",
amount = 100
};
MockAccountRepository.Setup(x => x.HasAccount(It.IsAny <string>())).Returns(Task.FromResult(true));
MockStatementRepository.Setup(x => x.Add(It.IsAny <Statement>())).Returns(Task.FromResult(new Statement()));
var result = _testService.Deposit(dto).Result;
Assert.IsNotNull(result);
}
public async Task ItShouldReturnAccountInResponseIfFound()
{
var accountId = 123L;
var orgid = accountId.ToString();
var account = new Core.Models.Account {
AccountId = accountId
};
MockAccountRepository.Setup(r => r.Get(orgid, AccountFieldsSelection.None)).ReturnsAsync(account);
var actual = await Unit.Find(orgid);
Assert.IsNotNull(actual);
Assert.AreEqual(SearchResponseCodes.Success, actual.StatusCode);
Assert.IsNotNull(actual.Account);
}
public async Task ItShouldReturnNoAccountInTheResponseIfNotFound()
{
var accountId = 123L;
var orgid = accountId.ToString();
var account = new Core.Models.Account {
AccountId = accountId
};
MockAccountRepository.Setup(r => r.Get(orgid, AccountFieldsSelection.PayeSchemes))
.ReturnsAsync(null as Core.Models.Account);
var actual = await Unit.FindPayeSchemes(orgid);
Assert.IsNotNull(actual);
Assert.AreEqual(new AccountDetailOrganisationsResponse().StatusCode, actual.StatusCode);
Assert.IsNull(actual.Account);
}
public async Task ItShouldReturnTheAccountWithBallanceLookupIfNoTransactionsAreFound()
{
MockAccountRepository.Setup(x => x.Get(Id, AccountFieldsSelection.Finance))
.Returns(Task.FromResult(new Core.Models.Account
{
Transactions = new List <TransactionViewModel>()
}));
MockAccountRepository.Setup(x => x.GetAccountBalance(Id))
.ReturnsAsync(0m);
var actual = await Unit.FindFinance(Id);
MockAccountRepository.Verify(x => x.GetAccountBalance(Id), Times.Once);
Assert.AreEqual(SearchResponseCodes.Success, actual.StatusCode);
Assert.IsNotNull(actual.Account);
}
public void TransferMoney_Should_ThrowAccountNotFoundExceptionn_When_PayeeAccountWasNotFound()
{
var sender = "NL95INGB1938035321";
var payee = "NL13ABNA7035378898";
var dto = new TransferMoneyDto
{
payee_iban_number = payee,
sender_iban_number = sender,
amount = 2000
};
Account senderInstance = new Account();
Account payeeInstance = null;
MockAccountRepository.Setup(x => x.GetByIBanNumber(sender)).Returns(Task.FromResult(senderInstance));
MockAccountRepository.Setup(x => x.GetByIBanNumber(payee)).Returns(Task.FromResult(payeeInstance));
Assert.ThrowsAsync <AccountNotFoundException>(() => _testService.TransferMoney(dto));
}
public async Task ItShouldReturnTheAccountWithBalanceFromTransactionsIfFound()
{
MockAccountRepository.Setup(x => x.Get(Id, AccountFieldsSelection.Finance))
.ReturnsAsync(new Core.Models.Account
{
Transactions = new List <TransactionViewModel> {
new TransactionViewModel {
Balance = 100m
}
}
});
var actual = await Unit.FindFinance(Id);
MockAccountRepository.Verify(x => x.GetAccountBalance(Id), Times.Never);
Assert.AreEqual(SearchResponseCodes.Success, actual.StatusCode);
Assert.IsNotNull(actual.Account);
}
public void TransferMoney_Should_Success_When_AmountIsLessThanTotalBalance()
{
var sender = "NL95INGB1938035321";
var payee = "NL13ABNA7035378898";
var dto = new TransferMoneyDto
{
payee_iban_number = payee,
sender_iban_number = sender,
amount = 2000
};
Account senderInstance = new Account();
Account payeeInstance = new Account();
MockAccountRepository.Setup(x => x.GetByIBanNumber(sender)).Returns(Task.FromResult(senderInstance));
MockAccountRepository.Setup(x => x.GetByIBanNumber(payee)).Returns(Task.FromResult(payeeInstance));
IEnumerable <Statement> statements = new List <Statement>
{
new Statement {
Amount = 100
},
new Statement {
Amount = 1000
},
new Statement {
Amount = 10000
}
};
MockStatementRepository.Setup(x => x.GetByAccountId(It.IsAny <int>())).Returns(Task.FromResult(statements));
TransferMoneyResultDto resultDto = new TransferMoneyResultDto {
success = true
};
MockTransactionRepository.Setup(x => x.SaveTransferringMoney(It.IsAny <TransferMoneyFullDto>())).Returns(Task.FromResult(resultDto));
var result = _testService.TransferMoney(dto).Result;
Assert.IsTrue(result.success);
}
public void Update()
{
//Arrange
var account = new Account()
{
Id = 1
};
var iRepository = new MockIRepository <Account>()
.MockUpdate(account);
var accountRepository = new MockAccountRepository();
var cardRepository = new MockCardRepository();
var accountService = new AccountService(
accountRepository.Object,
new EncryptionService(),
iRepository.Object,
cardRepository.Object);
//Act
var updatedAccount = accountService.Update(account);
//Assert
Assert.IsNotNull(updatedAccount);
}
public void GetById()
{
//Arrange
var account = new Account()
{
Id = 1
};
var iRepository = new MockIRepository <Account>()
.MockGetById(account);
var accountRepository = new MockAccountRepository();
var cardRepository = new MockCardRepository();
var accountService = new AccountService(
accountRepository.Object,
new EncryptionService(),
iRepository.Object,
cardRepository.Object);
//Act
var accountById = accountService.GetById(1);
//Assert
Assert.IsNotNull(accountById);
}
public void TransferMoney_SufficientFunds_OverPayInLimit()
{
var fromAccountId = Guid.NewGuid();
var toAccountId = Guid.NewGuid();
var user = new User {
Id = Guid.NewGuid(), Name = "User", Email = ""
};
var fromAccount = new Account {
Id = fromAccountId, Balance = Account.PayInLimit + 1, User = user
};
var toAccount = new Account {
Id = toAccountId, Balance = 0, User = user
};
IAccountRepository accounts = new MockAccountRepository();
accounts.Add(fromAccount);
accounts.Add(toAccount);
var notificationService = new MockNotificationService();
TransferMoney transferMoneyFeature = new TransferMoney(accounts, notificationService);
try
{
transferMoneyFeature.Execute(fromAccountId, toAccountId, fromAccount.Balance);
}
catch (InvalidOperationException ex)
{
if (ex.Message == "Account pay in limit reached")
{
return;
}
}
Assert.Fail();
}
