public void BankAccountWithdrawMoneyAnotateActivity()
{
//Arrange
Country country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
string activityReason = "reason";
var customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", "+3422", "company", country, new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
//Act
bankAccount.DepositMoney(1000, activityReason);
bankAccount.WithdrawMoney(1000, activityReason);
//Assert
Assert.True(bankAccount.Balance == 0);
Assert.NotNull(bankAccount.BankAccountActivity);
Assert.True(bankAccount.BankAccountActivity.Any());
Assert.True(bankAccount.BankAccountActivity.Last().Amount == -1000);
Assert.True(bankAccount.BankAccountActivity.Last().ActivityDescription == activityReason);
}
public void BankAccountFactoryCreateValidBankAccount()
{
//Arrange
var country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var customer = CustomerFactory.CreateCustomer(
"Unai",
"Zorrilla Castro",
"+3422",
"company",
country,
new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
BankAccount bankAccount = null;
//Act
bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
var validationContext = new ValidationContext(bankAccount, null, null);
var validationResults = customer.Validate(validationContext);
//Assert
Assert.IsNotNull(bankAccount);
Assert.IsTrue(bankAccount.BankAccountNumber == bankAccountNumber);
Assert.IsFalse(bankAccount.Locked);
Assert.IsTrue(bankAccount.CustomerId == customer.Id);
Assert.IsFalse(validationResults.Any());
}
public void BankAccountFactoryCreateValidBankAccount()
{
//Arrange
var country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", "+3422", "company", country, new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
BankAccount bankAccount = null;
//Act
bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
var validationContext = new ValidationContext(bankAccount, null, null);
var validationResults = customer.Validate(validationContext);
//Assert
Assert.NotNull(bankAccount);
Assert.True(bankAccount.BankAccountNumber == bankAccountNumber);
Assert.False(bankAccount.Locked);
Assert.True(bankAccount.CustomerId == customer.Id);
Assert.False(validationResults.Any());
}
public void BankAccountDepositMaxDecimalThrowOverflowBalance()
{
//Arrange
var country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var activityReason = "reason";
var customer = CustomerFactory.CreateCustomer(
"Unai",
"Zorrilla Castro",
"+3422",
"company",
country,
new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
customer.GenerateNewIdentity();
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
bankAccount.DepositMoney(1, activityReason);
bankAccount.DepositMoney(Decimal.MaxValue, activityReason);
}
public void GenerateAccountNumber_Should_ReturnIban()
{
var expectedBankAccountNumber = new BankAccountNumber
{
CountryCode = "PL",
CheckDigits = "61",
NationalBankCode = "1080",
BranchCode = "000",
NationalCheckDigit = 1,
AccountNumber = 0,
AccountNumberText = "0000000000000000",
Iban = "PL61108000010000000000000000",
IbanSeparated = "PL 61 1080 0001 0000 0000 0000 0000"
};
var result = _sut.GenerateBankAccountNumber(1);
Assert.AreEqual(expectedBankAccountNumber.CountryCode, result.CountryCode);
Assert.AreEqual(expectedBankAccountNumber.CheckDigits, result.CheckDigits);
Assert.AreEqual(expectedBankAccountNumber.NationalBankCode, result.NationalBankCode);
Assert.AreEqual(expectedBankAccountNumber.BranchCode, result.BranchCode);
Assert.AreEqual(expectedBankAccountNumber.NationalCheckDigit, result.NationalCheckDigit);
Assert.AreEqual(expectedBankAccountNumber.AccountNumber, result.AccountNumber);
Assert.AreEqual(expectedBankAccountNumber.AccountNumberText, result.AccountNumberText);
Assert.AreEqual(expectedBankAccountNumber.Iban, result.Iban);
Assert.AreEqual(expectedBankAccountNumber.IbanSeparated, result.IbanSeparated);
}
public void BankAccountRepositoryAddNewItemSaveItem()
{
//Arrange
var unitOfWork = new MainBCUnitOfWork();
var customerRepository = new CustomerRepository(unitOfWork);
var bankAccountRepository = new BankAccountRepository(unitOfWork);
var customer = customerRepository.Get(new Guid("43A38AC8-EAA9-4DF0-981F-2685882C7C45"));
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var newBankAccount = BankAccountFactory.CreateBankAccount(customer,bankAccountNumber);
//Act
bankAccountRepository.Add(newBankAccount);
try
{
unitOfWork.Commit();
}
catch (DbUpdateException ex)
{
var entry = ex.Entries.First();
}
}
public void BankAccountRepositoryAddNewItemSaveItem()
{
//Arrange
var unitOfWork = new MainBCUnitOfWork();
var customerRepository = new CustomerRepository(unitOfWork);
var bankAccountRepository = new BankAccountRepository(unitOfWork);
var customer = customerRepository.Get(new Guid("43A38AC8-EAA9-4DF0-981F-2685882C7C45"));
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var newBankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
//Act
bankAccountRepository.Add(newBankAccount);
try
{
unitOfWork.Commit();
}
catch (DbUpdateException ex)
{
var entry = ex.Entries.First();
}
}
public void GenerateAccountNumber_Should_ReturnIbanWithIteratedAccountNumber_When_SomeAccountNumberExistsInDb()
{
_context.BankAccounts.Add(new BankAccount {
AccountNumber = 0
});
_context.SaveChanges();
var expectedBankAccountNumber = new BankAccountNumber
{
CountryCode = "PL",
CheckDigits = "34",
NationalBankCode = "1080",
BranchCode = "000",
NationalCheckDigit = 1,
AccountNumber = 1,
AccountNumberText = "0000000000000001",
Iban = "PL34108000010000000000000001",
IbanSeparated = "PL 34 1080 0001 0000 0000 0000 0001"
};
var result = _sut.GenerateBankAccountNumber(1);
Assert.AreEqual(expectedBankAccountNumber.CountryCode, result.CountryCode);
Assert.AreEqual(expectedBankAccountNumber.CheckDigits, result.CheckDigits);
Assert.AreEqual(expectedBankAccountNumber.NationalBankCode, result.NationalBankCode);
Assert.AreEqual(expectedBankAccountNumber.BranchCode, result.BranchCode);
Assert.AreEqual(expectedBankAccountNumber.NationalCheckDigit, result.NationalCheckDigit);
Assert.AreEqual(expectedBankAccountNumber.AccountNumber, result.AccountNumber);
Assert.AreEqual(expectedBankAccountNumber.AccountNumberText, result.AccountNumberText);
Assert.AreEqual(expectedBankAccountNumber.Iban, result.Iban);
Assert.AreEqual(expectedBankAccountNumber.IbanSeparated, result.IbanSeparated);
}
public void GenerateAccountNumber_Should_ReturnIbanWithHeadquartersBranchCode_When_NoBranchIdIsPassedToMethod()
{
var expectedBankAccountNumber = new BankAccountNumber
{
CountryCode = "PL",
CheckDigits = "27",
NationalBankCode = "1080",
BranchCode = "001",
NationalCheckDigit = 4,
AccountNumber = 0,
AccountNumberText = "0000000000000000",
Iban = "PL27108000140000000000000000",
IbanSeparated = "PL 27 1080 0014 0000 0000 0000 0000"
};
var result = _sut.GenerateBankAccountNumber();
Assert.AreEqual(expectedBankAccountNumber.CountryCode, result.CountryCode);
Assert.AreEqual(expectedBankAccountNumber.CheckDigits, result.CheckDigits);
Assert.AreEqual(expectedBankAccountNumber.NationalBankCode, result.NationalBankCode);
Assert.AreEqual(expectedBankAccountNumber.BranchCode, result.BranchCode);
Assert.AreEqual(expectedBankAccountNumber.NationalCheckDigit, result.NationalCheckDigit);
Assert.AreEqual(expectedBankAccountNumber.AccountNumber, result.AccountNumber);
Assert.AreEqual(expectedBankAccountNumber.AccountNumberText, result.AccountNumberText);
Assert.AreEqual(expectedBankAccountNumber.Iban, result.Iban);
Assert.AreEqual(expectedBankAccountNumber.IbanSeparated, result.IbanSeparated);
}
public void BankAccountDepositAndWithdrawSetBalance()
{
//Arrange
var country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var activityReason = "reason";
var customer = CustomerFactory.CreateCustomer(
"Unai",
"Zorrilla Castro",
"+3422",
"company",
country,
new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
Assert.AreEqual(bankAccount.Balance, 0);
bankAccount.DepositMoney(1000, activityReason);
Assert.AreEqual(bankAccount.Balance, 1000);
bankAccount.WithdrawMoney(250, activityReason);
Assert.AreEqual(bankAccount.Balance, 750);
}
public void BankAccountLockSetLocked()
{
//Arrange
var country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var customer = CustomerFactory.CreateCustomer(
"Unai",
"Zorrilla Castro",
"+3422",
"company",
country,
new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
//Act
bankAccount.Lock();
//Assert
Assert.IsTrue(bankAccount.Locked);
}
public override string ToString()
{
if (BankAccountNumber == null || BankAccountNumber.Length < 4)
{
return("eCheck w/o Bank account");
}
return(string.Format("{0} ending in xx{1}",
"Electronic Check", BankAccountNumber.Substring(BankAccountNumber.Length - 4, 4)));
}
public override string ToString()
{
string s;
s = $@"Host Key: {HostKey.ToString()},
Private Name: {PrivateName}, Family Name: {FamilyName},
Fhone Number: {FhoneNumber.ToString()}, MailAddress: {MailAddress},
bank Branch: {bankBranch.ToString()}, BankAccountNumber: {BankAccountNumber.ToString()}, CollectionClearance:{CollectionClearance.ToString()} \n";
return(s);
}
/// <summary>
/// set bank account number
/// </summary>
/// <param name="accNum"></param>
/// <exception cref="ArgumentNullException">Arguments null</exception>
public void SetBankAccountNumber(BankAccountNumber accNum)
{
if (accNum == null)
{
throw new ArgumentNullException("Bank Account Number");
}
this.SetDirtyData();
_accNumber = accNum;
}
public override string ToString()
{
return("Bank Account Number: " + BankAccountNumber.ToString() + "\n" +
"my commition: " + MyCommition.ToString() + "\n" +
"Collection Clearance? " + CollectionClearance.ToString() + "\n" +
"Bank name: " + BankName + "/n" +
"Bank Number: " + BankNumber.ToString() + "/n" +
"Branch number: " + BranchNumber.ToString() + "/n" +
"Branch address: " + BranchAddress + "/n" +
"Branch city: " + BranchCity + "/n");
}
public bool Equals(StoreContactDetails other)
{
return(other != null &&
Name.ToLower().Trim() == other.Name.ToLower().Trim() &&
Email.ToLower().Trim() == other.Email.ToLower().Trim() &&
Address.ToLower().Trim() == other.Address.ToLower().Trim() &&
Phone.ToLower().Trim() == other.Phone.ToLower().Trim() &&
Bank.ToLower().Trim() == other.Bank.ToLower().Trim() &&
BankAccountNumber.ToLower().Trim() == other.BankAccountNumber.ToLower().Trim() &&
Description.ToLower().Trim() == other.Description.ToLower().Trim());
}
public override string ToString()
{
return("Host key: " + HostKey.ToString() + "\n" +
"First Name: " + FirstName + "\n" +
"Last Name: " + LastName + "\n" +
"Fhone Number: " + FhoneNumber.ToString() + "\n" +
"Mail Address: " + MailAddress + "\n" +
"Bank Branch Details: " + BankBranchDetails.ToString() + "\n" +
"Bank Account Number: " + BankAccountNumber.ToString() + "\n" +
"my commition: " + MyCommition.ToString() + "\n" +
"Collection Clearance? " + CollectionClearance.ToString() + "\n");
}
public void BankAccountCannotWithDrawMoneyIfBalanceIsLessThanAmountAccount()
{
//Arrange
Customer customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", IdentityGenerator.NewSequentialGuid(), new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
customer.Id = IdentityGenerator.NewSequentialGuid();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
//Act
bankAccount.WithdrawMoney(200, "the reason..");
}
BankAccountNumber CalculateNewBankAccountNumber()
{
var bankAccountNumber = new BankAccountNumber();
//simulate bank account number creation....
bankAccountNumber.OfficeNumber = "2354";
bankAccountNumber.NationalBankCode = "2134";
bankAccountNumber.CheckDigits = "02";
bankAccountNumber.AccountNumber = new Random().Next(1, Int32.MaxValue).ToString();
return(bankAccountNumber);
}
public override string ToString()
{
return("ID: " + ID.ToString() + "\n"
+ "Password: "******"\n"
+ "Private Name: " + PrivateName.ToString() + "\n"
+ "Family Name: " + FamilyName.ToString() + "\n"
+ "Phone Number: " + PhoneNumber.ToString() + "\n"
+ "Mail Address: " + MailAddress.ToString() + "\n"
+ "Bank Branch Details: " + BankBranchDetails.ToString() + "\n"
+ "Bank Account Number: " + BankAccountNumber.ToString() + "\n"
+ "Collection Clearance: " + CollectionClearance.ToString() + "\n"
+ "Host Key: " + HostKey.ToString() + "\n");
}
public void BankAccountCannotDepositMoneyInLockedAccount()
{
//Arrange
var customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", IdentityGenerator.NewSequentialGuid(), new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
customer.Id = IdentityGenerator.NewSequentialGuid();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
bankAccount.Lock();
//Act
bankAccount.DepositMoney(200, "the reason..");
}
public void BankAccountCannotDepositMoneyLessThanZero()
{
//Arrange
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
string activityReason = "reason";
Customer customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", IdentityGenerator.NewSequentialGuid(), new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
customer.Id = IdentityGenerator.NewSequentialGuid();
BankAccount bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
bankAccount.DepositMoney(-100, activityReason);
}
/// <summary>
/// Create a new instance of bankaccount
/// </summary>
/// <param name="customer">The customer associated with this bank account</param>
/// <param name="bankAccountNumber">The bank account number</param>
/// <returns>A valid bank account</returns>
public static BankAccount CreateBankAccount(Customer customer, BankAccountNumber bankAccountNumber)
{
var bankAccount = new BankAccount();
//set the bank account number
bankAccount.BankAccountNumber = bankAccountNumber;
//set default bank account as unlocked
bankAccount.UnLock();
//set the customer for this bank account
bankAccount.SetCustomer(customer);
return bankAccount;
}
public void BankAccountCannotWithDrawMoneyIfBalanceIsLessThanAmountAccount()
{
//Arrange
Country country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", "+3422", "company", country, new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
//Act
bankAccount.WithdrawMoney(200, "the reason..");
}
/// <summary>
/// Create a new instance of bankaccount
/// </summary>
/// <param name="customerId">The customer identifier</param>
/// <param name="bankAccountNumber">The bank account number</param>
/// <returns>A valid bank account</returns>
public static BankAccount CreateBankAccount(Guid customerId, BankAccountNumber bankAccountNumber)
{
var bankAccount = new BankAccount();
//set the bank account number
bankAccount.BankAccountNumber = bankAccountNumber;
//set default bank account as unlocked
bankAccount.UnLock();
//set the customer identifier
bankAccount.CustomerId = customerId;
return bankAccount;
}
public bool Equals(StoreContactDetails scd)
{
if (!Name.Equals(scd.Name) ||
!Email.Equals(scd.Email) ||
!Address.Equals(scd.Address) ||
!Phone.Equals(scd.Phone) ||
!BankAccountNumber.Equals(scd.BankAccountNumber) ||
!Bank.Equals(scd.Bank) ||
!Description.Equals(scd.Description))
{
return(false);
}
return(true);
}
public void BankAccountCannotDepositMoneyLessThanZero()
{
//Arrange
Country country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
string activityReason = "reason";
var customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", "+3422", "company", country, new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
bankAccount.DepositMoney(-100, activityReason);
}
/// <summary>
/// Construct
/// </summary>
/// <param name="coreDriver">Core Driver</param>
/// <param name="management">Matadata management</param>
/// <param name="id"></param>
/// <param name="descp"></param>
/// <param name="accNumber"></param>
/// <param name="bankKey"></param>
/// <param name="type"></param>
/// <exception cref="ArgumentNullException">Arguments null</exception>
/// <exception cref="MasterDataIdentityNotDefined">Master data identity is not defined.</exception>
public BankAccountMasterData(CoreDriver coreDriver, MasterDataManagement management,
MasterDataIdentity id, String descp, BankAccountNumber accNumber,
MasterDataIdentity bankKey, BankAccountType type)
: base(coreDriver, management, id, descp)
{
_accNumber = accNumber;
_bankAccType = type;
MasterDataBase bankKeyId = management.GetMasterData(bankKey,
MasterDataType.BANK_KEY);
if (bankKeyId == null)
{
throw new MasterDataIdentityNotDefined(bankKey,
MasterDataType.BANK_KEY);
}
_bankKey = bankKeyId.GetIdentity();
}
protected BankAccount(
BankAccountId bankAccountId,
BankAccountNumber bankAccountNumber,
Money balance,
BankAccountStateId bankAccountStateId,
DateTime createdAt,
DateTime updatedAt,
CustomerId customerId)
{
BankAccountId = bankAccountId;
BankAccountNumber = bankAccountNumber;
Balance = balance;
BankAccountStateId = bankAccountStateId;
CreatedAt = createdAt;
UpdatedAt = updatedAt;
CustomerId = customerId;
}
public static BankAccount From(
BankAccountId bankAccountId,
BankAccountNumber bankAccountNumber,
Money balance,
BankAccountStateId bankAccountStateId,
DateTime createdAt,
DateTime updatedAt,
CustomerId customerId)
{
return(new BankAccount(
bankAccountId,
bankAccountNumber,
balance,
bankAccountStateId,
createdAt,
updatedAt,
customerId));
}
/// <summary>
/// Create a new instance of bankaccount
/// </summary>
/// <param name="customer">The customer associated with this bank account</param>
/// <param name="bankAccountNumber">The bank account number</param>
/// <returns>A valid bank account</returns>
public static BankAccount CreateBankAccount(Customer customer, BankAccountNumber bankAccountNumber)
{
var bankAccount = new BankAccount();
//set the identity
bankAccount.GenerateNewIdentity();
//set the bank account number
bankAccount.BankAccountNumber = bankAccountNumber;
//set default bank account as unlocked
bankAccount.UnLock();
//set the customer for this bank account
bankAccount.SetCustomerOwnerOfThisBankAccount(customer);
return bankAccount;
}
public void BankAccountCannotDepositMoneyInLockedAccount()
{
//Arrange
Country country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", "+3422", "company", country, new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
bankAccount.Lock();
//Act
Exception ex = Assert.Throws <InvalidOperationException>(() => bankAccount.DepositMoney(200, "the reason.."));
Assert.IsType <InvalidOperationException>(ex);
}
public void TestMethod1()
{
AccountNumber number = new AccountNumber("86102024981111222233334444");
if (number.AcountNumber.Length == 26)
{
BankAccountNumber bankAccount = new BankAccountNumber();
string test = bankAccount.CheckBank(number);
}
else if (number.AcountNumber.Length == 28)
{
TheInternationalBankAccountNumber bankAccount = new TheInternationalBankAccountNumber();
string test = bankAccount.CheckBank(number);
}
else
{
string test = "Błędny numer konta bankowego";
}
}
public void TestMethod1()
{
AccountNumber number = new AccountNumber("86102024981111222233334444");
if (number.AcountNumber.Length == 26)
{
BankAccountNumber bankAccount = new BankAccountNumber();
string test= bankAccount.CheckBank(number);
}
else if (number.AcountNumber.Length == 28)
{
TheInternationalBankAccountNumber bankAccount = new TheInternationalBankAccountNumber();
string test = bankAccount.CheckBank(number);
}
else
{
string test = "Błędny numer konta bankowego";
}
}
public void BankAccountRepositoryRemoveItemDeleteIt()
{
//Arrange
var unitOfWork = new MainBcUnitOfWork();
var customerRepository = new CustomerRepository(unitOfWork);
var bankAccountRepository = new BankAccountRepository(unitOfWork);
var customer = customerRepository.Get(new Guid("43A38AC8-EAA9-4DF0-981F-2685882C7C45"));
var bankAccountNumber = new BankAccountNumber("4444", "5555", "3333333333", "02");
var newBankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
bankAccountRepository.Add(newBankAccount);
unitOfWork.Commit();
//Act
bankAccountRepository.Remove(newBankAccount);
unitOfWork.Commit();
}
public void BankAccountRepositoryAddNewItemSaveItem()
{
//Arrange
var unitOfWork = new MainBCUnitOfWork();
IBankAccountRepository bankAccountRepository = new BankAccountRepository(unitOfWork);
Guid customerId = new Guid("43A38AC8-EAA9-4DF0-981F-2685882C7C45");
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
BankAccount newBankAccount = BankAccountFactory.CreateBankAccount(customerId,bankAccountNumber);
newBankAccount.Id = IdentityGenerator.NewSequentialGuid();
//Act
bankAccountRepository.Add(newBankAccount);
bankAccountRepository.UnitOfWork.Commit();
//Assert
var inserted = bankAccountRepository.Get(newBankAccount.Id);
Assert.IsNotNull(inserted);
}
protected override void Seed(MainBCUnitOfWork unitOfWork)
{
/*
* Countries agg
*/
var spainCountry = new Country("Spain", "es-ES");
spainCountry.ChangeCurrentIdentity(new Guid("32BB805F-40A4-4C37-AA96-B7945C8C385C"));
var usaCountry = new Country("EEUU", "en-US");
usaCountry.ChangeCurrentIdentity(new Guid("C3C82D06-6A07-41FB-B7EA-903EC456BFC5"));
unitOfWork.Countries.Add(spainCountry);
unitOfWork.Countries.Add(usaCountry);
/*
* Customers agg
*/
var customerJhon = CustomerFactory.CreateCustomer("Jhon", "Jhon", "+34617", "company", spainCountry, new Address("Madrid", "280181", "Paseo de La finca", ""));
customerJhon.ChangeCurrentIdentity(new Guid("43A38AC8-EAA9-4DF0-981F-2685882C7C45"));
var customerMay = CustomerFactory.CreateCustomer("May", "Garcia", "+34617", "company", usaCountry, new Address("Seatle", "3332", "Alaskan Way", ""));
customerMay.ChangeCurrentIdentity(new Guid("0CD6618A-9C8E-4D79-9C6B-4AA69CF18AE6"));
unitOfWork.Customers.Add(customerJhon);
unitOfWork.Customers.Add(customerMay);
/*
* Product agg
*/
var book = new Book("The book title", "Any book description", "Krassis Press", "ABC");
book.ChangeUnitPrice(40M);
book.IncrementStock(2);
book.ChangeCurrentIdentity(new Guid("44668EBF-7B54-4431-8D61-C1298DB50857"));
var software = new Software("the new SO", "the software description", "XXXX0000--111");
software.ChangeUnitPrice(100M);
software.IncrementStock(3);
software.ChangeCurrentIdentity(new Guid("D7E5C537-6A0C-4E19-B41E-3653F4998085"));
unitOfWork.Products.Add(book);
unitOfWork.Products.Add(software);
/*
* Orders agg
*/
var orderA = OrderFactory.CreateOrder(customerJhon, "shipping name", "shipping city", "shipping address", "shipping zip code");
orderA.ChangeCurrentIdentity(new Guid("3135513C-63FD-43E6-9697-6C6E5D8CE55B"));
orderA.OrderDate = DateTime.Now;
orderA.AddNewOrderLine(book.Id, 1, 40, 0);
var orderB = OrderFactory.CreateOrder(customerMay, "shipping name", "shipping city", "shipping address", "shipping zip code");
orderB.GenerateNewIdentity();
orderB.OrderDate = DateTime.Now;
orderB.AddNewOrderLine(software.Id, 3, 12, 0);
unitOfWork.Orders.Add(orderA);
unitOfWork.Orders.Add(orderB);
/*
* Bank Account agg
*/
var bankAccountNumberJhon = new BankAccountNumber("1111", "2222", "3333333333", "01");
BankAccount bankAccountJhon = BankAccountFactory.CreateBankAccount(customerJhon, bankAccountNumberJhon);
bankAccountJhon.ChangeCurrentIdentity(new Guid("0343C0B0-7C40-444A-B044-B463F36A1A1F"));
bankAccountJhon.DepositMoney(1000, "Open BankAccount");
var bankAccountNumberMay = new BankAccountNumber("4444", "5555", "3333333333", "02");
BankAccount bankAccountMay = BankAccountFactory.CreateBankAccount(customerMay, bankAccountNumberMay);
bankAccountMay.GenerateNewIdentity();
bankAccountJhon.DepositMoney(2000, "Open BankAccount");
unitOfWork.BankAccounts.Add(bankAccountJhon);
unitOfWork.BankAccounts.Add(bankAccountMay);
}
public void PerformBankTransfer()
{
//Arrange
//--> source bank account data
var sourceId = new Guid("3481009C-A037-49DB-AE05-44FF6DB67DEC");
var bankAccountNumberSource = new BankAccountNumber("4444", "5555", "3333333333", "02");
var sourceCustomer = new Customer();
sourceCustomer.GenerateNewIdentity();
var source = BankAccountFactory.CreateBankAccount(sourceCustomer, bankAccountNumberSource);
source.ChangeCurrentIdentity(sourceId);
source.DepositMoney(1000, "initial");
var sourceBankAccountDTO = new BankAccountDTO()
{
Id = sourceId,
BankAccountNumber = source.Iban
};
//--> target bank account data
var targetCustomer = new Customer();
targetCustomer.GenerateNewIdentity();
var targetId = new Guid("8A091975-F783-4730-9E03-831E9A9435C1");
var bankAccountNumberTarget = new BankAccountNumber("1111", "2222", "3333333333", "01");
var target = BankAccountFactory.CreateBankAccount(targetCustomer, bankAccountNumberTarget);
target.ChangeCurrentIdentity(targetId);
var targetBankAccountDTO = new BankAccountDTO()
{
Id = targetId,
BankAccountNumber = target.Iban
};
var accounts = new List <BankAccount>()
{
source, target
};
var bankAccountRepository = new Mock <IBankAccountRepository>();
bankAccountRepository
.Setup(x => x.Get(It.IsAny <Guid>()))
.Returns((Guid guid) => {
return(accounts.Where(ba => ba.Id == guid).SingleOrDefault());
});
Mock <MainBCUnitOfWork> _mockContext = new Mock <MainBCUnitOfWork>();
_mockContext.Setup(c => c.Commit());
bankAccountRepository
.Setup(x => x.UnitOfWork).Returns(_mockContext.Object);
var customerRepository = new Mock <ICustomerRepository>();
IBankTransferService transferService = new BankTransferService();
Mock <ILogger <BankAppService> > _mockLogger = new Mock <ILogger <BankAppService> >();
IBankAppService bankingService = new BankAppService(bankAccountRepository.Object, customerRepository.Object, transferService, _mockLogger.Object);
//Act
bankingService.PerformBankTransfer(sourceBankAccountDTO, targetBankAccountDTO, 100M);
//Assert
Assert.Equal(source.Balance, 900);
Assert.Equal(target.Balance, 100);
}
public void BankAccountFactoryCreateValidBankAccount()
{
//Arrange
Customer customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", IdentityGenerator.NewSequentialGuid(), new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
customer.Id = IdentityGenerator.NewSequentialGuid();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
BankAccount bankAccount = null;
//Act
bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
var validationContext = new ValidationContext(bankAccount, null, null);
var validationResults = customer.Validate(validationContext);
//Assert
Assert.IsNotNull(bankAccount);
Assert.IsTrue(bankAccount.BankAccountNumber == bankAccountNumber);
Assert.IsFalse(bankAccount.Locked);
Assert.IsTrue(bankAccount.CustomerId == customer.Id);
Assert.IsFalse(validationResults.Any());
}
public static void CreateMasterData(CoreDriver coreDriver)
{
///
/// check the factory is initialized, and the factory with no master data
///
MasterDataManagement masterDataManagement = coreDriver.MdMgmt;
// vendor
VendorMasterDataFactory vendorFactory = (VendorMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.VENDOR);
Assert.AreEqual(0, vendorFactory.MasterDataCount);
// customer
CustomerMasterDataFactory customerFactory = (CustomerMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.CUSTOMER);
Assert.AreEqual(0, customerFactory.MasterDataCount);
// business area
BusinessAreaMasterDataFactory businessFactory = (BusinessAreaMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.BUSINESS_AREA);
Assert.AreEqual(0, businessFactory.MasterDataCount);
// bank key
BankKeyMasterDataFactory bankKeyFactory = (BankKeyMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.BANK_KEY);
Assert.AreEqual(0, bankKeyFactory.MasterDataCount);
// bank account
BankAccountMasterDataFactory bankAccountFactory = (BankAccountMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.BANK_ACCOUNT);
Assert.AreEqual(0, bankAccountFactory.MasterDataCount);
// GL account
GLAccountMasterDataFactory accountFactory = (GLAccountMasterDataFactory)masterDataManagement
.GetMasterDataFactory(MasterDataType.GL_ACCOUNT);
Assert.AreEqual(0, accountFactory.MasterDataCount);
/** add master data entities */
// vendor
VendorMasterData vendor = (VendorMasterData)vendorFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.VENDOR_BUS), TestData.VENDOR_BUS_DESCP);
Assert.IsTrue(vendor != null);
vendor = (VendorMasterData)vendorFactory.CreateNewMasterDataBase(
new MasterDataIdentity(TestData.VENDOR_SUBWAY),
TestData.VENDOR_SUBWAY_DESCP);
Assert.IsTrue(vendor != null);
// duplicate id
try
{
vendorFactory.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.VENDOR_SUBWAY), TestData.VENDOR_SUBWAY_DESCP);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
// customer
CustomerMasterData customer = (CustomerMasterData)customerFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.CUSTOMER1), TestData.CUSTOMER1_DESCP);
Assert.IsTrue(customer != null);
customer = (CustomerMasterData)customerFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.CUSTOMER2), TestData.CUSTOMER2_DESCP);
Assert.IsTrue(customer != null);
// duplicate id
try
{
customerFactory.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.CUSTOMER2), TestData.CUSTOMER2_DESCP);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
// bank key
BankKeyMasterData bankKey = (BankKeyMasterData)bankKeyFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BANK_KEY), TestData.BANK_KEY_DESCP);
Assert.IsTrue(bankKey != null);
// duplicate id
try
{
bankKeyFactory.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BANK_KEY), TestData.BANK_KEY_DESCP);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
// bank account
MasterDataIdentity bankKeyId = new MasterDataIdentity(TestData.BANK_KEY);
BankAccountNumber accountNum = new BankAccountNumber(
TestData.BANK_ACCOUNT_CMB_6235_ACC);
BankAccountMasterData bankAcc = (BankAccountMasterData)bankAccountFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BANK_ACCOUNT_CMB_6235),
TestData.BANK_ACCOUNT_CMB_6235_DESCP, accountNum,
bankKeyId, BankAccountType.SAVING_ACCOUNT);
Assert.IsTrue(bankAcc != null);
accountNum = new BankAccountNumber(TestData.BANK_ACCOUNT_CMB_6620_ACC);
bankAcc = (BankAccountMasterData)bankAccountFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BANK_ACCOUNT_CMB_6620),
TestData.BANK_ACCOUNT_CMB_6620_DESCP, accountNum,
bankKeyId, BankAccountType.CREDIT_CARD);
Assert.IsTrue(bankAcc != null);
// duplicate id
try
{
bankAccountFactory.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BANK_ACCOUNT_CMB_6620),
TestData.BANK_ACCOUNT_CMB_6620_DESCP, accountNum, bankKey,
BankAccountType.SAVING_ACCOUNT);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
// business area
BusinessAreaMasterData businessArea = (BusinessAreaMasterData)businessFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BUSINESS_AREA_ENTERTAIN),
TestData.BUSINESS_AREA_ENTERTAIN_DESCP,
CriticalLevel.MEDIUM);
Assert.IsTrue(businessArea != null);
businessArea = (BusinessAreaMasterData)businessFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BUSINESS_AREA_WORK),
TestData.BUSINESS_AREA_WORK_DESCP, CriticalLevel.HIGH);
Assert.IsTrue(businessArea != null);
businessArea = (BusinessAreaMasterData)businessFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BUSINESS_AREA_SNACKS),
TestData.BUSINESS_AREA_SNACKS_DESCP, CriticalLevel.LOW);
Assert.IsTrue(businessArea != null);
// duplicate id
try
{
businessArea = (BusinessAreaMasterData)businessFactory
.CreateNewMasterDataBase(new MasterDataIdentity(
TestData.BUSINESS_AREA_SNACKS),
TestData.BUSINESS_AREA_SNACKS_DESCP,
CriticalLevel.LOW);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
// G/L account
MasterDataIdentity bankAccId = new MasterDataIdentity(
TestData.BANK_ACCOUNT_CMB_6235);
GLAccountMasterData glAccount = (GLAccountMasterData)accountFactory
.CreateNewMasterDataBase(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_BANK),
TestData.GL_ACCOUNT_BANK_DESCP, bankAccId);
Assert.IsTrue(glAccount != null);
glAccount = (GLAccountMasterData)accountFactory
.CreateNewMasterDataBase(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_CASH),
TestData.GL_ACCOUNT_CASH_DESCP);
Assert.IsTrue(glAccount != null);
glAccount.SetInitAmount(TestData.AMOUNT_VENDOR);
glAccount = (GLAccountMasterData)accountFactory
.CreateNewMasterDataBase(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_COST),
TestData.GL_ACCOUNT_COST_DESCP);
Assert.IsTrue(glAccount != null);
glAccount = (GLAccountMasterData)accountFactory
.CreateNewMasterDataBase(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_EQUITY),
TestData.GL_ACCOUNT_EQUITY_DESCP);
Assert.IsTrue(glAccount != null);
glAccount = (GLAccountMasterData)accountFactory
.CreateNewMasterDataBase(new MasterDataIdentity_GLAccount(
TestData.GL_ACCOUNT_REV), TestData.GL_ACCOUNT_REV_DESCP);
Assert.IsTrue(glAccount != null);
// duplicate id
try
{
accountFactory.CreateNewMasterDataBase(
new MasterDataIdentity_GLAccount(TestData.GL_ACCOUNT_REV),
TestData.GL_ACCOUNT_REV_DESCP);
Assert.Fail("Duplicate Id");
}
catch (MasterDataIdentityExists)
{
}
}
BankAccountNumber CalculateNewBankAccountNumber()
{
var bankAccountNumber = new BankAccountNumber();
//simulate bank account number creation....
bankAccountNumber.OfficeNumber = "2354";
bankAccountNumber.NationalBankCode = "2134";
bankAccountNumber.CheckDigits = "02";
bankAccountNumber.AccountNumber = new Random().Next(1, Int32.MaxValue).ToString();
return bankAccountNumber;
}
public virtual bool HasIdentity()
{
return(Exist() && BankAccountNumber.HasValue());
}
public void BankAccountRepositoryRemoveItemDeleteIt()
{
//Arrange
var unitOfWork = new MainBCUnitOfWork();
IBankAccountRepository bankAccountRepository = new BankAccountRepository(unitOfWork);
Guid customerId = new Guid("43A38AC8-EAA9-4DF0-981F-2685882C7C45");
var bankAccountNumber = new BankAccountNumber("4444", "5555", "3333333333", "02");
BankAccount newBankAccount = BankAccountFactory.CreateBankAccount(customerId, bankAccountNumber);
newBankAccount.Id = IdentityGenerator.NewSequentialGuid();
bankAccountRepository.Add(newBankAccount);
bankAccountRepository.UnitOfWork.Commit();
//Act
bankAccountRepository.Remove(newBankAccount);
bankAccountRepository.UnitOfWork.Commit();
var result = bankAccountRepository.Get(newBankAccount.Id);
//Assert
Assert.IsNull(result);
}
public void BankAccountDepositMaxDecimalThrowOverflowBalance()
{
//Arrange
var country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var activityReason = "reason";
var customer = CustomerFactory.CreateCustomer(
"Unai",
"Zorrilla Castro",
"+3422",
"company",
country,
new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
customer.GenerateNewIdentity();
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
bankAccount.DepositMoney(1, activityReason);
bankAccount.DepositMoney(Decimal.MaxValue, activityReason);
}
public void BankAccountWithdrawMoneyAnotateActivity()
{
//Arrange
var country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var activityReason = "reason";
var customer = CustomerFactory.CreateCustomer(
"Unai",
"Zorrilla Castro",
"+3422",
"company",
country,
new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
//Act
bankAccount.DepositMoney(1000, activityReason);
bankAccount.WithdrawMoney(1000, activityReason);
//Assert
Assert.IsTrue(bankAccount.Balance == 0);
Assert.IsNotNull(bankAccount.BankAccountActivity);
Assert.IsNotNull(bankAccount.BankAccountActivity.Any());
Assert.IsTrue(bankAccount.BankAccountActivity.Last().Amount == -1000);
Assert.IsTrue(bankAccount.BankAccountActivity.Last().ActivityDescription == activityReason);
}
public void BankAccountCannotDepositMoneyInLockedAccount()
{
//Arrange
var country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var customer = CustomerFactory.CreateCustomer(
"Unai",
"Zorrilla Castro",
"+3422",
"company",
country,
new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
bankAccount.Lock();
//Act
bankAccount.DepositMoney(200, "the reason..");
}
public void BankAccountUnLockSetUnLocked()
{
//Arrange
Customer customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", IdentityGenerator.NewSequentialGuid(), new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
customer.Id = IdentityGenerator.NewSequentialGuid();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
//Act
bankAccount.Lock();
bankAccount.UnLock();
//Assert
Assert.IsFalse(bankAccount.Locked);
}
public void BankAccountRepositoryRemoveItemDeleteIt()
{
//Arrange
var unitOfWork = new MainBcUnitOfWork();
var customerRepository = new CustomerRepository(unitOfWork);
var bankAccountRepository = new BankAccountRepository(unitOfWork);
var customer = customerRepository.Get(new Guid("43A38AC8-EAA9-4DF0-981F-2685882C7C45"));
var bankAccountNumber = new BankAccountNumber("4444", "5555", "3333333333", "02");
var newBankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
bankAccountRepository.Add(newBankAccount);
unitOfWork.Commit();
//Act
bankAccountRepository.Remove(newBankAccount);
unitOfWork.Commit();
}
//for debugging
public override string ToString()
{
return(HostKey.ToString() + PrivateName.ToString() + FamilyName.ToString() +
FhoneNumber.ToString() + MailAddress.ToString() + BankAccountNumber.ToString() +
CollectionClearance.ToString());
}
public void BankAccountCannotWithDrawMoneyIfBalanceIsLessThanAmountAccount()
{
//Arrange
Country country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", "+3422", "company", country, new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
//Act
bankAccount.WithdrawMoney(200, "the reason..");
}
public void BankAccountCannotDepositMoneyLessThanZero()
{
//Arrange
var country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var activityReason = "reason";
var customer = CustomerFactory.CreateCustomer(
"Unai",
"Zorrilla Castro",
"+3422",
"company",
country,
new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
bankAccount.DepositMoney(-100, activityReason);
}
public void BankAccountDepositAndWithdrawSetBalance()
{
//Arrange
var country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var activityReason = "reason";
var customer = CustomerFactory.CreateCustomer(
"Unai",
"Zorrilla Castro",
"+3422",
"company",
country,
new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
Assert.AreEqual(bankAccount.Balance, 0);
bankAccount.DepositMoney(1000, activityReason);
Assert.AreEqual(bankAccount.Balance, 1000);
bankAccount.WithdrawMoney(250, activityReason);
Assert.AreEqual(bankAccount.Balance, 750);
}
public void BankAccountDepositAndWithdrawSetBalance()
{
//Arrange
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
string activityReason = "reason";
Customer customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", IdentityGenerator.NewSequentialGuid(), new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
customer.Id = IdentityGenerator.NewSequentialGuid();
BankAccount bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
Assert.AreEqual(bankAccount.Balance,0);
bankAccount.DepositMoney(1000, activityReason);
Assert.AreEqual(bankAccount.Balance, 1000);
bankAccount.WithdrawMoney(250, activityReason);
Assert.AreEqual(bankAccount.Balance, 750);
}
public void BankAccountWithdrawMoneyAnotateActivity()
{
//Arrange
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
string activityReason = "reason";
Customer customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", IdentityGenerator.NewSequentialGuid(), new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
customer.Id = IdentityGenerator.NewSequentialGuid();
BankAccount bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
//Act
bankAccount.DepositMoney(1000, activityReason);
bankAccount.WithdrawMoney(1000, activityReason);
//Assert
Assert.IsTrue(bankAccount.Balance == 0);
Assert.IsNotNull(bankAccount.BankAccountActivity);
Assert.IsNotNull(bankAccount.BankAccountActivity.Any());
Assert.IsTrue(bankAccount.BankAccountActivity.Last().Amount == -1000);
Assert.IsTrue(bankAccount.BankAccountActivity.Last().ActivityDescription == activityReason);
}
protected override void Seed(MainBcUnitOfWork context)
{
//NOTE: Each time you change the content of this method, ALL the records will be added to the database!!
//If you change this method, it is better to delete de whole database first.
////Demo data
//Countries
var spain = new Country("Spain", "ES");
spain.GenerateNewIdentity();
context.Countries.Add(spain);
var us = new Country("U.S.", "US");
us.GenerateNewIdentity();
context.Countries.Add(us);
var uk = new Country("U.K.", "GB");
uk.GenerateNewIdentity();
context.Countries.Add(uk);
var canada = new Country("Canada", "CA");
canada.GenerateNewIdentity();
context.Countries.Add(canada);
var italy = new Country("Italy", "IT");
italy.GenerateNewIdentity();
context.Countries.Add(italy);
var france = new Country("France", "FR");
france.GenerateNewIdentity();
context.Countries.Add(france);
var argentina = new Country("Argentina", "AR");
argentina.GenerateNewIdentity();
context.Countries.Add(argentina);
var russia = new Country("Russian Federation", "RUS");
russia.GenerateNewIdentity();
context.Countries.Add(russia);
var israel = new Country("Israel", "IS");
israel.GenerateNewIdentity();
context.Countries.Add(israel);
var brazil = new Country("Brazil", "BZ");
brazil.GenerateNewIdentity();
context.Countries.Add(brazil);
////
//Customers
//Cesar de la Torre
var customer1 = CustomerFactory.CreateCustomer(
"Cesar",
"De la Torre",
"+34 1234567",
"Microsoft",
spain,
new Address("Madrid", "28700", "Calle Club Deportivo 1", "Parque Empresarial La Finca, Edif. 1"));
customer1.SetTheCountryReference(spain.Id);
context.Customers.Add(customer1);
//Unai Zorrilla
var customer2 = CustomerFactory.CreateCustomer(
"Unai",
"Zorrilla",
"+34 1234567",
"Plain Concepts",
spain,
new Address("Madrid", "12345", "Calle Plain", "Barrio San Chinarro"));
customer2.SetTheCountryReference(spain.Id);
context.Customers.Add(customer2);
//Miguel Angel
var customer3 = CustomerFactory.CreateCustomer(
"Miguel Angel",
"Ramos",
"+1 1234567",
"Microsoft",
us,
new Address("Redmond", "12345", "One Microsoft Way", "Building X"));
customer3.SetTheCountryReference(us.Id);
context.Customers.Add(customer3);
//Eric Evans
var customer4 = CustomerFactory.CreateCustomer(
"Eric",
"Evans",
"+1 1234567",
"Domain Language",
us,
new Address("City", "12345", "DDD Street", "Building X"));
customer4.SetTheCountryReference(us.Id);
context.Customers.Add(customer4);
////
//Bank Accounts
//Account 001
var bankAccountNumber001 = new BankAccountNumber("1111", "2222", "3333333333", "01");
var newBankAccount001 = BankAccountFactory.CreateBankAccount(customer1, bankAccountNumber001);
newBankAccount001.DepositMoney(Convert.ToDecimal(5000), "Initial Balance");
context.BankAccounts.Add(newBankAccount001);
//Account 002
var bankAccountNumber002 = new BankAccountNumber("1111", "2222", "3333333333", "02");
var newBankAccount002 = BankAccountFactory.CreateBankAccount(customer2, bankAccountNumber002);
newBankAccount002.DepositMoney(Convert.ToDecimal(3000), "Initial Balance");
context.BankAccounts.Add(newBankAccount002);
}
public void BankAccountLockSetLocked()
{
//Arrange
var country = new Country("Spain", "es-ES");
country.GenerateNewIdentity();
var customer = CustomerFactory.CreateCustomer(
"Unai",
"Zorrilla Castro",
"+3422",
"company",
country,
new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
var bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
//Act
bankAccount.Lock();
//Assert
Assert.IsTrue(bankAccount.Locked);
}
public void PerformBankTransfer()
{
//Arrange
//--> source bank account data
var sourceId = new Guid("3481009C-A037-49DB-AE05-44FF6DB67DEC");
var bankAccountNumberSource = new BankAccountNumber("4444", "5555", "3333333333", "02");
var sourceCustomer = new Customer();
sourceCustomer.GenerateNewIdentity();
var source = BankAccountFactory.CreateBankAccount(sourceCustomer, bankAccountNumberSource);
source.ChangeCurrentIdentity(sourceId);
source.DepositMoney(1000, "initial");
var sourceBankAccountDto = new BankAccountDto()
{
Id = sourceId,
BankAccountNumber = source.Iban
};
//--> target bank account data
var targetCustomer = new Customer();
targetCustomer.GenerateNewIdentity();
var targetId = new Guid("8A091975-F783-4730-9E03-831E9A9435C1");
var bankAccountNumberTarget = new BankAccountNumber("1111", "2222", "3333333333", "01");
var target = BankAccountFactory.CreateBankAccount(targetCustomer, bankAccountNumberTarget);
target.ChangeCurrentIdentity(targetId);
var targetBankAccountDto = new BankAccountDto()
{
Id = targetId,
BankAccountNumber = target.Iban
};
var accounts = new List<BankAccount>()
{
source,
target
};
var bankAccountRepository = new StubIBankAccountRepository();
bankAccountRepository.GetGuid = (guid) => { return accounts.Where(ba => ba.Id == guid).SingleOrDefault(); };
bankAccountRepository.UnitOfWorkGet = () =>
{
var unitOfWork = new StubIUnitOfWork();
unitOfWork.Commit = () => { };
return unitOfWork;
};
var customerRepository = new StubICustomerRepository();
IBankTransferService transferService = new BankTransferService();
IBankAppService bankingService = new BankAppService(bankAccountRepository, customerRepository, transferService);
//Act
bankingService.PerformBankTransfer(sourceBankAccountDto, targetBankAccountDto, 100M);
//Assert
Assert.AreEqual(source.Balance, 900);
Assert.AreEqual(target.Balance, 100);
}
public void PerformBankTransfer()
{
//Arrange
//--> source bank account data
var sourceId = new Guid("3481009C-A037-49DB-AE05-44FF6DB67DEC");
var bankAccountNumberSource = new BankAccountNumber("4444", "5555", "3333333333", "02");
var sourceCustomer = new Customer();
sourceCustomer.GenerateNewIdentity();
var source = BankAccountFactory.CreateBankAccount(sourceCustomer, bankAccountNumberSource);
source.ChangeCurrentIdentity(sourceId);
source.DepositMoney(1000, "initial");
var sourceBankAccountDto = new BankAccountDto()
{
Id = sourceId,
BankAccountNumber = source.Iban
};
//--> target bank account data
var targetCustomer = new Customer();
targetCustomer.GenerateNewIdentity();
var targetId = new Guid("8A091975-F783-4730-9E03-831E9A9435C1");
var bankAccountNumberTarget = new BankAccountNumber("1111", "2222", "3333333333", "01");
var target = BankAccountFactory.CreateBankAccount(targetCustomer, bankAccountNumberTarget);
target.ChangeCurrentIdentity(targetId);
var targetBankAccountDto = new BankAccountDto()
{
Id = targetId,
BankAccountNumber = target.Iban
};
var accounts = new List <BankAccount>()
{
source,
target
};
var bankAccountRepository = new StubIBankAccountRepository();
bankAccountRepository.GetGuid = (guid) => { return(accounts.Where(ba => ba.Id == guid).SingleOrDefault()); };
bankAccountRepository.UnitOfWorkGet = () =>
{
var unitOfWork = new StubIUnitOfWork();
unitOfWork.Commit = () => { };
return(unitOfWork);
};
var customerRepository = new StubICustomerRepository();
IBankTransferService transferService = new BankTransferService();
IBankAppService bankingService = new BankAppService(bankAccountRepository, customerRepository, transferService);
//Act
bankingService.PerformBankTransfer(sourceBankAccountDto, targetBankAccountDto, 100M);
//Assert
Assert.AreEqual(source.Balance, 900);
Assert.AreEqual(target.Balance, 100);
}
public void PerformBankTransfer()
{
//Arrange
var sourceId = new Guid("3481009C-A037-49DB-AE05-44FF6DB67DEC");
var bankAccountNumberSource = new BankAccountNumber("4444", "5555", "3333333333", "02");
var source = BankAccountFactory.CreateBankAccount(Guid.NewGuid(), bankAccountNumberSource);
source.Id = sourceId;
source.DepositMoney(1000,"initial");
var sourceBankAccountDTO = new BankAccountDTO()
{
Id = sourceId,
BankAccountNumber = source.Iban
};
var targetId = new Guid("8A091975-F783-4730-9E03-831E9A9435C1");
var bankAccountNumberTarget = new BankAccountNumber("1111", "2222", "3333333333", "01");
var target = BankAccountFactory.CreateBankAccount(Guid.NewGuid(), bankAccountNumberTarget);
target.Id = targetId;
var targetBankAccountDTO = new BankAccountDTO()
{
Id = targetId,
BankAccountNumber = target.Iban
};
var accounts = new List<BankAccount>() { source, target };
var accountsDTO = new List<BankAccountDTO>() { sourceBankAccountDTO, targetBankAccountDTO };
SIBankAccountRepository bankAccountRepository = new SIBankAccountRepository();
bankAccountRepository.GetGuid = (guid) =>
{
return accounts.Where(a => a.Id == guid).SingleOrDefault();
};
bankAccountRepository.UnitOfWorkGet = () =>
{
var unitOfWork = new SIUnitOfWork();
unitOfWork.Commit = () => { };
return unitOfWork;
};
SICustomerRepository customerRepository = new SICustomerRepository();
IBankTransferService transferService = new BankTransferService();
ITypeAdapter adapter = PrepareTypeAdapter();
IBankAppService bankingService = new BankAppService(bankAccountRepository, customerRepository, transferService, adapter);
//Act
bankingService.PerformBankTransfer(sourceBankAccountDTO, targetBankAccountDTO, 100M);
}
public void BankAccountDepositMaxDecimalThrowOverflowBalance()
{
//Arrange
var bankAccountNumber = new BankAccountNumber("1111", "2222", "3333333333", "01");
string activityReason = "reason";
Customer customer = CustomerFactory.CreateCustomer("Unai", "Zorrilla Castro", IdentityGenerator.NewSequentialGuid(), new Address("city", "zipcode", "AddressLine1", "AddressLine2"));
customer.Id = IdentityGenerator.NewSequentialGuid();
BankAccount bankAccount = BankAccountFactory.CreateBankAccount(customer, bankAccountNumber);
bankAccount.DepositMoney(1, activityReason);
bankAccount.DepositMoney(Decimal.MaxValue, activityReason);
}
