Sonar code maintainability issues resolved.
Issue-ID: NONRTRIC-872
Change-Id: I94bbf5088f2808c9f9df5468ae4fef4a369723c5
Signed-off-by: aravind.est <aravindhan.a@est.tech>
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
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);
.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();
@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);
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)));
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)));
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)));
.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);
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();
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,
.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);
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();
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();
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();
.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);
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)));
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)));
.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);
.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)));
.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();
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)));
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();
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)));
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;
}
}
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
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());
}
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());
}
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
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);
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
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) {
}
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());
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));
}
}
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();
}
}
@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
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)));
@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();
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();
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)));
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);
@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();
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)));
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));
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();
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();
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);
@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();
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();
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)));
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();
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());
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));
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));
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));
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));