//[Theory]
//[InlineData("/api/Employee/All")]
public async Task GetAllEmployees(string url)
{
//Given a running server with employees allocated in his database
DalService.CreateUnitOfWork().Employees.GetAllAsync(PageRequest.Of(0, int.MaxValue)).Result.Should().HaveCountGreaterThan(0);
//When a client ask for URL /api/Employee/All
var client = TestServer.CreateClient();
var response = await client.GetAsync(url);
//Then the response will be successful
response.EnsureSuccessStatusCode(); // Status Code 200-299
//and the result body should not be null
var json = await response.Content.ReadAsStringAsync();
IEnumerable <EmployeeDto> reaultObjects = JsonConvert.DeserializeObject <IEnumerable <EmployeeDto> >(json);
reaultObjects.Should().NotBeNull();
//and the result body should match the employees in the database
var allEmployeesFromDb = DalService.CreateUnitOfWork().Employees.GetAllAsync(PageRequest.Of(0, int.MaxValue)).Result
.Select(e => Mapper.Map <EmployeeDto>(e));;
reaultObjects.Should().BeEquivalentTo(allEmployeesFromDb, options => options.IncludingNestedObjects());
}
public async Task GetBusinessPartnersPaging(string url)
{
//Given a running server with businessPartners allocated in his database
DalService.CreateUnitOfWork().BusinessPartners.GetAllAsync(PageRequest.Of(0, 1)).Result.Should().HaveCountGreaterThan(0);
//When a client ask for URL /api/BusinessPartner&page=x&size=y
var client = TestServer.CreateClient();
var response = await client.GetAsync(url);
//Then the response will be successful
response.EnsureSuccessStatusCode(); // Status Code 200-299
//and the result body should not be null
var json = await response.Content.ReadAsStringAsync();
var resultObjects = JsonConvert.DeserializeObject <IEnumerable <BusinessPartnerDto> >(json);
var businessPartnersDto = resultObjects as BusinessPartnerDto[] ?? resultObjects.ToArray();
businessPartnersDto.Should().NotBeNull();
//and the result body should contain size or less elements
var size = Convert.ToInt32(url.Split("size=")[1]);
//var page = Convert.ToInt32(url.Split("page=")[1].Split("&")[0]);
businessPartnersDto.Should().HaveCountLessOrEqualTo(size);
var bpsKeys = businessPartnersDto.Select(x => x.Key);
//and the result body should match the businessPartners in the database
var allBusinessPartnersFromDb = DalService.CreateUnitOfWork()
.BusinessPartners.FindAllAsync(x => bpsKeys.Contains(x.Key), PageRequest.Of(0, int.MaxValue)).Result
.Select(e => Mapper.Map <BusinessPartnerDto>(e)).ToList();
allBusinessPartnersFromDb.Count.Should().BeLessOrEqualTo(size);
businessPartnersDto.Should().BeEquivalentTo(allBusinessPartnersFromDb, options => options.IncludingNestedObjects());
}
public void AddNewValidQuotationShouldSucceed()
{
var numOfQuotationBefore = DalService.CreateUnitOfWork().Quotations.CountAsync().Result;
//Given a valid new quotation
var validQuotation = CreateValidQuotation();
//When adding the new quotation
var unitOfWork = DalService.CreateUnitOfWork();
{
var addedQuotations = unitOfWork.Quotations.AddAsync(validQuotation).Result;
_addedQuotationsToCancelAtDispose.Add(addedQuotations);
//Then the result should not be null
addedQuotations.Should().NotBeNull();
//and the result's document sum should be close to quantity*pricePerQuantity*(100-discountPrecent)/100 + VAT
var calculatedTotal = validQuotation.Items.Sum(i => i.PricePerQuantity * i.Quantity * (100 - i.DiscountPercent) / 100);
Debug.Assert(addedQuotations.VatPercent != null, "addedQuotations.VatPercent != null");
calculatedTotal += (calculatedTotal * addedQuotations.VatPercent.Value) / 100;
addedQuotations.DocTotal.Should().BeInRange(calculatedTotal - 1, calculatedTotal + 1);
//and the transaction should succeed
unitOfWork.CompleteAsync().Wait();
//and the repository should contain the new quotation
Debug.Assert(addedQuotations.Key != null, "addedQuotations.Key != null");
var quotationAfterCommit = DalService.CreateUnitOfWork().Quotations.FindByIdAsync(addedQuotations.Key.Value).Result;
quotationAfterCommit.Should().NotBeNull();
quotationAfterCommit.ValidUntil.Should().Be(validQuotation.ValidUntil);
var numOfQuotationAfter = DalService.CreateUnitOfWork().Quotations.CountAsync().Result;
numOfQuotationAfter.Should().Be(numOfQuotationBefore + 1);
}
}
public void AddingCustomerWithCidShouldFailAndThrowException()
{
//Given a BusinessPartner repository
var numberOfCustomerBefore = DalService.CreateUnitOfWork().BusinessPartners.CountAsync().Result;
//When Adding a BusinessPartner with a Cid (not null)
var businessPartner = new BusinessPartner
{
Key = "000",
Name = "testName"
};
//Than the adding function will throw an exception
BusinessPartner addedBusinessPartner = null;
Action comparison = () =>
{
using var uow = DalService.CreateUnitOfWork();
addedBusinessPartner = uow.BusinessPartners.AddAsync(businessPartner).Result;
uow.CompleteAsync().Wait();
};
comparison.Should().Throw <Exception>();
//and the database will not affected
DalService.CreateUnitOfWork().BusinessPartners.CountAsync().Result.Should().Be(numberOfCustomerBefore);
//and the returned BusinessPartner need to be null
(addedBusinessPartner == null).Should().BeTrue();
}
public async Task GetEmployeeBySn(string url)
{
//Given a running server with employees allocated in his database
var employeeId = Convert.ToInt32(url.Split("GetBySN/")[1]);
var employeeFromDb = DalService.CreateUnitOfWork().Employees.FindByIdAsync(employeeId).Result;
employeeFromDb.Should().NotBeNull();
//When a client ask for URL /api/Employee/GetByID/5
var client = TestServer.CreateClient();
var response = await client.GetAsync(url);
//Then the response will be successful
response.EnsureSuccessStatusCode(); // Status Code 200-299
//and the result body should not be null
var json = await response.Content.ReadAsStringAsync();
EmployeeDto reaultObject = JsonConvert.DeserializeObject <EmployeeDto>(json);
reaultObject.Should().NotBeNull();
//and the result body should match the employees in the database
reaultObject.Should().BeEquivalentTo(Mapper.Map <EmployeeDto>(employeeFromDb)
, options => options.IncludingNestedObjects());
}
public async Task GetEmployeesPageing(string url)
{
//Given a running server with employees allocated in his database
DalService.CreateUnitOfWork().Employees.GetAllAsync(PageRequest.Of(0, int.MaxValue)).Result.Should().HaveCountGreaterThan(0);
//When a client ask for URL /api/Employee&page=x&size=y
var client = TestServer.CreateClient();
var response = await client.GetAsync(url);
//Then the response will be successful
response.EnsureSuccessStatusCode(); // Status Code 200-299
//and the result body should not be null
var json = await response.Content.ReadAsStringAsync();
IEnumerable <EmployeeDto> reaultObjects = JsonConvert.DeserializeObject <IEnumerable <EmployeeDto> >(json);
reaultObjects.Should().NotBeNull();
//and the result body should contain size or less elements
var size = Convert.ToInt32(url.Split("size=")[1]);
var page = Convert.ToInt32(url.Split("page=")[1].Split("&")[0]);
reaultObjects.Should().HaveCountLessOrEqualTo(size);
//and the result body should match the employees in the database
var allEmployeesFromDb = DalService.CreateUnitOfWork()
.Employees.GetAllAsync(PageRequest.Of(page, size, Sort <EmployeeEntity> .By(x => x.Sn))).Result
.Select(e => Mapper.Map <EmployeeDto>(e));
reaultObjects.Should().BeEquivalentTo(allEmployeesFromDb, options => options.IncludingNestedObjects());
}
public async Task GetCompany(string url)
{
//Given a running server with company allocated in his database
var companyFromDb = DalService.CreateUnitOfWork().Company.GetAsync().Result;
companyFromDb.Should().NotBeNull();
//When a client ask for URL /api/Company
var client = TestServer.CreateClient();
var response = await client.GetAsync(url);
//Then the response will be successful
response.EnsureSuccessStatusCode(); // Status Code 200-299
//and the result body should not be null
var json = await response.Content.ReadAsStringAsync();
CompanyDto reaultObject = JsonConvert.DeserializeObject <CompanyDto>(json);
reaultObject.Should().NotBeNull();
//and the result body should match the company in the database
reaultObject.Should().BeEquivalentTo(Mapper.Map <CompanyDto>(companyFromDb),
options => options.IncludingNestedObjects());
}
public void AddCustomerListWithOneCustomerThatFailWillThrowExceptionAndRollback()
{
//Given a BusinessPartner repository
var numberOfCustomerBefore = DalService.CreateUnitOfWork().BusinessPartners.CountAsync().Result;
//When Adding a BusinessPartner list with one or more BusinessPartner that have a Cid (not null)
var customerList = Enumerable.Range(1, 5)
.Select(i => new BusinessPartner {
Name = "TESTAddCustomerListWithOneCustomerThatFailWillRollback " + i
})
.ToList();
customerList.ElementAt(3).Key = "000";
customerList.ElementAt(4).Key = "000";
Action comparison = () =>
{
using var uow = DalService.CreateUnitOfWork();
uow.BusinessPartners.AddAsync(customerList).Wait();
uow.CompleteAsync().Wait();
};
//Then action will throw an exception
comparison.Should().Throw <Exception>();
//and the number of elements in the repository will not affected - transaction will rollback
var numberOfCustomerAfterTransaction = DalService.CreateUnitOfWork().BusinessPartners.CountAsync().Result;
numberOfCustomerAfterTransaction.Should().Be(numberOfCustomerBefore);
}
public async Task PostBusinessPartner(string url)
{
//Given a running server with CardGroup and Salesman
DbContext.Salesmen.Add(new SalesmanEntity
{
Sn = -1,
Name = "TEST_S",
ActiveStatus = SalesmanEntity.Status.Active
});
DbContext.CardGroups.Add(new CardGroup {
Sn = 100, Name = "TEST_S"
});
DbContext.SaveChanges();
var validGroupCodes = DalService.CreateUnitOfWork().BusinessPartners.GetAllGroupsAsync().Result;
var validSalesmen = DalService.CreateUnitOfWork().Salesmen.GetAllAsync(PageRequest.Of(0, int.MaxValue)).Result;
var businessPartnersToPost = Enumerable.Range(1, 3).ToList()
.Select(i => new BusinessPartner {
Name = "TestWebBusinessPartner" + i,
GroupSn = validGroupCodes.FirstOrDefault()?.Sn,
SalesmanCode = validSalesmen.FirstOrDefault()?.Sn,
PartnerType = BusinessPartner.PartnerTypes.Customer,
Type = BusinessPartner.CardType.Private
}).ToList();
foreach (var businessPartnerToPost in businessPartnersToPost)
{
var jsonSend = JsonConvert.SerializeObject(Mapper.Map <BusinessPartnerDto>(businessPartnerToPost));
//When a client ask for URL /api/BusinessPartner} with a valid BusinessPartner in the request body
var client = TestServer.CreateClient();
var response = await client.PostAsync(url, new StringContent(jsonSend, Encoding.UTF8, "application/json"));
//Then the response will be successful
response.EnsureSuccessStatusCode(); // Status Code 200-299
//and the result body should be null and the name need to match
var json = await response.Content.ReadAsStringAsync();
var resultObject = JsonConvert.DeserializeObject <BusinessPartnerDto>(json);
resultObject.Should().NotBeNull();
resultObject.Name.Should().Be(businessPartnerToPost.Name);
resultObject.Should().BeEquivalentTo(businessPartnerToPost, opt => opt
.Excluding(x => x.CreationDateTime)
.Excluding(x => x.LastUpdateDateTime)
.Excluding(x => x.Key)
.IncludingNestedObjects()
);
//and the businessPartners should be added to the database
DalService.CreateUnitOfWork().BusinessPartners.FindByIdAsync(resultObject.Key).Result
.Should().NotBeNull();
}
}
public void Dispose()
{
//clear added BusinessPartner if any test failed
using var uow = DalService.CreateUnitOfWork();
uow.BusinessPartners.RemoveAsync(
uow.BusinessPartners.GetAllAsync(
PageRequest.Of(0, int.MaxValue, Sort <BusinessPartner> .By(x => x.Name))).Result
.Select(c => c.Key)
.Except(_customerBeforeTesting).ToList()).Wait();
uow.CompleteAsync().Wait();
}
public void GetCompanyShouldSucceed()
{
//Given allocated company repository
//When call to Get Company
var company = DalService.CreateUnitOfWork().Company.GetAsync().Result;
//Then the company should not be null
company.Should().NotBeNull();
//and the company should contain a name
company.Name.Should().NotBeNullOrWhiteSpace();
}
public async void MultiThreadedAddingCustomersShouldSucceed()
{
//Given a BusinessPartner Repository
var readonlyUow = DalService.CreateUnitOfWork();
var numberOfCustomerBefore = readonlyUow.BusinessPartners.CountAsync().Result;
//when a number of different threads want to add some BusinessPartner to the repository at the same time
const int numOfThreads = 5;
const int nymOfCustomerPerThread = 5;
var taskList = Enumerable.Range(1, numOfThreads).ToList().Select(i =>
{
return(Task <List <BusinessPartner> > .Factory.StartNew(() =>
{
var cc = Enumerable.Range(1, nymOfCustomerPerThread)
.Select(j => new BusinessPartner {
Name = $"TESTAddCustomerList thread={i}:index={j}"
})
.ToList();
using var u = DalService.CreateUnitOfWork();
var customerListAfter = u.BusinessPartners.AddAsync(cc).Result.ToList();
u.CompleteAsync().Wait();
return customerListAfter;
}));
}).ToArray();
var r = (await Task.WhenAll(taskList)).ToList();
//Then the BusinessPartner Repository will contain all of the BusinessPartner from the different threads
var numberOfCustomerAfter = readonlyUow.BusinessPartners.CountAsync().Result;
numberOfCustomerAfter.Should().Be(numberOfCustomerBefore + numOfThreads * nymOfCustomerPerThread);
r.ForEach(bps =>
{
var keys = bps.Select(cf => cf.Key);
var addedCustomer = readonlyUow.BusinessPartners
.FindAllAsync(c => keys.Contains(c.Key),
PageRequest.Of(0, nymOfCustomerPerThread + 1)).Result;
addedCustomer.Select(c => new[] { c.Key, c.Name })
.Should().BeEquivalentTo(bps.Select(c => new[] { c.Key, c.Name }),
options => options.IncludingNestedObjects());
});
//clear test
var customersToRemove = r.Aggregate((x1, x2) => x1.Union(x2).ToList());
using var uow = DalService.CreateUnitOfWork();
uow.BusinessPartners.RemoveAsync(customersToRemove.Select(c => c.Key).ToList()).Wait();
uow.CompleteAsync().Wait();
}
public void Dispose()
{
_addedQuotationsToCancelAtDispose.Where(q => q?.Key != null).ToList()
.ForEach(q =>
{
using (var u = DalService.CreateUnitOfWork())
{
if (q.Key != null)
{
u.Quotations.CancelAsync(q.Key.Value).Wait();
}
u.CompleteAsync().Wait();
}
});
}
public async Task <OrderEntity> CloseDocument(int key, CancellationToken cancellationToken)
{
using (var transaction = DalService.CreateUnitOfWork())
{
var doc = await transaction.Quotations.FindByIdAsync(key);
var closedDoc = await GetRepository(transaction).CloseAsync(key);
cancellationToken.ThrowIfCancellationRequested();
await transaction.CompleteAsync();
return(closedDoc);
}
}
public void FindBySnWithInValidSnShouldReturnNull()
{
var unitOfWork = DalService.CreateUnitOfWork();
//Given allocated Quotation repository
unitOfWork.Quotations.CountAsync().Result.Should().BeGreaterThan(0);
//and a invalid SN that match an existing entry
const short invalidSn = short.MinValue;
//When call to FIndBySN with the invalid SN
var gainQuotation = unitOfWork.Quotations.FindByIdAsync(invalidSn).Result;
//Then the returned quotation should be null
gainQuotation.Should().BeNull();
}
public void GetAllEmployeesShouldSucceed()
{
var unitOfWork = DalService.CreateUnitOfWork();
//Given allocated employee's repository
unitOfWork.Employees.CountAsync().Result.Should().BeGreaterThan(0);
//When GetAll Employees
var allEmployees = unitOfWork.Employees.GetAllAsync(PageRequest.Of(0, int.MaxValue)).Result.ToList();
//Then the number of gain employees should match the number of allocated employees
allEmployees.Count().Should().Be(unitOfWork.Employees.CountAsync().Result);
//and each employee should have an unique SN
allEmployees.Select(e => e.Sn).Distinct().Count().Should().Be(allEmployees.Count());
}
public async Task UpdateBusinessPartner(string url)
{
//Given a running server with businessPartners allocated in his database
using var unitOfWork = DalService.CreateUnitOfWork();
var bpsInDb = DbContext.BusinessPartners.Take(3).ToList();
await unitOfWork.CompleteAsync();
foreach (var businessPartnerFromDb in bpsInDb)
{
//When a client update the name of a valid BusinessPartner and ask for URL /api/BusinessPartner with the updated BusinessPartner
var updateName = businessPartnerFromDb.Name + " UPDATENAME";
businessPartnerFromDb.Name = updateName;
var bpDtoToSend = Mapper.Map <BusinessPartnerDto>(businessPartnerFromDb);
var jsonSend = JsonConvert.SerializeObject(bpDtoToSend);
var client = TestServer.CreateClient();
var response = await client.PutAsync($"{url}/{businessPartnerFromDb.Key}", new StringContent(jsonSend, Encoding.UTF8, "application/json"));
//Then the response will be successful
response.EnsureSuccessStatusCode(); // Status Code 200-299
//and the result body should be null
var json = await response.Content.ReadAsStringAsync();
var resultBpDto = JsonConvert.DeserializeObject <BusinessPartnerDto>(json);
resultBpDto.Should().NotBeNull();
//and the result should contain the updated name
resultBpDto.Name.Should().Be(updateName);
resultBpDto.Should().BeEquivalentTo(bpDtoToSend, config => config.Excluding(x => x.LastUpdateDateTime));
var resultBp = Mapper.Map <BusinessPartner>(resultBpDto);
Debug.Assert(businessPartnerFromDb.CreationDateTime != null, "businessPartnerFromDb.CreationDateTime != null");
resultBp.LastUpdateDateTime.Should()
.BeAfter(businessPartnerFromDb.LastUpdateDateTime ?? businessPartnerFromDb.CreationDateTime.Value);
//and the BusinessPartner should be updated in database
var updatedBusinessPartner = DalService.CreateUnitOfWork().BusinessPartners
.FindAllAsync(c => c.Key == resultBpDto.Key,
PageRequest.Of(0, 10, Sort <BusinessPartner> .By(x => x.Key))).Result.ElementAt(0);
updatedBusinessPartner.Name.Should().Be(updateName);
}
}
public void FindBySnWithValidSnShouldSucceed()
{
var unitOfWork = DalService.CreateUnitOfWork();
//Given allocated Quotation repository
unitOfWork.Quotations.CountAsync().Result.Should().BeGreaterThan(0);
//and a valid SN that match an existing entry
var validKey = unitOfWork.Quotations.GetAllAsync(PageRequest.Of(0, Int32.MaxValue)).Result
.ElementAt(new Random().Next(unitOfWork.Quotations.CountAsync().Result)).Key.Value;
//When call to FIndBySN with the valid SN
var gainQuotation = unitOfWork.Quotations.FindByIdAsync(validKey).Result;
//Then the returned quotation should not be null
gainQuotation.Should().NotBeNull();
//and contain a SN that match the searched SN
gainQuotation.Key.Value.Should().Be(validKey);
}
public void FindByIdEmployeesShouldSucceed()
{
var unitOfWork = DalService.CreateUnitOfWork();
//Given allocated employee's repository
unitOfWork.Employees.CountAsync().Result.Should().BeGreaterThan(0);
var allEmployees = unitOfWork.Employees.GetAllAsync(PageRequest.Of(0, int.MaxValue)).Result.ToList();
var validSn = unitOfWork.Employees.GetAllAsync(PageRequest.Of(0, int.MaxValue)).Result
.ElementAt(new Random().Next(allEmployees.Count() - 1)).Sn;
//When call to FindByID with a valid SN
var employee = unitOfWork.Employees.FindByIdAsync(validSn).Result;
//Then the employee should not be null
employee.Should().NotBeNull();
//and have the searched SN
employee.Sn.Should().Be(validSn);
}
public void CustomerWithBalanceMustHaveAccountFinanceRecordsToMatchIt()
{
//Given a BusinessPartner Repository with BusinessPartner that have a non zero balance
var customersWithBalance = DalService.CreateUnitOfWork().BusinessPartners
.FindAllAsync(c => c.Balance != 0,
PageRequest.Of(0, 100, Sort <BusinessPartner> .By(x => x.Key))).Result;
customersWithBalance.Should().HaveCountGreaterThan(0);
//When query BusinessPartner's account finance
var customersAccountRecords = customersWithBalance.Select(c =>
DalService.CreateUnitOfWork().BusinessPartners
.GetAccountBalanceRecordsAsync(c.Key).Result).ToList();
//Then he must have more then zero records
customersAccountRecords.ForEach(rList => rList.Should().HaveCountGreaterThan(0));
//and the sum of his record must match the total balance
customersWithBalance.Zip(customersAccountRecords, (c, r) => new { BusinessPartner = c, RecordsList = r })
.ToList().ForEach(a =>
a.RecordsList.Select(r => r.BalanceDebt).Sum().Should().Be(a.BusinessPartner.Balance));
}
public void AddValidCustomerListShouldSucceed()
{
//Given a repository
var numOfElementsBeforeAdding = DalService.CreateUnitOfWork().BusinessPartners.CountAsync().Result;
//When add 10 diffident customers
var customerList = Enumerable.Range(1, 10)
.Select(i => new BusinessPartner {
Name = "TESTAddCustomerListToRepository " + i
}).ToList();
using var uow = DalService.CreateUnitOfWork();
var customerListAfter = uow.BusinessPartners.AddAsync(customerList).Result.ToList();
uow.CompleteAsync().Wait();
//Then
//the repository must be 10 elements bigger Customers.GetAllAsync().Result
var numOfElementsAfterAdding = DalService.CreateUnitOfWork().BusinessPartners.CountAsync().Result;
numOfElementsAfterAdding.Should().Be(numOfElementsBeforeAdding + 10);
//and the added list must be of size 10
customerListAfter.Should().HaveCount(10);
//and the added list must contain a BusinessPartner id
customerListAfter.TrueForAll(c => c.Key != null).Should().BeTrue();
//and the repository must contain the added customers
var customerAtRepository = DalService.CreateUnitOfWork().BusinessPartners
.FindAllAsync(c => customerListAfter.Select(c2 => c2.Key).Contains(c.Key),
PageRequest.Of(0, 100, Sort <BusinessPartner> .By(x => x.Key))).Result;
customerAtRepository.Select(c => c.Name).Should().BeEquivalentTo(customerList.Select(c => c.Name));
//Clear Test
using var uow2 = DalService.CreateUnitOfWork();
uow2.BusinessPartners.RemoveAsync(customerListAfter.Select(c => c.Key).ToList()).Wait();
uow2.CompleteAsync().Wait();
}
public async Task UpdateOneValidBusinessPartnerShouldSucceed()
{
//Given a repository
//with at least 10 diffident customers
var bp = new BusinessPartner {
Name = "TEST_UpdateBpRepository"
};
using var uow = DalService.CreateUnitOfWork();
bp = await uow.BusinessPartners.AddAsync(bp);
await uow.CompleteAsync();
//When update business partner with valid attrs
using var uow1 = DalService.CreateUnitOfWork();
(await uow1.BusinessPartners.FindByIdAsync(bp.Key)).Should().NotBeNull();
bp.Phone2 = "053-555555";
await uow1.BusinessPartners.UpdateAsync(bp);
await uow1.CompleteAsync();
//Then
using var uow2 = DalService.CreateUnitOfWork();
var result = await uow2.BusinessPartners.FindByIdAsync(bp.Key);
result.Key.Should().Be(bp.Key);
result.Should().BeEquivalentTo(bp, opt => opt
.Excluding(x => x.LastUpdateDateTime)
.Excluding(x => x.CreationDateTime)//TODO
.IncludingNestedObjects()
);
//Clear Test
using var uow3 = DalService.CreateUnitOfWork();
uow3.BusinessPartners.RemoveAsync(bp.Key).Wait();
await uow3.CompleteAsync();
}
public void GetCustomerPagingTest()
{
//Given a linq to a database with at least 100 customers
DalService.CreateUnitOfWork().BusinessPartners.CountAsync().Result.Should().BeGreaterOrEqualTo(100);
//When activating a paging request
const int page = 10;
const int size = 6;
var customerPagingList = DalService.CreateUnitOfWork()
.BusinessPartners.GetAllAsync(PageRequest.Of(page, size, Sort <BusinessPartner> .By(x => x.Key))).Result
.ToList();
//Then the result will be at the same size
customerPagingList.Count().Should().Be(size);
//and the result page must be at the correct position
var allCustomers = DalService.CreateUnitOfWork().BusinessPartners
.GetAllAsync(PageRequest.Of(0, int.MaxValue, Sort <BusinessPartner> .By(x => x.Key))).Result
.ToList();
allCustomers.GetRange(page * size, size).ToList()
.Should().BeEquivalentTo(customerPagingList,
options => options.WithoutStrictOrdering().IncludingNestedObjects());
}
private QuotationEntity CreateValidQuotation()
{
var quotationCustomer = DalService.CreateUnitOfWork().BusinessPartners
.FirstOrDefaultAsync(c => c.IsActive == true).Result;
var quotationOwner = DalService.CreateUnitOfWork().Employees
.FirstOrDefaultAsync(e => e.IsActive).Result;
var quotationSalesman = DalService.CreateUnitOfWork().Salesmen
.FirstOrDefaultAsync(s => s.ActiveStatus == SalesmanEntity.Status.Active).Result;
return(new QuotationEntity
{
ExternalSn = "testQuotationSN",
CustomerSn = quotationCustomer.Key,
CustomerName = quotationCustomer.Name,
Comments = "this is a test quotation",
OwnerEmployeeSn = quotationOwner.Sn,
SalesmanSn = quotationSalesman.Sn,
Items = new List <DocItemEntity>()
{
new DocItemEntity()
{
Code = "999999",
Description = "testDescription3",
PricePerQuantity = 100,
Quantity = 1.5M,
Details = "testDetails",
Comments = "testComments",
DiscountPercent = 10,
Properties = new Dictionary <string, object>()
}
},
ValidUntil = DateTime.Now.Date.AddDays(1)
});
}
public void AddNewInvalidQuotationShouldFail()
{
var numOfQuotationBefore = DalService.CreateUnitOfWork().Quotations.CountAsync().Result;
//Given an invalid new quotation
var invalidQuotation = CreateValidQuotation();
invalidQuotation.Items = new List <DocItemEntity>(); //quotation without items is invalid
//When adding the new quotation
using (var unitOfWork = DalService.CreateUnitOfWork())
{
QuotationEntity addedQuotation = null;
var transaction = 0;
Exception exception = null;
try
{
addedQuotation = unitOfWork.Quotations.AddAsync(invalidQuotation).Result;
_addedQuotationsToCancelAtDispose.Add(addedQuotation);
transaction = unitOfWork.CompleteAsync().Result;
}
catch (Exception e)
{
exception = e;
}
finally
{
//Then the result should be null
addedQuotation.Should().BeNull();
//and the transaction should fail
transaction.Should().Be(0);
//and throw exception
exception.Should().NotBeNull();
//and the repository should not affected
var numOfQuotationAfter = DalService.CreateUnitOfWork().Quotations.CountAsync().Result;
numOfQuotationAfter.Should().Be(numOfQuotationBefore);
}
}
}
public BusinessPartnerRepositoryTests(DatabaseFixture fixture) : base(fixture)
{
_customerBeforeTesting = DalService.CreateUnitOfWork().BusinessPartners.GetAllAsync(
PageRequest.Of(0, int.MaxValue, Sort <BusinessPartner> .By(x => x.Name)))
.Result.Select(c => c.Key).ToList();
}