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 ActionResult <IEnumerable <ContentLimitItemPoco> > Get()
{
using (var dal = new DalService())
{
return(dal.ContentLimitItems.ToArray());
}
}
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 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());
}
/// <summary>
/// Возвращает экземпляр сервиса
/// </summary>
public IncomeService()
{
/*
* Вообще, тут должен быть Dependency Injection, но для упрощения сделано прямое
* создание нужного класса DAL-уровня прямо в конструкторе.
*
* Как правило, бизнес-логика довольно плотно взаимодействует с DAL-уровнем.
* От выбранного способа хранения данных и от выбранной конкретной СУБД зависит
* довольно многое.
*
* Даже если брать класс реляционных СУБД, то в зависимости
* от конкретной СУБД бизнес-логика может быть написана по-разному: для MS SQL
* одним образом, для PostgreSQL — другим, для Oracle — вообще третьим. Всякие
* красивые идеи про то, что ORM помогает сделать быстрый переход с одной СУБД
* на другую — как правило, бред полный. На больших проектах это никогда не работает
* быстро — только долго и с болью.
*
* Если же рассматривать класс NoSQL СУБД, то тут бизнес-логика может быть написана
* совершенно иначе.
*
* И в обоих случаях связь между уровнями BL и DAL — она достаточно тесная. Поэтому
* иногда не так страшно отойти от красивых паттернов, вроде DI, в сторону упрощения,
* как это сделано в данном примере.
*/
_dalService = new DalService();
}
private static async Task RunAllNoContrastAndBrightness()
{
var originalContainerPaths = Directory.GetFiles(MainConstants.ContainerDiffFolderPath, "*.bmp",
SearchOption.TopDirectoryOnly);
var originalKeysPaths = Directory.GetFiles(MainConstants.KeysDiffFolderPath, "*.bmp",
SearchOption.TopDirectoryOnly);
var i = 1;
foreach (var originalKeyPath in originalKeysPaths)
{
foreach (var originalFilePath in originalContainerPaths)
{
var newFileName = $"{Path.GetFileNameWithoutExtension(originalFilePath)}_{Path.GetFileNameWithoutExtension(originalKeyPath)}";
var model = await Executor.ProcessData(originalFilePath, Path.GetFileName(originalKeyPath),
newFileName,
0, 0, 0, Mode);
model.Mode = Mode;
Console.WriteLine($"Processing case #{i++} for {newFileName}");
await DalService.InsertResult(model);
}
}
}
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 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 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();
}
//[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 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);
}
}
private static async Task GetResultsForContainerByLevel()
{
var items = (await DalService.GetAllResults()).Where(x =>
x.Mode == (int)WatermarkingMode.OneContainerToAllKeysWithBrightness ||
x.Mode == (int)WatermarkingMode.OneContainerToAllKeysWithContrast ||
x.Mode == (int)WatermarkingMode.OneContainerToAllKeysWithNoise).ToList();
foreach (var item in items)
{
item.ContainerFileName = item.ContainerFileName.Substring(0, item.ContainerFileName.IndexOf('_'));
}
foreach (var container in items.GroupBy(x => x.ContainerFileName))
{
Console.WriteLine(); Console.WriteLine();
Console.WriteLine($"Results for {container.Key}");
var brightnessResults = container.Where(x => x.Contrast == 0 && x.Noise == 0)
.OrderBy(x => x.Brightness);
Console.WriteLine($"Results per brightness");
Console.WriteLine("Brightness - Encryption PSNR - Decryption PSNR - Encryption time - Decryption time - Key");
foreach (var data in brightnessResults)
{
Console.WriteLine("{0,8} {1,15} {2,15} {3,18} {4,18} {5,18}",
data.Brightness, Math.Round(data.EncryptionPsnr, 2), Math.Round(data.DecryptionPsnr, 2),
data.EncryptionTime.TotalMilliseconds, data.DecryptionTime.TotalMilliseconds, data.KeyFileName);
}
Console.WriteLine();
var contrastResults = container.Where(x => x.Brightness == 0 && x.Noise == 0)
.OrderBy(x => x.Contrast);
Console.WriteLine($"Results per contrast");
Console.WriteLine("Contrast - Encryption PSNR - Decryption PSNR - Encryption time - Decryption time - Key");
foreach (var data in contrastResults)
{
Console.WriteLine("{0,8} {1,15} {2,15} {3,18} {4,18} {5,18}",
data.Contrast, Math.Round(data.EncryptionPsnr, 2), Math.Round(data.DecryptionPsnr, 2),
data.EncryptionTime.TotalMilliseconds, data.DecryptionTime.TotalMilliseconds, data.KeyFileName);
}
Console.WriteLine();
var noiseResults = container.Where(x => x.Brightness == 0 && x.Contrast == 0)
.OrderBy(x => x.Noise);
Console.WriteLine($"Results per noise");
Console.WriteLine("Noise - Encryption PSNR - Decryption PSNR - Encryption time - Decryption time - Key");
foreach (var data in noiseResults)
{
Console.WriteLine("{0,8} {1,15} {2,15} {3,18} {4,18} {5,18}",
data.Noise, Math.Round(data.EncryptionPsnr, 2), Math.Round(data.DecryptionPsnr, 2),
data.EncryptionTime.TotalMilliseconds, data.DecryptionTime.TotalMilliseconds, data.KeyFileName);
}
Console.WriteLine("_______________________________________________________________________________________________________");
Console.WriteLine();
}
}
private static async Task RunDifferentNoise(List <WatermarkingResults> resultSet, string originalFilePath, string originalKeyFileName, string fileNameToCreate)
{
await ForEachAsync(ValuesForNoise, ParallelThreadsAmount, async noise =>
{
var model = await Executor.ProcessData(originalFilePath, originalKeyFileName, fileNameToCreate, 0, 0, noise, Mode);
AddToResultSet(resultSet, model);
model.Mode = Mode;
await DalService.InsertResult(model);
});
}
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();
}
private static async Task RunOneContainerForOneKey()
{
const string originalContainerFileName = "LenaOriginal512color";
const string originalKeyFileName = "kisspng-bmp";
var originalFilePath = Path.Combine(MainConstants.ContainerFolderPath, $"{originalContainerFileName}.bmp");
var model = await Executor.ProcessData(originalFilePath, $"{originalKeyFileName}.bmp", $"{originalContainerFileName}_{originalKeyFileName}", 0, 0, Mode);
model.Mode = Mode;
await DalService.InsertResult(model);
}
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());
}
private static async Task GetResultsForSimpleMode()
{
var items = (await DalService.GetAllResults()).Where(x => x.Mode == 3 || x.Mode == 4).ToList();
Console.WriteLine();
Console.WriteLine("Red - Green - Blue - Encryption PSNR - Decryption PSNR - Encryption time - Decryption time - Name");
Console.WriteLine();
foreach (var item in items)
{
item.ContainerFileName = item.ContainerFileName.Substring(0, item.ContainerFileName.IndexOf('_'));
Console.WriteLine("{0,4} {1,5} {2,5} {3,18} {4,18} {5,16} {6,17} {7,20}",
item.AverageRedColor, item.AverageGreenColor, item.AverageBlueColor,
Math.Round(item.EncryptionPsnr, 2), Math.Round(item.DecryptionPsnr, 2),
item.EncryptionTime.TotalMilliseconds, item.DecryptionTime.TotalMilliseconds,
item.ContainerFileName);
}
}
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);
}
}
private static async Task RunOneKeyForAllContainersNoContrastAndBrightness()
{
const string originalKeyFileName = "BabooOriginal128color.bmp";
var originalContainerPaths = Directory.GetFiles(MainConstants.ContainerDiffFolderPath, "*.bmp",
SearchOption.TopDirectoryOnly);
var results = new List <WatermarkingResults>();
foreach (var originalFilePath in originalContainerPaths)
{
var model = await Executor.ProcessData(originalFilePath, originalKeyFileName, Path.GetFileNameWithoutExtension(originalFilePath), 0, 0, Mode);
model.Mode = Mode;
AddToResultSet(results, model);
}
await DalService.InsertResults(results);
}
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);
}
private static async Task RunOneContainerForAllKeysNoContrastAndBrightness()
{
const string originalContainerFileName = "LenaOriginal512color";
var originalFilePath = Path.Combine(MainConstants.ContainerFolderPath, $"{originalContainerFileName}.bmp");
var originalKeysPaths = Directory.GetFiles(MainConstants.KeysDiffFolderPath, "*.bmp",
SearchOption.TopDirectoryOnly);
var results = new List <WatermarkingResults>();
await ForEachAsync(originalKeysPaths, 20, async originalKeyPath =>
{
var model = await Executor.ProcessData(originalFilePath, Path.GetFileName(originalKeyPath),
Path.GetFileNameWithoutExtension(originalKeyPath), 0, 0, 0, Mode);
model.Mode = Mode;
await DalService.InsertResult(model);
AddToResultSet(results, model);
});
//await DalService.InsertResults(results);
}
public object Put([FromBody] ContentLimitItemPoco poco)
{
var model = poco.ToModel();
if (!model.IsValid)
{
return(new
{
isSuccess = false,
messages = model.ValidationResults()
});
}
using (var dal = new DalService())
{
dal.Update(poco);
dal.SaveChanges();
return(new { isSuccess = true, record = poco });
}
}
private static async Task GetResultsForDiffContrastAndBrightness()
{
var items = (await DalService.GetAllResults()).Where(x => x.Mode == 1 || x.Mode == 2).ToList();
foreach (var item in items)
{
item.ContainerFileName = item.ContainerFileName.Substring(0, item.ContainerFileName.IndexOf('_'));
}
foreach (var container in items.GroupBy(x => x.ContainerFileName))
{
Console.WriteLine(); Console.WriteLine();
Console.WriteLine($"Results for {container.Key}");
var brightnessResults = container.Where(x => x.Contrast == 0)
.OrderBy(x => x.Brightness);
Console.WriteLine($"Results per brightness");
Console.WriteLine("Brightness - Encryption PSNR - Decryption PSNR - Encryption time - Decryption time");
foreach (var data in brightnessResults)
{
Console.WriteLine("{0,8} {1,15} {2,15} {3,18} {4,18}",
data.Brightness, Math.Round(data.EncryptionPsnr, 2), Math.Round(data.DecryptionPsnr, 2),
data.EncryptionTime.TotalMilliseconds, data.DecryptionTime.TotalMilliseconds);
}
Console.WriteLine();
var contrastResults = container.Where(x => x.Brightness == 0)
.OrderBy(x => x.Contrast);
Console.WriteLine($"Results per contrast");
Console.WriteLine("Contrast - Encryption PSNR - Decryption PSNR - Encryption time - Decryption time");
foreach (var data in contrastResults)
{
Console.WriteLine("{0,8} {1,15} {2,15} {3,18} {4,18}",
data.Contrast, Math.Round(data.EncryptionPsnr, 2), Math.Round(data.DecryptionPsnr, 2),
data.EncryptionTime.TotalMilliseconds, data.DecryptionTime.TotalMilliseconds);
}
}
}
