2 * ============LICENSE_START======================================================================
3 * Copyright (C) 2023 Nordix Foundation. All rights reserved.
4 * Copyright (C) 2023 OpenInfra Foundation Europe. All rights reserved.
5 * ===============================================================================================
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 * ============LICENSE_END========================================================================
20 package com.oransc.rappmanager.acm.service;
22 import static org.junit.jupiter.api.Assertions.assertEquals;
23 import static org.junit.jupiter.api.Assertions.assertFalse;
24 import static org.junit.jupiter.api.Assertions.assertNull;
25 import static org.junit.jupiter.api.Assertions.assertTrue;
26 import static org.mockito.ArgumentMatchers.any;
27 import static org.mockito.Mockito.never;
28 import static org.mockito.Mockito.times;
29 import static org.mockito.Mockito.verify;
30 import static org.springframework.test.web.client.match.MockRestRequestMatchers.method;
31 import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
32 import static org.springframework.test.web.client.response.MockRestResponseCreators.withServerError;
33 import static org.springframework.test.web.client.response.MockRestResponseCreators.withStatus;
35 import com.fasterxml.jackson.core.JsonProcessingException;
36 import com.fasterxml.jackson.databind.ObjectMapper;
37 import com.oransc.rappmanager.acm.configuration.ACMConfiguration;
38 import com.oransc.rappmanager.dme.service.DmeAcmInterceptor;
39 import com.oransc.rappmanager.models.cache.RappCacheService;
40 import com.oransc.rappmanager.models.csar.RappCsarConfigurationHandler;
41 import com.oransc.rappmanager.models.rapp.Rapp;
42 import com.oransc.rappmanager.models.rapp.RappEvent;
43 import com.oransc.rappmanager.models.rapp.RappResourceBuilder;
44 import com.oransc.rappmanager.models.rapp.RappResources;
45 import com.oransc.rappmanager.models.rapp.RappState;
46 import com.oransc.rappmanager.models.rappinstance.RappInstance;
47 import com.oransc.rappmanager.models.statemachine.RappInstanceStateMachine;
48 import com.oransc.rappmanager.models.statemachine.RappInstanceStateMachineConfig;
49 import java.io.IOException;
50 import java.util.UUID;
51 import java.util.stream.Stream;
52 import org.junit.jupiter.api.BeforeAll;
53 import org.junit.jupiter.api.BeforeEach;
54 import org.junit.jupiter.api.Test;
55 import org.junit.jupiter.api.TestInstance;
56 import org.junit.jupiter.params.ParameterizedTest;
57 import org.junit.jupiter.params.provider.Arguments;
58 import org.junit.jupiter.params.provider.MethodSource;
59 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
60 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
61 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
62 import org.onap.policy.clamp.models.acm.concepts.DeployState;
63 import org.onap.policy.clamp.models.acm.concepts.LockState;
64 import org.onap.policy.clamp.models.acm.messages.rest.commissioning.CommissioningResponse;
65 import org.onap.policy.clamp.models.acm.messages.rest.commissioning.PrimeOrder;
66 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse;
67 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
68 import org.springframework.beans.factory.annotation.Autowired;
69 import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
70 import org.springframework.boot.test.context.SpringBootTest;
71 import org.springframework.boot.test.mock.mockito.SpyBean;
72 import org.springframework.http.HttpMethod;
73 import org.springframework.http.HttpStatus;
74 import org.springframework.http.MediaType;
75 import org.springframework.test.web.client.ExpectedCount;
76 import org.springframework.test.web.client.MockRestServiceServer;
77 import org.springframework.web.client.RestTemplate;
80 classes = {BeanTestConfiguration.class, ACMConfiguration.class, AcmDeployer.class, DmeAcmInterceptor.class,
81 RappCsarConfigurationHandler.class, RappCacheService.class, RappInstanceStateMachineConfig.class,
82 RappInstanceStateMachine.class})
83 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
85 class AcmDeployerTest {
87 MockRestServiceServer mockServer;
89 AcmDeployer acmDeployer;
91 RestTemplate restTemplate;
93 ACMConfiguration acmConfiguration;
95 RappInstanceStateMachine rappInstanceStateMachine;
97 RappCsarConfigurationHandler rappCsarConfigurationHandler;
99 ObjectMapper objectMapper;
101 RappResourceBuilder rappResourceBuilder = new RappResourceBuilder();
102 private final String validRappFile = "valid-rapp-package.csar";
103 String validCsarFileLocation = "src/test/resources/";
104 String URI_ACM_COMPOSITIONS, URI_ACM_COMPOSITION, URI_ACM_INSTANCES, URI_ACM_INSTANCE;
108 URI_ACM_COMPOSITIONS = acmConfiguration.getBaseUrl() + "compositions";
109 URI_ACM_COMPOSITION = acmConfiguration.getBaseUrl() + "compositions/%s";
110 URI_ACM_INSTANCES = acmConfiguration.getBaseUrl() + "compositions/%s/instances";
111 URI_ACM_INSTANCE = acmConfiguration.getBaseUrl() + "compositions/%s/instances/%s";
116 mockServer = MockRestServiceServer.createServer(restTemplate);
120 void testCreateComposition() throws IOException {
121 RappResources rappResources = rappResourceBuilder.getResources();
122 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
123 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
124 .rappResources(rappResources).build();
126 String compositionPayload = rappCsarConfigurationHandler.getAcmCompositionPayload(rapp);
128 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
129 commissioningResponseExpected.setCompositionId(UUID.randomUUID());
130 mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
131 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
132 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
133 CommissioningResponse commissioningResponseActual = acmDeployer.createComposition(compositionPayload);
135 assertEquals(commissioningResponseActual.getCompositionId(), commissioningResponseExpected.getCompositionId());
139 void testCreateCompositionFailure() {
140 RappResources rappResources = rappResourceBuilder.getResources();
141 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
142 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
143 .rappResources(rappResources).build();
144 String compositionPayload = rappCsarConfigurationHandler.getAcmCompositionPayload(rapp);
145 mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
146 .andRespond(withStatus(HttpStatus.BAD_GATEWAY));
147 CommissioningResponse commissioningResponseActual = acmDeployer.createComposition(compositionPayload);
149 assertNull(commissioningResponseActual);
153 void testCompositionPriming() {
154 UUID compositionId = UUID.randomUUID();
155 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
156 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
158 acmDeployer.primeACMComposition(compositionId, PrimeOrder.PRIME);
163 void testDeployRappInstance() throws Exception {
165 UUID compositionId = UUID.randomUUID();
166 UUID rappId = UUID.randomUUID();
167 UUID instanceId = UUID.randomUUID();
168 Rapp rapp = Rapp.builder().name("").packageName(validRappFile).compositionId(compositionId)
169 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
170 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
171 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
172 InstantiationResponse instantiationResponse = new InstantiationResponse();
173 instantiationResponse.setInstanceId(instanceId);
174 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCES, compositionId)))
175 .andExpect(method(HttpMethod.POST)).andRespond(
176 withStatus(HttpStatus.ACCEPTED).contentType(MediaType.APPLICATION_JSON)
177 .body(objectMapper.writeValueAsString(instantiationResponse)));
178 mockServer.expect(ExpectedCount.once(),
179 requestTo(acmConfiguration.getBaseUrl() + "compositions/" + compositionId + "/instances/" + instanceId))
180 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
181 boolean rappDeployStateActual = acmDeployer.deployRappInstance(rapp, rappInstance);
182 assertTrue(rappDeployStateActual);
187 void testDeployRappInstanceFailureWithNoInstanceId() throws JsonProcessingException {
188 UUID compositionId = UUID.randomUUID();
189 UUID rappId = UUID.randomUUID();
190 Rapp rapp = Rapp.builder().name("").packageName(validRappFile).compositionId(compositionId)
191 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
192 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
193 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
194 InstantiationResponse instantiationResponse = new InstantiationResponse();
195 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCES, compositionId)))
196 .andExpect(method(HttpMethod.POST)).andRespond(
197 withStatus(HttpStatus.ACCEPTED).contentType(MediaType.APPLICATION_JSON)
198 .body(objectMapper.writeValueAsString(instantiationResponse)));
200 boolean rappDeployStateActual = acmDeployer.deployRappInstance(rapp, rappInstance);
202 assertFalse(rappDeployStateActual);
206 void testDeployRappInstanceFailure() {
207 UUID compositionId = UUID.randomUUID();
208 UUID rappId = UUID.randomUUID();
209 Rapp rapp = Rapp.builder().name("").packageName(validRappFile).compositionId(compositionId)
210 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
211 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
212 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
213 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCES, compositionId)))
214 .andExpect(method(HttpMethod.POST)).andRespond(withStatus(HttpStatus.BAD_GATEWAY));
216 boolean rappDeployStateActual = acmDeployer.deployRappInstance(rapp, rappInstance);
218 assertFalse(rappDeployStateActual);
222 void testUndeployRappInstance() throws JsonProcessingException {
223 UUID compositionId = UUID.randomUUID();
224 UUID rappId = UUID.randomUUID();
225 UUID instanceId = UUID.randomUUID();
226 Rapp rapp = Rapp.builder().rappId(rappId).name("").packageName(validRappFile).compositionId(compositionId)
227 .state(RappState.PRIMED).build();
229 expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.DEPLOYED, LockState.LOCKED,
230 ExpectedCount.once());
232 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
233 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
235 expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.UNDEPLOYED, LockState.UNLOCKED,
236 ExpectedCount.once());
238 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
239 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
241 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
242 rappInstance.getAcm().setAcmInstanceId(instanceId);
243 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
244 boolean rappUndeployStateActual = acmDeployer.undeployRappInstance(rapp, rappInstance);
246 assertTrue(rappUndeployStateActual);
250 void testUndeployRappInstanceFailure() throws JsonProcessingException {
251 UUID compositionId = UUID.randomUUID();
252 UUID rappId = UUID.randomUUID();
253 UUID instanceId = UUID.randomUUID();
254 Rapp rapp = Rapp.builder().name(rappId.toString()).packageName(validRappFile).compositionId(compositionId)
255 .state(RappState.PRIMED).build();
257 expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.DEPLOYED, LockState.LOCKED,
258 ExpectedCount.once());
260 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
261 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
263 expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.UNDEPLOYING, LockState.UNLOCKING,
264 ExpectedCount.manyTimes());
266 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
267 rappInstance.getAcm().setAcmInstanceId(instanceId);
268 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
269 boolean rappUndeployStateActual = acmDeployer.undeployRappInstance(rapp, rappInstance);
271 assertFalse(rappUndeployStateActual);
275 void testUndeployRappInstanceACMErrorFailure() throws JsonProcessingException {
276 UUID compositionId = UUID.randomUUID();
277 UUID rappId = UUID.randomUUID();
278 UUID instanceId = UUID.randomUUID();
279 Rapp rapp = Rapp.builder().name(rappId.toString()).packageName(validRappFile).compositionId(compositionId)
280 .state(RappState.PRIMED).build();
281 expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.DEPLOYED, LockState.LOCKED,
282 ExpectedCount.once());
283 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
284 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
285 mockServer.expect(ExpectedCount.manyTimes(),
286 requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId))).andExpect(method(HttpMethod.GET))
287 .andRespond(withServerError());
288 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
289 rappInstance.getAcm().setAcmInstanceId(instanceId);
290 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
291 boolean rappUndeployStateActual = acmDeployer.undeployRappInstance(rapp, rappInstance);
293 assertFalse(rappUndeployStateActual);
297 @MethodSource("getAcmStatusEventMap")
298 void testSyncRappInstanceStatus(DeployState deployState, LockState lockState, RappEvent rappEvent)
299 throws JsonProcessingException {
300 UUID compositionId = UUID.randomUUID();
301 UUID instanceId = UUID.randomUUID();
302 expectAcmGetInstanceToReturnState(compositionId, instanceId, deployState, lockState, ExpectedCount.once());
303 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
304 rappInstance.getAcm().setAcmInstanceId(instanceId);
305 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
306 acmDeployer.syncRappInstanceStatus(compositionId, rappInstance);
308 verify(rappInstanceStateMachine, times(1)).sendRappInstanceEvent(rappInstance, rappEvent);
311 private static Stream<Arguments> getAcmStatusEventMap() {
312 return Stream.of(Arguments.of(DeployState.UNDEPLOYING, LockState.UNLOCKING, RappEvent.UNDEPLOYING),
313 Arguments.of(DeployState.DEPLOYED, LockState.LOCKED, RappEvent.ACMDEPLOYED),
314 Arguments.of(DeployState.DEPLOYING, LockState.LOCKING, RappEvent.DEPLOYING),
315 Arguments.of(DeployState.UNDEPLOYED, LockState.UNLOCKED, RappEvent.ACMUNDEPLOYED));
319 void testSyncRappStatusFailure() {
320 UUID compositionId = UUID.randomUUID();
321 UUID instanceId = UUID.randomUUID();
323 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
324 .andExpect(method(HttpMethod.GET)).andRespond(withStatus(HttpStatus.BAD_GATEWAY));
326 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
327 rappInstance.getAcm().setAcmInstanceId(instanceId);
328 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
329 acmDeployer.syncRappInstanceStatus(compositionId, rappInstance);
331 verify(rappInstanceStateMachine, never()).sendRappInstanceEvent(any(), any());
335 void testPrimeRapp() throws JsonProcessingException {
336 UUID compositionId = UUID.randomUUID();
337 RappResources rappResources = rappResourceBuilder.getResources();
338 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
339 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
340 .compositionId(compositionId).rappResources(rappResources).build();
342 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
343 commissioningResponseExpected.setCompositionId(compositionId);
344 mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
345 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
346 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
347 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
348 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
349 boolean primeRapp = acmDeployer.primeRapp(rapp);
351 assertTrue(primeRapp);
355 void testPrimeRappFailure() throws JsonProcessingException {
356 UUID compositionId = UUID.randomUUID();
357 RappResources rappResources = rappResourceBuilder.getResources();
358 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
359 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
360 .compositionId(compositionId).rappResources(rappResources).build();
362 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
363 commissioningResponseExpected.setCompositionId(compositionId);
364 mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
365 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
366 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
367 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
368 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
369 boolean primeRapp = acmDeployer.primeRapp(rapp);
371 assertFalse(primeRapp);
372 assertEquals(RappState.COMMISSIONED, rapp.getState());
376 void testPrimeRappFailureWithoutCompositionId() throws JsonProcessingException {
377 UUID compositionId = UUID.randomUUID();
378 RappResources rappResources = rappResourceBuilder.getResources();
379 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
380 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
381 .compositionId(compositionId).rappResources(rappResources).build();
383 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
384 mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
385 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
386 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
387 boolean primeRapp = acmDeployer.primeRapp(rapp);
389 assertFalse(primeRapp);
393 void testDeprimeRapp() throws JsonProcessingException {
394 UUID compositionId = UUID.randomUUID();
395 RappResources rappResources = rappResourceBuilder.getResources();
396 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
397 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
398 .compositionId(compositionId).rappResources(rappResources).build();
400 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
401 commissioningResponseExpected.setCompositionId(compositionId);
402 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
403 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
404 AutomationCompositionDefinition automationCompositionDefinition =
405 getAutomationCompositionDefinition(compositionId, AcTypeState.COMMISSIONED);
406 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
407 .andExpect(method(HttpMethod.GET)).andRespond(
408 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
409 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
410 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
411 .andExpect(method(HttpMethod.DELETE)).andRespond(
412 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
413 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
415 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
417 assertTrue(deprimeRapp);
421 void testDeprimeRappClientRetry() throws JsonProcessingException {
422 UUID compositionId = UUID.randomUUID();
423 RappResources rappResources = rappResourceBuilder.getResources();
424 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
425 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
426 .compositionId(compositionId).rappResources(rappResources).build();
428 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
429 commissioningResponseExpected.setCompositionId(compositionId);
430 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
431 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
432 AutomationCompositionDefinition automationCompositionDefinition =
433 getAutomationCompositionDefinition(compositionId, AcTypeState.DEPRIMING);
434 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
435 .andExpect(method(HttpMethod.GET)).andRespond(
436 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
437 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
438 automationCompositionDefinition = getAutomationCompositionDefinition(compositionId, AcTypeState.COMMISSIONED);
439 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
440 .andExpect(method(HttpMethod.GET)).andRespond(
441 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
442 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
443 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
444 .andExpect(method(HttpMethod.DELETE)).andRespond(
445 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
446 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
448 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
450 assertTrue(deprimeRapp);
454 void testDeprimeFailureRapp() throws JsonProcessingException {
455 UUID compositionId = UUID.randomUUID();
456 RappResources rappResources = rappResourceBuilder.getResources();
457 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
458 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
459 .compositionId(compositionId).rappResources(rappResources).build();
461 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
462 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
463 AutomationCompositionDefinition automationCompositionDefinition =
464 getAutomationCompositionDefinition(compositionId, AcTypeState.COMMISSIONED);
465 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
466 .andExpect(method(HttpMethod.GET)).andRespond(
467 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
468 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
469 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
470 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
472 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
474 assertFalse(deprimeRapp);
478 void testDeprimeACMStatusFailureRapp() throws JsonProcessingException {
479 UUID compositionId = UUID.randomUUID();
480 RappResources rappResources = rappResourceBuilder.getResources();
481 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
482 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
483 .compositionId(compositionId).rappResources(rappResources).build();
485 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
486 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
487 AutomationCompositionDefinition automationCompositionDefinition =
488 getAutomationCompositionDefinition(compositionId, AcTypeState.DEPRIMING);
489 mockServer.expect(ExpectedCount.manyTimes(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
490 .andExpect(method(HttpMethod.GET)).andRespond(
491 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
492 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
494 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
496 assertFalse(deprimeRapp);
500 void testDeprimeACMStatusErrorRapp() {
501 UUID compositionId = UUID.randomUUID();
502 RappResources rappResources = rappResourceBuilder.getResources();
503 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
504 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
505 .compositionId(compositionId).rappResources(rappResources).build();
507 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
508 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
509 mockServer.expect(ExpectedCount.manyTimes(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
510 .andExpect(method(HttpMethod.GET)).andRespond(withServerError());
511 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
513 assertFalse(deprimeRapp);
517 void testDeprimeExceptionRapp() {
518 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
519 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
520 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
521 assertFalse(deprimeRapp);
525 void testDeleteComposition() throws JsonProcessingException {
526 UUID compositionId = UUID.randomUUID();
527 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
528 commissioningResponseExpected.setCompositionId(compositionId);
529 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
530 .andExpect(method(HttpMethod.DELETE)).andRespond(
531 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
532 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
533 CommissioningResponse commissioningResponse = acmDeployer.deleteComposition(compositionId);
535 assertEquals(commissioningResponse.getCompositionId(), compositionId);
539 void testDeleteCompositionFailure() {
540 UUID compositionId = UUID.randomUUID();
541 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
542 commissioningResponseExpected.setCompositionId(compositionId);
543 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
544 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
545 CommissioningResponse commissioningResponse = acmDeployer.deleteComposition(compositionId);
547 assertNull(commissioningResponse);
550 void expectAcmGetInstanceToReturnState(UUID compositionId, UUID instanceId, DeployState deployState,
551 LockState lockState, ExpectedCount expectedCount) throws JsonProcessingException {
552 AutomationComposition automationCompositionDeployed = new AutomationComposition();
553 automationCompositionDeployed.setCompositionId(compositionId);
554 automationCompositionDeployed.setInstanceId(instanceId);
555 automationCompositionDeployed.setDeployState(deployState);
556 automationCompositionDeployed.setLockState(lockState);
558 mockServer.expect(expectedCount, requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
559 .andExpect(method(HttpMethod.GET)).andRespond(
560 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
561 .body(objectMapper.writeValueAsString(automationCompositionDeployed)));
564 AutomationCompositionDefinition getAutomationCompositionDefinition(UUID compositionId, AcTypeState acTypeState) {
565 AutomationCompositionDefinition automationCompositionDefinition = new AutomationCompositionDefinition();
566 automationCompositionDefinition.setCompositionId(compositionId);
567 automationCompositionDefinition.setState(acTypeState);
568 automationCompositionDefinition.setServiceTemplate(new ToscaServiceTemplate());
569 return automationCompositionDefinition;