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 BankAccountRepositoryGetMethodReturnNullWhenIdIsEmpty()
{
//Arrange
var unitOfWork = new MainBcUnitOfWork();
var bankAccountRepository = new BankAccountRepository(unitOfWork);
//Act
var bankAccount = bankAccountRepository.Get(Guid.Empty);
//Assert
Assert.IsNull(bankAccount);
}
public void FindBankAccount_Invoke_NullSpecThrowArgumentNullException_Test()
{
//Arrange
IMainModuleUnitOfWork context = this.GetUnitOfWork();
ITraceManager traceManager = this.GetTraceManager();
BankAccountRepository repository = new BankAccountRepository(context, traceManager);
//Act
BankAccount actual;
actual = repository.GetBySpec(null)
.SingleOrDefault();
}
public override void Credit()
{
if (CurrentMovement?.SourceAccountId != null && CurrentMovement.TargetAccountId.HasValue)
{
var account = BankAccountRepository.GetById(CurrentMovement.SourceAccountId.Value);
var internalAccount = BankAccountRepository.GetById(CurrentMovement.TargetAccountId.Value);
Credit(account, internalAccount, CurrentMovement);
}
else
{
throw new ArgumentException("Current movement / Source account / Target Account can't be null.");
}
}
public void BankAccountRepositoryGetAllReturnMaterializedBankAccountsAndCustomers()
{
//Arrange
var bankAccountRepository = new BankAccountRepository(fixture.unitOfWork, fixture.bankAccountLogger);
//Act
var allItems = bankAccountRepository.GetAll();
//Assert
Assert.NotNull(allItems);
Assert.True(allItems.Any());
Assert.True(allItems.All(ba => ba.Customer != null));
}
public void GetUserForBankAccountSuccessfully()
{
var content = File.ReadAllText("../../../Fixtures/bank_account_get_users.json");
var client = GetMockClient(content);
var repo = new BankAccountRepository(client.Object);
const string userId = "ec9bf096-c505-4bef-87f6-18822b9dbf2c"; //some user created before
var gotUser = repo.GetUserForBankAccount("ec9bf096-c505-4bef-87f6-18822b9dbf2c");
client.VerifyAll();
Assert.IsNotNull(gotUser);
Assert.AreEqual(userId, gotUser.Id);
}
) Transfer(string fromAccount, string toAccount, string currency, decimal money, string message)
{
if (money < 0)
{
throw new BusinessException("Money should be greater than 0.");
}
var nowUtc = DateTime.Now.ToUniversalTime();
var sourceAccountEntity = BankAccountService.Get(fromAccount);
var targetAccountEntity = BankAccountService.Get(toAccount);
var currencyEntity = CurrencyService.Get(currency);
var exchangeRateFromSourceAccount = ExchangeRateHistoryService.GetExchangeRate(sourceAccountEntity.Currency, currencyEntity, nowUtc);
var exchangeRateToTargetAccount = ExchangeRateHistoryService.GetExchangeRate(currencyEntity, targetAccountEntity.Currency, nowUtc);
var deltaFromSourceAccount = money * exchangeRateFromSourceAccount;
var deltaToTargetAccount = money * exchangeRateToTargetAccount;
if (deltaFromSourceAccount > sourceAccountEntity.Balance)
{
throw new BusinessException("Source account balance is not sufficient");
}
else if (deltaFromSourceAccount <= 0 || deltaToTargetAccount <= 0)
{
throw new BusinessException("Transfer delta is not valid.");
}
sourceAccountEntity.Balance -= deltaFromSourceAccount;
targetAccountEntity.Balance += deltaToTargetAccount;
var entity = new TransferMoneyTransaction
{
DateTimeUtc = nowUtc,
SourceAccount = sourceAccountEntity,
Account = targetAccountEntity,
Currency = currencyEntity,
Money = money,
Message = message
};
TransactionRepository.Create(entity);
BankAccountRepository.Update(sourceAccountEntity);
BankAccountRepository.Update(targetAccountEntity);
UnitOfWork.SaveChanges();
return(
entity.Id,
exchangeRateFromSourceAccount, deltaFromSourceAccount, sourceAccountEntity.Balance,
exchangeRateToTargetAccount, deltaToTargetAccount, targetAccountEntity.Balance
);
}
public void BankAccountRepositoryGetMethodReturnMaterializedEntityById()
{
//Arrange
var bankAccountRepository = new BankAccountRepository(fixture.unitOfWork, fixture.bankAccountLogger);
var selectedBankAccount = new Guid("0343C0B0-7C40-444A-B044-B463F36A1A1F");
//Act
var bankAccount = bankAccountRepository.Get(selectedBankAccount);
//Assert
Assert.NotNull(bankAccount);
Assert.True(bankAccount.Id == selectedBankAccount);
}
public void BankAccountRepositoryGetAllReturnMaterializedBankAccountsAndCustomers()
{
//Arrange
var unitOfWork = new MainBCUnitOfWork();
var bankAccountRepository = new BankAccountRepository(unitOfWork);
//Act
var allItems = bankAccountRepository.GetAll();
//Assert
Assert.IsNotNull(allItems);
Assert.IsTrue(allItems.Any());
Assert.IsTrue(allItems.All(ba => ba.Customer != null));
}
public UnitOfWork(DataContext dataContext)
{
_dataContext = dataContext;
BranchRepository = new BranchRepository(dataContext);
AddressRepository = new AddressRepository(dataContext);
BankAccountRepository = new BankAccountRepository(dataContext);
DepartmentRepository = new DepartmentRepository(dataContext);
MunicipalityRepository = new MunicipalityRepository(dataContext);
PositionRepository = new PositionRepository(dataContext);
RegionRepository = new RegionRepository(dataContext);
SettlementRepository = new SettlementRepository(dataContext);
BasePositionStaffEntityRepositorty = new BasePositionStaffEntityRepository(dataContext);
PositionsAndDepartmentRepository = new PositionsAndDepartmentRepository(dataContext);
}
public BankAccountModel createAccount(string CustomerName, string CustomerID, string AccountNumber, float InitialBalance)
{
BankAccountRepository repository = new BankAccountRepository(this._context);
var account = repository.getByAccountNumber(AccountNumber);
if (account != null)
{
throw new Exception("there's another bank account with this Bank Number.");
}
account = repository.createAccount(CustomerName, CustomerID, AccountNumber, InitialBalance);
return(BanckAccountMapper.toModel(account));
}
protected override IEnumerable <FileParserInput> DownloadTransactions()
{
var downloadResults = new List <FileParserInput>();
Browser.WaitForJavaScript(12000);
Browser.FindElement(By.XPath("//*[@data-test='main-nav-kontozentrale']")).Click();
Browser.WaitForJavaScript();
//fist ist cumulative account
for (var i = 1; i < GetAccountLinks().Count; i++)
{
GetAccountLinks()[i].Click();
Browser.WaitForJavaScript(2000);
var valueParser =
ComponentContext.ResolveKeyed <IValueParser>(Constants.UniqueContainerKeys.ValueParserGermanDecimal);
var balance = GetAccountBalance().Text.CleanNumberStringFromOther();
var infoBox = Browser.FindElement(By.ClassName("info-box"));
var iban = infoBox.FindElement(By.TagName("h2")).Text.CleanString();
var bankAccount = BankAccountRepository.GetByIban(iban);
if (bankAccount == null)
{
bankAccount = new BankAccountEntity
{
AccountNumber = iban,
Iban = iban,
BankName = Constants.DownloadHandler.BankNameRaiffeisen,
AccountName = i == 0 ? Constants.DownloadHandler.AccountNameGiro : Constants.DownloadHandler.AccountNameSaving
};
BankAccountRepository.Insert(bankAccount);
}
TakeScreenshot(iban);
var resultingFile = DownloadFromWebElement(Browser.FindElement(By.ClassName("icon-csv")), iban);
downloadResults.Add(new FileParserInput
{
OwningEntity = bankAccount,
FileParser =
ComponentContext.ResolveKeyed <IFileParser>(Constants.UniqueContainerKeys.FileParserRaiffeisenGiro),
FilePath = resultingFile,
TargetEntity = typeof(RaiffeisenTransactionEntity),
Balance = (decimal)valueParser.Parse(balance),
BalanceSelectorFunc =
() => BankTransactionRepository.TransactionSumForAccountId(bankAccount.Id)
});
}
downloadResults.AddRange(DownloadDepots());
return(downloadResults);
}
public void BankAccountRepositoryFilterMethodReturnEntitisWithSatisfiedFilter()
{
//Arrange
var unitOfWork = new MainBcUnitOfWork();
var bankAccountRepository = new BankAccountRepository(unitOfWork);
var iban = string.Format("ES{0} {1} {2} {0}{3}", "02", "4444", "5555", "3333333333");
//Act
var allItems = bankAccountRepository.GetFiltered(ba => ba.Iban == iban);
//Assert
Assert.IsNotNull(allItems);
Assert.IsTrue(allItems.All(b => b.Iban == iban));
}
public void BankAccountRepositoryGetMethodReturnMaterializedEntityById()
{
//Arrange
var unitOfWork = new MainBcUnitOfWork();
var bankAccountRepository = new BankAccountRepository(unitOfWork);
var selectedBankAccount = new Guid("0343C0B0-7C40-444A-B044-B463F36A1A1F");
//Act
var bankAccount = bankAccountRepository.Get(selectedBankAccount);
//Assert
Assert.IsNotNull(bankAccount);
Assert.IsTrue(bankAccount.Id == selectedBankAccount);
}
public void BankAccountRepositoryFilterMethodReturnEntitisWithSatisfiedFilter()
{
//Arrange
var bankAccountRepository = new BankAccountRepository(fixture.unitOfWork, fixture.bankAccountLogger);
string iban = string.Format("ES{0} {1} {2} {0}{3}", "02", "4444", "5555", "3333333333");
//Act
var allItems = bankAccountRepository.GetFiltered(ba => ba.Iban == iban);
//Assert
Assert.NotNull(allItems);
Assert.True(allItems.All(b => b.Iban == iban));
}
public void BankAccountRepositoryGetMethodReturnMaterializedEntityById()
{
//Arrange
var unitOfWork = new MainBCUnitOfWork();
var bankAccountRepository = new BankAccountRepository(unitOfWork);
var selectedBankAccount = new Guid("0343C0B0-7C40-444A-B044-B463F36A1A1F");
//Act
var bankAccount = bankAccountRepository.Get(selectedBankAccount);
//Assert
Assert.IsNotNull(bankAccount);
Assert.IsTrue(bankAccount.Id == selectedBankAccount);
}
public void BankAccountRepositoryFilterMethodReturnEntitisWithSatisfiedFilter()
{
//Arrange
var unitOfWork = new MainBCUnitOfWork();
IBankAccountRepository bankAccountRepository = new BankAccountRepository(unitOfWork);
string iban = string.Format("ES{0} {1} {2} {0}{3}", "02", "4444", "5555", "3333333333");
//Act
var allItems = bankAccountRepository.GetFiltered(ba => ba.Iban == iban);
//Assert
Assert.IsNotNull(allItems);
Assert.IsTrue(allItems.All(b => b.Iban == iban));
}
public void GetBankAccountSuccessfully()
{
var content = File.ReadAllText("../../../Fixtures/bank_account_get_by_id.json");
var client = GetMockClient(content);
var repo = new BankAccountRepository(client.Object);
const string id = "ec9bf096-c505-4bef-87f6-18822b9dbf2c";
var response = repo.GetBankAccountById(id);
client.VerifyAll();
var first = response.Values.First();
var firstJson = JsonConvert.SerializeObject(first);
var gotAccount = JsonConvert.DeserializeObject <IDictionary <string, object> >(firstJson);
Assert.AreEqual(id, gotAccount["id"]);
}
public override void TestInitialize()
{
base.TestInitialize();
TransactionRepository = Container.Resolve <IRepository <RaiffeisenTransactionEntity> >();
BankAccountRepository = Container.Resolve <IRepository <BankAccountEntity> >();
BankAccountEntity = new BankAccountEntity
{
AccountName = "Giro",
BankName = "Raiffeisen",
AccountNumber = "AT001234567891234",
Iban = "AT001234567891234"
};
BankAccountRepository.InsertOrGetWithEquality(BankAccountEntity);
BankAccountRepository.Save();
}
public void BankAccountRepositoryAllMatchingMethodReturnEntitiesWithSatisfiedCriteria()
{
//Arrange
var bankAccountRepository = new BankAccountRepository(fixture.unitOfWork, fixture.bankAccountLogger);
string iban = string.Format("ES{0} {1} {2} {0}{3}", "02", "4444", "5555", "3333333333");
var spec = BankAccountSpecifications.BankAccountIbanNumber(iban);
//Act
var result = bankAccountRepository.AllMatching(spec);
//Assert
Assert.NotNull(result);
Assert.True(result.All(b => b.Iban == iban));
}
public void FindPagedBankAccountsWithTransferInformation_Invoke_InvalidPageCountThrowArgumentException_Test()
{
//Arrange
IMainModuleUnitOfWork context = this.GetUnitOfWork();
ITraceManager traceManager = this.GetTraceManager();
BankAccountRepository repository = new BankAccountRepository(context, traceManager);
int pageIndex = 0;
int pageCount = 0;
//act
IEnumerable <BankAccount> result = repository.FindPagedBankAccountsWithTransferInformation(pageIndex, pageCount);
//Assert
Assert.IsNotNull(result);
Assert.IsTrue(result.Count() > 0);
}
public AccountWindowViewModel(IServiceProvider serviceProvider, TransferBroker broker, BankAccountRepository bankRepo, UserRepository userRepo, InvestmentRepository investRepo, LoanRepository loanRepo)
{
this.broker = broker;
this.serviceProvider = serviceProvider;
this.bankRepo = bankRepo;
this.userRepo = userRepo;
this.investRepo = investRepo;
this.loanRepo = loanRepo;
broker.TransferStarted += Broker_TransferStarted;
broker.TimePassed += Broker_TimePassed;
broker.Update += Broker_Update;
Loans = new ObservableCollection <LoanViewModel>();
Investments = new ObservableCollection <InvestmentViewModel>();
LoggedUsers = new ObservableCollection <User>();
InitializeCommands();
}
public void BankAccountRepositoryAllMatchingMethodReturnEntitiesWithSatisfiedCriteria()
{
//Arrange
var unitOfWork = new MainBCUnitOfWork();
IBankAccountRepository bankAccountRepository = new BankAccountRepository(unitOfWork);
string iban = string.Format("ES{0} {1} {2} {0}{3}","02","4444","5555","3333333333");
var spec =BankAccountSpecifications.BankAccountWithNumber(iban);
//Act
var result = bankAccountRepository.AllMatching(spec);
//Assert
Assert.IsNotNull(result);
Assert.IsTrue(result.All(b => b.Iban == iban));
}
public override LoanProposal Handle(LoanProposal request)
{
Console.WriteLine("\nValidating bank account balance.");
var clientId = request;
var repo = new BankAccountRepository();
var bankAccount = repo.Find(x => x.ClientId == request.ClientId).FirstOrDefault();
if (bankAccount.Balance < request.Amount * 0.5m)
{
throw new Exception($"The client bank account must have at least 50% of the required loan amount.");
}
return(base.Handle(request));
}
public void Find_Should_Return_Bank_Account()
{
//Arrange
var dataContextMock = new Mock <DataContext>();
var dbSetMock = new Mock <DbSet <BankAccount> >();
dbSetMock.Setup(b => b.Find(It.IsAny <Guid>())).Returns(new BankAccount());
dataContextMock.Setup(b => b.Set <BankAccount>()).Returns(dbSetMock.Object);
//Act
var bankAccountRepository = new BankAccountRepository(dataContextMock.Object);
var bankAccount = bankAccountRepository.Find(new Guid());
//Assert
Assert.NotNull(bankAccount);
Assert.IsAssignableFrom <BankAccount>(bankAccount);
}
public void FindBanksAccounts_Invoke_AccountNumber_Test()
{
//Arrange
IMainModuleUnitOfWork context = this.GetUnitOfWork();
ITraceManager traceManager = this.GetTraceManager();
BankAccountRepository repository = new BankAccountRepository(context, traceManager);
BankAccountSearchSpecification spec = new BankAccountSearchSpecification(bankAccountNumber, null);
//Act
IEnumerable <BankAccount> actual;
actual = repository.GetBySpec(spec);
//Assert
Assert.IsNotNull(actual);
Assert.IsTrue(actual.Count() == 1);
}
public void FindBanksAccounts_Invoke_CustomerName_Test()
{
//Arrange
IMainModuleUnitOfWork context = this.GetUnitOfWork();
ITraceManager traceManager = this.GetTraceManager();
BankAccountRepository repository = new BankAccountRepository(context, traceManager);
string name = "Unai";
BankAccountSearchSpecification spec = new BankAccountSearchSpecification(null, name);
//Act
IEnumerable <BankAccount> actual;
actual = repository.GetBySpec(spec);
//Assert
Assert.IsNotNull(actual);
}
public BankAccountModel CreateEditBankAccount(BankAccountModel model)
{
BankAccountEntity entity;
//is update
if (model.Id != default(long))
{
entity = BankAccountRepository.GetById(model.Id);
entity = Mapper.Map(model, entity);
}
else
{
entity = Mapper.Map <BankAccountEntity>(model);
entity = BankAccountRepository.Insert(entity);
}
BankAccountRepository.Save();
return(Mapper.Map <BankAccountModel>(entity));
}
public void BankAccountRepositoryPagedMethodReturnEntitiesInPageFashion()
{
//Arrange
var bankAccountRepository = new BankAccountRepository(fixture.unitOfWork, fixture.bankAccountLogger);
//Act
var pageI = bankAccountRepository.GetPaged(0, 1, b => b.Id, false);
var pageII = bankAccountRepository.GetPaged(1, 1, b => b.Id, false);
//Assert
Assert.NotNull(pageI);
Assert.True(pageI.Count() == 1);
Assert.NotNull(pageII);
Assert.True(pageII.Count() == 1);
Assert.False(pageI.Intersect(pageII).Any());
}
public void CustomerService_Customer_WithBankAccountAndTransactions()
{
// Arrange
var customerService = new CustomerService(new CustomerRepository(_dbContext),
new BankAccountRepository(_dbContext),
new TransactionRepository(_dbContext));
var name = Guid.NewGuid().ToString();
var surname = Guid.NewGuid().ToString();
_dbContext.Customers.Add(new Customer
{
Name = name,
Surname = surname,
DateCreated = DateTime.UtcNow
});
_dbContext.SaveChanges();
var bankAccountRepository = new BankAccountRepository(_dbContext);
bankAccountRepository.Add(new BankAccount
{
CustomerId = 1
}).GetAwaiter().GetResult();
_dbContext.SaveChanges();
_dbContext.Transactions.Add(new Transaction
{
Amount = 50,
BankAccountId = 1,
DateCreated = DateTime.UtcNow
});
_dbContext.SaveChanges();
// Act
var customer = customerService.GetCustomer(1).GetAwaiter().GetResult();
// Assert
Assert.NotNull(customer);
Assert.Equal(name, customer.Name);
Assert.Equal(surname, customer.Surname);
Assert.True(1 == customer.BankAccounts.Count());
Assert.True(1 == customer.BankAccounts.First().Transactions.Count());
}
protected override IEnumerable <FileParserInput> DownloadTransactions()
{
Browser.WaitForJavaScript(5000);
var ibanRaw = Browser.FindElement(By.ClassName("accountText")).Text; //First is Tagesgeld
var iban = ibanRaw.Split(':')[1].CleanString();
var balanceStr = Browser.FindElement(new ByChained(By.ClassName("currency"), By.ClassName("amountblock-wrapper"))).Text;
var valueParser =
ComponentContext.ResolveKeyed <IValueParser>(Constants.UniqueContainerKeys.ValueParserGermanDecimal);
var balance = (decimal)valueParser.Parse(balanceStr);
Browser.FindElement(By.ClassName("accountInfo-wrapper")).Click();
Browser.WaitForJavaScript();
var bankAccount = BankAccountRepository.GetByIban(iban);
if (bankAccount == null)
{
bankAccount = new BankAccountEntity
{
AccountNumber = iban,
Iban = iban,
BankName = Constants.DownloadHandler.BankNameRci,
AccountName = Constants.DownloadHandler.AccountNameSaving
};
BankAccountRepository.Insert(bankAccount);
}
TakeScreenshot(iban);
var exportButton = Browser.FindElement(By.ClassName("transactions-csv-export"));
var file = DownloadFromWebElement(exportButton, iban);
yield return(new FileParserInput
{
Balance = balance,
BalanceSelectorFunc = () => BankTransactionRepository.TransactionSumForAccountId(bankAccount.Id),
FileParser = ComponentContext.ResolveKeyed <IFileParser>(Constants.UniqueContainerKeys.FileParserRci),
FilePath = file,
OwningEntity = bankAccount,
TargetEntity = typeof(RciTransactionEntity)
});
}
public void FindBankAccount_Invoke_InvalidCodeReturnNullObject_Test()
{
//Arrange
IMainModuleUnitOfWork context = this.GetUnitOfWork();
ITraceManager traceManager = this.GetTraceManager();
BankAccountRepository repository = new BankAccountRepository(context, traceManager);
string invalidCode = "0200011111";
BankAccountNumberSpecification spec = new BankAccountNumberSpecification(invalidCode);
//Act
BankAccount actual;
actual = repository.GetBySpec(spec)
.SingleOrDefault();
//Assert
Assert.IsNull(actual);
}
public void GetUserForBankAccountSuccessfully()
{
var content = File.ReadAllText("../../../Fixtures/bank_account_get_users.json");
var client = GetMockClient(content);
var repo = new BankAccountRepository(client.Object);
const string userId = "ec9bf096-c505-4bef-87f6-18822b9dbf2c"; //some user created before
var resp = repo.GetUserForBankAccount("ec9bf096-c505-4bef-87f6-18822b9dbf2c");
client.VerifyAll();
Assert.IsNotNull(resp);
var users = resp["users"];
Assert.IsNotNull(users);
var user = JsonConvert.DeserializeObject <IDictionary <string, object> >(JsonConvert.SerializeObject(users));
Assert.AreEqual(userId, user["id"]);
}
public async Task AddAccountAsyncAsync_Test()
{
var item = new BankAccountInfo()
{
AccountNumber = 123456,
SocialId = "123456789",
BankCode = 31,
BranchNumber = 1,
BirthDay = new DateTime(1972, 1, 1),
CityCode = "CityCode",
NameEnglish = "NameEnglish",
NameLocal = "NameLocal"
};
IBankAccountRepository bankRepository = new BankAccountRepository();
await bankRepository.CreateAsync(item);
Assert.True(item.Id > 0);
}
public void BankAccountRepositoryGetMethodReturnMaterializedEntityById()
{
//Arrange
var unitOfWork = new MainBCUnitOfWork();
//DbContextManager.DbContextBuilder<TestDbContext> builder = new DbContextBuilder<TestDbContext>("Infrastructure.Data.Ef.Test.UnitOfWork.MainBCUnitOfWork", @"E:\MyCode\MyCommonLibrary\TestOutput\Infrastructure.Data.Ef.Test", "Infrastructure.Data.Ef.Test.UnitOfWork.Mapping");
//var unitOfWork = builder.BuildDbContext();
IBankAccountRepository bankAccountRepository = new BankAccountRepository(unitOfWork);
Guid selectedBankAccount = new Guid("0343C0B0-7C40-444A-B044-B463F36A1A1F");
//Act
var bankAccount = bankAccountRepository.Get(selectedBankAccount);
//Assert
Assert.IsNotNull(bankAccount);
Assert.IsTrue(bankAccount.Id == selectedBankAccount);
}
public void BankAccountRepositoryPagedMethodReturnEntitiesInPageFashion()
{
//Arrange
var unitOfWork = new MainBCUnitOfWork();
var bankAccountRepository = new BankAccountRepository(unitOfWork);
//Act
var pageI = bankAccountRepository.GetPaged(0, 1, b => b.Id, false);
var pageII = bankAccountRepository.GetPaged(1, 1, b => b.Id, false);
//Assert
Assert.IsNotNull(pageI);
Assert.IsTrue(pageI.Count() == 1);
Assert.IsNotNull(pageII);
Assert.IsTrue(pageII.Count() == 1);
Assert.IsFalse(pageI.Intersect(pageII).Any());
}
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);
}
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 BankAccountRepositoryGetAllReturnMaterializedBankAccountsAndCustomers()
{
//Arrange
var unitOfWork = new MainBcUnitOfWork();
var bankAccountRepository = new BankAccountRepository(unitOfWork);
//Act
var allItems = bankAccountRepository.GetAll();
//Assert
Assert.IsNotNull(allItems);
Assert.IsTrue(allItems.Any());
Assert.IsTrue(allItems.All(ba => ba.Customer != null));
}
public void BankAccountRepositoryPagedMethodReturnEntitiesInPageFashion()
{
//Arrange
var unitOfWork = new MainBcUnitOfWork();
var bankAccountRepository = new BankAccountRepository(unitOfWork);
//Act
var pageI = bankAccountRepository.GetPaged(0, 1, b => b.Id, false);
var pageIi = bankAccountRepository.GetPaged(1, 1, b => b.Id, false);
//Assert
Assert.IsNotNull(pageI);
Assert.IsTrue(pageI.Count() == 1);
Assert.IsNotNull(pageIi);
Assert.IsTrue(pageIi.Count() == 1);
Assert.IsFalse(pageI.Intersect(pageIi).Any());
}
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();
}
