Fix sonar code maintainability issues

Sonar code maintainability issues resolved.

Issue-ID: NONRTRIC-872
Change-Id: I94bbf5088f2808c9f9df5468ae4fef4a369723c5
Signed-off-by: aravind.est <aravindhan.a@est.tech>

diff --git a/rapp-manager-acm/src/test/java/com/oransc/rappmanager/acm/service/AcmDeployerTest.java b/rapp-manager-acm/src/test/java/com/oransc/rappmanager/acm/service/AcmDeployerTest.java
index 5f6b509..36e0ba4 100755 (executable)
--- a/rapp-manager-acm/src/test/java/com/oransc/rappmanager/acm/service/AcmDeployerTest.java
+++ b/rapp-manager-acm/src/test/java/com/oransc/rappmanager/acm/service/AcmDeployerTest.java
@@ -102,14 +102,14 @@ class AcmDeployerTest {
     RappResourceBuilder rappResourceBuilder = new RappResourceBuilder();
     private final String validRappFile = "valid-rapp-package.csar";
     String validCsarFileLocation = "src/test/resources/";
-    String URI_ACM_COMPOSITIONS, URI_ACM_COMPOSITION, URI_ACM_INSTANCES, URI_ACM_INSTANCE;
+    String uriAcmCompositions, uriAcmComposition, uriAcmInstances, uriAcmInstance;
 
     @BeforeAll
     void initACMURI() {
-        URI_ACM_COMPOSITIONS = acmConfiguration.getBaseUrl() + "compositions";
-        URI_ACM_COMPOSITION = acmConfiguration.getBaseUrl() + "compositions/%s";
-        URI_ACM_INSTANCES = acmConfiguration.getBaseUrl() + "compositions/%s/instances";
-        URI_ACM_INSTANCE = acmConfiguration.getBaseUrl() + "compositions/%s/instances/%s";
+        uriAcmCompositions = acmConfiguration.getBaseUrl() + "compositions";
+        uriAcmComposition = acmConfiguration.getBaseUrl() + "compositions/%s";
+        uriAcmInstances = acmConfiguration.getBaseUrl() + "compositions/%s/instances";
+        uriAcmInstance = acmConfiguration.getBaseUrl() + "compositions/%s/instances/%s";
     }
 
     @BeforeEach
@@ -128,7 +128,7 @@ class AcmDeployerTest {
 
         CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
         commissioningResponseExpected.setCompositionId(UUID.randomUUID());
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriAcmCompositions)).andExpect(method(HttpMethod.POST))
                 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                     .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
         CommissioningResponse commissioningResponseActual = acmDeployer.createComposition(compositionPayload);
@@ -143,7 +143,7 @@ class AcmDeployerTest {
                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
                             .rappResources(rappResources).build();
         String compositionPayload = rappCsarConfigurationHandler.getAcmCompositionPayload(rapp);
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriAcmCompositions)).andExpect(method(HttpMethod.POST))
                 .andRespond(withStatus(HttpStatus.BAD_GATEWAY));
         CommissioningResponse commissioningResponseActual = acmDeployer.createComposition(compositionPayload);
         mockServer.verify();
@@ -153,7 +153,7 @@ class AcmDeployerTest {
     @Test
     void testCompositionPriming() {
         UUID compositionId = UUID.randomUUID();
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
 
         acmDeployer.primeACMComposition(compositionId, PrimeOrder.PRIME);
@@ -171,7 +171,7 @@ class AcmDeployerTest {
         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
         InstantiationResponse instantiationResponse = new InstantiationResponse();
         instantiationResponse.setInstanceId(instanceId);
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCES, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmInstances, compositionId)))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.ACCEPTED).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(instantiationResponse)));
@@ -195,7 +195,7 @@ class AcmDeployerTest {
         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
         InstantiationResponse instantiationResponse = new InstantiationResponse();
         instantiationResponse.setInstanceId(instanceId);
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCES, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmInstances, compositionId)))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.ACCEPTED).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(instantiationResponse)));
@@ -215,7 +215,7 @@ class AcmDeployerTest {
         RappInstance rappInstance = rappResourceBuilder.getRappInstance();
         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
         InstantiationResponse instantiationResponse = new InstantiationResponse();
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCES, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmInstances, compositionId)))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.ACCEPTED).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(instantiationResponse)));
@@ -232,7 +232,7 @@ class AcmDeployerTest {
                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
         RappInstance rappInstance = rappResourceBuilder.getRappInstance();
         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCES, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmInstances, compositionId)))
                 .andExpect(method(HttpMethod.POST)).andRespond(withStatus(HttpStatus.BAD_GATEWAY));
 
         boolean rappDeployStateActual = acmDeployer.deployRappInstance(rapp, rappInstance);
@@ -251,13 +251,13 @@ class AcmDeployerTest {
         expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.DEPLOYED, LockState.LOCKED,
                 ExpectedCount.once());
 
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmInstance, compositionId, instanceId)))
                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
 
         expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.UNDEPLOYED, LockState.UNLOCKED,
                 ExpectedCount.once());
 
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmInstance, compositionId, instanceId)))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 
         RappInstance rappInstance = rappResourceBuilder.getRappInstance();
@@ -279,7 +279,7 @@ class AcmDeployerTest {
         expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.DEPLOYED, LockState.LOCKED,
                 ExpectedCount.once());
 
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmInstance, compositionId, instanceId)))
                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
 
         expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.UNDEPLOYING, LockState.UNLOCKING,
@@ -302,10 +302,10 @@ class AcmDeployerTest {
                             .state(RappState.PRIMED).build();
         expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.DEPLOYED, LockState.LOCKED,
                 ExpectedCount.once());
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmInstance, compositionId, instanceId)))
                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
         mockServer.expect(ExpectedCount.manyTimes(),
-                        requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId))).andExpect(method(HttpMethod.GET))
+                        requestTo(String.format(uriAcmInstance, compositionId, instanceId))).andExpect(method(HttpMethod.GET))
                 .andRespond(withServerError());
         RappInstance rappInstance = rappResourceBuilder.getRappInstance();
         rappInstance.getAcm().setAcmInstanceId(instanceId);
@@ -342,7 +342,7 @@ class AcmDeployerTest {
         UUID compositionId = UUID.randomUUID();
         UUID instanceId = UUID.randomUUID();
 
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmInstance, compositionId, instanceId)))
                 .andExpect(method(HttpMethod.GET)).andRespond(withStatus(HttpStatus.BAD_GATEWAY));
 
         RappInstance rappInstance = rappResourceBuilder.getRappInstance();
@@ -363,10 +363,10 @@ class AcmDeployerTest {
 
         CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
         commissioningResponseExpected.setCompositionId(compositionId);
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriAcmCompositions)).andExpect(method(HttpMethod.POST))
                 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                     .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
         boolean primeRapp = acmDeployer.primeRapp(rapp);
         mockServer.verify();
@@ -383,10 +383,10 @@ class AcmDeployerTest {
 
         CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
         commissioningResponseExpected.setCompositionId(compositionId);
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriAcmCompositions)).andExpect(method(HttpMethod.POST))
                 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                     .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
         boolean primeRapp = acmDeployer.primeRapp(rapp);
         mockServer.verify();
@@ -403,7 +403,7 @@ class AcmDeployerTest {
                             .compositionId(compositionId).rappResources(rappResources).build();
 
         CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriAcmCompositions)).andExpect(method(HttpMethod.POST))
                 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                     .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
         boolean primeRapp = acmDeployer.primeRapp(rapp);
@@ -421,15 +421,15 @@ class AcmDeployerTest {
 
         CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
         commissioningResponseExpected.setCompositionId(compositionId);
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
         AutomationCompositionDefinition automationCompositionDefinition =
                 getAutomationCompositionDefinition(compositionId, AcTypeState.COMMISSIONED);
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.GET)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
@@ -449,20 +449,20 @@ class AcmDeployerTest {
 
         CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
         commissioningResponseExpected.setCompositionId(compositionId);
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
         AutomationCompositionDefinition automationCompositionDefinition =
                 getAutomationCompositionDefinition(compositionId, AcTypeState.DEPRIMING);
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.GET)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
         automationCompositionDefinition = getAutomationCompositionDefinition(compositionId, AcTypeState.COMMISSIONED);
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.GET)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
@@ -480,15 +480,15 @@ class AcmDeployerTest {
                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
                             .compositionId(compositionId).rappResources(rappResources).build();
 
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
         AutomationCompositionDefinition automationCompositionDefinition =
                 getAutomationCompositionDefinition(compositionId, AcTypeState.COMMISSIONED);
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.GET)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
 
         boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
@@ -504,11 +504,11 @@ class AcmDeployerTest {
                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
                             .compositionId(compositionId).rappResources(rappResources).build();
 
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
         AutomationCompositionDefinition automationCompositionDefinition =
                 getAutomationCompositionDefinition(compositionId, AcTypeState.DEPRIMING);
-        mockServer.expect(ExpectedCount.manyTimes(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.manyTimes(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.GET)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
@@ -526,9 +526,9 @@ class AcmDeployerTest {
                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
                             .compositionId(compositionId).rappResources(rappResources).build();
 
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
-        mockServer.expect(ExpectedCount.manyTimes(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.manyTimes(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.GET)).andRespond(withServerError());
         boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
         mockServer.verify();
@@ -548,7 +548,7 @@ class AcmDeployerTest {
         UUID compositionId = UUID.randomUUID();
         CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
         commissioningResponseExpected.setCompositionId(compositionId);
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
@@ -562,7 +562,7 @@ class AcmDeployerTest {
         UUID compositionId = UUID.randomUUID();
         CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
         commissioningResponseExpected.setCompositionId(compositionId);
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriAcmComposition, compositionId)))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
         CommissioningResponse commissioningResponse = acmDeployer.deleteComposition(compositionId);
         mockServer.verify();
@@ -577,7 +577,7 @@ class AcmDeployerTest {
         automationCompositionDeployed.setDeployState(deployState);
         automationCompositionDeployed.setLockState(lockState);
 
-        mockServer.expect(expectedCount, requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
+        mockServer.expect(expectedCount, requestTo(String.format(uriAcmInstance, compositionId, instanceId)))
                 .andExpect(method(HttpMethod.GET)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(automationCompositionDeployed)));

diff --git a/rapp-manager-application/src/test/java/com/oransc/rappmanager/rest/RappInstanceControllerTest.java b/rapp-manager-application/src/test/java/com/oransc/rappmanager/rest/RappInstanceControllerTest.java
index 931901e..d237d2f 100755 (executable)
--- a/rapp-manager-application/src/test/java/com/oransc/rappmanager/rest/RappInstanceControllerTest.java
+++ b/rapp-manager-application/src/test/java/com/oransc/rappmanager/rest/RappInstanceControllerTest.java
@@ -299,10 +299,9 @@ class RappInstanceControllerTest {
         rappInstance.setState(RappInstanceState.UNDEPLOYED);
         Map<UUID, RappInstance> instances = new HashMap();
         instances.put(rappInstanceId, rappInstance);
-        Rapp rapp = Rapp.builder().rappId(rappId).name(String.valueOf(rappId)).packageName(validRappFile)
+        return Rapp.builder().rappId(rappId).name(String.valueOf(rappId)).packageName(validRappFile)
                             .packageLocation(validCsarFileLocation).state(RappState.PRIMED).rappInstances(instances)
                             .build();
-        return rapp;
     }
 
 }

diff --git a/rapp-manager-application/src/test/java/com/oransc/rappmanager/service/RappServiceTest.java b/rapp-manager-application/src/test/java/com/oransc/rappmanager/service/RappServiceTest.java
index 0627f68..672bda9 100755 (executable)
--- a/rapp-manager-application/src/test/java/com/oransc/rappmanager/service/RappServiceTest.java
+++ b/rapp-manager-application/src/test/java/com/oransc/rappmanager/service/RappServiceTest.java
@@ -75,7 +75,7 @@ class RappServiceTest {
 
     private final String validRappFile = "valid-rapp-package.csar";
 
-    private final String STATE_TRANSITION_NOT_PERMITTED = "State transition from %s to %s is not permitted.";
+    private final String stateTransitionNotPermitted = "State transition from %s to %s is not permitted.";
 
 
     @Test
@@ -97,7 +97,7 @@ class RappServiceTest {
         RappHandlerException rappHandlerException =
                 assertThrows(RappHandlerException.class, () -> rappService.primeRapp(rapp));
         assertEquals(HttpStatus.BAD_REQUEST, rappHandlerException.getStatusCode());
-        assertEquals(String.format(STATE_TRANSITION_NOT_PERMITTED, RappState.PRIMING, RappState.PRIMED),
+        assertEquals(String.format(stateTransitionNotPermitted, RappState.PRIMING, RappState.PRIMED),
                 rappHandlerException.getMessage());
         assertEquals(RappState.PRIMING, rapp.getState());
     }
@@ -194,7 +194,7 @@ class RappServiceTest {
         RappHandlerException rappHandlerException =
                 assertThrows(RappHandlerException.class, () -> rappService.deprimeRapp(rapp));
         assertEquals(HttpStatus.BAD_REQUEST, rappHandlerException.getStatusCode());
-        assertEquals(String.format(STATE_TRANSITION_NOT_PERMITTED, RappState.COMMISSIONED, RappState.COMMISSIONED),
+        assertEquals(String.format(stateTransitionNotPermitted, RappState.COMMISSIONED, RappState.COMMISSIONED),
                 rappHandlerException.getMessage());
         assertEquals(RappState.COMMISSIONED, rapp.getState());
     }

diff --git a/rapp-manager-dme/src/test/java/com/oransc/rappmanager/dme/service/DmeAcmInterceptorTest.java b/rapp-manager-dme/src/test/java/com/oransc/rappmanager/dme/service/DmeAcmInterceptorTest.java
index 005afcc..eaee4b7 100755 (executable)
--- a/rapp-manager-dme/src/test/java/com/oransc/rappmanager/dme/service/DmeAcmInterceptorTest.java
+++ b/rapp-manager-dme/src/test/java/com/oransc/rappmanager/dme/service/DmeAcmInterceptorTest.java
@@ -57,7 +57,7 @@ class DmeAcmInterceptorTest {
     DmeAcmInterceptor dmeAcmInterceptor;
 
     RappDmeResourceBuilder rappDmeResourceBuilder = new RappDmeResourceBuilder();
-    private static final String validRappFile = "valid-rapp-package.csar";
+    private static final String VALID_RAPP_FILE = "valid-rapp-package.csar";
     String validCsarFileLocation = "src/test/resources/";
 
     @ParameterizedTest
@@ -68,7 +68,7 @@ class DmeAcmInterceptorTest {
                 new HashMap<>(Map.of(UUID.randomUUID(), new AutomationCompositionElement()));
         automationComposition.setElements(elements);
         assertEquals(1, automationComposition.getElements().size());
-        Rapp rApp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
+        Rapp rApp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(VALID_RAPP_FILE)
                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
                             .rappResources(rappDmeResourceBuilder.getResources()).build();
         dmeAcmInterceptor.injectAutomationComposition(automationComposition, rApp, rAppInstance);

diff --git a/rapp-manager-dme/src/test/java/com/oransc/rappmanager/dme/service/DmeDeployerTest.java b/rapp-manager-dme/src/test/java/com/oransc/rappmanager/dme/service/DmeDeployerTest.java
index f3080e5..ab0c5f5 100755 (executable)
--- a/rapp-manager-dme/src/test/java/com/oransc/rappmanager/dme/service/DmeDeployerTest.java
+++ b/rapp-manager-dme/src/test/java/com/oransc/rappmanager/dme/service/DmeDeployerTest.java
@@ -82,19 +82,19 @@ class DmeDeployerTest {
 
     RappDmeResourceBuilder rappDmeResourceBuilder = new RappDmeResourceBuilder();
 
-    private static final String validRappFile = "valid-rapp-package.csar";
-    private static final String validRappFileNewInfoType = "valid-rapp-package-new-info-type.csar";
+    private static final String VALID_RAPP_FILE = "valid-rapp-package.csar";
+    private static final String VALID_RAPP_FILE_NEW_INFO_TYPE = "valid-rapp-package-new-info-type.csar";
     String validCsarFileLocation = "src/test/resources/";
     ObjectMapper objectMapper = new ObjectMapper();
 
-    String URI_INFO_TYPES, URI_INFO_TYPE, URI_INFO_PRODUCER, URI_INFO_CONSUMER;
+    String uriInfoTypes, uriInfoType, uriInfoProducer, uriInfoConsumer;
 
     @BeforeAll
     void initACMURI() {
-        URI_INFO_TYPES = dmeConfiguration.getBaseUrl() + "/data-producer/v1/info-types";
-        URI_INFO_TYPE = dmeConfiguration.getBaseUrl() + "/data-producer/v1/info-types/%s";
-        URI_INFO_PRODUCER = dmeConfiguration.getBaseUrl() + "/data-producer/v1/info-producers/%s";
-        URI_INFO_CONSUMER = dmeConfiguration.getBaseUrl() + "/data-consumer/v1/info-jobs/%s";
+        uriInfoTypes = dmeConfiguration.getBaseUrl() + "/data-producer/v1/info-types";
+        uriInfoType = dmeConfiguration.getBaseUrl() + "/data-producer/v1/info-types/%s";
+        uriInfoProducer = dmeConfiguration.getBaseUrl() + "/data-producer/v1/info-producers/%s";
+        uriInfoConsumer = dmeConfiguration.getBaseUrl() + "/data-consumer/v1/info-jobs/%s";
     }
 
     @BeforeEach
@@ -111,11 +111,11 @@ class DmeDeployerTest {
         rapp.setPackageName(rappFile);
         rapp.setRappResources(rappResources);
         List<String> infoTypes = List.of();
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_INFO_TYPES)).andExpect(method(HttpMethod.GET)).andRespond(
+        mockServer.expect(ExpectedCount.once(), requestTo(uriInfoTypes)).andExpect(method(HttpMethod.GET)).andRespond(
                 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                         .body(objectMapper.writeValueAsString(infoTypes)));
         assertTrue(dmeDeployer.primeRapp(rapp));
-        if (rappFile.equals(validRappFileNewInfoType)) {
+        if (rappFile.equals(VALID_RAPP_FILE_NEW_INFO_TYPE)) {
             mockServer.verify();
         }
         if (isSuccess) {
@@ -126,22 +126,22 @@ class DmeDeployerTest {
     }
 
     private static Stream<Arguments> getSuccessParamsWithUnavailableInfoTypes() {
-        return Stream.of(Arguments.of(validRappFile, true), Arguments.of(validRappFileNewInfoType, false));
+        return Stream.of(Arguments.of(VALID_RAPP_FILE, true), Arguments.of(VALID_RAPP_FILE_NEW_INFO_TYPE, false));
     }
 
     @ParameterizedTest
-    @ValueSource(strings = {validRappFile, validRappFileNewInfoType})
+    @ValueSource(strings = {VALID_RAPP_FILE, VALID_RAPP_FILE_NEW_INFO_TYPE})
     void testPrimeRappSuccessWithValidInfoType(String rappFile) throws JsonProcessingException {
         RappResources rappResources = rappDmeResourceBuilder.getResources();
         Rapp rapp = getRapp(Optional.empty());
         rapp.setPackageName(rappFile);
         rapp.setRappResources(rappResources);
         List<String> infoTypes = List.of("new-info-type-not-available");
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_INFO_TYPES)).andExpect(method(HttpMethod.GET)).andRespond(
+        mockServer.expect(ExpectedCount.once(), requestTo(uriInfoTypes)).andExpect(method(HttpMethod.GET)).andRespond(
                 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                         .body(objectMapper.writeValueAsString(infoTypes)));
         assertTrue(dmeDeployer.primeRapp(rapp));
-        if (rappFile.equals(validRappFileNewInfoType)) {
+        if (rappFile.equals(VALID_RAPP_FILE_NEW_INFO_TYPE)) {
             mockServer.verify();
         }
         assertNull(rapp.getReason());
@@ -152,7 +152,7 @@ class DmeDeployerTest {
         RappResources rappResources = rappDmeResourceBuilder.getResources();
         rappResources.setDme(null);
         Rapp rapp = getRapp(Optional.empty());
-        rapp.setPackageName(validRappFile);
+        rapp.setPackageName(VALID_RAPP_FILE);
         rapp.setRappResources(rappResources);
         assertTrue(dmeDeployer.primeRapp(rapp));
     }
@@ -194,7 +194,7 @@ class DmeDeployerTest {
     }
 
     Rapp getRapp(Optional<UUID> rappOptional) {
-        return Rapp.builder().rappId(rappOptional.orElse(UUID.randomUUID())).name("").packageName(validRappFile)
+        return Rapp.builder().rappId(rappOptional.orElse(UUID.randomUUID())).name("").packageName(VALID_RAPP_FILE)
                        .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
     }
 }

diff --git a/rapp-manager-sme/src/test/java/com/oransc/rappmanager/sme/service/SmeDeployerTest.java b/rapp-manager-sme/src/test/java/com/oransc/rappmanager/sme/service/SmeDeployerTest.java
index 3daab9e..50307a5 100755 (executable)
--- a/rapp-manager-sme/src/test/java/com/oransc/rappmanager/sme/service/SmeDeployerTest.java
+++ b/rapp-manager-sme/src/test/java/com/oransc/rappmanager/sme/service/SmeDeployerTest.java
@@ -84,20 +84,20 @@ class SmeDeployerTest {
     @Autowired
     ObjectMapper objectMapper;
     private final String validRappFile = "valid-rapp-package.csar";
-    String URI_PROVIDER_REGISTRATIONS, URI_PROVIDER_REGISTRATION, URI_PUBLISH_APIS, URI_PUBLISH_API, URI_INVOKERS,
-            URI_INVOKER;
+    String uriProviderRegistrations, uriProviderRegistration, uriPublishApis, uriPublishApi, uriInvokers,
+            uriInvoker;
 
     @BeforeAll
     void initSmeUri() {
-        URI_PROVIDER_REGISTRATIONS =
+        uriProviderRegistrations =
                 smeConfiguration.getBaseUrl() + smeConfiguration.getProviderBasePath() + "registrations";
-        URI_PROVIDER_REGISTRATION =
+        uriProviderRegistration =
                 smeConfiguration.getBaseUrl() + smeConfiguration.getProviderBasePath() + "registrations/%s";
-        URI_PUBLISH_APIS = smeConfiguration.getBaseUrl() + smeConfiguration.getPublishApiBasePath() + "%s/service-apis";
-        URI_PUBLISH_API =
+        uriPublishApis = smeConfiguration.getBaseUrl() + smeConfiguration.getPublishApiBasePath() + "%s/service-apis";
+        uriPublishApi =
                 smeConfiguration.getBaseUrl() + smeConfiguration.getPublishApiBasePath() + "%s/service-apis/%s";
-        URI_INVOKERS = smeConfiguration.getBaseUrl() + smeConfiguration.getInvokerBasePath() + "onboardedInvokers";
-        URI_INVOKER = smeConfiguration.getBaseUrl() + smeConfiguration.getInvokerBasePath() + "onboardedInvokers/%s";
+        uriInvokers = smeConfiguration.getBaseUrl() + smeConfiguration.getInvokerBasePath() + "onboardedInvokers";
+        uriInvoker = smeConfiguration.getBaseUrl() + smeConfiguration.getInvokerBasePath() + "onboardedInvokers/%s";
     }
 
     @BeforeEach
@@ -109,7 +109,7 @@ class SmeDeployerTest {
     void testCreateAMF() throws JsonProcessingException {
         String apiProvDomId = UUID.randomUUID().toString();
         APIProviderEnrolmentDetails apiProviderEnrolmentDetails = new APIProviderEnrolmentDetails(apiProvDomId);
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriProviderRegistrations))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
@@ -120,7 +120,7 @@ class SmeDeployerTest {
 
     @Test
     void testCreateAMFFailure() {
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriProviderRegistrations))
                 .andExpect(method(HttpMethod.POST)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
         APIProviderEnrolmentDetails apiProviderEnrolmentResponse = smeDeployer.createAMF();
         mockServer.verify();
@@ -131,11 +131,11 @@ class SmeDeployerTest {
     void testDeleteAMF() throws JsonProcessingException {
         String apiProvDomId = UUID.randomUUID().toString();
         APIProviderEnrolmentDetails apiProviderEnrolmentDetails = new APIProviderEnrolmentDetails(apiProvDomId);
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriProviderRegistrations))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PROVIDER_REGISTRATION, apiProvDomId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriProviderRegistration, apiProvDomId)))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         smeDeployer.createAMF();
         smeDeployer.deleteAMF();
@@ -149,7 +149,7 @@ class SmeDeployerTest {
                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
                         .state(RappState.COMMISSIONED).build();
         APIProviderEnrolmentDetails apiProviderEnrolmentDetails = getProviderDomainApiEnrollmentDetails();
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriProviderRegistrations))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
@@ -165,7 +165,7 @@ class SmeDeployerTest {
         Rapp rapp =
                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
                         .state(RappState.COMMISSIONED).build();
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriProviderRegistrations))
                 .andExpect(method(HttpMethod.POST)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
         RappInstance rappInstance = getRappInstance();
         boolean createProviderDomain = smeDeployer.createProviderDomain(rapp, rappInstance);
@@ -176,7 +176,7 @@ class SmeDeployerTest {
     @Test
     void testDeleteProviderFunc() {
         UUID registrationId = UUID.randomUUID();
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PROVIDER_REGISTRATION, registrationId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriProviderRegistration, registrationId)))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         smeDeployer.deleteProviderFunc(String.valueOf(registrationId));
         mockServer.verify();
@@ -190,7 +190,7 @@ class SmeDeployerTest {
                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
                         .state(RappState.COMMISSIONED).build();
         ServiceAPIDescription serviceAPIDescription = getServiceApiDescription();
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_APIS, apfId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriPublishApis, apfId)))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(serviceAPIDescription)));
@@ -209,7 +209,7 @@ class SmeDeployerTest {
         Rapp rapp =
                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
                         .state(RappState.COMMISSIONED).build();
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_APIS, apfId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriPublishApis, apfId)))
                 .andExpect(method(HttpMethod.POST)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
         RappInstance rappInstance = getRappInstance();
         rappInstance.getSme().setApfId(String.valueOf(apfId));
@@ -222,7 +222,7 @@ class SmeDeployerTest {
     void testDeletePublishApi() {
         String serviceApiId = String.valueOf(UUID.randomUUID());
         String apfId = String.valueOf(UUID.randomUUID());
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApiId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriPublishApi, apfId, serviceApiId)))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         smeDeployer.deletePublishApi(serviceApiId, apfId);
         mockServer.verify();
@@ -235,7 +235,7 @@ class SmeDeployerTest {
                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
                         .state(RappState.COMMISSIONED).build();
         APIInvokerEnrolmentDetails apiInvokerEnrolmentDetails = getApiInvokerEnrollmentDetails();
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_INVOKERS)).andExpect(method(HttpMethod.POST)).andRespond(
+        mockServer.expect(ExpectedCount.once(), requestTo(uriInvokers)).andExpect(method(HttpMethod.POST)).andRespond(
                 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                         .body(objectMapper.writeValueAsString(apiInvokerEnrolmentDetails)));
         RappInstance rappInstance = getRappInstance();
@@ -250,7 +250,7 @@ class SmeDeployerTest {
         Rapp rapp =
                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
                         .state(RappState.COMMISSIONED).build();
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_INVOKERS)).andExpect(method(HttpMethod.POST))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriInvokers)).andExpect(method(HttpMethod.POST))
                 .andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
         RappInstance rappInstance = getRappInstance();
         boolean createInvoker = smeDeployer.createInvoker(rapp, rappInstance);
@@ -261,7 +261,7 @@ class SmeDeployerTest {
     @Test
     void testDeleteInvoker() {
         String invokerId = String.valueOf(UUID.randomUUID());
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokerId)))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriInvoker, invokerId)))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         smeDeployer.deleteInvoker(invokerId);
         mockServer.verify();
@@ -278,18 +278,18 @@ class SmeDeployerTest {
         Rapp rapp =
                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
                         .state(RappState.COMMISSIONED).build();
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriProviderRegistrations))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
         ServiceAPIDescription serviceAPIDescription = getServiceApiDescription();
         mockServer.expect(ExpectedCount.once(),
-                        requestTo(String.format(URI_PUBLISH_APIS, apfProviderFunctionDetails.getApiProvFuncId())))
+                        requestTo(String.format(uriPublishApis, apfProviderFunctionDetails.getApiProvFuncId())))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(serviceAPIDescription)));
         APIInvokerEnrolmentDetails apiInvokerEnrolmentDetails = getApiInvokerEnrollmentDetails();
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_INVOKERS)).andExpect(method(HttpMethod.POST)).andRespond(
+        mockServer.expect(ExpectedCount.once(), requestTo(uriInvokers)).andExpect(method(HttpMethod.POST)).andRespond(
                 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                         .body(objectMapper.writeValueAsString(apiInvokerEnrolmentDetails)));
         RappInstance rappInstance = getRappInstance();
@@ -310,13 +310,13 @@ class SmeDeployerTest {
         Rapp rapp =
                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
                         .state(RappState.COMMISSIONED).build();
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriProviderRegistrations))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
         ServiceAPIDescription serviceAPIDescription = getServiceApiDescription();
         mockServer.expect(ExpectedCount.once(),
-                        requestTo(String.format(URI_PUBLISH_APIS, apfProviderFunctionDetails.getApiProvFuncId())))
+                        requestTo(String.format(uriPublishApis, apfProviderFunctionDetails.getApiProvFuncId())))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(serviceAPIDescription)));
@@ -335,7 +335,7 @@ class SmeDeployerTest {
                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
                         .state(RappState.COMMISSIONED).build();
         APIInvokerEnrolmentDetails apiInvokerEnrolmentDetails = getApiInvokerEnrollmentDetails();
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_INVOKERS)).andExpect(method(HttpMethod.POST)).andRespond(
+        mockServer.expect(ExpectedCount.once(), requestTo(uriInvokers)).andExpect(method(HttpMethod.POST)).andRespond(
                 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                         .body(objectMapper.writeValueAsString(apiInvokerEnrolmentDetails)));
         RappInstance rappInstance = getRappInstance();
@@ -370,17 +370,17 @@ class SmeDeployerTest {
         Rapp rapp =
                 Rapp.builder().rappId(rappId).name("").packageName(validRappFile).packageLocation(validCsarFileLocation)
                         .state(RappState.COMMISSIONED).build();
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_PROVIDER_REGISTRATIONS))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriProviderRegistrations))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(apiProviderEnrolmentDetails)));
         ServiceAPIDescription serviceAPIDescription = getServiceApiDescription();
         mockServer.expect(ExpectedCount.once(),
-                        requestTo(String.format(URI_PUBLISH_APIS, apfProviderFunctionDetails.getApiProvFuncId())))
+                        requestTo(String.format(uriPublishApis, apfProviderFunctionDetails.getApiProvFuncId())))
                 .andExpect(method(HttpMethod.POST)).andRespond(
                         withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
                                 .body(objectMapper.writeValueAsString(serviceAPIDescription)));
-        mockServer.expect(ExpectedCount.once(), requestTo(URI_INVOKERS)).andExpect(method(HttpMethod.POST))
+        mockServer.expect(ExpectedCount.once(), requestTo(uriInvokers)).andExpect(method(HttpMethod.POST))
                 .andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
         RappInstance rappInstance = getRappInstance();
         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
@@ -399,19 +399,19 @@ class SmeDeployerTest {
                 String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
         Rapp rapp = Rapp.builder().rappId(rappId).name(rappId.toString()).packageName(validRappFile)
                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(0))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriInvoker, invokers.get(0))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(1))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriInvoker, invokers.get(1))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(0))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriPublishApi, apfId, serviceApis.get(0))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(1))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriPublishApi, apfId, serviceApis.get(1))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         mockServer.expect(ExpectedCount.once(),
-                        requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[0])))
+                        requestTo(String.format(uriProviderRegistration, providerFuncs.values().toArray()[0])))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         mockServer.expect(ExpectedCount.once(),
-                        requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[1])))
+                        requestTo(String.format(uriProviderRegistration, providerFuncs.values().toArray()[1])))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         RappInstance rappInstance = getRappInstance();
         rappInstance.getSme().setApfId(String.valueOf(apfId));
@@ -433,15 +433,15 @@ class SmeDeployerTest {
                 String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
         Rapp rapp = Rapp.builder().rappId(rappId).name(rappId.toString()).packageName(validRappFile)
                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(0))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriPublishApi, apfId, serviceApis.get(0))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(1))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriPublishApi, apfId, serviceApis.get(1))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         mockServer.expect(ExpectedCount.once(),
-                        requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[0])))
+                        requestTo(String.format(uriProviderRegistration, providerFuncs.values().toArray()[0])))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         mockServer.expect(ExpectedCount.once(),
-                        requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[1])))
+                        requestTo(String.format(uriProviderRegistration, providerFuncs.values().toArray()[1])))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         RappInstance rappInstance = getRappInstance();
         rappInstance.getSme().setApfId(String.valueOf(apfId));
@@ -461,9 +461,9 @@ class SmeDeployerTest {
         List<String> invokers = List.of(String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
         Rapp rapp = Rapp.builder().rappId(rappId).name(rappId.toString()).packageName(validRappFile)
                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(0))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriInvoker, invokers.get(0))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(1))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriInvoker, invokers.get(1))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         RappInstance rappInstance = getRappInstance();
         rappInstance.getSme().setApfId(String.valueOf(apfId));
@@ -496,19 +496,19 @@ class SmeDeployerTest {
                 String.valueOf(UUID.randomUUID()), String.valueOf(UUID.randomUUID()));
         Rapp rapp = Rapp.builder().rappId(rappId).name(rappId.toString()).packageName(validRappFile)
                             .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(0))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriInvoker, invokers.get(0))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_INVOKER, invokers.get(1))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriInvoker, invokers.get(1))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(0))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriPublishApi, apfId, serviceApis.get(0))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
-        mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_PUBLISH_API, apfId, serviceApis.get(1))))
+        mockServer.expect(ExpectedCount.once(), requestTo(String.format(uriPublishApi, apfId, serviceApis.get(1))))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         mockServer.expect(ExpectedCount.once(),
-                        requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[0])))
+                        requestTo(String.format(uriProviderRegistration, providerFuncs.values().toArray()[0])))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
         mockServer.expect(ExpectedCount.once(),
-                        requestTo(String.format(URI_PROVIDER_REGISTRATION, providerFuncs.values().toArray()[1])))
+                        requestTo(String.format(uriProviderRegistration, providerFuncs.values().toArray()[1])))
                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
         RappInstance rappInstance = getRappInstance();
         rappInstance.getSme().setApfId(String.valueOf(apfId));