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 ApiVersionInfoRequestModel(); createModel.SetProperties(DateTime.Parse("1/1/1988 12:00:00 AM"), "B"); CreateResponse <ApiVersionInfoResponseModel> createResult = await client.VersionInfoCreateAsync(createModel); createResult.Success.Should().BeTrue(); ApiVersionInfoResponseModel getResponse = await client.VersionInfoGetAsync(2); getResponse.Should().NotBeNull(); ActionResponse deleteResult = await client.VersionInfoDeleteAsync(2); deleteResult.Success.Should().BeTrue(); ApiVersionInfoResponseModel verifyResponse = await client.VersionInfoGetAsync(2); verifyResponse.Should().BeNull(); }
private async Task <ApiVersionInfoResponseModel> CreateRecord(ApiClient client) { var model = new ApiVersionInfoRequestModel(); model.SetProperties(DateTime.Parse("1/1/1988 12:00:00 AM"), "B"); CreateResponse <ApiVersionInfoResponseModel> result = await client.VersionInfoCreateAsync(model); result.Success.Should().BeTrue(); return(result.Record); }
public void MapResponseToRequest() { var mapper = new ApiVersionInfoModelMapper(); var model = new ApiVersionInfoResponseModel(); model.SetProperties(1, DateTime.Parse("1/1/1987 12:00:00 AM"), "A"); ApiVersionInfoRequestModel response = mapper.MapResponseToRequest(model); response.AppliedOn.Should().Be(DateTime.Parse("1/1/1987 12:00:00 AM")); response.Description.Should().Be("A"); }
public void MapModelToBO() { var mapper = new BOLVersionInfoMapper(); ApiVersionInfoRequestModel model = new ApiVersionInfoRequestModel(); model.SetProperties(DateTime.Parse("1/1/1987 12:00:00 AM"), "A"); BOVersionInfo response = mapper.MapModelToBO(1, model); response.AppliedOn.Should().Be(DateTime.Parse("1/1/1987 12:00:00 AM")); response.Description.Should().Be("A"); }
public virtual BOVersionInfo MapModelToBO( long version, ApiVersionInfoRequestModel model ) { BOVersionInfo boVersionInfo = new BOVersionInfo(); boVersionInfo.SetProperties( version, model.AppliedOn, model.Description); return(boVersionInfo); }
public virtual async Task <IActionResult> Create([FromBody] ApiVersionInfoRequestModel model) { CreateResponse <ApiVersionInfoResponseModel> result = await this.VersionInfoService.Create(model); if (result.Success) { return(this.Created($"{this.Settings.ExternalBaseUrl}/api/VersionInfoes/{result.Record.Version}", result)); } else { return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result)); } }
public void CreatePatch() { var mapper = new ApiVersionInfoModelMapper(); var model = new ApiVersionInfoRequestModel(); model.SetProperties(DateTime.Parse("1/1/1987 12:00:00 AM"), "A"); JsonPatchDocument <ApiVersionInfoRequestModel> patch = mapper.CreatePatch(model); var response = new ApiVersionInfoRequestModel(); patch.ApplyTo(response); response.AppliedOn.Should().Be(DateTime.Parse("1/1/1987 12:00:00 AM")); response.Description.Should().Be("A"); }
public virtual async Task <CreateResponse <ApiVersionInfoResponseModel> > Create( ApiVersionInfoRequestModel model) { CreateResponse <ApiVersionInfoResponseModel> response = new CreateResponse <ApiVersionInfoResponseModel>(await this.versionInfoModelValidator.ValidateCreateAsync(model)); if (response.Success) { var bo = this.bolVersionInfoMapper.MapModelToBO(default(long), model); var record = await this.versionInfoRepository.Create(this.dalVersionInfoMapper.MapBOToEF(bo)); response.SetRecord(this.bolVersionInfoMapper.MapBOToModel(this.dalVersionInfoMapper.MapEFToBO(record))); } return(response); }
private async Task <ApiVersionInfoRequestModel> PatchModel(long id, JsonPatchDocument <ApiVersionInfoRequestModel> patch) { var record = await this.VersionInfoService.Get(id); if (record == null) { return(null); } else { ApiVersionInfoRequestModel request = this.VersionInfoModelMapper.MapResponseToRequest(record); patch.ApplyTo(request); return(request); } }
public async void Create() { var mock = new ServiceMockFacade <IVersionInfoRepository>(); var model = new ApiVersionInfoRequestModel(); mock.RepositoryMock.Setup(x => x.Create(It.IsAny <VersionInfo>())).Returns(Task.FromResult(new VersionInfo())); var service = new VersionInfoService(mock.LoggerMock.Object, mock.RepositoryMock.Object, mock.ModelValidatorMockFactory.VersionInfoModelValidatorMock.Object, mock.BOLMapperMockFactory.BOLVersionInfoMapperMock, mock.DALMapperMockFactory.DALVersionInfoMapperMock); CreateResponse <ApiVersionInfoResponseModel> response = await service.Create(model); response.Should().NotBeNull(); mock.ModelValidatorMockFactory.VersionInfoModelValidatorMock.Verify(x => x.ValidateCreateAsync(It.IsAny <ApiVersionInfoRequestModel>())); mock.RepositoryMock.Verify(x => x.Create(It.IsAny <VersionInfo>())); }
public async void Delete() { var mock = new ServiceMockFacade <IVersionInfoRepository>(); var model = new ApiVersionInfoRequestModel(); mock.RepositoryMock.Setup(x => x.Delete(It.IsAny <long>())).Returns(Task.CompletedTask); var service = new VersionInfoService(mock.LoggerMock.Object, mock.RepositoryMock.Object, mock.ModelValidatorMockFactory.VersionInfoModelValidatorMock.Object, mock.BOLMapperMockFactory.BOLVersionInfoMapperMock, mock.DALMapperMockFactory.DALVersionInfoMapperMock); ActionResponse response = await service.Delete(default(long)); response.Should().NotBeNull(); mock.RepositoryMock.Verify(x => x.Delete(It.IsAny <long>())); mock.ModelValidatorMockFactory.VersionInfoModelValidatorMock.Verify(x => x.ValidateDeleteAsync(It.IsAny <long>())); }
public virtual async Task <UpdateResponse <ApiVersionInfoResponseModel> > Update( long version, ApiVersionInfoRequestModel model) { var validationResult = await this.versionInfoModelValidator.ValidateUpdateAsync(version, model); if (validationResult.IsValid) { var bo = this.bolVersionInfoMapper.MapModelToBO(version, model); await this.versionInfoRepository.Update(this.dalVersionInfoMapper.MapBOToEF(bo)); var record = await this.versionInfoRepository.Get(version); return(new UpdateResponse <ApiVersionInfoResponseModel>(this.bolVersionInfoMapper.MapBOToModel(this.dalVersionInfoMapper.MapEFToBO(record)))); } else { return(new UpdateResponse <ApiVersionInfoResponseModel>(validationResult)); } }
public virtual async Task <IActionResult> Update(long id, [FromBody] ApiVersionInfoRequestModel model) { ApiVersionInfoRequestModel request = await this.PatchModel(id, this.VersionInfoModelMapper.CreatePatch(model)); if (request == null) { return(this.StatusCode(StatusCodes.Status404NotFound)); } else { UpdateResponse <ApiVersionInfoResponseModel> result = await this.VersionInfoService.Update(id, request); if (result.Success) { return(this.Ok(result)); } else { return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result)); } } }
public virtual async Task <IActionResult> Patch(long id, [FromBody] JsonPatchDocument <ApiVersionInfoRequestModel> patch) { ApiVersionInfoResponseModel record = await this.VersionInfoService.Get(id); if (record == null) { return(this.StatusCode(StatusCodes.Status404NotFound)); } else { ApiVersionInfoRequestModel model = await this.PatchModel(id, patch); UpdateResponse <ApiVersionInfoResponseModel> result = await this.VersionInfoService.Update(id, model); if (result.Success) { return(this.Ok(result)); } else { return(this.StatusCode(StatusCodes.Status422UnprocessableEntity, result)); } } }
public async Task <ValidationResult> ValidateUpdateAsync(long id, ApiVersionInfoRequestModel model) { this.AppliedOnRules(); this.DescriptionRules(); return(await this.ValidateAsync(model, id)); }
public virtual async Task <UpdateResponse <ApiVersionInfoResponseModel> > VersionInfoUpdateAsync(long id, ApiVersionInfoRequestModel item) { HttpResponseMessage httpResponse = await this.client.PutAsJsonAsync($"api/VersionInfoes/{id}", item).ConfigureAwait(false); return(JsonConvert.DeserializeObject <UpdateResponse <ApiVersionInfoResponseModel> >(httpResponse.Content.ContentToString())); }