public async void Update()
{
var mock = new ServiceMockFacade <IPipelineStepRepository>();
var model = new ApiPipelineStepRequestModel();
mock.RepositoryMock.Setup(x => x.Create(It.IsAny <PipelineStep>())).Returns(Task.FromResult(new PipelineStep()));
mock.RepositoryMock.Setup(x => x.Get(It.IsAny <int>())).Returns(Task.FromResult(new PipelineStep()));
var service = new PipelineStepService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.PipelineStepModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLPipelineStepMapperMock,
mock.DALMapperMockFactory.DALPipelineStepMapperMock,
mock.BOLMapperMockFactory.BOLHandlerPipelineStepMapperMock,
mock.DALMapperMockFactory.DALHandlerPipelineStepMapperMock,
mock.BOLMapperMockFactory.BOLOtherTransportMapperMock,
mock.DALMapperMockFactory.DALOtherTransportMapperMock,
mock.BOLMapperMockFactory.BOLPipelineStepDestinationMapperMock,
mock.DALMapperMockFactory.DALPipelineStepDestinationMapperMock,
mock.BOLMapperMockFactory.BOLPipelineStepNoteMapperMock,
mock.DALMapperMockFactory.DALPipelineStepNoteMapperMock,
mock.BOLMapperMockFactory.BOLPipelineStepStepRequirementMapperMock,
mock.DALMapperMockFactory.DALPipelineStepStepRequirementMapperMock);
UpdateResponse <ApiPipelineStepResponseModel> response = await service.Update(default(int), model);
response.Should().NotBeNull();
mock.ModelValidatorMockFactory.PipelineStepModelValidatorMock.Verify(x => x.ValidateUpdateAsync(It.IsAny <int>(), It.IsAny <ApiPipelineStepRequestModel>()));
mock.RepositoryMock.Verify(x => x.Update(It.IsAny <PipelineStep>()));
}
public async void Delete()
{
var mock = new ServiceMockFacade <IPipelineStepRepository>();
var model = new ApiPipelineStepRequestModel();
mock.RepositoryMock.Setup(x => x.Delete(It.IsAny <int>())).Returns(Task.CompletedTask);
var service = new PipelineStepService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.PipelineStepModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLPipelineStepMapperMock,
mock.DALMapperMockFactory.DALPipelineStepMapperMock,
mock.BOLMapperMockFactory.BOLHandlerPipelineStepMapperMock,
mock.DALMapperMockFactory.DALHandlerPipelineStepMapperMock,
mock.BOLMapperMockFactory.BOLOtherTransportMapperMock,
mock.DALMapperMockFactory.DALOtherTransportMapperMock,
mock.BOLMapperMockFactory.BOLPipelineStepDestinationMapperMock,
mock.DALMapperMockFactory.DALPipelineStepDestinationMapperMock,
mock.BOLMapperMockFactory.BOLPipelineStepNoteMapperMock,
mock.DALMapperMockFactory.DALPipelineStepNoteMapperMock,
mock.BOLMapperMockFactory.BOLPipelineStepStepRequirementMapperMock,
mock.DALMapperMockFactory.DALPipelineStepStepRequirementMapperMock);
ActionResponse response = await service.Delete(default(int));
response.Should().NotBeNull();
mock.RepositoryMock.Verify(x => x.Delete(It.IsAny <int>()));
mock.ModelValidatorMockFactory.PipelineStepModelValidatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <int>()));
}
public async Task <ValidationResult> ValidateUpdateAsync(int id, ApiPipelineStepRequestModel model)
{
this.NameRules();
this.PipelineStepStatusIdRules();
this.ShipperIdRules();
return(await this.ValidateAsync(model, id));
}
public async void TestDelete()
{
var builder = new WebHostBuilder()
.UseEnvironment("Production")
.UseStartup <TestStartup>();
TestServer testServer = new TestServer(builder);
var client = new ApiClient(testServer.CreateClient());
var createModel = new ApiPipelineStepRequestModel();
createModel.SetProperties("B", 1, 1);
CreateResponse <ApiPipelineStepResponseModel> createResult = await client.PipelineStepCreateAsync(createModel);
createResult.Success.Should().BeTrue();
ApiPipelineStepResponseModel getResponse = await client.PipelineStepGetAsync(2);
getResponse.Should().NotBeNull();
ActionResponse deleteResult = await client.PipelineStepDeleteAsync(2);
deleteResult.Success.Should().BeTrue();
ApiPipelineStepResponseModel verifyResponse = await client.PipelineStepGetAsync(2);
verifyResponse.Should().BeNull();
}
private async Task <ApiPipelineStepResponseModel> CreateRecord(ApiClient client)
{
var model = new ApiPipelineStepRequestModel();
model.SetProperties("B", 1, 1);
CreateResponse <ApiPipelineStepResponseModel> result = await client.PipelineStepCreateAsync(model);
result.Success.Should().BeTrue();
return(result.Record);
}
public void MapModelToBO()
{
var mapper = new BOLPipelineStepMapper();
ApiPipelineStepRequestModel model = new ApiPipelineStepRequestModel();
model.SetProperties("A", 1, 1);
BOPipelineStep response = mapper.MapModelToBO(1, model);
response.Name.Should().Be("A");
response.PipelineStepStatusId.Should().Be(1);
response.ShipperId.Should().Be(1);
}
public void MapResponseToRequest()
{
var mapper = new ApiPipelineStepModelMapper();
var model = new ApiPipelineStepResponseModel();
model.SetProperties(1, "A", 1, 1);
ApiPipelineStepRequestModel response = mapper.MapResponseToRequest(model);
response.Name.Should().Be("A");
response.PipelineStepStatusId.Should().Be(1);
response.ShipperId.Should().Be(1);
}
public virtual async Task <IActionResult> Create([FromBody] ApiPipelineStepRequestModel model)
{
CreateResponse <ApiPipelineStepResponseModel> result = await this.PipelineStepService.Create(model);
if (result.Success)
{
return(this.Created($"{this.Settings.ExternalBaseUrl}/api/PipelineSteps/{result.Record.Id}", result));
}
else
{
return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result));
}
}
public virtual BOPipelineStep MapModelToBO(
int id,
ApiPipelineStepRequestModel model
)
{
BOPipelineStep boPipelineStep = new BOPipelineStep();
boPipelineStep.SetProperties(
id,
model.Name,
model.PipelineStepStatusId,
model.ShipperId);
return(boPipelineStep);
}
public virtual async Task <CreateResponse <ApiPipelineStepResponseModel> > Create(
ApiPipelineStepRequestModel model)
{
CreateResponse <ApiPipelineStepResponseModel> response = new CreateResponse <ApiPipelineStepResponseModel>(await this.pipelineStepModelValidator.ValidateCreateAsync(model));
if (response.Success)
{
var bo = this.bolPipelineStepMapper.MapModelToBO(default(int), model);
var record = await this.pipelineStepRepository.Create(this.dalPipelineStepMapper.MapBOToEF(bo));
response.SetRecord(this.bolPipelineStepMapper.MapBOToModel(this.dalPipelineStepMapper.MapEFToBO(record)));
}
return(response);
}
private async Task <ApiPipelineStepRequestModel> PatchModel(int id, JsonPatchDocument <ApiPipelineStepRequestModel> patch)
{
var record = await this.PipelineStepService.Get(id);
if (record == null)
{
return(null);
}
else
{
ApiPipelineStepRequestModel request = this.PipelineStepModelMapper.MapResponseToRequest(record);
patch.ApplyTo(request);
return(request);
}
}
public void CreatePatch()
{
var mapper = new ApiPipelineStepModelMapper();
var model = new ApiPipelineStepRequestModel();
model.SetProperties("A", 1, 1);
JsonPatchDocument <ApiPipelineStepRequestModel> patch = mapper.CreatePatch(model);
var response = new ApiPipelineStepRequestModel();
patch.ApplyTo(response);
response.Name.Should().Be("A");
response.PipelineStepStatusId.Should().Be(1);
response.ShipperId.Should().Be(1);
}
public virtual async Task <UpdateResponse <ApiPipelineStepResponseModel> > Update(
int id,
ApiPipelineStepRequestModel model)
{
var validationResult = await this.pipelineStepModelValidator.ValidateUpdateAsync(id, model);
if (validationResult.IsValid)
{
var bo = this.bolPipelineStepMapper.MapModelToBO(id, model);
await this.pipelineStepRepository.Update(this.dalPipelineStepMapper.MapBOToEF(bo));
var record = await this.pipelineStepRepository.Get(id);
return(new UpdateResponse <ApiPipelineStepResponseModel>(this.bolPipelineStepMapper.MapBOToModel(this.dalPipelineStepMapper.MapEFToBO(record))));
}
else
{
return(new UpdateResponse <ApiPipelineStepResponseModel>(validationResult));
}
}
public virtual async Task <IActionResult> Update(int id, [FromBody] ApiPipelineStepRequestModel model)
{
ApiPipelineStepRequestModel request = await this.PatchModel(id, this.PipelineStepModelMapper.CreatePatch(model));
if (request == null)
{
return(this.StatusCode(StatusCodes.Status404NotFound));
}
else
{
UpdateResponse <ApiPipelineStepResponseModel> result = await this.PipelineStepService.Update(id, request);
if (result.Success)
{
return(this.Ok(result));
}
else
{
return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result));
}
}
}
public async void Create()
{
var mock = new ServiceMockFacade <IPipelineStepRepository>();
var model = new ApiPipelineStepRequestModel();
mock.RepositoryMock.Setup(x => x.Create(It.IsAny <PipelineStep>())).Returns(Task.FromResult(new PipelineStep()));
var service = new PipelineStepService(mock.LoggerMock.Object,
mock.RepositoryMock.Object,
mock.ModelValidatorMockFactory.PipelineStepModelValidatorMock.Object,
mock.BOLMapperMockFactory.BOLPipelineStepMapperMock,
mock.DALMapperMockFactory.DALPipelineStepMapperMock,
mock.BOLMapperMockFactory.BOLPipelineStepNoteMapperMock,
mock.DALMapperMockFactory.DALPipelineStepNoteMapperMock,
mock.BOLMapperMockFactory.BOLPipelineStepStepRequirementMapperMock,
mock.DALMapperMockFactory.DALPipelineStepStepRequirementMapperMock);
CreateResponse <ApiPipelineStepResponseModel> response = await service.Create(model);
response.Should().NotBeNull();
mock.ModelValidatorMockFactory.PipelineStepModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiPipelineStepRequestModel>()));
mock.RepositoryMock.Verify(x => x.Create(It.IsAny <PipelineStep>()));
}
public virtual async Task <IActionResult> Patch(int id, [FromBody] JsonPatchDocument <ApiPipelineStepRequestModel> patch)
{
ApiPipelineStepResponseModel record = await this.PipelineStepService.Get(id);
if (record == null)
{
return(this.StatusCode(StatusCodes.Status404NotFound));
}
else
{
ApiPipelineStepRequestModel model = await this.PatchModel(id, patch);
UpdateResponse <ApiPipelineStepResponseModel> result = await this.PipelineStepService.Update(id, model);
if (result.Success)
{
return(this.Ok(result));
}
else
{
return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result));
}
}
}
