* ============LICENSE_START=======================================================
* Copyright (C) 2021 Pantheon.tech
* Modifications Copyright (C) 2021 highstreet technologies GmbH
- * Modifications Copyright (C) 2021-2024 Nordix Foundation
+ * Modifications Copyright (C) 2021-2025 OpenInfra Foundation Europe. All rights reserved.
* Modifications Copyright (C) 2021-2022 Bell Canada.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
import ch.qos.logback.classic.spi.ILoggingEvent
import ch.qos.logback.core.read.ListAppender
import com.fasterxml.jackson.databind.ObjectMapper
+import groovy.json.JsonSlurper
import org.mapstruct.factory.Mappers
import org.onap.cps.TestUtils
-import org.onap.cps.events.EventsPublisher
-import org.onap.cps.ncmp.api.NetworkCmProxyDataService
-import org.onap.cps.ncmp.api.NetworkCmProxyQueryService
-import org.onap.cps.ncmp.api.impl.inventory.CmHandleState
-import org.onap.cps.ncmp.api.impl.inventory.CompositeState
-import org.onap.cps.ncmp.api.impl.inventory.DataStoreSyncState
-import org.onap.cps.ncmp.api.impl.inventory.LockReasonCategory
-import org.onap.cps.ncmp.api.impl.trustlevel.TrustLevel
-import org.onap.cps.ncmp.api.models.NcmpServiceCmHandle
-import org.onap.cps.ncmp.rest.controller.handlers.NcmpCachedResourceRequestHandler
-import org.onap.cps.ncmp.rest.controller.handlers.NcmpPassthroughResourceRequestHandler
-import org.onap.cps.ncmp.rest.executor.CpsNcmpTaskExecutor
-import org.onap.cps.ncmp.rest.mapper.CmHandleStateMapper
-import org.onap.cps.ncmp.rest.mapper.DataOperationRequestMapper
+import org.onap.cps.events.EventsProducer
+import org.onap.cps.ncmp.impl.NetworkCmProxyInventoryFacadeImpl
+import org.onap.cps.ncmp.api.inventory.models.CompositeState
+import org.onap.cps.ncmp.api.inventory.models.NcmpServiceCmHandle
+import org.onap.cps.ncmp.impl.data.NetworkCmProxyFacade
+import org.onap.cps.ncmp.api.inventory.DataStoreSyncState
+import org.onap.cps.ncmp.api.inventory.models.CmHandleState
+import org.onap.cps.ncmp.api.inventory.models.LockReasonCategory
+import org.onap.cps.ncmp.impl.utils.AlternateIdMatcher
import org.onap.cps.ncmp.rest.model.DataOperationDefinition
import org.onap.cps.ncmp.rest.model.DataOperationRequest
+import org.onap.cps.ncmp.rest.model.RestOutputCmHandle
+import org.onap.cps.ncmp.rest.util.CmHandleStateMapper
+import org.onap.cps.ncmp.rest.util.DataOperationRequestMapper
import org.onap.cps.ncmp.rest.util.DeprecationHelper
-import org.onap.cps.spi.FetchDescendantsOption
-import org.onap.cps.spi.model.ModuleDefinition
-import org.onap.cps.spi.model.ModuleReference
+import org.onap.cps.ncmp.rest.util.NcmpRestInputMapper
+import org.onap.cps.api.model.ModuleDefinition
+import org.onap.cps.api.model.ModuleReference
+import org.onap.cps.ncmp.rest.util.RestOutputCmHandleMapper
import org.onap.cps.utils.JsonObjectMapper
import org.slf4j.LoggerFactory
import org.spockframework.spring.SpringBean
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
import org.springframework.http.HttpStatus
import org.springframework.http.MediaType
+import org.springframework.http.ResponseEntity
import org.springframework.test.web.servlet.MockMvc
+import reactor.core.publisher.Flux
+import reactor.core.publisher.Mono
import spock.lang.Shared
import spock.lang.Specification
import java.time.ZoneOffset
import java.time.format.DateTimeFormatter
-import static org.onap.cps.ncmp.api.impl.inventory.CompositeState.DataStores
-import static org.onap.cps.ncmp.api.impl.inventory.CompositeState.Operational
-import static org.onap.cps.ncmp.api.impl.operations.DatastoreType.OPERATIONAL
-import static org.onap.cps.ncmp.api.impl.operations.DatastoreType.PASSTHROUGH_OPERATIONAL
-import static org.onap.cps.ncmp.api.impl.operations.DatastoreType.PASSTHROUGH_RUNNING
-import static org.onap.cps.ncmp.api.impl.operations.OperationType.CREATE
-import static org.onap.cps.ncmp.api.impl.operations.OperationType.DELETE
-import static org.onap.cps.ncmp.api.impl.operations.OperationType.PATCH
-import static org.onap.cps.ncmp.api.impl.operations.OperationType.UPDATE
-import static org.onap.cps.spi.FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS
-import static org.onap.cps.spi.FetchDescendantsOption.OMIT_DESCENDANTS
+import static org.onap.cps.ncmp.api.data.models.DatastoreType.PASSTHROUGH_OPERATIONAL
+import static org.onap.cps.ncmp.api.data.models.DatastoreType.PASSTHROUGH_RUNNING
+import static org.onap.cps.ncmp.api.data.models.OperationType.CREATE
+import static org.onap.cps.ncmp.api.data.models.OperationType.DELETE
+import static org.onap.cps.ncmp.api.data.models.OperationType.PATCH
+import static org.onap.cps.ncmp.api.data.models.OperationType.UPDATE
+import static org.onap.cps.ncmp.api.inventory.models.CompositeState.DataStores
+import static org.onap.cps.ncmp.api.inventory.models.CompositeState.Operational
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch
MockMvc mvc
@SpringBean
- NetworkCmProxyDataService mockNetworkCmProxyDataService = Mock()
+ NetworkCmProxyFacade mockNetworkCmProxyFacade = Mock()
@SpringBean
- NetworkCmProxyQueryService mockNetworkCmProxyQueryService = Mock()
+ NetworkCmProxyInventoryFacadeImpl mockNetworkCmProxyInventoryFacade = Mock()
+
+ @SpringBean
+ AlternateIdMatcher mockAlternateIdMatcher = Mock()
@SpringBean
ObjectMapper objectMapper = new ObjectMapper()
DataOperationRequestMapper dataOperationRequestMapper = Mappers.getMapper(DataOperationRequestMapper)
@SpringBean
- Map<String, TrustLevel> trustLevelPerCmHandle = [:]
-
- @SpringBean
- CpsNcmpTaskExecutor mockCpsTaskExecutor = Mock()
+ RestOutputCmHandleMapper mockRestOutputCmHandleMapper = Mock()
@SpringBean
DeprecationHelper stubbedDeprecationHelper = Stub()
- @SpringBean
- NcmpCachedResourceRequestHandler ncmpCachedResourceRequestHandler = new NcmpCachedResourceRequestHandler(mockCpsTaskExecutor, mockNetworkCmProxyDataService, mockNetworkCmProxyQueryService)
-
- @SpringBean
- NcmpPassthroughResourceRequestHandler ncmpPassthroughResourceRequestHandler = new NcmpPassthroughResourceRequestHandler(mockCpsTaskExecutor, mockNetworkCmProxyDataService)
-
@Value('${rest.api.ncmp-base-path}/v1')
def ncmpBasePathV1
@Shared
def NO_TOPIC = null
- def NO_REQUEST_ID = null
+ def NO_OPTIONS = null
def NO_AUTH_HEADER = null
- def TIMOUT_FOR_TEST = 1234
def logger = Spy(ListAppender<ILoggingEvent>)
def setup() {
- ncmpCachedResourceRequestHandler.notificationFeatureEnabled = true
- ncmpCachedResourceRequestHandler.timeOutInMilliSeconds = TIMOUT_FOR_TEST
- ncmpPassthroughResourceRequestHandler.notificationFeatureEnabled = true
- ncmpPassthroughResourceRequestHandler.timeOutInMilliSeconds = TIMOUT_FOR_TEST
setupLogger()
}
def cleanup() {
- ((Logger) LoggerFactory.getLogger(EventsPublisher.class)).detachAndStopAllAppenders()
+ ((Logger) LoggerFactory.getLogger(EventsProducer.class)).detachAndStopAllAppenders()
}
def 'Get Resource Data from pass-through operational.'() {
given: 'resource data url'
- def getUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-operational" +
- "?resourceIdentifier=parent/child&options=(a=1,b=2)"
+ def getUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-operational?resourceIdentifier=parent/child&options=(a=1,b=2)"
when: 'get data resource request is performed'
- def response = mvc.perform(
- get(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
- ).andReturn().response
- then: 'the NCMP data service is called with getResourceDataOperationalForCmHandle'
- 1 * mockNetworkCmProxyDataService.getResourceDataForCmHandle(PASSTHROUGH_OPERATIONAL.datastoreName, 'testCmHandle',
- 'parent/child','(a=1,b=2)', NO_TOPIC, NO_REQUEST_ID, NO_AUTH_HEADER)
+ def response = mvc.perform(get(getUrl).contentType(MediaType.APPLICATION_JSON)).andReturn().response
+ then: 'the NCMP data service is called with correct parameters'
+ 1 * mockNetworkCmProxyFacade.getResourceDataForCmHandle(_, '(a=1,b=2)', NO_TOPIC, false, NO_AUTH_HEADER) >> Mono.just(new ResponseEntity<Object>(HttpStatus.OK))
and: 'response status is Ok'
- response.status == HttpStatus.OK.value()
+ assert response.status == HttpStatus.OK.value()
}
def 'Get Resource Data from ncmp-datastore:operational (cached) parameters handling with #scenario.'() {
given: 'resource data url'
- def getUrl = "$ncmpBasePathV1/ch/h123/data/ds/ncmp-datastore:operational" +
- "?resourceIdentifier=parent/child${additionalUrlParam}"
+ def getUrl = "$ncmpBasePathV1/ch/h123/data/ds/ncmp-datastore:operational?resourceIdentifier=parent/child${additionalUrlParam}"
+ and: 'the expected cm resource address'
when: 'get data resource request is performed'
- def response = mvc.perform(
- get(getUrl).contentType(MediaType.APPLICATION_JSON)).andReturn().response
- then: 'task executor is called appropriate number of times'
- 1 * mockNetworkCmProxyDataService.getResourceDataForCmHandle('ncmp-datastore:operational', 'h123', 'parent/child', expectedIncludeDescendants)
+ def response = mvc.perform(get(getUrl).contentType(MediaType.APPLICATION_JSON)).andReturn().response
+ then: 'the NCMP data service is called with correct parameters'
+ 1 * mockNetworkCmProxyFacade.getResourceDataForCmHandle(_, NO_OPTIONS, NO_TOPIC, expectedIncludeDescendants, NO_AUTH_HEADER)
and: 'response status is OK'
- response.status == HttpStatus.OK.value()
+ assert response.status == HttpStatus.OK.value()
where: 'the following parameters are used'
scenario | additionalUrlParam || expectedIncludeDescendants
- 'no additional param' | '' || OMIT_DESCENDANTS
- 'include descendants true' | '&include-descendants=true' || INCLUDE_ALL_DESCENDANTS
- 'include descendants TRUE' | '&include-descendants=true' || INCLUDE_ALL_DESCENDANTS
- 'include descendants false' | '&include-descendants=false' || OMIT_DESCENDANTS
- 'include descendants FALSE' | '&include-descendants=FALSE' || OMIT_DESCENDANTS
- 'options (ignored)' | '&options=(a-=1)' || OMIT_DESCENDANTS
+ 'no additional param' | '' || false
+ 'include descendants true' | '&include-descendants=true' || true
+ 'include descendants TRUE' | '&include-descendants=true' || true
+ 'include descendants false' | '&include-descendants=false' || false
+ 'include descendants FALSE' | '&include-descendants=FALSE' || false
}
def 'Execute (async) data operation to read data from dmi service.'() {
given: 'data operation url'
def getUrl = "$ncmpBasePathV1/data?topic=my-topic-name"
- def dataOperationRequestJsonData = jsonObjectMapper.asJsonString(getDataOperationRequest("read", datastore.datastoreName))
+ def dataOperationRequestJsonData = jsonObjectMapper.asJsonString(getDataOperationRequest('read', datastore.datastoreName))
when: 'post data operation request is performed'
- def response = mvc.perform(
- post(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
- .content(dataOperationRequestJsonData)
- ).andReturn().response
+ def response = mvc.perform(post(getUrl).contentType(MediaType.APPLICATION_JSON).content(dataOperationRequestJsonData)).andReturn().response
then: 'response status is Ok'
- response.status == HttpStatus.OK.value()
- and: 'async request id is generated'
- assert response.contentAsString.contains('requestId')
- then: 'the request is handled asynchronously'
- 1 * mockCpsTaskExecutor.executeTask(*_)
+ assert response.status == HttpStatus.OK.value()
+ then: 'the request for (async) data operation invoked once'
+ 1 * mockNetworkCmProxyFacade.executeDataOperationForCmHandles('my-topic-name', _, NO_AUTH_HEADER)
where: 'the following data stores are used'
datastore << [PASSTHROUGH_RUNNING, PASSTHROUGH_OPERATIONAL]
}
- def 'Execute (async) data operation with some validation error.'() {
- given: 'data operation url'
- def getUrl = "$ncmpBasePathV1/data?topic=my-topic-name"
- def dataOperationRequestJsonData = jsonObjectMapper.asJsonString(
- getDataOperationRequest('read', 'invalid datastore'))
- when: 'post data resource request is performed'
- def response = mvc.perform(
- post(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
- .content(dataOperationRequestJsonData)
- ).andReturn().response
- then: 'response status is BAD_REQUEST'
- response.status == HttpStatus.BAD_REQUEST.value()
- }
-
- def 'Get data operation resource data when notification feature is disabled for datastore: #datastore.'() {
- given: 'data operation url'
- def getUrl = "$ncmpBasePathV1/data?topic=my-topic-name"
- def dataOperationRequestJsonData = jsonObjectMapper.asJsonString(
- getDataOperationRequest("read", PASSTHROUGH_RUNNING.datastoreName))
- ncmpPassthroughResourceRequestHandler.notificationFeatureEnabled = false
- when: 'post data resource request is performed'
- def response = mvc.perform(
- post(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
- .content(dataOperationRequestJsonData)
- ).andReturn().response
- then: 'response status is Ok'
- response.status == HttpStatus.OK.value()
- and: 'async request id is unavailable'
- assert response.contentAsString == '{"status":"Asynchronous request is unavailable as notification feature is currently disabled."}'
- }
-
def 'Query Resource Data from operational.'() {
given: 'the query resource data url'
- def getUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:operational/query" +
- "?cps-path=/cps/path"
+ def getUrl = "$ncmpBasePathV1/ch/ch-1/data/ds/ncmp-datastore:operational/query?cps-path=/cps/path"
when: 'the query data resource request is performed'
- def response = mvc.perform(
- get(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
- ).andReturn().response
+ def response = mvc.perform(get(getUrl).contentType(MediaType.APPLICATION_JSON)).andReturn().response
then: 'the NCMP query service is called with queryResourceDataOperationalForCmHandle'
- 1 * mockNetworkCmProxyQueryService.queryResourceDataOperational('testCmHandle',
- '/cps/path',
- FetchDescendantsOption.OMIT_DESCENDANTS)
+ 1 * mockNetworkCmProxyFacade.queryResourceDataForCmHandle('ch-1','/cps/path', false)
and: 'response status is Ok'
- response.status == HttpStatus.OK.value()
+ assert response.status == HttpStatus.OK.value()
}
def 'Query Resource Data with unsupported datastore'() {
given: 'the query resource data url'
- def getUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-running/query" +
- "?cps-path=/cps/path"
+ def getUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-running/query?cps-path=/cps/path"
when: 'the query data resource request is performed'
- def response = mvc.perform(
- get(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
- ).andReturn().response
+ def response = mvc.perform(get(getUrl).contentType(MediaType.APPLICATION_JSON)).andReturn().response
then: 'a 400 BAD_REQUEST is returned for the unsupported datastore'
- response.status == 400
+ assert response.status == 400
and: 'the error message is that the datastore is not supported'
- response.contentAsString.contains("ncmp-datastore:passthrough-running is not supported")
+ assert response.contentAsString.contains("ncmp-datastore:passthrough-running is not supported")
}
def 'Get Resource Data from pass-through running with #scenario value in resource identifier param.'() {
given: 'resource data url'
- def getUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-running" +
- "?resourceIdentifier=" + resourceIdentifier + "&options=(a=1,b=2)"
+ def getUrl = "$ncmpBasePathV1/ch/ch-1/data/ds/ncmp-datastore:passthrough-running?resourceIdentifier=$resourceIdentifier&options=(a=1)"
and: 'ncmp service returns json object'
- mockNetworkCmProxyDataService.getResourceDataForCmHandle(PASSTHROUGH_RUNNING.datastoreName, 'testCmHandle',
- resourceIdentifier,'(a=1,b=2)', NO_TOPIC, NO_REQUEST_ID, NO_AUTH_HEADER) >> '{valid-json}'
+ 1 * mockNetworkCmProxyFacade.getResourceDataForCmHandle(_, '(a=1)', NO_TOPIC, false, NO_AUTH_HEADER)
+ >> new ResponseEntity<Object>('{valid-json}', HttpStatus.OK)
when: 'get data resource request is performed'
- def response = mvc.perform(
- get(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
- ).andReturn().response
+ def response = mvc.perform(get(getUrl).contentType(MediaType.APPLICATION_JSON)).andReturn().response
then: 'response status is Ok'
- response.status == HttpStatus.OK.value()
- and: 'response contains valid object body'
- response.getContentAsString() == '{valid-json}'
+ assert response.status == 200
+ and: 'response contains the object returned by the service'
+ def responseAsJsonObject = new JsonSlurper().parseText(response.getContentAsString())
+ assert responseAsJsonObject.body == '{valid-json}'
where: 'tokens are used in the resource identifier parameter'
scenario | resourceIdentifier
'/' | 'id/with/slashes'
def 'Update resource data from pass-through running.'() {
given: 'update resource data url'
- def updateUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-running" +
- "?resourceIdentifier=parent/child"
+ def updateUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-running?resourceIdentifier=parent/child"
when: 'update data resource request is performed'
- def response = mvc.perform(
- put(updateUrl)
- .contentType(MediaType.APPLICATION_JSON_VALUE).content(requestBody)
- ).andReturn().response
+ def response = mvc.perform(put(updateUrl).contentType(MediaType.APPLICATION_JSON_VALUE).content(requestBody)).andReturn().response
then: 'ncmp service method to update resource is called'
- 1 * mockNetworkCmProxyDataService.writeResourceDataPassThroughRunningForCmHandle('testCmHandle',
- 'parent/child', UPDATE, requestBody, 'application/json;charset=UTF-8', NO_AUTH_HEADER)
+ 1 * mockNetworkCmProxyFacade.writeResourceDataPassThroughRunningForCmHandle('testCmHandle','parent/child', UPDATE, requestBody, 'application/json;charset=UTF-8', NO_AUTH_HEADER)
and: 'the response status is OK'
- response.status == HttpStatus.OK.value()
+ assert response.status == HttpStatus.OK.value()
}
def 'Create Resource Data from pass-through running with #scenario.'() {
given: 'resource data url'
- def url = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-running" +
- "?resourceIdentifier=parent/child"
+ def url = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-running?resourceIdentifier=parent/child"
when: 'create resource request is performed'
- def response = mvc.perform(
- post(url)
- .contentType(MediaType.APPLICATION_JSON_VALUE).content(requestBody)
- ).andReturn().response
+ def response = mvc.perform(post(url).contentType(MediaType.APPLICATION_JSON_VALUE).content(requestBody)).andReturn().response
then: 'ncmp service method to create resource called'
- 1 * mockNetworkCmProxyDataService.writeResourceDataPassThroughRunningForCmHandle('testCmHandle',
- 'parent/child', CREATE, requestBody, 'application/json;charset=UTF-8', NO_AUTH_HEADER)
+ 1 * mockNetworkCmProxyFacade.writeResourceDataPassThroughRunningForCmHandle('testCmHandle', 'parent/child', CREATE, requestBody, 'application/json;charset=UTF-8', NO_AUTH_HEADER)
and: 'resource is created'
- response.status == HttpStatus.CREATED.value()
+ assert response.status == HttpStatus.CREATED.value()
}
def 'Get module references for the given dataspace and cm handle.'() {
when: 'get module resource request is performed'
def response = mvc.perform(get(getUrl)).andReturn().response
then: 'ncmp service method to get yang resource module references is called'
- mockNetworkCmProxyDataService.getYangResourcesModuleReferences('some-cmhandle')
- >> [new ModuleReference(moduleName: 'some-name1', revision: '2021-10-03')]
+ mockNetworkCmProxyInventoryFacade.getYangResourcesModuleReferences('some-cmhandle') >> [new ModuleReference(moduleName: 'some-name1', revision: '2021-10-03')]
and: 'response contains an array with the module name and revision'
response.getContentAsString() == '[{"moduleName":"some-name1","revision":"2021-10-03"}]'
and: 'response returns an OK http code'
- response.status == HttpStatus.OK.value()
+ assert response.status == HttpStatus.OK.value()
}
- def 'Retrieve cm handles.'() {
- given: 'an endpoint and json data'
+ def 'Execute cm handle search.'() {
+ given: 'search endpoint and JSON request'
def searchesEndpoint = "$ncmpBasePathV1/ch/searches"
String jsonString = TestUtils.getResourceFileContent('cmhandle-search.json')
- and: 'the service method is invoked with module names and returns two cm handles'
- def cmHandle1 = new NcmpServiceCmHandle()
- cmHandle1.cmHandleId = 'ch-1'
- cmHandle1.publicProperties = [color: 'yellow']
- def cmHandle2 = new NcmpServiceCmHandle()
- cmHandle2.cmHandleId = 'ch-2'
- cmHandle2.publicProperties = [color: 'green']
- mockNetworkCmProxyDataService.executeCmHandleSearch(_) >> [cmHandle1, cmHandle2]
- and: 'map for trust level per cmHandle has value for only one cm handle'
-// trustLevelPerCmHandle.get('') >> { TrustLevel.NONE }
- trustLevelPerCmHandle.put('ch-1', TrustLevel.NONE)
- when: 'the searches api is invoked'
- def response = mvc.perform(post(searchesEndpoint)
- .contentType(MediaType.APPLICATION_JSON)
- .content(jsonString)).andReturn().response
- then: 'response status returns OK'
- response.status == HttpStatus.OK.value()
- and: 'the expected response content is returned'
- response.contentAsString == '[{"cmHandle":"ch-1","publicCmHandleProperties":[{"color":"yellow"}],"state":null,"trustLevel":"NONE"},{"cmHandle":"ch-2","publicCmHandleProperties":[{"color":"green"}],"state":null,"trustLevel":null}]'
- }
-
- def 'Get complete Cm Handle details by Cm Handle id.'() {
- given: 'an endpoint and a cm handle'
- def cmHandleDetailsEndpoint = "$ncmpBasePathV1/ch/some-cm-handle"
- and: 'an existing ncmp service cm handle'
- def cmHandleId = 'some-cm-handle'
- def dmiProperties = [prop: 'some DMI property']
- def publicProperties = ["public prop": 'some public property']
- def compositeState = compositeStateTestObject()
- def ncmpServiceCmHandle = new NcmpServiceCmHandle(cmHandleId: cmHandleId, dmiProperties: dmiProperties, publicProperties: publicProperties, compositeState: compositeState)
- and: 'the service method is invoked with the cm handle id'
- 1 * mockNetworkCmProxyDataService.getNcmpServiceCmHandle('some-cm-handle') >> ncmpServiceCmHandle
- and: 'map for trust level per cmHandle has values'
- trustLevelPerCmHandle.get('some-cm-handle') >> { TrustLevel.COMPLETE }
+ and: 'the inventory facade returns two cm handles'
+ def ncmpServiceCmHandle1 = new NcmpServiceCmHandle(cmHandleId: 'ch-1')
+ def ncmpServiceCmHandle2 = new NcmpServiceCmHandle(cmHandleId: 'ch-2')
+ mockNetworkCmProxyInventoryFacade.northboundCmHandleSearch(_) >> Flux.fromIterable([ncmpServiceCmHandle1, ncmpServiceCmHandle2])
+ and: 'mapper converts cm handles without private properties'
+ def restHandle1 = new RestOutputCmHandle(cmHandle: 'rest ch-1')
+ def restHandle2 = new RestOutputCmHandle(cmHandle: 'rest ch-2')
+ mockRestOutputCmHandleMapper.toRestOutputCmHandle(ncmpServiceCmHandle1, false) >> restHandle1
+ mockRestOutputCmHandleMapper.toRestOutputCmHandle(ncmpServiceCmHandle2, false) >> restHandle2
+ when: 'the search endpoint is invoked'
+ def response = mvc.perform(post(searchesEndpoint).contentType(MediaType.APPLICATION_JSON).content(jsonString)).andReturn().response
+ then: 'response status is OK'
+ assert response.status == HttpStatus.OK.value()
+ and: 'the response contains the rest version of both cm handles'
+ assert response.contentAsString.contains('rest ch-1')
+ assert response.contentAsString.contains('rest ch-2')
+ }
+
+
+ def 'Get complete Cm Handle details by Cm Handle Reference.'() {
+ given: 'an endpoint and a cm handle reference'
+ def cmHandleDetailsEndpoint = "$ncmpBasePathV1/ch/cm handle id in request"
+ and: 'existing cm handle from inventory facade'
+ def cmHandle = new NcmpServiceCmHandle(cmHandleId: 'ch-1')
+ mockNetworkCmProxyInventoryFacade.getNcmpServiceCmHandle('cm handle id in request') >> cmHandle
+ and: 'mapper converts cm handle without private properties'
+ def restOutputCmHandle = new RestOutputCmHandle(cmHandle: 'rest version of the cm handle')
+ mockRestOutputCmHandleMapper.toRestOutputCmHandle(cmHandle, false) >> restOutputCmHandle
when: 'the cm handle details api is invoked'
- def response = mvc.perform(
- get(cmHandleDetailsEndpoint)).andReturn().response
- then: 'the correct response is returned'
+ def response = mvc.perform(get(cmHandleDetailsEndpoint)).andReturn().response
+ then: 'response status is OK'
response.status == HttpStatus.OK.value()
- and: 'the response contains the public properties'
- assertContainsPublicProperties(response)
- and: 'the response contains the cm handle state'
- assertContainsState(response)
- and: 'the content does not contain dmi properties'
- !response.contentAsString.contains("some DMI property")
+ and: 'the response contains the rest version of the cm handle'
+ assert response.contentAsString.contains('rest version of the cm handle')
}
- def 'Get Cm Handle public properties by Cm Handle id.'() {
+ def 'Get Cm Handle public properties by Cm Handle Reference.'() {
given: 'a cm handle properties endpoint'
- def cmHandlePropertiesEndpoint = "$ncmpBasePathV1/ch/some-cm-handle/properties"
+ def cmHandlePropertiesEndpoint = "$ncmpBasePathV1/ch/some-cm-handle-reference/properties"
and: 'some cm handle public properties'
def publicProperties = ['public prop': 'some public property']
and: 'the service method is invoked with the cm handle id returning the cm handle public properties'
- 1 * mockNetworkCmProxyDataService
- .getCmHandlePublicProperties('some-cm-handle') >> publicProperties
+ 1 * mockNetworkCmProxyInventoryFacade.getPublicCmHandleProperties('some-cm-handle-reference') >> publicProperties
when: 'the cm handle properties api is invoked'
- def response = mvc.perform(
- get(cmHandlePropertiesEndpoint)).andReturn().response
+ def response = mvc.perform(get(cmHandlePropertiesEndpoint)).andReturn().response
then: 'the correct response is returned'
- response.status == HttpStatus.OK.value()
+ assert response.status == HttpStatus.OK.value()
and: 'the response contains the public properties'
assertContainsPublicProperties(response)
}
- def 'Get Cm Handle composite state by Cm Handle id.'() {
+ def 'Get Cm Handle composite state by Cm Handle Reference.'() {
given: 'a cm handle state endpoint'
- def cmHandlePropertiesEndpoint = "$ncmpBasePathV1/ch/some-cm-handle/state"
+ def cmHandlePropertiesEndpoint = "$ncmpBasePathV1/ch/some-cm-handle-reference/state"
and: 'some cm handle composite state'
def compositeState = compositeStateTestObject()
and: 'the service method is invoked with the cm handle id returning the cm handle composite state'
- 1 * mockNetworkCmProxyDataService
- .getCmHandleCompositeState('some-cm-handle') >> compositeState
+ 1 * mockNetworkCmProxyInventoryFacade.getCmHandleCompositeState('some-cm-handle-reference') >> compositeState
when: 'the cm handle state api is invoked'
- def response = mvc.perform(
- get(cmHandlePropertiesEndpoint)).andReturn().response
+ def response = mvc.perform(get(cmHandlePropertiesEndpoint)).andReturn().response
then: 'the correct response is returned'
response.status == HttpStatus.OK.value()
and: 'the response contains the cm handle state'
- assertContainsState(response)
+ assert assertContainsState(response)
}
def 'Call execute cm handle searches with unrecognized condition name.'() {
- given: 'an endpoint and json data'
+ given: 'the search endpoint and a request with an unrecognized condition name'
def searchesEndpoint = "$ncmpBasePathV1/ch/searches"
String jsonString = TestUtils.getResourceFileContent('invalid-cmhandle-search.json')
- and: 'the service method is invoked with module names and returns two cm handles'
- def cmHandel1 = new NcmpServiceCmHandle()
- cmHandel1.cmHandleId = 'ch-1'
- cmHandel1.publicProperties = [color: 'yellow']
- def cmHandel2 = new NcmpServiceCmHandle()
- cmHandel2.cmHandleId = 'ch-2'
- cmHandel2.publicProperties = [color: 'green']
- mockNetworkCmProxyDataService.executeCmHandleSearch(_) >> [cmHandel1, cmHandel2]
- and: 'map for trust level per cmHandle has values'
- trustLevelPerCmHandle.put('ch-1', TrustLevel.COMPLETE)
- trustLevelPerCmHandle.put('ch-2', TrustLevel.NONE)
when: 'the searches api is invoked'
- def response = mvc.perform(
- post(searchesEndpoint)
- .contentType(MediaType.APPLICATION_JSON)
- .content(jsonString)).andReturn().response
- then: 'an empty cm handle identifier is returned'
- response.contentAsString == '[{"cmHandle":"ch-1","publicCmHandleProperties":[{"color":"yellow"}],"state":null,"trustLevel":"COMPLETE"},{"cmHandle":"ch-2","publicCmHandleProperties":[{"color":"green"}],"state":null,"trustLevel":"NONE"}]'
+ mvc.perform(post(searchesEndpoint).contentType(MediaType.APPLICATION_JSON).content(jsonString))
+ then: 'the request was still accepted and forwarded to the correct services'
+ 1 * mockNetworkCmProxyInventoryFacade.northboundCmHandleSearch(_) >> Flux.fromIterable([new NcmpServiceCmHandle()])
+ 1 * mockRestOutputCmHandleMapper.toRestOutputCmHandle(_, _) >> new RestOutputCmHandle(cmHandle: 'some cm handle')
}
def 'Query for cm handles matching query parameters'() {
given: 'an endpoint and json data'
def searchesEndpoint = "$ncmpBasePathV1/ch/id-searches"
and: 'the service method is invoked with module names and returns cm handle ids'
- 1 * mockNetworkCmProxyDataService.executeCmHandleIdSearch(_) >> ['ch-1', 'ch-2']
+ 1 * mockNetworkCmProxyInventoryFacade.northboundCmHandleIdSearch(_, _) >> ['ch-1', 'ch-2']
when: 'the searches api is invoked'
- def response = mvc.perform(
- post(searchesEndpoint)
- .contentType(MediaType.APPLICATION_JSON)
- .content('{}')).andReturn().response
+ def response = mvc.perform(post(searchesEndpoint).contentType(MediaType.APPLICATION_JSON).content('{}')).andReturn().response
then: 'cm handle ids are returned'
- response.contentAsString == '["ch-1","ch-2"]'
+ assert response.contentAsString == '["ch-1","ch-2"]'
}
def 'Query for cm handles with invalid request payload'() {
when: 'the searches api is invoked'
def searchesEndpoint = "$ncmpBasePathV1/ch/id-searches"
def invalidInputData = '{invalidJson}'
- def response = mvc.perform(
- post(searchesEndpoint)
- .contentType(MediaType.APPLICATION_JSON)
- .content(invalidInputData)).andReturn().response
+ def response = mvc.perform(post(searchesEndpoint).contentType(MediaType.APPLICATION_JSON).content(invalidInputData)).andReturn().response
then: 'BAD_REQUEST is returned'
- response.getStatus() == 400
+ assert response.getStatus() == 400
}
def 'Patch resource data in pass-through running datastore.'() {
given: 'patch resource data url'
- def url = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-running" +
- "?resourceIdentifier=parent/child"
+ def url = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-running?resourceIdentifier=parent/child"
when: 'patch data resource request is performed'
- def response = mvc.perform(
- patch(url)
- .contentType(MediaType.APPLICATION_JSON)
- .accept(MediaType.APPLICATION_JSON).content(requestBody)
- ).andReturn().response
+ def response = mvc.perform(patch(url).contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON).content(requestBody)).andReturn().response
then: 'ncmp service method to update resource is called'
- 1 * mockNetworkCmProxyDataService.writeResourceDataPassThroughRunningForCmHandle('testCmHandle',
- 'parent/child', PATCH, requestBody, 'application/json;charset=UTF-8', NO_AUTH_HEADER)
+ 1 * mockNetworkCmProxyFacade.writeResourceDataPassThroughRunningForCmHandle('testCmHandle', 'parent/child', PATCH, requestBody, 'application/json;charset=UTF-8', NO_AUTH_HEADER)
and: 'the response status is OK'
- response.status == HttpStatus.OK.value()
+ assert response.status == HttpStatus.OK.value()
}
def 'Delete resource data in pass-through running datastore.'() {
given: 'delete resource data url'
- def url = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-running" +
- "?resourceIdentifier=parent/child"
+ def url = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-running?resourceIdentifier=parent/child"
when: 'delete data resource request is performed'
- def response = mvc.perform(
- delete(url)
- .contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON)).andReturn().response
+ def response = mvc.perform(delete(url).contentType(MediaType.APPLICATION_JSON).accept(MediaType.APPLICATION_JSON)).andReturn().response
then: 'the ncmp service method to delete resource is called (with null as body)'
- 1 * mockNetworkCmProxyDataService.writeResourceDataPassThroughRunningForCmHandle('testCmHandle',
- 'parent/child', DELETE, null, 'application/json;charset=UTF-8', NO_AUTH_HEADER)
+ 1 * mockNetworkCmProxyFacade.writeResourceDataPassThroughRunningForCmHandle('testCmHandle', 'parent/child', DELETE, null, 'application/json;charset=UTF-8', NO_AUTH_HEADER)
and: 'the response is No Content'
- response.status == HttpStatus.NO_CONTENT.value()
- }
-
- def 'Get resource data from DMI with valid topic i.e. async request for #scenario'() {
- given: 'resource data url'
- def getUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:${datastoreInUrl}" +
- "?resourceIdentifier=parent/child&options=(a=1,b=2)&topic=my-topic-name"
- when: 'get data resource request is performed'
- def response = mvc.perform(
- get(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
- .accept(MediaType.APPLICATION_JSON_VALUE)
- ).andReturn().response
- then: 'async request id is generated'
- assert response.contentAsString.contains("requestId")
- where: 'the following parameters are used'
- scenario | datastoreInUrl
- ':passthrough-operational' | 'passthrough-operational'
- ':passthrough-running' | 'passthrough-running'
+ assert response.status == HttpStatus.NO_CONTENT.value()
}
def 'Getting module definitions for a module'() {
when: 'get module definition request is performed with module name'
- def response = mvc.perform(
- get("$ncmpBasePathV1/ch/some-cmhandle/modules/definitions?module-name=sampleModuleName"))
- .andReturn().response
+ def response = mvc.perform(get("$ncmpBasePathV1/ch/some-cmhandle/modules/definitions?module-name=sampleModuleName")).andReturn().response
then: 'ncmp service method is invoked with correct parameters'
- mockNetworkCmProxyDataService.getModuleDefinitionsByCmHandleAndModule('some-cmhandle', 'sampleModuleName', _)
- >> [new ModuleDefinition('sampleModuleName', '2021-10-03',
- 'module sampleModuleName{ sample module content }')]
+ mockNetworkCmProxyInventoryFacade.getModuleDefinitionsByCmHandleAndModule('some-cmhandle', 'sampleModuleName', _)
+ >> [new ModuleDefinition('sampleModuleName', '2021-10-03','module sampleModuleName{ sample module content }')]
and: 'response contains an array with the module name, revision and content'
response.getContentAsString() == '[{"moduleName":"sampleModuleName","revision":"2021-10-03","content":"module sampleModuleName{ sample module content }"}]'
and: 'response returns an OK http code'
- response.status == HttpStatus.OK.value()
+ assert response.status == HttpStatus.OK.value()
}
def 'Getting module definitions filtering on #scenario'() {
when: 'get module definition request is performed'
def response = mvc.perform(
- get("$ncmpBasePathV1/ch/some-cmhandle/modules/definitions?module-name=" + moduleName + "&revision=" + revision))
+ get("$ncmpBasePathV1/ch/some-cmhandle-reference/modules/definitions?module-name=" + moduleName + "&revision=" + revision))
.andReturn().response
- then: 'ncmp service method to get definitions by cm handle is invoked when needed'
- numberOfCallsToByCmHandleId * mockNetworkCmProxyDataService.getModuleDefinitionsByCmHandleId('some-cmhandle') >> []
+ then: 'ncmp service method to get definitions by cm handle reference is invoked when needed'
+ numberOfCallsToByCmHandleId * mockNetworkCmProxyInventoryFacade.getModuleDefinitionsByCmHandleReference('some-cmhandle-reference') >> []
and: 'ncmp service method to get definitions by module is invoked when needed'
- numberOfCallsToByModule * mockNetworkCmProxyDataService.getModuleDefinitionsByCmHandleAndModule('some-cmhandle', moduleName, revision) >> []
+ numberOfCallsToByModule * mockNetworkCmProxyInventoryFacade.getModuleDefinitionsByCmHandleAndModule('some-cmhandle-reference', moduleName, revision) >> []
and: 'response returns an OK http code'
response.status == HttpStatus.OK.value()
and: 'the correct message is logged when needed'
put("$ncmpBasePathV1/ch/some-cm-handle-id/data-sync?dataSyncEnabled=" + dataSyncEnabledFlag))
.andReturn().response
then: 'method to set data sync enabled is called'
- 1 * mockNetworkCmProxyDataService.setDataSyncEnabled('some-cm-handle-id', dataSyncEnabledFlag)
+ 1 * mockNetworkCmProxyInventoryFacade.setDataSyncEnabled('some-cm-handle-id', dataSyncEnabledFlag)
and: 'the response returns an OK http code'
response.status == HttpStatus.OK.value()
where: 'the following parameters are used'
'disabled' | false
}
- def 'Get Resource Data from operational with or without descendants'() {
- given: 'resource data url with descendants #enabled'
- def getUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:operational" +
- "?resourceIdentifier=parent/child&include-descendants=${booleanValue}"
- when: 'get data resource request is performed'
- def response = mvc.perform(
- get(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
- ).andReturn().response
- then: 'the NCMP data service is called with getResourceDataOperational with #descendantsOption'
- 1 * mockNetworkCmProxyDataService.getResourceDataForCmHandle(OPERATIONAL.datastoreName, 'testCmHandle', 'parent/child', descendantsOption)
- and: 'response status is Ok'
- response.status == HttpStatus.OK.value()
- where: 'the following parameters are used'
- booleanValue | descendantsOption
- false | OMIT_DESCENDANTS
- true | INCLUDE_ALL_DESCENDANTS
- }
-
def 'Attempt execute #operation rest operation on resource data with #scenario'() {
given: 'resource data url'
def url = "$ncmpBasePathV1/ch/testCmHandle/data/ds/${datastoreInUrl}?resourceIdentifier=parent/child"
'invalid datastore' | 'DELETE' | 'invalid'
}
+ def 'Ensure URI-encoded alternateId with slashes is accepted for #operation - #scenario'() {
+ given: 'A URI-encoded alternateId that includes slashes'
+ def alternateIdWithSlashes = '/some/cps/path'
+ def encodedAlternateId = URLEncoder.encode(alternateIdWithSlashes, 'UTF-8')
+ def url = "$ncmpBasePathV1/ch/${encodedAlternateId}/data/ds/ncmp-datastore:passthrough-running?resourceIdentifier=some-value"
+ when: 'A passthrough operation is executed on the URL containing the encoded alternateId'
+ def response = mvc.perform(executeRestOperation('POST', url)).andReturn().response
+ then: 'The API successfully processes the request and returns the expected HTTP status'
+ assert response.status == HttpStatus.CREATED.value()
+ }
+
def executeRestOperation(operation, url) {
if (operation == 'POST') {
return post(url).contentType(MediaType.APPLICATION_JSON_VALUE).content(requestBody)
Code Review / cps.git / blobdiff