public async Task <OperationDetails> DeleteStoreTypeAsync(StoreTypeDto storeTypeDto)
{
if (storeTypeDto == null)
{
Logger.Error("Something went wrong");
return(new OperationDetails(false, "Something went wrong", "StoreType"));
}
StoreType storeType = await unitOfWork.StoreTypeRepository.GetByIdAsync(storeTypeDto.Id);
if (storeType == null)
{
Logger.Error("Store type not found");
return(new OperationDetails(false, "Store type not found", "StoreType"));
}
try
{
await unitOfWork.StoreTypeRepository.DeleteAsync(storeType);
await unitOfWork.SaveAsync();
Logger.Info("Successfully deleted");
return(new OperationDetails(true));
}
catch (Exception ex)
{
Logger.Error(ex.Message);
return(new OperationDetails(false, ex.Message));
}
}
public async Task GetStoreTypeByIdAsync_When_Correct_Should_return_StoreDto()
{
//arrange
StoreTypeDto storeTypeDto = new StoreTypeDto
{
Id = 0,
Name = "Test store"
};
StoreType storeType = new StoreType
{
Id = 0,
Name = "Test store"
};
storeTypeRepository.Setup(x => x.GetByIdAsync(0)).ReturnsAsync(storeType);
mapper.Setup(x => x.Map <StoreType, StoreTypeDto>(storeType)).Returns(storeTypeDto);
//act
var actualResult = await storeTypeService.GetStoreTypeByIdAsync(storeTypeDto.Id);
//assert
actualResult.Should().BeEquivalentTo(storeTypeDto);
storeTypeRepository.Verify(x => x.GetByIdAsync(storeTypeDto.Id), Times.Once);
}
public async Task UpdateStoreTypeAsync_When_Update_StoreType_Should_Return_Exception()
{
//arrange
var expectedResult = new OperationDetails(false, "Exception message");
StoreTypeDto storeTypeDto = new StoreTypeDto
{
Id = 0,
Name = "Test store"
};
StoreType storeType = new StoreType
{
Id = 0,
Name = "Test store"
};
mapper.Setup(x => x.Map <StoreTypeDto, StoreType>(storeTypeDto)).Returns(storeType);
storeTypeRepository.Setup(x => x.UpdateAsync(storeType)).Throws(new Exception("Exception message"));
//act
var actualResult = await storeTypeService.UpdateStoreTypeAsync(storeTypeDto);
//assert
actualResult.Should().BeEquivalentTo(expectedResult);
}
public async Task DeleteStoreTypeAsync_When_StoreType_Null_Should_Return_StoreType_Not_Found()
{
//arrange
var expectedResult = new OperationDetails(false, "Store type not found", "StoreType");
StoreTypeDto storeTypeDto = new StoreTypeDto
{
Id = 0,
Name = "Test store"
};
StoreType storeType = new StoreType
{
Id = 0,
Name = "Test store"
};
mapper.Setup(x => x.Map <StoreTypeDto, StoreType>(storeTypeDto)).Returns(storeType);
//act
var actualResult = await storeTypeService.DeleteStoreTypeAsync(storeTypeDto);
//arrange
actualResult.Should().BeEquivalentTo(expectedResult);
}
public async Task AddStoreTypeAsync_When_Duplication_Name_Store_Should_Return_StoreType_Already_Exists()
{
//arrange
var expectedResult = new OperationDetails(false, "A Store type with this name already exists", "StoreType");
StoreTypeDto storeTypeDto = new StoreTypeDto
{
Id = 0,
Name = "Test store"
};
StoreType storeType = new StoreType
{
Id = 0,
Name = "Test store"
};
mapper.Setup(x => x.Map <StoreTypeDto, StoreType>(storeTypeDto)).Returns(storeType);
storeTypeRepository.Setup(x => x.GetByName(storeType.Name)).Returns(storeType);
//act
var actualResult = await storeTypeService.AddStoreTypeAsync(storeTypeDto);
//assert
actualResult.Should().BeEquivalentTo(expectedResult);
}
public async Task UpdateStoreTypePost_When_OperationDetails_Is_Succedeed_Should_RedirectToAction_StoreTypeList()
{
//arrange
//arrange
StoreTypeViewModel storeTypeViewModel = new StoreTypeViewModel
{
Id = 0,
Name = "test"
};
StoreTypeDto storetypeDto = new StoreTypeDto
{
Id = 0,
Name = "test"
};
OperationDetails operationDetails = new OperationDetails(true);
mapper.Setup(x => x.Map <StoreTypeViewModel, StoreTypeDto>(storeTypeViewModel)).Returns(storetypeDto);
storeTypeService.Setup(x => x.UpdateStoreTypeAsync(storetypeDto)).ReturnsAsync(operationDetails);
//act
var actualResult = await storeTypeAdminController.UpdateStoreType(storeTypeViewModel) as RedirectToRouteResult;
//assert
Assert.IsNotNull(actualResult);
Assert.IsTrue(storeTypeAdminController.ModelState.IsValid);
Assert.That(actualResult.RouteValues["action"], Is.EqualTo("StoreTypeList"));
storeTypeService.Verify(x => x.UpdateStoreTypeAsync(storetypeDto), Times.Once);
}
public async Task <OperationDetails> UpdateStoreTypeAsync(StoreTypeDto storeTypeDto)
{
if (storeTypeDto == null)
{
Logger.Error("Something went wrong");
return(new OperationDetails(false, "Something went wrong", "StoreType"));
}
StoreType storeType = mapper.Map <StoreTypeDto, StoreType>(storeTypeDto);
try
{
await unitOfWork.StoreTypeRepository.UpdateAsync(storeType);
await unitOfWork.SaveAsync();
Logger.Info("Successfully updated");
return(new OperationDetails(true));
}
catch (Exception ex)
{
Logger.Error(ex.Message);
return(new OperationDetails(false, ex.Message));
}
}
public async Task <OperationDetails> AddStoreTypeAsync(StoreTypeDto storeTypeDto)
{
if (storeTypeDto == null)
{
Logger.Error("Something went wrong");
return(new OperationDetails(false, "Something went wrong", "StoreType"));
}
StoreType storeType = mapper.Map <StoreTypeDto, StoreType>(storeTypeDto);
try
{
if (unitOfWork.StoreTypeRepository.GetByName(storeType.Name) != null)
{
Logger.Error("A Store type with this name already exists");
return(new OperationDetails(false, "A Store type with this name already exists", "StoreType"));
}
await unitOfWork.StoreTypeRepository.CreateAsync(storeType);
await unitOfWork.SaveAsync();
Logger.Info("Successfully added");
return(new OperationDetails(true));
}
catch (Exception ex)
{
Logger.Error(ex.Message);
return(new OperationDetails(false, "Unfortunately, something went wrong....", "StoreType"));
}
}
public async Task UpdateStoreType_When_Get_Update_Should_Return_View()
{
//arrange
StoreTypeViewModel storeTypeViewModel = new StoreTypeViewModel
{
Id = 0,
Name = "test"
};
StoreTypeDto storetypeDto = new StoreTypeDto
{
Id = 0,
Name = "test"
};
storeTypeService.Setup(x => x.GetStoreTypeByIdAsync(0)).ReturnsAsync(storetypeDto);
mapper.Setup(x => x.Map <StoreTypeDto, StoreTypeViewModel>(storetypeDto)).Returns(storeTypeViewModel);
//act
var actualResult = await storeTypeAdminController.UpdateStoreType(0) as ViewResult;
//assert
Assert.IsNotNull(actualResult);
Assert.IsTrue(storeTypeAdminController.ModelState.IsValid);
storeTypeService.Verify(x => x.GetStoreTypeByIdAsync(0), Times.Once);
}
public async Task AddStore_Post_When_OperationDetails_Is_Succedeed_Should_Return_View_SuccessAdd()
{
//arrange
StoreTypeViewModel storeTypeViewModel = new StoreTypeViewModel
{
Id = 0,
Name = "test"
};
StoreTypeDto storetypeDto = new StoreTypeDto
{
Id = 0,
Name = "test"
};
OperationDetails operationDetails = new OperationDetails(true);
mapper.Setup(x => x.Map <StoreTypeViewModel, StoreTypeDto>(storeTypeViewModel)).Returns(storetypeDto);
storeTypeService.Setup(x => x.AddStoreTypeAsync(storetypeDto)).ReturnsAsync(operationDetails);
storeTypeService.Setup(x => x.GetAllStoreType()).Returns(new List <StoreTypeDto>());
//act
var actualResult = await storeTypeAdminController.AddStoreType(storeTypeViewModel) as ViewResult;
//assert
Assert.IsNotNull(actualResult);
Assert.IsTrue(storeTypeAdminController.ModelState.IsValid);
Assert.AreEqual(actualResult.ViewName, "SuccessAdd");
storeTypeService.Verify(x => x.AddStoreTypeAsync(storetypeDto), Times.Once);
}
public void StoreTypeDto_Test_Property()
{
//Arrange
var fixture = new StoreTypeDto();
//Act
fixture.Id = 1;
fixture.Name = "test";
//Assert
fixture.Id.Should().Be(1);
fixture.Name.Should().BeEquivalentTo("test");
}
public async Task <ActionResult> UpdateStoreType(StoreTypeViewModel model)
{
StoreTypeDto storeTypeDto = mapper.Map <StoreTypeViewModel, StoreTypeDto>(model);
OperationDetails operationDetails = await storeTypeService.UpdateStoreTypeAsync(storeTypeDto);
if (operationDetails.Succedeed)
{
return(RedirectToAction("StoreTypeList"));
}
ModelState.AddModelError(operationDetails.Property, operationDetails.Message);
return(RedirectToAction("StoreTypeList"));
}
public async Task <ActionResult> AddStoreType(StoreTypeViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
StoreTypeDto storeTypeDto = mapper.Map <StoreTypeViewModel, StoreTypeDto>(model);
OperationDetails operationDetails = await storeTypeService.AddStoreTypeAsync(storeTypeDto);
if (operationDetails.Succedeed)
{
return(View("SuccessAdd"));
}
ModelState.AddModelError(operationDetails.Property, operationDetails.Message);
return(View(model));
}
public async Task UpdateStoreTypeAsync_When_Correct_Update_Should_Return_True()
{
//arrange
StoreTypeDto storeTypeDto = new StoreTypeDto
{
Id = 0,
Name = "Test store"
};
StoreType storeType = new StoreType
{
Id = 0,
Name = "Test store"
};
mapper.Setup(x => x.Map <StoreTypeDto, StoreType>(storeTypeDto)).Returns(storeType);
//act
await storeTypeService.UpdateStoreTypeAsync(storeTypeDto);
//assert
storeTypeRepository.Verify(x => x.UpdateAsync(storeType), Times.Once);
}
private static List <StoreTypeDto> CreateListStoreTypeDto()
{
StoreTypeDto storeTypeDto1 = new StoreTypeDto
{
Id = 0,
Name = "Test store"
};
StoreTypeDto storeTypeDto2 = new StoreTypeDto
{
Id = 0,
Name = "Test store 2"
};
StoreTypeDto storeTypeDto3 = new StoreTypeDto
{
Id = 0,
Name = "Test store 3"
};
return(new List <StoreTypeDto> {
storeTypeDto1, storeTypeDto2, storeTypeDto3
});
}
public async Task AddStoreTypeAsync_When_Correct_Add_StoreType_Should_Return_True()
{
//arrange
var expectedResult = new OperationDetails(true);
StoreTypeDto storeTypeDto = new StoreTypeDto
{
Id = 0,
Name = "Test store"
};
StoreType storeType = new StoreType
{
Id = 0,
Name = "Test store"
};
mapper.Setup(x => x.Map <StoreTypeDto, StoreType>(storeTypeDto)).Returns(storeType);
//act
var actualResult = await storeTypeService.AddStoreTypeAsync(storeTypeDto);
//assert
actualResult.Should().BeEquivalentTo(expectedResult);
}
public async Task <ActionResult> UpdateStoreType(int id)
{
StoreTypeDto storeTypeDto = await storeTypeService.GetStoreTypeByIdAsync(id);
return(View(mapper.Map <StoreTypeDto, StoreTypeViewModel>(storeTypeDto)));
}
public ActionResult Update(StoreTypeDto dto)
{
var result = _storeTypeContract.Update(dto);
return(Json(result, JsonRequestBehavior.AllowGet));
}
