gerrit.onap Code Review - policy/clamp.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2024 Nordix Foundation.
   4  *  Modifications Copyright (C) 2021 AT&T Intellectual Property. 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
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  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  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.clamp.acm.runtime.instantiation;
  23
  24 import static org.assertj.core.api.Assertions.assertThat;
  25 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  26 import static org.mockito.ArgumentMatchers.any;
  27 import static org.mockito.Mockito.doNothing;
  28 import static org.mockito.Mockito.mock;
  29 import static org.mockito.Mockito.verify;
  30 import static org.mockito.Mockito.when;
  31 import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVICE_TEMPLATE_YAML;
  32
  33 import java.util.ArrayList;
  34 import java.util.List;
  35 import java.util.Optional;
  36 import java.util.UUID;
  37 import org.junit.jupiter.api.BeforeAll;
  38 import org.junit.jupiter.api.Test;
  39 import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
  40 import org.onap.policy.clamp.acm.runtime.supervision.SupervisionAcHandler;
  41 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
  42 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  43 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  44 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
  45 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  46 import org.onap.policy.clamp.models.acm.concepts.LockState;
  47 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  48 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.AcInstanceStateUpdate;
  49 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  50 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
  51 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.SubOrder;
  52 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
  53 import org.onap.policy.clamp.models.acm.persistence.provider.AcInstanceStateResolver;
  54 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
  55 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
  56 import org.onap.policy.clamp.models.acm.persistence.provider.ProviderUtils;
  57 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  58 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
  59
  60 /**
  61  * Class to perform unit test of {@link AutomationCompositionInstantiationProvider}}.
  62  *
  63  */
  64 class AutomationCompositionInstantiationProviderTest {
  65     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  66     private static final String AC_INSTANTIATION_UPDATE_JSON =
  67             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  68
  69     private static final String AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON =
  70             "src/test/resources/rest/acm/AutomationCompositionElementsNotFound.json";
  71     private static final String AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON =
  72             "src/test/resources/rest/acm/AutomationCompositionNotFound.json";
  73     private static final String DELETE_BAD_REQUEST = "Automation composition state is still %s";
  74
  75     private static final String AC_ELEMENT_NAME_NOT_FOUND = """
  76             "AutomationComposition" INVALID, item has status INVALID
  77               "entry PMSHInstance0AcElementNotFound" INVALID, item has status INVALID
  78                 "entry org.onap.domain.pmsh.DCAEMicroservice" INVALID, Not found
  79                 "entry org.onap.domain.pmsh.PMSH_MonitoringPolicyAutomationCompositionElement" INVALID, Not found
  80             """;
  81     private static final String AC_DEFINITION_NOT_FOUND = """
  82             "AutomationComposition" INVALID, item has status INVALID
  83               item "ServiceTemplate" value "%s" INVALID, Commissioned automation composition definition not found
  84             """;
  85
  86     private static final String DO_NOT_MATCH = " do not match with ";
  87
  88     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
  89
  90     @BeforeAll
  91     public static void setUpBeforeClass() {
  92         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
  93         var jpa =
  94                 ProviderUtils.getJpaAndValidate(serviceTemplate, JpaToscaServiceTemplate::new, "toscaServiceTemplate");
  95         serviceTemplate = jpa.toAuthorative();
  96     }
  97
  98     @Test
  99     void testInstantiationCrud() {
 100         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 101         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 102         var compositionId = acDefinition.getCompositionId();
 103         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 104         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 105         var acProvider = mock(AutomationCompositionProvider.class);
 106         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 107         var participantProvider = mock(ParticipantProvider.class);
 108         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 109                 null, supervisionAcHandler, participantProvider,
 110                 CommonTestData.getTestParamaterGroup());
 111         var automationCompositionCreate =
 112                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 113         automationCompositionCreate.setCompositionId(compositionId);
 114         when(acProvider.createAutomationComposition(automationCompositionCreate))
 115                 .thenReturn(automationCompositionCreate);
 116
 117         var instantiationResponse = instantiationProvider.createAutomationComposition(
 118                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 119         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 120
 121         verify(acProvider).createAutomationComposition(automationCompositionCreate);
 122
 123         when(acProvider.getAutomationCompositions(compositionId, automationCompositionCreate.getName(),
 124                 automationCompositionCreate.getVersion())).thenReturn(List.of(automationCompositionCreate));
 125
 126         var automationCompositionsGet = instantiationProvider.getAutomationCompositions(compositionId,
 127                 automationCompositionCreate.getName(), automationCompositionCreate.getVersion());
 128         assertThat(automationCompositionCreate)
 129                 .isEqualTo(automationCompositionsGet.getAutomationCompositionList().get(0));
 130
 131         var automationCompositionUpdate =
 132                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 133         automationCompositionUpdate.setCompositionId(compositionId);
 134         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 135                 .thenReturn(automationCompositionUpdate);
 136         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 137                 .thenReturn(automationCompositionUpdate);
 138
 139         instantiationResponse = instantiationProvider.updateAutomationComposition(
 140                 automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
 141         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 142
 143         verify(acProvider).updateAutomationComposition(automationCompositionUpdate);
 144
 145         when(acProvider.deleteAutomationComposition(automationCompositionUpdate.getInstanceId()))
 146                 .thenReturn(automationCompositionUpdate);
 147         doNothing().when(participantProvider).verifyParticipantState(any());
 148         instantiationProvider.deleteAutomationComposition(automationCompositionCreate.getCompositionId(),
 149                 automationCompositionCreate.getInstanceId());
 150
 151         verify(supervisionAcHandler).delete(any(), any());
 152     }
 153
 154     @Test
 155     void testInstantiationUpdate() {
 156         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 157         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 158         var compositionId = acDefinition.getCompositionId();
 159         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 160
 161         var automationCompositionUpdate =
 162                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 163         automationCompositionUpdate.setCompositionId(compositionId);
 164         automationCompositionUpdate.setInstanceId(UUID.randomUUID());
 165         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 166         automationCompositionUpdate.setLockState(LockState.LOCKED);
 167         var acProvider = mock(AutomationCompositionProvider.class);
 168         var acmFromDb = new AutomationComposition(automationCompositionUpdate);
 169         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId())).thenReturn(acmFromDb);
 170         when(acProvider.updateAutomationComposition(acmFromDb)).thenReturn(acmFromDb);
 171
 172         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 173         var participantProvider = mock(ParticipantProvider.class);
 174         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 175                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 176                 CommonTestData.getTestParamaterGroup());
 177         var instantiationResponse = instantiationProvider.updateAutomationComposition(
 178                 automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
 179
 180         verify(supervisionAcHandler).update(any());
 181         verify(acProvider).updateAutomationComposition(acmFromDb);
 182         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 183
 184         var elements = new ArrayList<>(automationCompositionUpdate.getElements().values());
 185         automationCompositionUpdate.getElements().clear();
 186         for (var element : elements) {
 187             element.setId(UUID.randomUUID());
 188             automationCompositionUpdate.getElements().put(element.getId(), element);
 189         }
 190         assertThatThrownBy(
 191             () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 192             .hasMessageStartingWith("Element id not present ");
 193     }
 194
 195     @Test
 196     void testUpdateBadRequest() {
 197         var automationCompositionUpdate =
 198                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 199         automationCompositionUpdate.setDeployState(DeployState.DEPLOYING);
 200         automationCompositionUpdate.setLockState(LockState.NONE);
 201         var acProvider = mock(AutomationCompositionProvider.class);
 202         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 203                 .thenReturn(automationCompositionUpdate);
 204
 205         var instantiationProvider =
 206             new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 207                 new AcInstanceStateResolver(), mock(SupervisionAcHandler.class), mock(ParticipantProvider.class),
 208                 mock(AcRuntimeParameterGroup.class));
 209
 210         var compositionId = automationCompositionUpdate.getCompositionId();
 211         assertThatThrownBy(
 212                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 213                         .hasMessageMatching(
 214                                 "Not allowed to UPDATE in the state " + automationCompositionUpdate.getDeployState());
 215
 216         automationCompositionUpdate.setDeployState(DeployState.UPDATING);
 217         automationCompositionUpdate.setLockState(LockState.LOCKED);
 218         automationCompositionUpdate.setCompositionTargetId(UUID.randomUUID());
 219         assertThatThrownBy(
 220                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 221                         .hasMessageMatching(
 222                                 "Not allowed to MIGRATE in the state " + automationCompositionUpdate.getDeployState());
 223     }
 224
 225     @Test
 226     void testUpdateRestartedBadRequest() {
 227         var automationCompositionUpdate =
 228                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 229         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 230         automationCompositionUpdate.setLockState(LockState.LOCKED);
 231         automationCompositionUpdate.setRestarting(true);
 232         var acProvider = mock(AutomationCompositionProvider.class);
 233         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 234                 .thenReturn(automationCompositionUpdate);
 235
 236         var instantiationProvider =
 237                 new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class), null,
 238                         mock(SupervisionAcHandler.class), mock(ParticipantProvider.class),
 239                         mock(AcRuntimeParameterGroup.class));
 240
 241         var compositionId = automationCompositionUpdate.getCompositionId();
 242         assertThatThrownBy(
 243                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 244                         .hasMessageMatching("There is a restarting process, Update not allowed");
 245
 246         automationCompositionUpdate.setCompositionTargetId(UUID.randomUUID());
 247         assertThatThrownBy(
 248                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 249                 .hasMessageMatching("There is a restarting process, Update not allowed");
 250
 251         automationCompositionUpdate.setDeployState(DeployState.UNDEPLOYED);
 252         automationCompositionUpdate.setLockState(LockState.NONE);
 253
 254         var instanceId = automationCompositionUpdate.getInstanceId();
 255         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 256                 .hasMessageMatching("There is a restarting process, Delete not allowed");
 257     }
 258
 259     @Test
 260     void testUpdateCompositionRestartedBadRequest() {
 261         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 262         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 263         acDefinition.setRestarting(true);
 264         var compositionId = acDefinition.getCompositionId();
 265         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 266
 267         var automationCompositionUpdate =
 268                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 269         automationCompositionUpdate.setCompositionId(compositionId);
 270         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 271         automationCompositionUpdate.setLockState(LockState.LOCKED);
 272         var acProvider = mock(AutomationCompositionProvider.class);
 273         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 274                 .thenReturn(automationCompositionUpdate);
 275         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 276                 .thenReturn(automationCompositionUpdate);
 277
 278         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 279         var participantProvider = mock(ParticipantProvider.class);
 280         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 281                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 282                 mock(AcRuntimeParameterGroup.class));
 283         assertThatThrownBy(
 284                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 285                         .hasMessageMatching("\"AutomationComposition\" INVALID, item has status INVALID\n"
 286                                 + "  item \"ServiceTemplate.restarting\" value \"true\" INVALID,"
 287                                 + " There is a restarting process in composition\n");
 288     }
 289
 290     @Test
 291     void testInstantiationMigration() {
 292         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 293         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 294         var compositionId = acDefinition.getCompositionId();
 295         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 296
 297         var automationComposition =
 298                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 299         automationComposition.setCompositionId(compositionId);
 300         automationComposition.setDeployState(DeployState.DEPLOYED);
 301         automationComposition.setLockState(LockState.LOCKED);
 302         automationComposition.setCompositionTargetId(UUID.randomUUID());
 303         var acProvider = mock(AutomationCompositionProvider.class);
 304         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 305                 .thenReturn(automationComposition);
 306         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 307
 308         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 309         var participantProvider = mock(ParticipantProvider.class);
 310         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 311             new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, new AcRuntimeParameterGroup());
 312
 313         assertThatThrownBy(() -> instantiationProvider
 314                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
 315                         .hasMessageMatching(
 316                                 String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId()));
 317
 318         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 319         var compositionTargetId = acDefinitionTarget.getCompositionId();
 320         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 321
 322         automationComposition.setCompositionTargetId(compositionTargetId);
 323
 324         var instantiationResponse = instantiationProvider
 325                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
 326
 327         verify(supervisionAcHandler).migrate(any());
 328         verify(acProvider).updateAutomationComposition(automationComposition);
 329         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
 330     }
 331
 332
 333     @Test
 334     void testInstantiationMigrationPrecheck() {
 335         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 336         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 337         var compositionId = acDefinition.getCompositionId();
 338         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 339
 340         var automationComposition =
 341             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 342         automationComposition.setCompositionId(compositionId);
 343         automationComposition.setDeployState(DeployState.DEPLOYED);
 344         automationComposition.setLockState(LockState.LOCKED);
 345         automationComposition.setCompositionTargetId(UUID.randomUUID());
 346         automationComposition.setPrecheck(true);
 347         var acProvider = mock(AutomationCompositionProvider.class);
 348         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 349             .thenReturn(automationComposition);
 350         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 351
 352         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 353         var acmParticipantProvider = mock(ParticipantProvider.class);
 354         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 355             new AcInstanceStateResolver(), supervisionAcHandler, acmParticipantProvider, new AcRuntimeParameterGroup());
 356
 357         assertThatThrownBy(() -> instantiationProvider
 358             .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
 359             .hasMessageMatching(
 360                 String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId()));
 361
 362         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 363         var compositionTargetId = acDefinitionTarget.getCompositionId();
 364         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 365
 366         automationComposition.setCompositionTargetId(compositionTargetId);
 367
 368         var instantiationResponse = instantiationProvider
 369             .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
 370
 371         verify(supervisionAcHandler).migratePrecheck(any());
 372         verify(acProvider).updateAutomationComposition(automationComposition);
 373         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
 374     }
 375
 376     @Test
 377     void testMigrateBadRequest() {
 378         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 379         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 380         var compositionId = acDefinition.getCompositionId();
 381         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 382
 383         var automationComposition =
 384                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 385         automationComposition.setCompositionId(compositionId);
 386         automationComposition.setDeployState(DeployState.DEPLOYED);
 387         automationComposition.setLockState(LockState.LOCKED);
 388         var acProvider = mock(AutomationCompositionProvider.class);
 389         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 390                 .thenReturn(automationComposition);
 391         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 392
 393         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 394         var compositionTargetId = acDefinitionTarget.getCompositionId();
 395         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 396
 397         var acMigrate = new AutomationComposition(automationComposition);
 398         acMigrate.setCompositionTargetId(compositionTargetId);
 399         automationComposition.getElements().clear();
 400
 401         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 402         var participantProvider = mock(ParticipantProvider.class);
 403         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 404                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 405                 new AcRuntimeParameterGroup());
 406
 407         assertThatThrownBy(() -> instantiationProvider
 408                 .updateAutomationComposition(automationComposition.getCompositionId(), acMigrate))
 409                 .hasMessageStartingWith("Element id not present");
 410     }
 411
 412     @Test
 413     void testMigratePrecheckBadRequest() {
 414         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 415         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 416         var compositionId = acDefinition.getCompositionId();
 417         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 418
 419         var automationComposition =
 420                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 421         automationComposition.setCompositionId(compositionId);
 422         automationComposition.setDeployState(DeployState.DEPLOYED);
 423         automationComposition.setLockState(LockState.LOCKED);
 424         automationComposition.setPrecheck(true);
 425         var acProvider = mock(AutomationCompositionProvider.class);
 426         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 427                 .thenReturn(automationComposition);
 428         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 429
 430         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 431         var compositionTargetId = acDefinitionTarget.getCompositionId();
 432         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 433
 434         var acMigrate = new AutomationComposition(automationComposition);
 435         acMigrate.setCompositionTargetId(compositionTargetId);
 436         automationComposition.getElements().clear();
 437
 438         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 439         var participantProvider = mock(ParticipantProvider.class);
 440         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 441                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 442                 new AcRuntimeParameterGroup());
 443
 444         assertThatThrownBy(() -> instantiationProvider
 445                 .updateAutomationComposition(automationComposition.getCompositionId(), acMigrate))
 446                 .hasMessageStartingWith("Element id not present");
 447     }
 448
 449     @Test
 450     void testInstantiationDelete() {
 451         var automationComposition =
 452                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 453         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 454         var acProvider = mock(AutomationCompositionProvider.class);
 455         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 456         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 457         var compositionId = acDefinition.getCompositionId();
 458         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 459         automationComposition.setCompositionId(compositionId);
 460         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 461         var participantProvider = mock(ParticipantProvider.class);
 462         var acRuntimeParameterGroup = mock(AcRuntimeParameterGroup.class);
 463
 464         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 465                 null, supervisionAcHandler, participantProvider, acRuntimeParameterGroup);
 466
 467         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 468                 .thenReturn(automationComposition);
 469
 470         var wrongCompositionId = UUID.randomUUID();
 471         var instanceId = automationComposition.getInstanceId();
 472         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(wrongCompositionId, instanceId))
 473                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 474
 475         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYED, LockState.LOCKED);
 476         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYING, LockState.NONE);
 477         assertThatDeleteThrownBy(automationComposition, DeployState.UNDEPLOYING, LockState.LOCKED);
 478         assertThatDeleteThrownBy(automationComposition, DeployState.DELETING, LockState.NONE);
 479
 480         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 481         automationComposition.setLockState(LockState.NONE);
 482         when(acProvider.deleteAutomationComposition(instanceId)).thenReturn(automationComposition);
 483
 484         instantiationProvider.deleteAutomationComposition(compositionId, instanceId);
 485         verify(supervisionAcHandler).delete(any(), any());
 486     }
 487
 488     private void assertThatDeleteThrownBy(AutomationComposition automationComposition, DeployState deployState,
 489             LockState lockState) {
 490         automationComposition.setDeployState(deployState);
 491         automationComposition.setLockState(lockState);
 492         var acProvider = mock(AutomationCompositionProvider.class);
 493         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 494         var acRuntimeParamaterGroup = mock(AcRuntimeParameterGroup.class);
 495
 496         var instantiationProvider =
 497                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null,
 498                         acRuntimeParamaterGroup);
 499
 500         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 501                 .thenReturn(automationComposition);
 502
 503         var compositionId = automationComposition.getCompositionId();
 504         var instanceId = automationComposition.getInstanceId();
 505         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 506                 .hasMessageMatching(String.format(DELETE_BAD_REQUEST, deployState));
 507     }
 508
 509     @Test
 510     void testCreateAutomationCompositions_NoDuplicates() {
 511         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 512         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 513         var compositionId = acDefinition.getCompositionId();
 514         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 515
 516         var automationCompositionCreate =
 517                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "NoDuplicates");
 518         automationCompositionCreate.setCompositionId(compositionId);
 519         automationCompositionCreate.setInstanceId(UUID.randomUUID());
 520
 521         var acProvider = mock(AutomationCompositionProvider.class);
 522         when(acProvider.createAutomationComposition(automationCompositionCreate))
 523                 .thenReturn(automationCompositionCreate);
 524         var participantProvider = mock(ParticipantProvider.class);
 525
 526         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 527                 null, null, participantProvider,
 528                 CommonTestData.getTestParamaterGroup());
 529
 530         var instantiationResponse = instantiationProvider.createAutomationComposition(
 531                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 532         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 533
 534         when(acProvider.findAutomationComposition(automationCompositionCreate.getKey().asIdentifier()))
 535                 .thenReturn(Optional.of(automationCompositionCreate));
 536
 537         assertThatThrownBy(
 538                 () -> instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate))
 539                         .hasMessageMatching(automationCompositionCreate.getKey().asIdentifier() + " already defined");
 540     }
 541
 542     @Test
 543     void testCreateAutomationCompositions_CommissionedAcElementNotFound() {
 544         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 545         var participantProvider = mock(ParticipantProvider.class);
 546         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 547         var compositionId = acDefinition.getCompositionId();
 548         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 549         var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(
 550                 AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON, "AcElementNotFound");
 551         automationComposition.setCompositionId(compositionId);
 552
 553         var acProvider = mock(AutomationCompositionProvider.class);
 554         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null,
 555                 participantProvider, CommonTestData.getTestParamaterGroup());
 556
 557         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 558                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 559
 560         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 561                 .thenReturn(automationComposition);
 562
 563         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 564                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 565     }
 566
 567     @Test
 568     void testAcDefinitionNotFound() {
 569         var automationComposition = InstantiationUtils
 570                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 571
 572         var acProvider = mock(AutomationCompositionProvider.class);
 573         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 574                 .thenReturn(automationComposition);
 575         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 576                 null, null, null,
 577                 mock(AcRuntimeParameterGroup.class));
 578
 579         var compositionId = automationComposition.getCompositionId();
 580         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 581                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
 582
 583         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 584                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
 585     }
 586
 587     @Test
 588     void testCompositionIdDoNotMatch() {
 589         var automationComposition = InstantiationUtils
 590                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 591
 592         var acProvider = mock(AutomationCompositionProvider.class);
 593         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 594                 .thenReturn(automationComposition);
 595         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 596                 null, null, null,
 597                 mock(AcRuntimeParameterGroup.class));
 598
 599         var compositionId = automationComposition.getCompositionId();
 600         var wrongCompositionId = UUID.randomUUID();
 601         assertThatThrownBy(() -> provider.createAutomationComposition(wrongCompositionId, automationComposition))
 602                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 603
 604         assertThatThrownBy(() -> provider.updateAutomationComposition(wrongCompositionId, automationComposition))
 605                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 606
 607         assertThatThrownBy(
 608                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 609                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 610         assertThatThrownBy(() -> provider.compositionInstanceState(wrongCompositionId,
 611                 automationComposition.getInstanceId(), new AcInstanceStateUpdate()))
 612                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 613
 614         var compositionTargetId = UUID.randomUUID();
 615         automationComposition.setCompositionTargetId(compositionTargetId);
 616         assertThatThrownBy(
 617                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 618                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 619
 620         var result = provider.getAutomationComposition(compositionTargetId, automationComposition.getInstanceId());
 621         assertThat(result).isNotNull();
 622     }
 623
 624     @Test
 625     void testCompositionNotPrimed() {
 626         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 627         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 628         var compositionId = acDefinition.getCompositionId();
 629         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 630         var acProvider = mock(AutomationCompositionProvider.class);
 631         var provider =
 632                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null,
 633                         null);
 634
 635         var automationComposition =
 636                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 637         automationComposition.setCompositionId(compositionId);
 638         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 639                 .hasMessageMatching("\"AutomationComposition\" INVALID, item has status INVALID\n"
 640                         + "  item \"ServiceTemplate.state\" value \"COMMISSIONED\" INVALID,"
 641                         + " Commissioned automation composition definition not primed\n");
 642     }
 643
 644     @Test
 645     void testCompositionInstanceState() {
 646         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 647         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 648         var compositionId = acDefinition.getCompositionId();
 649         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 650
 651         var automationComposition = InstantiationUtils
 652                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 653         var instanceId = UUID.randomUUID();
 654         automationComposition.setCompositionId(compositionId);
 655         automationComposition.setInstanceId(instanceId);
 656         var acProvider = mock(AutomationCompositionProvider.class);
 657         when(acProvider.getAutomationComposition(instanceId)).thenReturn(automationComposition);
 658
 659         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 660         var participantProvider = mock(ParticipantProvider.class);
 661         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 662                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 663                 mock(AcRuntimeParameterGroup.class));
 664
 665         var acInstanceStateUpdate = new AcInstanceStateUpdate();
 666         acInstanceStateUpdate.setDeployOrder(DeployOrder.DEPLOY);
 667         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 668         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 669         verify(supervisionAcHandler).deploy(any(AutomationComposition.class),
 670                 any(AutomationCompositionDefinition.class));
 671
 672         automationComposition.setDeployState(DeployState.DEPLOYED);
 673         automationComposition.setLockState(LockState.LOCKED);
 674         acInstanceStateUpdate.setDeployOrder(DeployOrder.UNDEPLOY);
 675         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 676         verify(supervisionAcHandler).undeploy(any(AutomationComposition.class),
 677                 any(AutomationCompositionDefinition.class));
 678
 679         automationComposition.setDeployState(DeployState.DEPLOYED);
 680         automationComposition.setLockState(LockState.LOCKED);
 681         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 682         acInstanceStateUpdate.setLockOrder(LockOrder.UNLOCK);
 683         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 684         verify(supervisionAcHandler).unlock(any(AutomationComposition.class),
 685                 any(AutomationCompositionDefinition.class));
 686
 687         automationComposition.setDeployState(DeployState.DEPLOYED);
 688         automationComposition.setLockState(LockState.UNLOCKED);
 689         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 690         acInstanceStateUpdate.setLockOrder(LockOrder.LOCK);
 691         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 692         verify(supervisionAcHandler).lock(any(AutomationComposition.class), any(AutomationCompositionDefinition.class));
 693
 694         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 695         automationComposition.setLockState(LockState.NONE);
 696         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 697         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 698         acInstanceStateUpdate.setSubOrder(SubOrder.PREPARE);
 699         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 700         verify(supervisionAcHandler).prepare(any(AutomationComposition.class));
 701
 702         automationComposition.setDeployState(DeployState.DEPLOYED);
 703         automationComposition.setLockState(LockState.LOCKED);
 704         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 705         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 706         acInstanceStateUpdate.setSubOrder(SubOrder.REVIEW);
 707         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 708         verify(supervisionAcHandler).review(any(AutomationComposition.class));
 709     }
 710 }