public async Task Discover_product_by_name_expect_two()
{
var target = new ProductServices(Helper.CreateMemoryUow());
var mockProduct1 = FixturesDto.ProductsBuildOne();
// Bogus doesn't ensure unique names
mockProduct1.Name = "Prod1";
await target.CreateAsync(mockProduct1);
var mockProduct2 = FixturesDto.ProductsBuildOne();
await target.CreateAsync(mockProduct2);
var mockProduct3 = FixturesDto.ProductsBuildOne();
mockProduct3.Name = mockProduct2.Name;
await target.CreateAsync(mockProduct3);
var result = await target.GetByNameAsync(mockProduct2.Name);
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count(), $"Expected two products with name '{ mockProduct2.Name}' to be found!");
Assert.AreEqual(mockProduct2.Name, result.First().Name);
}
public async Task ProductOption_Update_BadRequest_scenario()
{
var mockDto = FixturesDto.ProductOptionBuildOne(null);
mockDto.Id = Guid.NewGuid();
var mockApi = AutoMapper.Mapper.Map <ProductOptionApiModel>(mockDto);
mockIProductOptionServices.Setup(m => m.UpdateAsync(It.IsAny <ProductOptionDto>())).Returns(Task.FromResult(mockDto));
target.ModelState.AddModelError("Name", "Name is not present!");
IHttpActionResult result = await target.UpdateOption(mockApi.Id, mockApi) as InvalidModelStateResult;
AssertX.IsInstanceOfType(result, typeof(InvalidModelStateResult));
CollectionAssert.Contains(((InvalidModelStateResult)result).ModelState.Keys.ToArray(), "Name");
target.ModelState.Clear();
result = await target.UpdateOption(Guid.Empty, mockApi) as BadRequestErrorMessageResult;
AssertX.IsInstanceOfType(result, typeof(BadRequestErrorMessageResult));
mockIProductOptionServices.Setup(m => m.UpdateAsync(It.IsAny <ProductOptionDto>())).Throws(new EntityNotFoundException("Not found!"));
result = await target.UpdateOption(mockApi.Id, mockApi) as NotFoundResult;
AssertX.IsInstanceOfType(result, typeof(NotFoundResult));
mockIProductOptionServices.Setup(m => m.UpdateAsync(It.IsAny <ProductOptionDto>())).Throws(new DbUpdateConcurrencyException());
result = await target.UpdateOption(mockApi.Id, mockApi) as ConflictResult;
AssertX.IsInstanceOfType(result, typeof(ConflictResult));
}
public List <FixturesDto> GetFixturesAsDtoAll()
{
var query = (from f in _wpbDataContext.Fixtures
//where f.FixtureDate >= timestampNow && f.FixtureDate <= timestampSeven
join homeTeam in _wpbDataContext.Teams on f.HomeTeamId equals homeTeam.Id
join awayTeam in _wpbDataContext.Teams on f.AwayTeamId equals awayTeam.Id
join subDiv in _wpbDataContext.SubDivisions on f.SubDivisionId equals subDiv.Id
join div in _wpbDataContext.Divisions on subDiv.DivisionId equals div.Id
select new FixturesDto
{
FixtureDate = f.FixtureDate,
HomeTeamName = homeTeam.TeamName,
HomeTeamCode = homeTeam.TeamCode,
HomeTeamHasLogo = homeTeam.HasLogo,
HomeTeamLogo = FixturesDto.GetLogolUrl(homeTeam.Logo),
AwayTeamName = awayTeam.TeamName,
AwayTeamCode = awayTeam.TeamCode,
AwayTeamHasLogo = awayTeam.HasLogo,
AwayTeamLogo = FixturesDto.GetLogolUrl(awayTeam.Logo),
Division = div.DivisionName,
DivisionCode = div.DivisionCode,
SubDivision = subDiv.SubDivisionTitle,
SubDivisionCode = subDiv.SubDivisionCode
});
return(query.ToList());
}
public async Task Delete_product_fail()
{
var target = new ProductServices(Helper.CreateMemoryUow());
var mockProduct = FixturesDto.ProductsBuildOne();
var result = Task.FromResult(target.CreateAsync(mockProduct)).Result;
var newProductId = Guid.NewGuid();;
var deleteResult = await target.DeleteByIdAsync(newProductId);
Assert.IsFalse(deleteResult);
}
public async Task ProductOption_GetOption_NotFound()
{
var mockDto = FixturesDto.ProductOptionBuildOne(null);
mockDto.Id = Guid.NewGuid();
mockIProductOptionServices.Setup(m => m.GetByIdAsync(mockDto.Id)).Returns(Task.FromResult(mockDto));
var result = await target.GetOption(mockDto.ProductId, Guid.NewGuid()) as NotFoundResult;
AssertX.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task Product_GetById_notFound()
{
var mockProductDto = FixturesDto.ProductsBuildOne();
mockProductDto.Id = Guid.NewGuid();
mockIProductServices.Setup(m => m.GetByIdAsync(mockProductDto.Id)).Returns(Task.FromResult(mockProductDto));
var result = await target.GetProduct(Guid.NewGuid()) as IHttpActionResult;
AssertX.IsInstanceOfType(result, typeof(NotFoundResult));
}
public void BasicCreateAsyncTest()
{
var target = new ProductServices(Helper.CreateMemoryUow());
var mockProduct = FixturesDto.ProductsBuildOne();
var result = Task.FromResult(target.CreateAsync(mockProduct)).Result;
Assert.IsNull(result.Exception);
Assert.IsNotNull(result.Result);
// The row version is returned
Assert.IsNotNull(result.Result.RowVersion);
Assert.IsTrue(result.Result.RowVersion.Length > 0);
}
public async Task ProductOption_CreateOption_InvalidModel()
{
var mockDto = FixturesDto.ProductOptionBuildOne(null);
var mockApi = AutoMapper.Mapper.Map <ProductOptionApiModel>(mockDto);
mockIProductOptionServices.Setup(m => m.CreateAsync(It.IsAny <ProductOptionDto>())).Returns(Task.FromResult(mockDto));
target.ModelState.AddModelError("Name", "No Value");
var result = await target.CreateOption(mockDto.ProductId, mockApi) as InvalidModelStateResult;
AssertX.IsInstanceOfType(result, typeof(InvalidModelStateResult));
CollectionAssert.Contains(result.ModelState.Keys.ToArray(), "Name");
}
public async Task Product_GetById_success()
{
var mockProductDto = FixturesDto.ProductsBuildOne();
mockProductDto.Id = Guid.NewGuid();
mockIProductServices.Setup(m => m.GetByIdAsync(It.IsAny <Guid>())).Returns(Task.FromResult(mockProductDto));
var result = await target.GetProduct(mockProductDto.Id) as OkNegotiatedContentResult <ProductApiModel>;
AssertX.AreEqual(mockProductDto.Id, result.Content.Id);
}
public async Task Product_Delete_success()
{
var mockProductDto = FixturesDto.ProductsBuildOne();
mockProductDto.Id = Guid.NewGuid();
mockIProductServices.Setup(m => m.DeleteByIdAsync(It.IsAny <Guid>())).Returns(Task.FromResult(true));
var result = await target.Delete(mockProductDto.Id) as StatusCodeResult;
AssertX.IsInstanceOfType(result, typeof(StatusCodeResult));
Assert.AreEqual(HttpStatusCode.NoContent, result.StatusCode);
}
public async Task Discover_product_by_id()
{
var target = new ProductServices(Helper.CreateMemoryUow());
var mockProduct1 = FixturesDto.ProductsBuildOne();
await target.CreateAsync(mockProduct1);
var mockProduct2 = FixturesDto.ProductsBuildOne();
await target.CreateAsync(mockProduct2);
var result = await target.GetByIdAsync(mockProduct2.Id);
Assert.IsNotNull(result);
Assert.AreEqual(mockProduct2.Id, result.Id);
}
public async Task Product_Update_success()
{
var mockProductDto = FixturesDto.ProductsBuildOne();
mockProductDto.Id = Guid.NewGuid();
var mockApiModel = AutoMapper.Mapper.Map <ProductApiModel>(mockProductDto);
mockIProductServices.Setup(m => m.UpdateAsync(It.IsAny <ProductDto>())).Returns(Task.FromResult(mockProductDto));
var result = await target.Update(mockProductDto.Id, mockApiModel) as OkNegotiatedContentResult <ProductApiModel>;
AssertX.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <ProductApiModel>));
Assert.AreEqual(mockProductDto.Id, result.Content.Id);
}
public async Task Product_SearchByName_notFound()
{
var mockProductDto = FixturesDto.ProductsBuildOne();
var retMock = (new List <ProductDto>()
{
mockProductDto
}).AsEnumerable();
mockIProductServices.Setup(m => m.GetByNameAsync("Me")).Returns(Task.FromResult(retMock));
var result = await target.SearchByName("Any") as IHttpActionResult;
AssertX.IsInstanceOfType(result, typeof(NotFoundResult));
}
public async Task Product_searchByName_success()
{
var mockProductDto = FixturesDto.ProductsBuildOne();
var retMock = (new List <ProductDto>()
{
mockProductDto
}).AsEnumerable();
mockIProductServices.Setup(m => m.GetByNameAsync(It.IsAny <string>())).Returns(Task.FromResult(retMock));
var result = await target.SearchByName("Any") as OkNegotiatedContentResult <IEnumerable <ProductApiModel> >;
AssertX.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <IEnumerable <ProductApiModel> >));
}
public async Task Get_all_products_expected_two()
{
var target = new ProductServices(Helper.CreateMemoryUow());
var mockProduct1 = FixturesDto.ProductsBuildOne();
await target.CreateAsync(mockProduct1);
var mockProduct2 = FixturesDto.ProductsBuildOne();
await target.CreateAsync(mockProduct2);
var result = await target.GetAllAsync();
Assert.IsNotNull(result);
Assert.AreEqual(2, result.Count(), "Expected two products to be found!");
}
public async Task ProductOption_CreateOption_Ok()
{
var mockDto = FixturesDto.ProductOptionBuildOne(null);
var mockApi = AutoMapper.Mapper.Map <ProductOptionApiModel>(mockDto);
mockIProductOptionServices.Setup(m => m.CreateAsync(It.IsAny <ProductOptionDto>())).Returns(Task.FromResult(mockDto));
var result = await target.CreateOption(mockDto.ProductId, mockApi) as CreatedAtRouteNegotiatedContentResult <ProductOptionApiModel>;
AssertX.IsInstanceOfType(result, typeof(CreatedAtRouteNegotiatedContentResult <ProductOptionApiModel>));
Assert.AreEqual(mockApi.ProductId, result.Content.ProductId);
Assert.AreEqual(mockApi.Name, result.Content.Name);
Assert.AreEqual(mockApi.Description, result.Content.Description);
}
public async Task ProductOption_GetOption_success()
{
var mockDto = FixturesDto.ProductOptionBuildOne(null);
mockDto.Id = Guid.NewGuid();
mockIProductOptionServices.Setup(m => m.GetByIdAsync(mockDto.Id)).Returns(Task.FromResult(mockDto));
var result = await target.GetOption(mockDto.ProductId, mockDto.Id) as OkNegotiatedContentResult <ProductOptionApiModel>;
AssertX.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <ProductOptionApiModel>));
Assert.AreEqual(mockDto.ProductId, result.Content.ProductId);
Assert.AreEqual(mockDto.Name, result.Content.Name);
Assert.AreEqual(mockDto.Description, result.Content.Description);
}
public async Task Product_Create_invalid_model()
{
var mockProductDto = FixturesDto.ProductsBuildOne();
var mockApiModel = AutoMapper.Mapper.Map <ProductApiModel>(mockProductDto);
mockApiModel.Price = -100;
mockProductDto.Id = Guid.NewGuid();
mockIProductServices.Setup(m => m.CreateAsync(It.IsAny <ProductDto>())).Returns(Task.FromResult(mockProductDto));
target.ModelState.AddModelError("Price", "Price should be a positive value!");
var result = await target.Create(mockApiModel) as InvalidModelStateResult;
AssertX.IsInstanceOfType(result, typeof(InvalidModelStateResult));
CollectionAssert.Contains(result.ModelState.Keys.ToArray(), "Price");
}
public async Task ProductOption_GetOptions_success()
{
var mockDto = FixturesDto.ProductOptionBuildOne(null);
var retMock = (new List <ProductOptionDto>()
{
mockDto
}).AsEnumerable();
mockIProductOptionServices.Setup(m => m.GetByProductIdAsync(mockDto.ProductId)).Returns(Task.FromResult(retMock));
var result = await target.GetOptions(mockDto.ProductId) as OkNegotiatedContentResult <IEnumerable <ProductOptionApiModel> >;
AssertX.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <IEnumerable <ProductOptionApiModel> >));
Assert.AreEqual(retMock.First().ProductId, result.Content.First().Id);
Assert.AreEqual(retMock.First().Name, result.Content.First().Name);
Assert.AreEqual(retMock.First().Description, result.Content.First().Description);
}
public async Task Update_product_success()
{
var target = new ProductServices(Helper.CreateMemoryUow());
var mockProduct1 = FixturesDto.ProductsBuildOne();
await target.CreateAsync(mockProduct1);
var mockProduct2 = FixturesDto.ProductsBuildOne();
await target.CreateAsync(mockProduct2);
var mockProduct3 = FixturesDto.ProductsBuildOne();
var prodtoUpdate = await target.CreateAsync(mockProduct3);
prodtoUpdate.Name = "UpdatedProd";
var result = await target.UpdateAsync(prodtoUpdate);
Assert.IsNotNull(result);
Assert.AreEqual(prodtoUpdate.Name, result.Name);
Assert.AreNotEqual(mockProduct3.Name, result.Name);
}
public async Task ProductOption_Update_success()
{
var mockDto = FixturesDto.ProductOptionBuildOne(null);
mockDto.Id = Guid.NewGuid();
var mockApi = AutoMapper.Mapper.Map <ProductOptionApiModel>(mockDto);
mockApi.Name = "New Value";
var transformedDto = AutoMapper.Mapper.Map <ProductOptionDto>(mockApi);
mockIProductOptionServices.Setup(m => m.UpdateAsync(It.IsAny <ProductOptionDto>())).Returns(Task.FromResult(transformedDto));
var result = await target.UpdateOption(mockApi.Id, mockApi) as OkNegotiatedContentResult <ProductOptionApiModel>;
AssertX.IsInstanceOfType(result, typeof(OkNegotiatedContentResult <ProductOptionApiModel>));
Assert.AreEqual(mockDto.Id, result.Content.Id);
Assert.AreEqual(mockDto.Id, result.Content.Id);
Assert.AreEqual(mockApi.Name, result.Content.Name);
Assert.AreNotEqual(mockDto.Name, result.Content.Name);
}
public async Task Update_product_conflict()
{
var target = new ProductServices(Helper.CreateMemoryUow());
var mockProduct1 = FixturesDto.ProductsBuildOne();
await target.CreateAsync(mockProduct1);
var mockProduct2 = FixturesDto.ProductsBuildOne();
await target.CreateAsync(mockProduct2);
var mockProduct3 = FixturesDto.ProductsBuildOne();
var prodtoUpdate = await target.CreateAsync(mockProduct3);
prodtoUpdate.Name = "UpdatedProd";
// Initial update
var result = await target.UpdateAsync(prodtoUpdate);
// need to revise
prodtoUpdate.Name = "Confict";
var result2 = Task.FromResult(target.UpdateAsync(prodtoUpdate)).Result;
Assert.IsNotNull(result2.Exception);
Assert.IsInstanceOfType(result2.Exception.InnerException, typeof(System.Data.Entity.Infrastructure.DbUpdateConcurrencyException));
}
