2 * ============LICENSE_START======================================================================
3 * Copyright (C) 2023 Nordix Foundation. All rights reserved.
4 * ===============================================================================================
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 * ============LICENSE_END========================================================================
19 package com.oransc.rappmanager.acm.service;
21 import static org.junit.jupiter.api.Assertions.assertEquals;
22 import static org.junit.jupiter.api.Assertions.assertFalse;
23 import static org.junit.jupiter.api.Assertions.assertNull;
24 import static org.junit.jupiter.api.Assertions.assertTrue;
25 import static org.mockito.ArgumentMatchers.any;
26 import static org.mockito.Mockito.never;
27 import static org.mockito.Mockito.times;
28 import static org.mockito.Mockito.verify;
29 import static org.springframework.test.web.client.match.MockRestRequestMatchers.method;
30 import static org.springframework.test.web.client.match.MockRestRequestMatchers.requestTo;
31 import static org.springframework.test.web.client.response.MockRestResponseCreators.withServerError;
32 import static org.springframework.test.web.client.response.MockRestResponseCreators.withStatus;
34 import com.fasterxml.jackson.core.JsonProcessingException;
35 import com.fasterxml.jackson.databind.ObjectMapper;
36 import com.oransc.rappmanager.acm.configuration.ACMConfiguration;
37 import com.oransc.rappmanager.models.cache.RappCacheService;
38 import com.oransc.rappmanager.models.csar.RappCsarConfigurationHandler;
39 import com.oransc.rappmanager.models.rapp.Rapp;
40 import com.oransc.rappmanager.models.rapp.RappEvent;
41 import com.oransc.rappmanager.models.rapp.RappResourceBuilder;
42 import com.oransc.rappmanager.models.rapp.RappResources;
43 import com.oransc.rappmanager.models.rapp.RappState;
44 import com.oransc.rappmanager.models.rappinstance.RappInstance;
45 import com.oransc.rappmanager.models.statemachine.RappInstanceStateMachine;
46 import com.oransc.rappmanager.models.statemachine.RappInstanceStateMachineConfig;
47 import java.io.IOException;
48 import java.util.UUID;
49 import java.util.stream.Stream;
50 import org.junit.jupiter.api.BeforeAll;
51 import org.junit.jupiter.api.BeforeEach;
52 import org.junit.jupiter.api.Test;
53 import org.junit.jupiter.api.TestInstance;
54 import org.junit.jupiter.params.ParameterizedTest;
55 import org.junit.jupiter.params.provider.Arguments;
56 import org.junit.jupiter.params.provider.MethodSource;
57 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
58 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
59 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
60 import org.onap.policy.clamp.models.acm.concepts.DeployState;
61 import org.onap.policy.clamp.models.acm.concepts.LockState;
62 import org.onap.policy.clamp.models.acm.messages.rest.commissioning.CommissioningResponse;
63 import org.onap.policy.clamp.models.acm.messages.rest.commissioning.PrimeOrder;
64 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse;
65 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
66 import org.springframework.beans.factory.annotation.Autowired;
67 import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
68 import org.springframework.boot.test.context.SpringBootTest;
69 import org.springframework.boot.test.mock.mockito.SpyBean;
70 import org.springframework.http.HttpMethod;
71 import org.springframework.http.HttpStatus;
72 import org.springframework.http.MediaType;
73 import org.springframework.test.web.client.ExpectedCount;
74 import org.springframework.test.web.client.MockRestServiceServer;
75 import org.springframework.web.client.RestTemplate;
77 @SpringBootTest(classes = {BeanTestConfiguration.class, ACMConfiguration.class, AcmDeployer.class,
78 RappCsarConfigurationHandler.class, RappCacheService.class, RappInstanceStateMachineConfig.class,
79 RappInstanceStateMachine.class})
80 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
82 class AcmDeployerTest {
84 MockRestServiceServer mockServer;
86 AcmDeployer acmDeployer;
88 RestTemplate restTemplate;
90 ACMConfiguration acmConfiguration;
92 RappInstanceStateMachine rappInstanceStateMachine;
94 RappCsarConfigurationHandler rappCsarConfigurationHandler;
96 ObjectMapper objectMapper;
98 RappResourceBuilder rappResourceBuilder = new RappResourceBuilder();
99 private final String validRappFile = "valid-rapp-package.csar";
100 String validCsarFileLocation = "src/test/resources/";
101 String URI_ACM_COMPOSITIONS, URI_ACM_COMPOSITION, URI_ACM_INSTANCES, URI_ACM_INSTANCE;
105 URI_ACM_COMPOSITIONS = acmConfiguration.getBaseUrl() + "compositions";
106 URI_ACM_COMPOSITION = acmConfiguration.getBaseUrl() + "compositions/%s";
107 URI_ACM_INSTANCES = acmConfiguration.getBaseUrl() + "compositions/%s/instances";
108 URI_ACM_INSTANCE = acmConfiguration.getBaseUrl() + "compositions/%s/instances/%s";
113 mockServer = MockRestServiceServer.createServer(restTemplate);
117 void testCreateComposition() throws IOException {
118 RappResources rappResources = rappResourceBuilder.getResources();
119 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
120 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
121 .rappResources(rappResources).build();
123 String compositionPayload = rappCsarConfigurationHandler.getAcmCompositionPayload(rapp);
125 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
126 commissioningResponseExpected.setCompositionId(UUID.randomUUID());
127 mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
128 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
129 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
130 CommissioningResponse commissioningResponseActual = acmDeployer.createComposition(compositionPayload);
132 assertEquals(commissioningResponseActual.getCompositionId(), commissioningResponseExpected.getCompositionId());
136 void testCreateCompositionFailure() {
137 RappResources rappResources = rappResourceBuilder.getResources();
138 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
139 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
140 .rappResources(rappResources).build();
141 String compositionPayload = rappCsarConfigurationHandler.getAcmCompositionPayload(rapp);
142 mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
143 .andRespond(withStatus(HttpStatus.BAD_GATEWAY));
144 CommissioningResponse commissioningResponseActual = acmDeployer.createComposition(compositionPayload);
146 assertNull(commissioningResponseActual);
150 void testCompositionPriming() {
151 UUID compositionId = UUID.randomUUID();
152 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
153 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
155 acmDeployer.primeACMComposition(compositionId, PrimeOrder.PRIME);
160 void testDeployRappInstance() throws Exception {
162 UUID compositionId = UUID.randomUUID();
163 UUID rappId = UUID.randomUUID();
164 UUID instanceId = UUID.randomUUID();
165 Rapp rapp = Rapp.builder().name(rappId.toString()).packageName(validRappFile).compositionId(compositionId)
166 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
167 InstantiationResponse instantiationResponse = new InstantiationResponse();
168 instantiationResponse.setInstanceId(instanceId);
169 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCES, compositionId)))
170 .andExpect(method(HttpMethod.POST)).andRespond(
171 withStatus(HttpStatus.ACCEPTED).contentType(MediaType.APPLICATION_JSON)
172 .body(objectMapper.writeValueAsString(instantiationResponse)));
173 mockServer.expect(ExpectedCount.once(),
174 requestTo(acmConfiguration.getBaseUrl() + "compositions/" + compositionId + "/instances/" + instanceId))
175 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
176 boolean rappDeployStateActual = acmDeployer.deployRappInstance(rapp, rappResourceBuilder.getRappInstance());
177 assertTrue(rappDeployStateActual);
182 void testDeployRappInstanceFailureWithNoInstanceId() throws JsonProcessingException {
183 UUID compositionId = UUID.randomUUID();
184 UUID rappId = UUID.randomUUID();
185 Rapp rapp = Rapp.builder().name(rappId.toString()).packageName(validRappFile).compositionId(compositionId)
186 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
187 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
188 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
189 InstantiationResponse instantiationResponse = new InstantiationResponse();
190 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCES, compositionId)))
191 .andExpect(method(HttpMethod.POST)).andRespond(
192 withStatus(HttpStatus.ACCEPTED).contentType(MediaType.APPLICATION_JSON)
193 .body(objectMapper.writeValueAsString(instantiationResponse)));
195 boolean rappDeployStateActual = acmDeployer.deployRappInstance(rapp, rappInstance);
197 assertFalse(rappDeployStateActual);
201 void testDeployRappInstanceFailure() {
202 UUID compositionId = UUID.randomUUID();
203 UUID rappId = UUID.randomUUID();
204 Rapp rapp = Rapp.builder().name(rappId.toString()).packageName(validRappFile).compositionId(compositionId)
205 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
206 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
207 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
208 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCES, compositionId)))
209 .andExpect(method(HttpMethod.POST)).andRespond(withStatus(HttpStatus.BAD_GATEWAY));
211 boolean rappDeployStateActual = acmDeployer.deployRappInstance(rapp, rappInstance);
213 assertFalse(rappDeployStateActual);
217 void testUndeployRappInstance() throws JsonProcessingException {
218 UUID compositionId = UUID.randomUUID();
219 UUID rappId = UUID.randomUUID();
220 UUID instanceId = UUID.randomUUID();
221 Rapp rapp = Rapp.builder().rappId(rappId).name("").packageName(validRappFile).compositionId(compositionId)
222 .state(RappState.PRIMED).build();
224 expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.DEPLOYED, LockState.LOCKED,
225 ExpectedCount.once());
227 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
228 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
230 expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.UNDEPLOYED, LockState.UNLOCKED,
231 ExpectedCount.once());
233 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
234 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
236 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
237 rappInstance.getAcm().setAcmInstanceId(instanceId);
238 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
239 boolean rappUndeployStateActual = acmDeployer.undeployRappInstance(rapp, rappInstance);
241 assertTrue(rappUndeployStateActual);
245 void testUndeployRappInstanceFailure() throws JsonProcessingException {
246 UUID compositionId = UUID.randomUUID();
247 UUID rappId = UUID.randomUUID();
248 UUID instanceId = UUID.randomUUID();
249 Rapp rapp = Rapp.builder().name(rappId.toString()).packageName(validRappFile).compositionId(compositionId)
250 .state(RappState.PRIMED).build();
252 expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.DEPLOYED, LockState.LOCKED,
253 ExpectedCount.once());
255 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
256 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
258 expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.UNDEPLOYING, LockState.UNLOCKING,
259 ExpectedCount.manyTimes());
261 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
262 rappInstance.getAcm().setAcmInstanceId(instanceId);
263 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
264 boolean rappUndeployStateActual = acmDeployer.undeployRappInstance(rapp, rappInstance);
266 assertFalse(rappUndeployStateActual);
270 void testUndeployRappInstanceACMErrorFailure() throws JsonProcessingException {
271 UUID compositionId = UUID.randomUUID();
272 UUID rappId = UUID.randomUUID();
273 UUID instanceId = UUID.randomUUID();
274 Rapp rapp = Rapp.builder().name(rappId.toString()).packageName(validRappFile).compositionId(compositionId)
275 .state(RappState.PRIMED).build();
276 expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.DEPLOYED, LockState.LOCKED,
277 ExpectedCount.once());
278 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
279 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
280 mockServer.expect(ExpectedCount.manyTimes(),
281 requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId))).andExpect(method(HttpMethod.GET))
282 .andRespond(withServerError());
283 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
284 rappInstance.getAcm().setAcmInstanceId(instanceId);
285 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
286 boolean rappUndeployStateActual = acmDeployer.undeployRappInstance(rapp, rappInstance);
288 assertFalse(rappUndeployStateActual);
292 @MethodSource("getAcmStatusEventMap")
293 void testSyncRappInstanceStatus(DeployState deployState, LockState lockState, RappEvent rappEvent)
294 throws JsonProcessingException {
295 UUID compositionId = UUID.randomUUID();
296 UUID instanceId = UUID.randomUUID();
297 expectAcmGetInstanceToReturnState(compositionId, instanceId, deployState, lockState, ExpectedCount.once());
298 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
299 rappInstance.getAcm().setAcmInstanceId(instanceId);
300 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
301 acmDeployer.syncRappInstanceStatus(compositionId, rappInstance);
303 verify(rappInstanceStateMachine, times(1)).sendRappInstanceEvent(rappInstance, rappEvent);
306 private static Stream<Arguments> getAcmStatusEventMap() {
307 return Stream.of(Arguments.of(DeployState.UNDEPLOYING, LockState.UNLOCKING, RappEvent.UNDEPLOYING),
308 Arguments.of(DeployState.DEPLOYED, LockState.LOCKED, RappEvent.ACMDEPLOYED),
309 Arguments.of(DeployState.DEPLOYING, LockState.LOCKING, RappEvent.DEPLOYING),
310 Arguments.of(DeployState.UNDEPLOYED, LockState.UNLOCKED, RappEvent.ACMUNDEPLOYED));
314 void testSyncRappStatusFailure() {
315 UUID compositionId = UUID.randomUUID();
316 UUID instanceId = UUID.randomUUID();
318 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
319 .andExpect(method(HttpMethod.GET)).andRespond(withStatus(HttpStatus.BAD_GATEWAY));
321 RappInstance rappInstance = rappResourceBuilder.getRappInstance();
322 rappInstance.getAcm().setAcmInstanceId(instanceId);
323 rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
324 acmDeployer.syncRappInstanceStatus(compositionId, rappInstance);
326 verify(rappInstanceStateMachine, never()).sendRappInstanceEvent(any(), any());
330 void testPrimeRapp() throws JsonProcessingException {
331 UUID compositionId = UUID.randomUUID();
332 RappResources rappResources = rappResourceBuilder.getResources();
333 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
334 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
335 .compositionId(compositionId).rappResources(rappResources).build();
337 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
338 commissioningResponseExpected.setCompositionId(compositionId);
339 mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
340 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
341 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
342 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
343 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
344 boolean primeRapp = acmDeployer.primeRapp(rapp);
346 assertTrue(primeRapp);
350 void testPrimeRappFailure() throws JsonProcessingException {
351 UUID compositionId = UUID.randomUUID();
352 RappResources rappResources = rappResourceBuilder.getResources();
353 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
354 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
355 .compositionId(compositionId).rappResources(rappResources).build();
357 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
358 commissioningResponseExpected.setCompositionId(compositionId);
359 mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
360 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
361 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
362 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
363 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
364 boolean primeRapp = acmDeployer.primeRapp(rapp);
366 assertFalse(primeRapp);
367 assertEquals(RappState.COMMISSIONED, rapp.getState());
371 void testPrimeRappFailureWithoutCompositionId() throws JsonProcessingException {
372 UUID compositionId = UUID.randomUUID();
373 RappResources rappResources = rappResourceBuilder.getResources();
374 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
375 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
376 .compositionId(compositionId).rappResources(rappResources).build();
378 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
379 mockServer.expect(ExpectedCount.once(), requestTo(URI_ACM_COMPOSITIONS)).andExpect(method(HttpMethod.POST))
380 .andRespond(withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
381 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
382 boolean primeRapp = acmDeployer.primeRapp(rapp);
384 assertFalse(primeRapp);
388 void testDeprimeRapp() throws JsonProcessingException {
389 UUID compositionId = UUID.randomUUID();
390 RappResources rappResources = rappResourceBuilder.getResources();
391 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
392 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
393 .compositionId(compositionId).rappResources(rappResources).build();
395 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
396 commissioningResponseExpected.setCompositionId(compositionId);
397 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
398 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
399 AutomationCompositionDefinition automationCompositionDefinition =
400 getAutomationCompositionDefinition(compositionId, AcTypeState.COMMISSIONED);
401 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
402 .andExpect(method(HttpMethod.GET)).andRespond(
403 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
404 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
405 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
406 .andExpect(method(HttpMethod.DELETE)).andRespond(
407 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
408 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
410 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
412 assertTrue(deprimeRapp);
416 void testDeprimeRappClientRetry() throws JsonProcessingException {
417 UUID compositionId = UUID.randomUUID();
418 RappResources rappResources = rappResourceBuilder.getResources();
419 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
420 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
421 .compositionId(compositionId).rappResources(rappResources).build();
423 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
424 commissioningResponseExpected.setCompositionId(compositionId);
425 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
426 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
427 AutomationCompositionDefinition automationCompositionDefinition =
428 getAutomationCompositionDefinition(compositionId, AcTypeState.DEPRIMING);
429 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
430 .andExpect(method(HttpMethod.GET)).andRespond(
431 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
432 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
433 automationCompositionDefinition = getAutomationCompositionDefinition(compositionId, AcTypeState.COMMISSIONED);
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 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
439 .andExpect(method(HttpMethod.DELETE)).andRespond(
440 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
441 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
443 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
445 assertTrue(deprimeRapp);
449 void testDeprimeFailureRapp() throws JsonProcessingException {
450 UUID compositionId = UUID.randomUUID();
451 RappResources rappResources = rappResourceBuilder.getResources();
452 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
453 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
454 .compositionId(compositionId).rappResources(rappResources).build();
456 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
457 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
458 AutomationCompositionDefinition automationCompositionDefinition =
459 getAutomationCompositionDefinition(compositionId, AcTypeState.COMMISSIONED);
460 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
461 .andExpect(method(HttpMethod.GET)).andRespond(
462 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
463 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
464 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
465 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
467 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
469 assertFalse(deprimeRapp);
473 void testDeprimeACMStatusFailureRapp() throws JsonProcessingException {
474 UUID compositionId = UUID.randomUUID();
475 RappResources rappResources = rappResourceBuilder.getResources();
476 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
477 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
478 .compositionId(compositionId).rappResources(rappResources).build();
480 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
481 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
482 AutomationCompositionDefinition automationCompositionDefinition =
483 getAutomationCompositionDefinition(compositionId, AcTypeState.DEPRIMING);
484 mockServer.expect(ExpectedCount.manyTimes(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
485 .andExpect(method(HttpMethod.GET)).andRespond(
486 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
487 .body(objectMapper.writeValueAsString(automationCompositionDefinition)));
489 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
491 assertFalse(deprimeRapp);
495 void testDeprimeACMStatusErrorRapp() {
496 UUID compositionId = UUID.randomUUID();
497 RappResources rappResources = rappResourceBuilder.getResources();
498 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
499 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED)
500 .compositionId(compositionId).rappResources(rappResources).build();
502 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
503 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.OK));
504 mockServer.expect(ExpectedCount.manyTimes(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
505 .andExpect(method(HttpMethod.GET)).andRespond(withServerError());
506 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
508 assertFalse(deprimeRapp);
512 void testDeprimeExceptionRapp() {
513 Rapp rapp = Rapp.builder().rappId(UUID.randomUUID()).name("").packageName(validRappFile)
514 .packageLocation(validCsarFileLocation).state(RappState.COMMISSIONED).build();
515 boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
516 assertFalse(deprimeRapp);
520 void testDeleteComposition() throws JsonProcessingException {
521 UUID compositionId = UUID.randomUUID();
522 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
523 commissioningResponseExpected.setCompositionId(compositionId);
524 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
525 .andExpect(method(HttpMethod.DELETE)).andRespond(
526 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
527 .body(objectMapper.writeValueAsString(commissioningResponseExpected)));
528 CommissioningResponse commissioningResponse = acmDeployer.deleteComposition(compositionId);
530 assertEquals(commissioningResponse.getCompositionId(), compositionId);
534 void testDeleteCompositionFailure() {
535 UUID compositionId = UUID.randomUUID();
536 CommissioningResponse commissioningResponseExpected = new CommissioningResponse();
537 commissioningResponseExpected.setCompositionId(compositionId);
538 mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_COMPOSITION, compositionId)))
539 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.INTERNAL_SERVER_ERROR));
540 CommissioningResponse commissioningResponse = acmDeployer.deleteComposition(compositionId);
542 assertNull(commissioningResponse);
545 void expectAcmGetInstanceToReturnState(UUID compositionId, UUID instanceId, DeployState deployState,
546 LockState lockState, ExpectedCount expectedCount) throws JsonProcessingException {
547 AutomationComposition automationCompositionDeployed = new AutomationComposition();
548 automationCompositionDeployed.setCompositionId(compositionId);
549 automationCompositionDeployed.setInstanceId(instanceId);
550 automationCompositionDeployed.setDeployState(deployState);
551 automationCompositionDeployed.setLockState(lockState);
553 mockServer.expect(expectedCount, requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
554 .andExpect(method(HttpMethod.GET)).andRespond(
555 withStatus(HttpStatus.OK).contentType(MediaType.APPLICATION_JSON)
556 .body(objectMapper.writeValueAsString(automationCompositionDeployed)));
559 AutomationCompositionDefinition getAutomationCompositionDefinition(UUID compositionId, AcTypeState acTypeState) {
560 AutomationCompositionDefinition automationCompositionDefinition = new AutomationCompositionDefinition();
561 automationCompositionDefinition.setCompositionId(compositionId);
562 automationCompositionDefinition.setState(acTypeState);
563 automationCompositionDefinition.setServiceTemplate(new ToscaServiceTemplate());
564 return automationCompositionDefinition;