diff --git a/src/test/java/org/etsi/osl/services/api/ri639/CommonTests.java b/src/test/java/org/etsi/osl/services/api/ri639/CommonTests.java new file mode 100644 index 0000000000000000000000000000000000000000..a78c4eb5d2956aaa5935289dbe8fed5bdd8dfd0e --- /dev/null +++ b/src/test/java/org/etsi/osl/services/api/ri639/CommonTests.java @@ -0,0 +1,142 @@ +/*- + * ========================LICENSE_START================================= + * org.etsi.osl.tmf.api + * %% + * Copyright (C) 2019 - 2024 openslice.io + * %% + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * =========================LICENSE_END================================== + */ + +package org.etsi.osl.services.api.ri639; + +import com.fasterxml.jackson.databind.ObjectMapper; +import jakarta.servlet.FilterChain; +import jakarta.servlet.ServletException; +import jakarta.servlet.http.HttpServletRequest; +import jakarta.servlet.http.HttpServletResponse; +import org.etsi.osl.tmf.ri639.api.*; +import org.junit.jupiter.api.Test; +import org.springframework.mock.web.MockHttpServletRequest; + +import java.io.IOException; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +public class CommonTests { + + @Test + public void testApiException() { + int errorCode = 404; + String errorMessage = "Not Found"; + + ApiException exception = new ApiException(errorCode, errorMessage); + + assertEquals(errorMessage, exception.getMessage()); + } + + @Test + public void testApiOriginFilter() throws IOException, ServletException { + HttpServletRequest request = mock(HttpServletRequest.class); + HttpServletResponse response = mock(HttpServletResponse.class); + FilterChain chain = mock(FilterChain.class); + + ApiOriginFilter filter = new ApiOriginFilter(); + filter.doFilter(request, response, chain); + + verify(response).addHeader("Access-Control-Allow-Origin", "*"); + verify(response).addHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT"); + verify(response).addHeader("Access-Control-Allow-Headers", "Content-Type"); + verify(chain).doFilter(request, response); + } + + @Test + public void testApiResponseMessage() { + int[] codes = {ApiResponseMessage.ERROR, ApiResponseMessage.WARNING, ApiResponseMessage.INFO, ApiResponseMessage.OK, ApiResponseMessage.TOO_BUSY, 6}; + + String[] types = {"error", "warning", "info", "ok", "too busy", "unknown"}; + + String[] messages = {"An error occured", "This is a warning", "Given info", "ok", "System is too busy", "unknown code"}; + + for (int i = 0; i < codes.length; i++) { + int code = codes[i]; + String type = types[i]; + String message = messages[i]; + + ApiResponseMessage responseMessage = new ApiResponseMessage(code, message); + + assertEquals(message, responseMessage.getMessage()); + assertEquals(code, responseMessage.getCode()); + assertEquals(type, responseMessage.getType()); + + } + + ApiResponseMessage responseMessage = new ApiResponseMessage(); + responseMessage.setMessage("Error"); + assertEquals("Error", responseMessage.getMessage()); + responseMessage.setType("ok"); + assertEquals("ok", responseMessage.getType()); + responseMessage.setCode(ApiResponseMessage.OK); + assertEquals(ApiResponseMessage.OK, responseMessage.getCode()); + } + + @Test + public void testHubApiController() { + ObjectMapper objectMapper = new ObjectMapper(); + HttpServletRequest request = new MockHttpServletRequest(); + + HubApiController controller = new HubApiController(objectMapper, request); + + Optional returnedObjectMapper = controller.getObjectMapper(); + Optional returnedRequest = controller.getRequest(); + + assertTrue(returnedObjectMapper.isPresent()); + assertTrue(returnedRequest.isPresent()); + + assertEquals(objectMapper, returnedObjectMapper.get()); + assertEquals(request, returnedRequest.get()); + } + + @Test + public void testListenerApiController() { + ObjectMapper objectMapper = new ObjectMapper(); + HttpServletRequest request = new MockHttpServletRequest(); + + ListenerApiController controller = new ListenerApiController(objectMapper, request); + + Optional returnedObjectMapper = controller.getObjectMapper(); + Optional returnedRequest = controller.getRequest(); + + assertTrue(returnedObjectMapper.isPresent()); + assertTrue(returnedRequest.isPresent()); + + assertEquals(objectMapper, returnedObjectMapper.get()); + assertEquals(request, returnedRequest.get()); + } + + @Test + public void testNotFoundException() { + int errorCode = 404; + String errorMessage = "Not Found"; + + NotFoundException exception = new NotFoundException(errorCode, errorMessage); + + assertEquals(errorMessage, exception.getMessage()); + } + +} + diff --git a/src/test/java/org/etsi/osl/services/api/ri639/ResourceApiControllerTest.java b/src/test/java/org/etsi/osl/services/api/ri639/ResourceApiControllerTest.java new file mode 100644 index 0000000000000000000000000000000000000000..9e2f8df94245b1dd78af3745ecdfbd2efeb737e5 --- /dev/null +++ b/src/test/java/org/etsi/osl/services/api/ri639/ResourceApiControllerTest.java @@ -0,0 +1,213 @@ +package org.etsi.osl.services.api.ri639; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; +import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*; + +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.util.List; + +import java.security.Principal; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.etsi.osl.tmf.JsonUtils; +import org.etsi.osl.tmf.OpenAPISpringBoot; +import org.etsi.osl.tmf.rcm634.model.ResourceSpecificationRef; +import org.etsi.osl.tmf.ri639.api.ResourceApiController; +import org.etsi.osl.tmf.ri639.model.LogicalResource; +import org.etsi.osl.tmf.ri639.model.Resource; + +import org.etsi.osl.tmf.ri639.model.ResourceCreate; +import org.etsi.osl.tmf.ri639.reposervices.ResourceRepoService; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.http.HttpStatus; +import org.springframework.http.MediaType; +import org.springframework.security.test.context.support.WithMockUser; +import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.context.WebApplicationContext; +import org.springframework.http.ResponseEntity; + + +@RunWith(SpringRunner.class) +@Transactional +@SpringBootTest( webEnvironment = SpringBootTest.WebEnvironment.MOCK , classes = OpenAPISpringBoot.class) +@AutoConfigureMockMvc +@ActiveProfiles("testing") + +public class ResourceApiControllerTest { + + private static final int FIXED_BOOTSTRAPS_RESOURCES = 0; + + @Autowired + private MockMvc mvc; + + @Autowired + ResourceRepoService resourceRepoService; + + @Autowired + private WebApplicationContext context; + + @Autowired + private ObjectMapper objectMapper; + + private ResourceApiController mockResourceApiController; + + private ResourceRepoService mockResourceRepoService; + + @Before + public void setup() { + mvc = MockMvcBuilders + .webAppContextSetup(context) + .apply(springSecurity()) + .build(); + + // Mocks + mockResourceRepoService = mock(ResourceRepoService.class); + ObjectMapper mockObjectMapper = mock(ObjectMapper.class); + mockResourceApiController = new ResourceApiController(mockObjectMapper, null); + } + + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testListResource() throws Exception { + + String response = mvc.perform(MockMvcRequestBuilders.get("/resourceInventoryManagement/v4/resource") + + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk() ) + .andReturn().getResponse().getContentAsString(); + + List resourceList = objectMapper.readValue(response, new TypeReference>() {}); + + assertThat(resourceList.size()).isEqualTo(resourceRepoService.findAll().size()); + } + + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testDeleteResource() throws Exception { + + String response = createResource(); + + Resource responsesResource = JsonUtils.toJsonObj(response, LogicalResource.class); + String id = responsesResource.getId(); + + mvc.perform(MockMvcRequestBuilders.delete("/resourceInventoryManagement/v4/resource/" + id ) + .with( SecurityMockMvcRequestPostProcessors.csrf()) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk() ) + .andReturn().getResponse().getContentAsString(); + + assertThat( resourceRepoService.findAll().size() ).isEqualTo( FIXED_BOOTSTRAPS_RESOURCES ); + } + + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testCreateResourceHandleException(){ + + ResourceCreate resourceCreate = createResourceObject(); + + when(mockResourceRepoService.addResource(any())) + .thenThrow(new RuntimeException("Test exception")); + + ResponseEntity response = mockResourceApiController.createResource(mock(Principal.class), resourceCreate); + + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR); + } + + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testDeleteResourceHandleException() throws Exception{ + + String response = createResource(); + + Resource responsesResource = JsonUtils.toJsonObj(response, LogicalResource.class); + String id = responsesResource.getId(); + + when(mockResourceRepoService.deleteByUuid(any())) + .thenThrow(new RuntimeException("Test exception")); + + ResponseEntity responseDelete = mockResourceApiController.deleteResource(id); + + assertThat(responseDelete.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR); + } + + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testListResourceHandleException(){ + + when(mockResourceRepoService.findAll()) + .thenThrow(new RuntimeException("Test exception")); + + ResponseEntity> response = mockResourceApiController.listResource(mock(Principal.class), null, null, null, null); + + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR); + } + + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testRetrieveResourceHandleException(){ + + when(mockResourceRepoService.findByUuid(any())) + .thenThrow(new RuntimeException("Test exception")); + + ResponseEntity response = mockResourceApiController.retrieveResource(mock(Principal.class), "test id", ""); + + assertThat(response.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR); + } + + + private String createResource() throws Exception{ + + ResourceCreate resourceCreate = createResourceObject(); + + String response = mvc.perform(MockMvcRequestBuilders.post("/resourceInventoryManagement/v4/resource") + .with( SecurityMockMvcRequestPostProcessors.csrf()) + .contentType(MediaType.APPLICATION_JSON) + .content( JsonUtils.toJson( resourceCreate ) )) + .andExpect(status().isOk()) + .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andReturn().getResponse().getContentAsString(); + + assertThat( resourceRepoService.findAll().size() ).isEqualTo( FIXED_BOOTSTRAPS_RESOURCES + 1 ); + return response; + } + + + private ResourceCreate createResourceObject() { + ResourceCreate resourceCreate = new ResourceCreate(); + resourceCreate.setName("Test Resource"); + resourceCreate.setCategory("Experimentation"); + resourceCreate.setDescription("A Test Resource"); + resourceCreate.setStartOperatingDate( OffsetDateTime.now(ZoneOffset.UTC ).toString() ); + resourceCreate.setEndOperatingDate( OffsetDateTime.now(ZoneOffset.UTC ).toString() ); + + ResourceSpecificationRef aServiceSpecificationRef = new ResourceSpecificationRef(); + + resourceCreate.setResourceSpecification( aServiceSpecificationRef ); + + return resourceCreate; + } +} diff --git a/src/test/java/org/etsi/osl/services/api/ri639/ResourceRepoServiceTest.java b/src/test/java/org/etsi/osl/services/api/ri639/ResourceRepoServiceTest.java new file mode 100644 index 0000000000000000000000000000000000000000..632ab428567593708e5cdf346ac21caf4d3fcb78 --- /dev/null +++ b/src/test/java/org/etsi/osl/services/api/ri639/ResourceRepoServiceTest.java @@ -0,0 +1,342 @@ +package org.etsi.osl.services.api.ri639; + + +import org.apache.commons.io.IOUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.etsi.osl.services.api.ResourceInventoryIntegrationTest; +import org.etsi.osl.tmf.JsonUtils; +import org.etsi.osl.tmf.OpenAPISpringBoot; +import org.etsi.osl.tmf.common.model.Any; +import org.etsi.osl.tmf.common.model.UserPartRoleType; +import org.etsi.osl.tmf.common.model.service.Note; +import org.etsi.osl.tmf.common.model.service.ResourceRef; +import org.etsi.osl.tmf.prm669.model.RelatedParty; +import org.etsi.osl.tmf.rcm634.model.*; +import org.etsi.osl.tmf.ri639.model.*; +import org.etsi.osl.tmf.ri639.reposervices.ResourceRepoService; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.http.MediaType; +import org.springframework.security.test.context.support.WithMockUser; +import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.context.WebApplicationContext; + +import java.io.File; +import java.io.FileInputStream; +import java.io.InputStream; +import java.net.URI; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*; + + +@RunWith(SpringRunner.class) +@Transactional +@SpringBootTest( webEnvironment = SpringBootTest.WebEnvironment.MOCK , classes = OpenAPISpringBoot.class) +//@AutoConfigureTestDatabase //this automatically uses h2 +@AutoConfigureMockMvc +@ActiveProfiles("testing") +//@TestPropertySource( +// locations = "classpath:application-testing.yml") +public class ResourceRepoServiceTest { + + private static final transient Log logger = LogFactory.getLog( ResourceInventoryIntegrationTest.class.getName()); + + @Autowired + private MockMvc mvc; + + @Autowired + ResourceRepoService resourceRepoService; + + @Autowired + private WebApplicationContext context; + + @Before + public void setup() { + mvc = MockMvcBuilders + .webAppContextSetup(context) + .apply(springSecurity()) + .build(); + } + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testFindAll() throws Exception { + + // Test with not null fields and params + String fields = "resourceVersion, usageState"; + Map params = new HashMap<>(); + params.put("category", "Non existing category"); + + List resourceList = resourceRepoService.findAll(fields, params); + assertThat(resourceList.size()).isEqualTo(resourceRepoService.findAll().size()); + + } + + +// // This test causes "HikariPool-1 - Connection is not available, request timed out after 30000ms" error for other tests +// @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) +// @Test +// public void testUpdateResource() throws Exception { + + // Test with non-existing resource +// String nonExistingResourceId = "nonExistingId"; +// ResourceUpdate ru = new ResourceUpdate(); +// +// Resource nullResource = resourceRepoService.updateResource(nonExistingResourceId, ru, false); +// assertThat(nullResource).isEqualTo(null); + + // Test with existing resource +// String response = createResource(); +// +// Resource responsesResource = JsonUtils.toJsonObj(response, LogicalResource.class); +// String id = responsesResource.getId(); +// +// ResourceUpdate resourceUpdate = new ResourceUpdate(); +// resourceUpdate.setAtType("New atType"); +// resourceUpdate.setName("New name"); +// resourceUpdate.setCategory("New category"); +// resourceUpdate.setDescription("New description"); +// resourceUpdate.setStartOperatingDate(OffsetDateTime.now(ZoneOffset.UTC ).toString()); +// resourceUpdate.setUsageState(responsesResource.getUsageState()); +// resourceUpdate.setResourceStatus(ResourceStatusType.ALARM); +// resourceUpdate.setResourceVersion("New version"); +// resourceUpdate.setAdministrativeState(responsesResource.getAdministrativeState()); +// resourceUpdate.setResourceSpecification(responsesResource.getResourceSpecification()); +// resourceUpdate.setPlace(new RelatedPlaceRefOrValue()); +// +// RelatedParty relatedParty = new RelatedParty(); +// relatedParty.setName("Related Party"); +// List relatedPartyList = new ArrayList<>(); +// relatedPartyList.add(relatedParty); +// +// resourceUpdate.setRelatedParty(relatedPartyList); +// +// Resource updatedResource = resourceRepoService.updateResource(id, resourceUpdate, false); +// +// assertThat(updatedResource.getName()).isEqualTo("New name"); +// assertThat(updatedResource.getCategory()).isEqualTo("New category"); +// assertThat(updatedResource.getDescription()).isEqualTo("New description"); +// assertThat(updatedResource.getResourceVersion()).isEqualTo("New version"); +// assertThat(updatedResource.getResourceStatus()).isEqualTo(ResourceStatusType.ALARM); +// } + + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testFindAllActiveResourcesToTerminate() throws Exception { + + String response = createResource(); + + Resource responsesResource = JsonUtils.toJsonObj(response, LogicalResource.class); + String id = responsesResource.getId(); + + List resourcesList = resourceRepoService.findAllActiveResourcesToTerminate(); + assertThat(resourcesList).contains(id); + } + + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testFindAllActiveAndReservedResourcesOfPartners() throws Exception { + + String response = createResource(); + + Resource responsesResource = JsonUtils.toJsonObj(response, LogicalResource.class); + String id = responsesResource.getId(); + + List resourcesList = resourceRepoService.findAllActiveAndReservedResourcesOfPartners(); + assertThat(resourcesList).contains(id); + } + +// // This test causes "HikariPool-1 - Connection is not available, request timed out after 30000ms" error for other tests +// @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) +// @Test +// public void testAddOrUpdateResourceByNameCategoryVersion() throws Exception { +// +// String response = createResource(); +// +// Resource responsesResource = JsonUtils.toJsonObj(response, LogicalResource.class); +// String name = responsesResource.getName(); +// String category = responsesResource.getCategory(); +// String version = responsesResource.getResourceVersion(); +// +// ResourceCreate aResource = new ResourceCreate(); +// aResource.setName("A new name"); +// aResource.setCategory("A new category"); +// +// Resource response2 = resourceRepoService.addOrUpdateResourceByNameCategoryVersion(name, category, version, aResource); +// assertThat(response2.getName()).isEqualTo("A new name"); +// assertThat(response2.getCategory()).isEqualTo("A new category"); +// } + + + private String createResource() throws Exception{ + + /** + * first add 2 specs + */ + + File sspec = new File( "src/test/resources/testResourceSpec.json" ); + InputStream in = new FileInputStream( sspec ); + String sspectext = IOUtils.toString(in, "UTF-8"); + + + ResourceSpecificationCreate sspeccr1 = JsonUtils.toJsonObj( sspectext, ResourceSpecificationCreate.class); + sspeccr1.setName("Spec1"); + ResourceSpecification responsesSpec1 = createResourceSpec( sspeccr1); + + //res 2 is an RFS + ResourceSpecificationCreate sspeccr2 = JsonUtils.toJsonObj( sspectext, ResourceSpecificationCreate.class); + sspeccr2.setName("Spec2"); + + sspeccr2.addResourceSpecificationRelationshipWith( responsesSpec1 ); + LogicalResourceSpecification responsesSpec2 = (LogicalResourceSpecification) createResourceSpec( sspeccr2 ); + /** + * add them as bundle + */ + + ResourceSpecificationCreate sspeccr3 = JsonUtils.toJsonObj( sspectext, ResourceSpecificationCreate.class); + sspeccr3.setName("BundleExampleSpec"); + sspeccr3.isBundle(true); + sspeccr3.addResourceSpecificationRelationshipWith( responsesSpec1 ); + sspeccr3.addResourceSpecificationRelationshipWith( responsesSpec2 ); + ResourceSpecification responsesSpec3 = createResourceSpec( sspeccr3); + + ResourceCreate aResource = new ResourceCreate(); + aResource.setName("aNew Resource parent"); + aResource.setCategory("Experimentation"); + aResource.setDescription("Experimentation Descr"); + aResource.setStartOperatingDate( OffsetDateTime.now(ZoneOffset.UTC ).toString() ); + aResource.setEndOperatingDate( OffsetDateTime.now(ZoneOffset.UTC ).toString() ); + aResource.setResourceStatus(ResourceStatusType.AVAILABLE); + + + + Note noteItem = new Note(); + noteItem.text("test note"); + aResource.addNoteItem(noteItem); + + Characteristic resCharacteristicItem = new Characteristic(); + + resCharacteristicItem.setName( "externalPartnerServiceId" ); + resCharacteristicItem.setValue( new Any("NONE")); + aResource.addResourceCharacteristicItem(resCharacteristicItem); + + ResourceSpecificationRef aServiceSpecificationRef = new ResourceSpecificationRef(); + aServiceSpecificationRef.setId(responsesSpec3.getId() ); + aServiceSpecificationRef.setName(responsesSpec3.getName()); + + aResource.setResourceSpecification( aServiceSpecificationRef ); + //create a first resoruce that will be added to the next one as ref + String responseResource = mvc.perform(MockMvcRequestBuilders.post("/resourceInventoryManagement/v4/resource") + .with( SecurityMockMvcRequestPostProcessors.csrf()) + .contentType(MediaType.APPLICATION_JSON) + .content( JsonUtils.toJson( aResource ) )) + .andExpect(status().isOk()) + .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andReturn().getResponse().getContentAsString(); + logger.info("responseResource = " + responseResource); + Resource responseRsc = JsonUtils.toJsonObj( responseResource, LogicalResource.class); + + + aResource.setName("aNew Resource"); + + ResourceRelationship rri = new ResourceRelationship(); + rri.setRelationshipType("PARENT"); + ResourceRef rrref = new ResourceRef(); + rrref.setName( responseRsc.getName() ); + rrref.setId( responseRsc.getId() ); + rri.setResource( rrref ); + aResource.addResourceRelationshipItem( rri ); + + logger.info("aService JSON = " + JsonUtils.toJsonString( aResource )); + + responseResource = mvc.perform(MockMvcRequestBuilders.post("/resourceInventoryManagement/v4/resource") + .with( SecurityMockMvcRequestPostProcessors.csrf()) + .contentType(MediaType.APPLICATION_JSON) + .content( JsonUtils.toJson( aResource ) )) + .andExpect(status().isOk()) + .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andReturn().getResponse().getContentAsString(); + logger.info("responseResource = " + responseResource); + responseRsc = JsonUtils.toJsonObj( responseResource, LogicalResource.class); + + + logger.info("testService = " + JsonUtils.toJsonString( responseRsc )); + + + assertThat( responseRsc.getCategory() ).isEqualTo( "Experimentation" ); + assertThat( responseRsc.getDescription() ).isEqualTo( "Experimentation Descr" ); + assertThat( responseRsc.getStartOperatingDate() ).isNotNull(); + assertThat( responseRsc.getEndOperatingDate() ).isNotNull(); + assertThat( responseRsc.getResourceCharacteristic().size() ).isEqualTo( 1 ); + assertThat( responseRsc.getResourceCharacteristicByName( "externalPartnerServiceId" ) ).isNotNull(); + assertThat( responseRsc.getResourceCharacteristicByName( "externalPartnerServiceId" ).getValue().getValue() ).isEqualTo( "NONE" ) ; + assertThat( responseRsc.getResourceSpecification().getId() ).isNotNull(); + assertThat( responseRsc.getResourceSpecification().getName() ).isNotNull(); + assertThat( responseRsc.getResourceRelationship().size() ).isEqualTo( 1 ); + + + assertThat( responseRsc.getNote().size() ).isEqualTo( 2 ); + + boolean userPartyRoleexists = false; + for (RelatedParty r : responseRsc.getRelatedParty()) { + if ( r.getName().equals( "osadmin" ) && r.getRole().equals( UserPartRoleType.REQUESTER.toString() )) { + userPartyRoleexists = true; + } + } + + assertThat(userPartyRoleexists ).isTrue() ; + + assertThat( resourceRepoService.findAll().size() ).isEqualTo( 2 ); + + return responseResource; + } + + + private ResourceSpecification createResourceSpec(ResourceSpecificationUpdate sspeccr1) throws Exception{ + + URI url = new URI("/resourceCatalogManagement/v4/resourceSpecification"); + if (sspeccr1 instanceof PhysicalResourceSpecificationUpdate ) { + url = new URI("/resourceCatalogManagement/v4/resourceSpecification"); + } + String responseSpec = mvc.perform(MockMvcRequestBuilders.post( url ) + .with( SecurityMockMvcRequestPostProcessors.csrf()) + .contentType(MediaType.APPLICATION_JSON) + .content( JsonUtils.toJson( sspeccr1 ) )) + .andExpect(status().isOk()) + .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andReturn().getResponse().getContentAsString(); + + ResourceSpecification responsesSpec1; + if (sspeccr1 instanceof PhysicalResourceSpecificationUpdate ) { + responsesSpec1 = JsonUtils.toJsonObj(responseSpec, PhysicalResourceSpecification.class); + }else { + responsesSpec1 = JsonUtils.toJsonObj(responseSpec, LogicalResourceSpecification.class); + } + + return responsesSpec1; + } +}