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 ApiPipelineRequestModel(); createModel.SetProperties(1, 2); CreateResponse <ApiPipelineResponseModel> createResult = await client.PipelineCreateAsync(createModel); createResult.Success.Should().BeTrue(); ApiPipelineResponseModel getResponse = await client.PipelineGetAsync(2); getResponse.Should().NotBeNull(); ActionResponse deleteResult = await client.PipelineDeleteAsync(2); deleteResult.Success.Should().BeTrue(); ApiPipelineResponseModel verifyResponse = await client.PipelineGetAsync(2); verifyResponse.Should().BeNull(); }
private async Task <ApiPipelineResponseModel> CreateRecord() { var model = new ApiPipelineRequestModel(); model.SetProperties(1, 2); CreateResponse <ApiPipelineResponseModel> result = await this.Client.PipelineCreateAsync(model); result.Success.Should().BeTrue(); return(result.Record); }
public void MapResponseToRequest() { var mapper = new ApiPipelineModelMapper(); var model = new ApiPipelineResponseModel(); model.SetProperties(1, 1, 1); ApiPipelineRequestModel response = mapper.MapResponseToRequest(model); response.PipelineStatusId.Should().Be(1); response.SaleId.Should().Be(1); }
public void MapModelToBO() { var mapper = new BOLPipelineMapper(); ApiPipelineRequestModel model = new ApiPipelineRequestModel(); model.SetProperties(1, 1); BOPipeline response = mapper.MapModelToBO(1, model); response.PipelineStatusId.Should().Be(1); response.SaleId.Should().Be(1); }
public virtual BOPipeline MapModelToBO( int id, ApiPipelineRequestModel model ) { BOPipeline boPipeline = new BOPipeline(); boPipeline.SetProperties( id, model.PipelineStatusId, model.SaleId); return(boPipeline); }
public virtual async Task <IActionResult> Create([FromBody] ApiPipelineRequestModel model) { CreateResponse <ApiPipelineResponseModel> result = await this.PipelineService.Create(model); if (result.Success) { return(this.Created($"{this.Settings.ExternalBaseUrl}/api/Pipelines/{result.Record.Id}", result)); } else { return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result)); } }
public void CreatePatch() { var mapper = new ApiPipelineModelMapper(); var model = new ApiPipelineRequestModel(); model.SetProperties(1, 1); JsonPatchDocument <ApiPipelineRequestModel> patch = mapper.CreatePatch(model); var response = new ApiPipelineRequestModel(); patch.ApplyTo(response); response.PipelineStatusId.Should().Be(1); response.SaleId.Should().Be(1); }
public virtual async Task <CreateResponse <ApiPipelineResponseModel> > Create( ApiPipelineRequestModel model) { CreateResponse <ApiPipelineResponseModel> response = new CreateResponse <ApiPipelineResponseModel>(await this.PipelineModelValidator.ValidateCreateAsync(model)); if (response.Success) { var bo = this.BolPipelineMapper.MapModelToBO(default(int), model); var record = await this.PipelineRepository.Create(this.DalPipelineMapper.MapBOToEF(bo)); response.SetRecord(this.BolPipelineMapper.MapBOToModel(this.DalPipelineMapper.MapEFToBO(record))); } return(response); }
private async Task <ApiPipelineRequestModel> PatchModel(int id, JsonPatchDocument <ApiPipelineRequestModel> patch) { var record = await this.PipelineService.Get(id); if (record == null) { return(null); } else { ApiPipelineRequestModel request = this.PipelineModelMapper.MapResponseToRequest(record); patch.ApplyTo(request); return(request); } }
public async void Create() { var mock = new ServiceMockFacade <IPipelineRepository>(); var model = new ApiPipelineRequestModel(); mock.RepositoryMock.Setup(x => x.Create(It.IsAny <Pipeline>())).Returns(Task.FromResult(new Pipeline())); var service = new PipelineService(mock.LoggerMock.Object, mock.RepositoryMock.Object, mock.ModelValidatorMockFactory.PipelineModelValidatorMock.Object, mock.BOLMapperMockFactory.BOLPipelineMapperMock, mock.DALMapperMockFactory.DALPipelineMapperMock); CreateResponse <ApiPipelineResponseModel> response = await service.Create(model); response.Should().NotBeNull(); mock.ModelValidatorMockFactory.PipelineModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiPipelineRequestModel>())); mock.RepositoryMock.Verify(x => x.Create(It.IsAny <Pipeline>())); }
public async void Delete() { var mock = new ServiceMockFacade <IPipelineRepository>(); var model = new ApiPipelineRequestModel(); mock.RepositoryMock.Setup(x => x.Delete(It.IsAny <int>())).Returns(Task.CompletedTask); var service = new PipelineService(mock.LoggerMock.Object, mock.RepositoryMock.Object, mock.ModelValidatorMockFactory.PipelineModelValidatorMock.Object, mock.BOLMapperMockFactory.BOLPipelineMapperMock, mock.DALMapperMockFactory.DALPipelineMapperMock); ActionResponse response = await service.Delete(default(int)); response.Should().NotBeNull(); mock.RepositoryMock.Verify(x => x.Delete(It.IsAny <int>())); mock.ModelValidatorMockFactory.PipelineModelValidatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <int>())); }
public virtual async Task <UpdateResponse <ApiPipelineResponseModel> > Update( int id, ApiPipelineRequestModel model) { var validationResult = await this.PipelineModelValidator.ValidateUpdateAsync(id, model); if (validationResult.IsValid) { var bo = this.BolPipelineMapper.MapModelToBO(id, model); await this.PipelineRepository.Update(this.DalPipelineMapper.MapBOToEF(bo)); var record = await this.PipelineRepository.Get(id); return(new UpdateResponse <ApiPipelineResponseModel>(this.BolPipelineMapper.MapBOToModel(this.DalPipelineMapper.MapEFToBO(record)))); } else { return(new UpdateResponse <ApiPipelineResponseModel>(validationResult)); } }
public virtual async Task <IActionResult> Update(int id, [FromBody] ApiPipelineRequestModel model) { ApiPipelineRequestModel request = await this.PatchModel(id, this.PipelineModelMapper.CreatePatch(model)); if (request == null) { return(this.StatusCode(StatusCodes.Status404NotFound)); } else { UpdateResponse <ApiPipelineResponseModel> result = await this.PipelineService.Update(id, request); if (result.Success) { return(this.Ok(result)); } else { return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result)); } } }
public virtual async Task <IActionResult> Patch(int id, [FromBody] JsonPatchDocument <ApiPipelineRequestModel> patch) { ApiPipelineResponseModel record = await this.PipelineService.Get(id); if (record == null) { return(this.StatusCode(StatusCodes.Status404NotFound)); } else { ApiPipelineRequestModel model = await this.PatchModel(id, patch); UpdateResponse <ApiPipelineResponseModel> result = await this.PipelineService.Update(id, model); if (result.Success) { return(this.Ok(result)); } else { return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result)); } } }
public async Task <ValidationResult> ValidateUpdateAsync(int id, ApiPipelineRequestModel model) { this.PipelineStatusIdRules(); this.SaleIdRules(); return(await this.ValidateAsync(model, id)); }