rapp-manager-acm/src/test/java/com/oransc/rappmanager/acm/service/AcmDeployerTest.java

   1 /*-
   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
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  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========================================================================
  17  */
  18
  19 package com.oransc.rappmanager.acm.service;
  20
  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;
  33
  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;
  76
  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)
  81 @AutoConfigureMockMvc
  82 class AcmDeployerTest {
  83
  84     MockRestServiceServer mockServer;
  85     @SpyBean
  86     AcmDeployer acmDeployer;
  87     @Autowired
  88     RestTemplate restTemplate;
  89     @Autowired
  90     ACMConfiguration acmConfiguration;
  91     @SpyBean
  92     RappInstanceStateMachine rappInstanceStateMachine;
  93     @Autowired
  94     RappCsarConfigurationHandler rappCsarConfigurationHandler;
  95     @Autowired
  96     ObjectMapper objectMapper;
  97
  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;
 102
 103     @BeforeAll
 104     void initACMURI() {
 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";
 109     }
 110
 111     @BeforeEach
 112     public void init() {
 113         mockServer = MockRestServiceServer.createServer(restTemplate);
 114     }
 115
 116     @Test
 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();
 122
 123         String compositionPayload = rappCsarConfigurationHandler.getAcmCompositionPayload(rapp);
 124
 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);
 131         mockServer.verify();
 132         assertEquals(commissioningResponseActual.getCompositionId(), commissioningResponseExpected.getCompositionId());
 133     }
 134
 135     @Test
 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);
 145         mockServer.verify();
 146         assertNull(commissioningResponseActual);
 147     }
 148
 149     @Test
 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));
 154
 155         acmDeployer.primeACMComposition(compositionId, PrimeOrder.PRIME);
 156         mockServer.verify();
 157     }
 158
 159     @Test
 160     void testDeployRappInstance() throws Exception {
 161
 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);
 178         mockServer.verify();
 179     }
 180
 181     @Test
 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)));
 194
 195         boolean rappDeployStateActual = acmDeployer.deployRappInstance(rapp, rappInstance);
 196         mockServer.verify();
 197         assertFalse(rappDeployStateActual);
 198     }
 199
 200     @Test
 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));
 210
 211         boolean rappDeployStateActual = acmDeployer.deployRappInstance(rapp, rappInstance);
 212         mockServer.verify();
 213         assertFalse(rappDeployStateActual);
 214     }
 215
 216     @Test
 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();
 223
 224         expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.DEPLOYED, LockState.LOCKED,
 225                 ExpectedCount.once());
 226
 227         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
 228                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
 229
 230         expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.UNDEPLOYED, LockState.UNLOCKED,
 231                 ExpectedCount.once());
 232
 233         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
 234                 .andExpect(method(HttpMethod.DELETE)).andRespond(withStatus(HttpStatus.NO_CONTENT));
 235
 236         RappInstance rappInstance = rappResourceBuilder.getRappInstance();
 237         rappInstance.getAcm().setAcmInstanceId(instanceId);
 238         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 239         boolean rappUndeployStateActual = acmDeployer.undeployRappInstance(rapp, rappInstance);
 240         mockServer.verify();
 241         assertTrue(rappUndeployStateActual);
 242     }
 243
 244     @Test
 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();
 251
 252         expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.DEPLOYED, LockState.LOCKED,
 253                 ExpectedCount.once());
 254
 255         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
 256                 .andExpect(method(HttpMethod.PUT)).andRespond(withStatus(HttpStatus.ACCEPTED));
 257
 258         expectAcmGetInstanceToReturnState(compositionId, instanceId, DeployState.UNDEPLOYING, LockState.UNLOCKING,
 259                 ExpectedCount.manyTimes());
 260
 261         RappInstance rappInstance = rappResourceBuilder.getRappInstance();
 262         rappInstance.getAcm().setAcmInstanceId(instanceId);
 263         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 264         boolean rappUndeployStateActual = acmDeployer.undeployRappInstance(rapp, rappInstance);
 265         mockServer.verify();
 266         assertFalse(rappUndeployStateActual);
 267     }
 268
 269     @Test
 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);
 287         mockServer.verify();
 288         assertFalse(rappUndeployStateActual);
 289     }
 290
 291     @ParameterizedTest
 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);
 302         mockServer.verify();
 303         verify(rappInstanceStateMachine, times(1)).sendRappInstanceEvent(rappInstance, rappEvent);
 304     }
 305
 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));
 311     }
 312
 313     @Test
 314     void testSyncRappStatusFailure() {
 315         UUID compositionId = UUID.randomUUID();
 316         UUID instanceId = UUID.randomUUID();
 317
 318         mockServer.expect(ExpectedCount.once(), requestTo(String.format(URI_ACM_INSTANCE, compositionId, instanceId)))
 319                 .andExpect(method(HttpMethod.GET)).andRespond(withStatus(HttpStatus.BAD_GATEWAY));
 320
 321         RappInstance rappInstance = rappResourceBuilder.getRappInstance();
 322         rappInstance.getAcm().setAcmInstanceId(instanceId);
 323         rappInstanceStateMachine.onboardRappInstance(rappInstance.getRappInstanceId());
 324         acmDeployer.syncRappInstanceStatus(compositionId, rappInstance);
 325         mockServer.verify();
 326         verify(rappInstanceStateMachine, never()).sendRappInstanceEvent(any(), any());
 327     }
 328
 329     @Test
 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();
 336
 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);
 345         mockServer.verify();
 346         assertTrue(primeRapp);
 347     }
 348
 349     @Test
 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();
 356
 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);
 365         mockServer.verify();
 366         assertFalse(primeRapp);
 367         assertEquals(RappState.COMMISSIONED, rapp.getState());
 368     }
 369
 370     @Test
 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();
 377
 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);
 383         mockServer.verify();
 384         assertFalse(primeRapp);
 385     }
 386
 387     @Test
 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();
 394
 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)));
 409
 410         boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
 411         mockServer.verify();
 412         assertTrue(deprimeRapp);
 413     }
 414
 415     @Test
 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();
 422
 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)));
 442
 443         boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
 444         mockServer.verify();
 445         assertTrue(deprimeRapp);
 446     }
 447
 448     @Test
 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();
 455
 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));
 466
 467         boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
 468         mockServer.verify();
 469         assertFalse(deprimeRapp);
 470     }
 471
 472     @Test
 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();
 479
 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)));
 488
 489         boolean deprimeRapp = acmDeployer.deprimeRapp(rapp);
 490         mockServer.verify();
 491         assertFalse(deprimeRapp);
 492     }
 493
 494     @Test
 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();
 501
 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);
 507         mockServer.verify();
 508         assertFalse(deprimeRapp);
 509     }
 510
 511     @Test
 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);
 517     }
 518
 519     @Test
 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);
 529         mockServer.verify();
 530         assertEquals(commissioningResponse.getCompositionId(), compositionId);
 531     }
 532
 533     @Test
 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);
 541         mockServer.verify();
 542         assertNull(commissioningResponse);
 543     }
 544
 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);
 552
 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)));
 557     }
 558
 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;
 565     }
 566 }