package org.onap.cps.ncmp.rest.controller
+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.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete
+import static org.onap.cps.ncmp.api.impl.operations.OperationType.CREATE
+import static org.onap.cps.ncmp.api.impl.operations.OperationType.UPDATE
+import static org.onap.cps.ncmp.api.impl.operations.OperationType.PATCH
+import static org.onap.cps.ncmp.api.impl.operations.OperationType.DELETE
+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.DatastoreType.OPERATIONAL
+import static org.onap.cps.spi.FetchDescendantsOption.OMIT_DESCENDANTS
+import static org.onap.cps.spi.FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS
+
import com.fasterxml.jackson.databind.ObjectMapper
import org.mapstruct.factory.Mappers
import org.onap.cps.TestUtils
import org.onap.cps.ncmp.api.NetworkCmProxyDataService
import org.onap.cps.ncmp.api.NetworkCmProxyQueryService
-import org.onap.cps.ncmp.api.inventory.CmHandleState
-import org.onap.cps.ncmp.api.inventory.CompositeState
-import org.onap.cps.ncmp.api.inventory.DataStoreSyncState
-import org.onap.cps.ncmp.api.inventory.LockReasonCategory
+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.rest.model.DataOperationRequest
import org.onap.cps.ncmp.rest.model.DataOperationDefinition
import org.onap.cps.ncmp.api.models.NcmpServiceCmHandle
import java.time.ZoneOffset
import java.time.format.DateTimeFormatter
-import static org.onap.cps.ncmp.api.inventory.CompositeState.DataStores
-import static org.onap.cps.ncmp.api.inventory.CompositeState.Operational
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete
-import static org.onap.cps.ncmp.api.impl.operations.OperationType.CREATE
-import static org.onap.cps.ncmp.api.impl.operations.OperationType.UPDATE
-import static org.onap.cps.ncmp.api.impl.operations.OperationType.PATCH
-import static org.onap.cps.ncmp.api.impl.operations.OperationType.DELETE
-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.DatastoreType.OPERATIONAL
-import static org.onap.cps.spi.FetchDescendantsOption.OMIT_DESCENDANTS;
-import static org.onap.cps.spi.FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS;
-
-
@WebMvcTest(NetworkCmProxyController)
class NetworkCmProxyControllerSpec extends Specification {
DataOperationRequestMapper dataOperationRequestMapper = Mappers.getMapper(DataOperationRequestMapper)
@SpringBean
- CpsNcmpTaskExecutor spiedCpsTaskExecutor = Spy()
+ Map<String, TrustLevel> trustLevelPerCmHandle = [:]
+
+ @SpringBean
+ CpsNcmpTaskExecutor mockCpsTaskExecutor = Mock()
@SpringBean
DeprecationHelper stubbedDeprecationHelper = Stub()
@SpringBean
- NcmpCachedResourceRequestHandler ncmpCachedResourceRequestHandler = new NcmpCachedResourceRequestHandler(spiedCpsTaskExecutor, mockNetworkCmProxyDataService, mockNetworkCmProxyQueryService)
+ NcmpCachedResourceRequestHandler ncmpCachedResourceRequestHandler = new NcmpCachedResourceRequestHandler(mockCpsTaskExecutor, mockNetworkCmProxyDataService, mockNetworkCmProxyQueryService)
@SpringBean
- NcmpPassthroughResourceRequestHandler ncmpPassthroughResourceRequestHandler = new NcmpPassthroughResourceRequestHandler(spiedCpsTaskExecutor, mockNetworkCmProxyDataService)
+ NcmpPassthroughResourceRequestHandler ncmpPassthroughResourceRequestHandler = new NcmpPassthroughResourceRequestHandler(mockCpsTaskExecutor, mockNetworkCmProxyDataService)
@Value('${rest.api.ncmp-base-path}/v1')
def ncmpBasePathV1
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)"
+ "?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)
+ 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)
+ 'parent/child','(a=1,b=2)', NO_TOPIC, NO_REQUEST_ID)
and: 'response status is Ok'
response.status == HttpStatus.OK.value()
}
- def 'Get Resource Data Async Topic Handling with #scenario.'() {
- given: 'resource data url'
- def getUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:passthrough-operational?resourceIdentifier=parent/child&${topicQueryParam}"
- 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'
- expectedNumberOfTaskExecutions * spiedCpsTaskExecutor.executeTask(_, TIMOUT_FOR_TEST)
- and: 'response status is OK'
- response.status == HttpStatus.OK.value()
- where: 'the following parameters are used'
- scenario | datastoreInUrl | topicQueryParam || expectedNumberOfTaskExecutions
- 'url with valid topic' | 'passthrough-operational' | '&topic=my-topic-name' || 1
- 'no topic in url' | 'passthrough-operational' | '' || 0
- 'null topic in url' | 'passthrough-operational' | '&topic=null' || 1
- }
-
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}"
+ "?resourceIdentifier=parent/child${additionalUrlParam}"
when: 'get data resource request is performed'
def response = mvc.perform(
- get(getUrl).contentType(MediaType.APPLICATION_JSON)).andReturn().response
+ 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)
and: 'response status is OK'
'options (ignored)' | '&options=(a-=1)' || OMIT_DESCENDANTS
}
- def 'Get Resource Data with invalid topic parameter: #scenario.'() {
- given: 'resource data url'
- def getUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:${datastoreInUrl}" +
- "?resourceIdentifier=parent/child&options=(a=1,b=2)${topicQueryParam}"
- when: 'get data resource (async) request is performed'
- def response = mvc.perform(
- get(getUrl).contentType(MediaType.APPLICATION_JSON)).andReturn().response
- then: 'abad request is returned'
- response.status == HttpStatus.BAD_REQUEST.value()
- where: 'the following parameters are used'
- scenario | datastoreInUrl | topicQueryParam
- 'empty topic in url' | 'passthrough-operational' | '&topic=\"\"'
- 'missing topic in url' | 'passthrough-operational' | '&topic='
- 'blank topic value in url' | 'passthrough-operational' | '&topic=\" \"'
- 'invalid non-empty topic value in url' | 'passthrough-operational' | '&topic=1_5_*_#'
- }
-
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 expectedDmiDataOperationRequest
- = jsonObjectMapper.convertJsonString(dataOperationRequestJsonData, org.onap.cps.ncmp.api.models.DataOperationRequest.class)
+ def dataOperationRequestJsonData = jsonObjectMapper.asJsonString(getDataOperationRequest("read", datastore.datastoreName))
when: 'post data operation request is performed'
def response = mvc.perform(
post(getUrl)
then: 'response status is Ok'
response.status == HttpStatus.OK.value()
and: 'async request id is generated'
- assert response.contentAsString.contains("requestId")
- then: 'wait a little to allow execution of service method by task executor (on separate thread)'
- Thread.sleep(100)
- then: 'the service has been invoked with the correct parameters '
- 1 * mockNetworkCmProxyDataService.executeDataOperationForCmHandles('my-topic-name', expectedDmiDataOperationRequest, _)
+ assert response.contentAsString.contains('requestId')
+ then: 'the request is handled asynchronously'
+ 1 * mockCpsTaskExecutor.executeTask(*_)
where: 'the following data stores are used'
datastore << [PASSTHROUGH_RUNNING, PASSTHROUGH_OPERATIONAL]
}
- def 'Execute (async) data operation for #scenario from dmi service.'() {
+ 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(operation, datastore))
+ getDataOperationRequest('read', 'invalid datastore'))
when: 'post data resource request is performed'
def response = mvc.perform(
post(getUrl)
).andReturn().response
then: 'response status is BAD_REQUEST'
response.status == HttpStatus.BAD_REQUEST.value()
- where: 'the following parameters are used'
- scenario | datastore | operation
- 'non-supported datastoreName' | OPERATIONAL.datastoreName | 'read'
- 'non-supported operation (passthrough-running)' | PASSTHROUGH_RUNNING.datastoreName | 'create'
- 'non-supported operation (passthrough-operational)' | PASSTHROUGH_OPERATIONAL.datastoreName | 'create'
}
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", datastore.datastoreName))
+ getDataOperationRequest("read", PASSTHROUGH_RUNNING.datastoreName))
ncmpPassthroughResourceRequestHandler.notificationFeatureEnabled = false
when: 'post data resource request is performed'
def response = mvc.perform(
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."}'
- where: 'the following data stores are used'
- datastore << [PASSTHROUGH_RUNNING, PASSTHROUGH_OPERATIONAL]
}
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"
+ "?cps-path=/cps/path"
when: 'the query data resource request is performed'
def response = mvc.perform(
- get(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
+ 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)
+ '/cps/path',
+ FetchDescendantsOption.OMIT_DESCENDANTS)
and: 'response status is Ok'
response.status == HttpStatus.OK.value()
}
- def 'Query Resource Data using datastore of #datastore'() {
+ def 'Query Resource Data with unsupported datastore'() {
given: 'the query resource data url'
- def getUrl = "$ncmpBasePathV1/ch/testCmHandle/data/ds/ncmp-datastore:${datastore}/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)
+ get(getUrl)
+ .contentType(MediaType.APPLICATION_JSON)
).andReturn().response
then: 'a 400 BAD_REQUEST is returned for the unsupported datastore'
response.status == 400
- and: 'the error message is that datastore #datastore is not supported'
- response.contentAsString.contains("ncmp-datastore:${datastore} is not supported")
- where: 'the following datastore is used'
- datastore << ["passthrough-running", "passthrough-operational"]
+ and: 'the error message is that the datastore is not supported'
+ 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)"
+ "?resourceIdentifier=" + resourceIdentifier + "&options=(a=1,b=2)"
and: 'ncmp service returns json object'
mockNetworkCmProxyDataService.getResourceDataForCmHandle(PASSTHROUGH_RUNNING.datastoreName, 'testCmHandle',
- resourceIdentifier,'(a=1,b=2)', NO_TOPIC, NO_REQUEST_ID) >> '{valid-json}'
+ resourceIdentifier,'(a=1,b=2)', NO_TOPIC, NO_REQUEST_ID) >> '{valid-json}'
when: 'get data resource request is performed'
def response = mvc.perform(
- get(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
+ get(getUrl)
+ .contentType(MediaType.APPLICATION_JSON)
).andReturn().response
then: 'response status is Ok'
response.status == HttpStatus.OK.value()
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"
+ "?resourceIdentifier=parent/child"
when: 'update data resource request is performed'
def response = mvc.perform(
- put(updateUrl)
- .contentType(MediaType.APPLICATION_JSON_VALUE).content(requestBody)
+ 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')
+ 'parent/child', UPDATE, requestBody, 'application/json;charset=UTF-8')
and: 'the response status is OK'
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"
+ "?resourceIdentifier=parent/child"
when: 'create resource request is performed'
def response = mvc.perform(
- post(url)
- .contentType(MediaType.APPLICATION_JSON_VALUE).content(requestBody)
+ 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')
+ 'parent/child', CREATE, requestBody, 'application/json;charset=UTF-8')
and: 'resource is created'
response.status == HttpStatus.CREATED.value()
}
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')]
+ >> [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'
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 = 'some-cmhandle-id1'
+ cmHandle1.cmHandleId = 'ch-1'
cmHandle1.publicProperties = [color: 'yellow']
def cmHandle2 = new NcmpServiceCmHandle()
- cmHandle2.cmHandleId = 'some-cmhandle-id2'
+ 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
+ .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":"some-cmhandle-id1","publicCmHandleProperties":[{"color":"yellow"}],"state":null},{"cmHandle":"some-cmhandle-id2","publicCmHandleProperties":[{"color":"green"}],"state":null}]'
+ 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.'() {
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 }
when: 'the cm handle details api is invoked'
def response = mvc.perform(
- get(cmHandleDetailsEndpoint)).andReturn().response
+ get(cmHandleDetailsEndpoint)).andReturn().response
then: 'the correct response is returned'
response.status == HttpStatus.OK.value()
and: 'the response contains the 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
+ .getCmHandlePublicProperties('some-cm-handle') >> publicProperties
when: 'the cm handle properties api is invoked'
def response = mvc.perform(
- get(cmHandlePropertiesEndpoint)).andReturn().response
+ get(cmHandlePropertiesEndpoint)).andReturn().response
then: 'the correct response is returned'
response.status == HttpStatus.OK.value()
and: 'the response contains the public properties'
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
+ .getCmHandleCompositeState('some-cm-handle') >> compositeState
when: 'the cm handle state api is invoked'
def response = mvc.perform(
- get(cmHandlePropertiesEndpoint)).andReturn().response
+ get(cmHandlePropertiesEndpoint)).andReturn().response
then: 'the correct response is returned'
response.status == HttpStatus.OK.value()
and: 'the response contains the cm handle state'
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 = 'some-cmhandle-id1'
+ cmHandel1.cmHandleId = 'ch-1'
cmHandel1.publicProperties = [color: 'yellow']
def cmHandel2 = new NcmpServiceCmHandle()
- cmHandel2.cmHandleId = 'some-cmhandle-id2'
+ 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
+ post(searchesEndpoint)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content(jsonString)).andReturn().response
then: 'an empty cm handle identifier is returned'
- response.contentAsString == '[{"cmHandle":"some-cmhandle-id1","publicCmHandleProperties":[{"color":"yellow"}],"state":null},{"cmHandle":"some-cmhandle-id2","publicCmHandleProperties":[{"color":"green"}],"state":null}]'
+ response.contentAsString == '[{"cmHandle":"ch-1","publicCmHandleProperties":[{"color":"yellow"}],"state":null,"trustLevel":"COMPLETE"},{"cmHandle":"ch-2","publicCmHandleProperties":[{"color":"green"}],"state":null,"trustLevel":"NONE"}]'
}
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(_) >> ['some-cmhandle-id1', 'some-cmhandle-id2']
+ 1 * mockNetworkCmProxyDataService.executeCmHandleIdSearch(_) >> ['ch-1', 'ch-2']
when: 'the searches api is invoked'
def response = mvc.perform(
- post(searchesEndpoint)
- .contentType(MediaType.APPLICATION_JSON)
- .content('{}')).andReturn().response
+ post(searchesEndpoint)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content('{}')).andReturn().response
then: 'cm handle ids are returned'
- response.contentAsString == '["some-cmhandle-id1","some-cmhandle-id2"]'
+ response.contentAsString == '["ch-1","ch-2"]'
}
def 'Query for cm handles with invalid request payload'() {
def searchesEndpoint = "$ncmpBasePathV1/ch/id-searches"
def invalidInputData = '{invalidJson}'
def response = mvc.perform(
- post(searchesEndpoint)
- .contentType(MediaType.APPLICATION_JSON)
- .content(invalidInputData)).andReturn().response
+ post(searchesEndpoint)
+ .contentType(MediaType.APPLICATION_JSON)
+ .content(invalidInputData)).andReturn().response
then: 'BAD_REQUEST is returned'
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"
+ "?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)
+ 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')
+ 'parent/child', PATCH, requestBody, 'application/json;charset=UTF-8')
and: 'the response status is OK'
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"
+ "?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
+ 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')
+ 'parent/child', DELETE, null, 'application/json;charset=UTF-8')
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"
+ "?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)
+ get(getUrl)
+ .contentType(MediaType.APPLICATION_JSON)
+ .accept(MediaType.APPLICATION_JSON_VALUE)
).andReturn().response
then: 'async request id is generated'
assert response.contentAsString.contains("requestId")
def 'Get module definitions based on cmHandleId.'() {
when: 'get module definition request is performed'
def response = mvc.perform(
- get("$ncmpBasePathV1/ch/some-cmhandle/modules/definitions"))
- .andReturn().response
+ get("$ncmpBasePathV1/ch/some-cmhandle/modules/definitions"))
+ .andReturn().response
then: 'ncmp service method to get module definitions is called'
mockNetworkCmProxyDataService.getModuleDefinitionsByCmHandleId('some-cmhandle')
- >> [new ModuleDefinition('sampleModuleName', '2021-10-03',
- 'module sampleModuleName{ sample module content }')]
+ >> [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'
def 'Set the data sync enabled based on the cm handle id and the data sync flag is #scenario'() {
when: 'the set data sync enabled request is invoked'
def response = mvc.perform(
- put("$ncmpBasePathV1/ch/some-cm-handle-id/data-sync?dataSyncEnabled=" + dataSyncEnabledFlag))
- .andReturn().response
+ 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)
and: 'the response returns an OK http code'
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=${enabled}"
+ "?resourceIdentifier=parent/child&include-descendants=${booleanValue}"
when: 'get data resource request is performed'
def response = mvc.perform(
- get(getUrl)
- .contentType(MediaType.APPLICATION_JSON)
+ 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'
- enabled | descendantsOption
- false | FetchDescendantsOption.OMIT_DESCENDANTS
- true | FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS
+ booleanValue | descendantsOption
+ false | OMIT_DESCENDANTS
+ true | INCLUDE_ALL_DESCENDANTS
}
def 'Attempt execute #operation rest operation on resource data with #scenario'() {
def url = "$ncmpBasePathV1/ch/testCmHandle/data/ds/${datastoreInUrl}?resourceIdentifier=parent/child"
when: 'selected request for data resource is performed on url'
def response = mvc.perform(
- executeRestOperation(operation, url))
- .andReturn().response
+ executeRestOperation(operation, url))
+ .andReturn().response
then: 'the response status is as expected'
assert response.status == HttpStatus.BAD_REQUEST.value()
and: 'the response is as expected'
def dataStores() {
DataStores.builder()
- .operationalDataStore(Operational.builder()
- .dataStoreSyncState(DataStoreSyncState.NONE_REQUESTED)
- .lastSyncTime(formattedDateAndTime.toString()).build()).build()
+ .operationalDataStore(Operational.builder()
+ .dataStoreSyncState(DataStoreSyncState.NONE_REQUESTED)
+ .lastSyncTime(formattedDateAndTime.toString()).build()).build()
}
def compositeStateTestObject() {
new CompositeState(cmHandleState: CmHandleState.ADVISED,
- lockReason: CompositeState.LockReason.builder().lockReasonCategory(LockReasonCategory.LOCKED_MODULE_SYNC_FAILED).details("lock details").build(),
- lastUpdateTime: formattedDateAndTime.toString(),
- dataSyncEnabled: false,
- dataStores: dataStores())
+ lockReason: CompositeState.LockReason.builder().lockReasonCategory(LockReasonCategory.MODULE_SYNC_FAILED).details("lock details").build(),
+ lastUpdateTime: formattedDateAndTime.toString(),
+ dataSyncEnabled: false,
+ dataStores: dataStores())
}
def assertContainsAll(response, assertContent) {
def assertContainsState(response) {
def expectedContent = [
- '"state":',
- '"cmHandleState":"ADVISED"',
- '"reason":"LOCKED_MISBEHAVING"',
- '"details":"lock details"',
- '"lastUpdateTime":"2022-12-31T20:30:40.000+0000"',
- '"dataSyncEnabled":false',
- '"dataSyncState":',
- '"operational":',
- '"syncState":"NONE_REQUESTED"',
- '"lastSyncTime":"2022-12-31T20:30:40.000+0000"',
- '"running":null'
+ '"state":',
+ '"cmHandleState":"ADVISED"',
+ '"lockReason":{"reason":"MODULE_SYNC_FAILED","details":"lock details"}',
+ '"lastUpdateTime":"2022-12-31T20:30:40.000+0000"',
+ '"dataSyncEnabled":false',
+ '"dataSyncState":',
+ '"operational":',
+ '"syncState":"NONE_REQUESTED"',
+ '"lastSyncTime":"2022-12-31T20:30:40.000+0000"',
+ '"running":null'
]
return assertContainsAll(response, expectedContent)
}
def assertContainsPublicProperties(response) {
def expectedContent = [
- '"publicCmHandleProperties":',
- '"public prop"',
- '"some public property"'
+ '"publicCmHandleProperties":',
+ '"public prop"',
+ '"some public property"'
]
return assertContainsAll(response, expectedContent)
}
Code Review / cps.git / blobdiff