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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2025 OpenInfra Foundation Europe. All rights reserved.
   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.junit.jupiter.api.Assertions.assertEquals;
  27 import static org.junit.jupiter.api.Assertions.assertThrows;
  28 import static org.mockito.ArgumentMatchers.any;
  29 import static org.mockito.Mockito.doNothing;
  30 import static org.mockito.Mockito.doThrow;
  31 import static org.mockito.Mockito.mock;
  32 import static org.mockito.Mockito.never;
  33 import static org.mockito.Mockito.verify;
  34 import static org.mockito.Mockito.when;
  35 import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVICE_TEMPLATE_YAML;
  36
  37 import jakarta.ws.rs.core.Response;
  38 import jakarta.ws.rs.core.Response.Status;
  39 import java.util.ArrayList;
  40 import java.util.List;
  41 import java.util.UUID;
  42 import org.junit.jupiter.api.BeforeAll;
  43 import org.junit.jupiter.api.Test;
  44 import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
  45 import org.onap.policy.clamp.acm.runtime.main.utils.EncryptionUtils;
  46 import org.onap.policy.clamp.acm.runtime.supervision.SupervisionAcHandler;
  47 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
  48 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  49 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  50 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
  51 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionRollback;
  52 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  53 import org.onap.policy.clamp.models.acm.concepts.LockState;
  54 import org.onap.policy.clamp.models.acm.concepts.MigrationState;
  55 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  56 import org.onap.policy.clamp.models.acm.concepts.SubState;
  57 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.AcInstanceStateUpdate;
  58 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  59 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
  60 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.SubOrder;
  61 import org.onap.policy.clamp.models.acm.persistence.concepts.JpaAutomationCompositionRollback;
  62 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
  63 import org.onap.policy.clamp.models.acm.persistence.provider.AcInstanceStateResolver;
  64 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
  65 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
  66 import org.onap.policy.clamp.models.acm.persistence.provider.ProviderUtils;
  67 import org.onap.policy.clamp.models.acm.utils.AcmStateUtils;
  68 import org.onap.policy.models.base.PfModelRuntimeException;
  69 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  70 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
  71 import org.springframework.data.domain.Pageable;
  72
  73 /**
  74  * Class to perform unit test of {@link AutomationCompositionInstantiationProvider}}.
  75  *
  76  */
  77 class AutomationCompositionInstantiationProviderTest {
  78
  79     public static final String MIGRATION_SERVICE_TEMPLATE_YAML = "clamp/acm/pmsh/funtional-pmsh-usecase-migration.yaml";
  80     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  81     private static final String AC_INSTANTIATION_UPDATE_JSON =
  82             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  83     private static final String AC_MIGRATE_JSON = "src/test/resources/rest/acm/AutomationCompositionMigrate.json";
  84
  85     private static final String AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON =
  86             "src/test/resources/rest/acm/AutomationCompositionElementsNotFound.json";
  87     private static final String AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON =
  88             "src/test/resources/rest/acm/AutomationCompositionNotFound.json";
  89     private static final String DELETE_BAD_REQUEST = "Not valid order DELETE;";
  90
  91     private static final String AC_ELEMENT_NAME_NOT_FOUND = """
  92                 "entry org.onap.domain.pmsh.DCAEMicroservice" INVALID, Not found
  93                 "entry org.onap.domain.pmsh.PMSH_MonitoringPolicyAutomationCompositionElement" INVALID, Not found
  94             """;
  95     private static final String AC_DEFINITION_NOT_FOUND = """
  96             "AutomationComposition" INVALID, item has status INVALID
  97               item "ServiceTemplate" value "%s" INVALID, Commissioned automation composition definition not found
  98             """;
  99
 100     private static final String DO_NOT_MATCH = " do not match with ";
 101
 102     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
 103     private static ToscaServiceTemplate serviceTemplateMigration = new ToscaServiceTemplate();
 104
 105     @BeforeAll
 106     static void setUpBeforeClass() {
 107         var st = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 108         var jpa = ProviderUtils.getJpaAndValidate(st, JpaToscaServiceTemplate::new, "toscaServiceTemplate");
 109         serviceTemplate = jpa.toAuthorative();
 110
 111         st = InstantiationUtils.getToscaServiceTemplate(MIGRATION_SERVICE_TEMPLATE_YAML);
 112         jpa = ProviderUtils.getJpaAndValidate(st, JpaToscaServiceTemplate::new, "migrationServiceTemplate");
 113         serviceTemplateMigration = jpa.toAuthorative();
 114     }
 115
 116     @Test
 117     void testGetAutomationCompositionsWithNull() {
 118         var instantiationProvider = new AutomationCompositionInstantiationProvider(
 119                 mock(AutomationCompositionProvider.class), mock(AcDefinitionProvider.class),
 120                 new AcInstanceStateResolver(), mock(SupervisionAcHandler.class), mock(ParticipantProvider.class),
 121                 CommonTestData.getTestParamaterGroup(), new EncryptionUtils(CommonTestData.getTestParamaterGroup()));
 122         assertThatThrownBy(() -> instantiationProvider
 123                 .getAutomationCompositions(null, null, null, Pageable.unpaged()))
 124                 .hasMessage("compositionId is marked non-null but is null");
 125         assertThatThrownBy(() -> instantiationProvider
 126                 .getAutomationCompositions(UUID.randomUUID(), null, null, null))
 127                 .hasMessage("pageable is marked non-null but is null");
 128     }
 129
 130     @Test
 131     void testInstantiationCrud() {
 132         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 133         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 134         var compositionId = acDefinition.getCompositionId();
 135         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 136         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 137         var acProvider = mock(AutomationCompositionProvider.class);
 138         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 139         var participantProvider = mock(ParticipantProvider.class);
 140         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 141         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 142                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 143                 CommonTestData.getTestParamaterGroup(), encryptionUtils);
 144         var automationCompositionCreate =
 145                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 146         automationCompositionCreate.setCompositionId(compositionId);
 147         when(acProvider.createAutomationComposition(automationCompositionCreate))
 148                 .thenReturn(automationCompositionCreate);
 149
 150         var instantiationResponse = instantiationProvider.createAutomationComposition(
 151                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 152         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 153
 154         verify(acProvider).createAutomationComposition(automationCompositionCreate);
 155
 156         assertEquals(StateChangeResult.NO_ERROR, acProvider.createAutomationComposition(automationCompositionCreate)
 157                 .getStateChangeResult());
 158
 159         when(acProvider.getAutomationCompositions(compositionId, automationCompositionCreate.getName(),
 160                 automationCompositionCreate.getVersion(), Pageable.unpaged()))
 161                 .thenReturn(List.of(automationCompositionCreate));
 162
 163         var automationCompositionsGet = instantiationProvider.getAutomationCompositions(compositionId,
 164                 automationCompositionCreate.getName(), automationCompositionCreate.getVersion(), Pageable.unpaged());
 165         assertThat(automationCompositionCreate)
 166                 .isEqualTo(automationCompositionsGet.getAutomationCompositionList().get(0));
 167
 168         var automationCompositionUpdate =
 169                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 170         automationCompositionUpdate.setCompositionId(compositionId);
 171         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 172                 .thenReturn(automationCompositionUpdate);
 173         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 174                 .thenReturn(automationCompositionUpdate);
 175
 176         instantiationResponse = instantiationProvider.updateAutomationComposition(
 177                 automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
 178         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 179
 180         verify(acProvider).updateAutomationComposition(automationCompositionUpdate);
 181
 182         when(acProvider.deleteAutomationComposition(automationCompositionUpdate.getInstanceId()))
 183                 .thenReturn(automationCompositionUpdate);
 184         doNothing().when(participantProvider).verifyParticipantState(any());
 185         instantiationProvider.deleteAutomationComposition(automationCompositionCreate.getCompositionId(),
 186                 automationCompositionCreate.getInstanceId());
 187
 188         verify(supervisionAcHandler).delete(any(), any());
 189     }
 190
 191     @Test
 192     void testInstantiationUpdate() {
 193         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 194         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 195         var compositionId = acDefinition.getCompositionId();
 196         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 197
 198         var automationCompositionUpdate =
 199                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 200         automationCompositionUpdate.setCompositionId(compositionId);
 201         automationCompositionUpdate.setInstanceId(UUID.randomUUID());
 202         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 203         automationCompositionUpdate.setLockState(LockState.LOCKED);
 204         var acProvider = mock(AutomationCompositionProvider.class);
 205         var acmFromDb = new AutomationComposition(automationCompositionUpdate);
 206         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId())).thenReturn(acmFromDb);
 207         when(acProvider.updateAutomationComposition(acmFromDb)).thenReturn(acmFromDb);
 208
 209         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 210         var participantProvider = mock(ParticipantProvider.class);
 211         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 212         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 213                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 214                 CommonTestData.getTestParamaterGroup(), encryptionUtils);
 215
 216         var instantiationResponse = instantiationProvider.updateAutomationComposition(
 217                 automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
 218
 219         verify(supervisionAcHandler).update(any(), any());
 220         verify(acProvider).updateAutomationComposition(acmFromDb);
 221         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 222
 223         var elements = new ArrayList<>(automationCompositionUpdate.getElements().values());
 224         automationCompositionUpdate.getElements().clear();
 225         for (var element : elements) {
 226             element.setId(UUID.randomUUID());
 227             automationCompositionUpdate.getElements().put(element.getId(), element);
 228         }
 229         acmFromDb.getElements().values().forEach(element ->
 230                 element.setDeployState(DeployState.DEPLOYED));
 231         acmFromDb.setDeployState(DeployState.DEPLOYED);
 232         assertThatThrownBy(
 233                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 234                 .hasMessageStartingWith("Element id not present ");
 235
 236     }
 237
 238     @Test
 239     void testUpdateBadRequest() {
 240         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 241         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 242         var compositionId = acDefinition.getCompositionId();
 243         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 244
 245         var automationCompositionUpdate =
 246                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 247         automationCompositionUpdate.setDeployState(DeployState.DEPLOYING);
 248         automationCompositionUpdate.setLockState(LockState.NONE);
 249         automationCompositionUpdate.setCompositionId(compositionId);
 250         var acProvider = mock(AutomationCompositionProvider.class);
 251         var encryptionUtils = mock(EncryptionUtils.class);
 252         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 253                 .thenReturn(automationCompositionUpdate);
 254
 255         var instantiationProvider =
 256                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 257                         new AcInstanceStateResolver(), mock(SupervisionAcHandler.class),
 258                         mock(ParticipantProvider.class),
 259                         mock(AcRuntimeParameterGroup.class), encryptionUtils);
 260
 261
 262         assertThatThrownBy(
 263                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 264                 .hasMessageMatching(
 265                         "Not allowed to UPDATE in the state " + automationCompositionUpdate.getDeployState());
 266
 267         automationCompositionUpdate.setDeployState(DeployState.UPDATING);
 268         automationCompositionUpdate.setLockState(LockState.LOCKED);
 269         automationCompositionUpdate.setCompositionTargetId(UUID.randomUUID());
 270         assertThatThrownBy(
 271                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 272                 .hasMessageMatching(
 273                         "Not allowed to MIGRATE in the state " + automationCompositionUpdate.getDeployState());
 274     }
 275
 276     @Test
 277     void testMigrationAddRemoveElements() {
 278         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 279         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 280         var compositionId = acDefinition.getCompositionId();
 281         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 282         var instanceId = UUID.randomUUID();
 283
 284         var automationComposition =
 285                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 286         automationComposition.setCompositionId(compositionId);
 287         automationComposition.setInstanceId(instanceId);
 288         automationComposition.setDeployState(DeployState.DEPLOYED);
 289         automationComposition.setLockState(LockState.LOCKED);
 290         var acProvider = mock(AutomationCompositionProvider.class);
 291         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 292                 .thenReturn(automationComposition);
 293
 294         var automationCompositionTarget =
 295                 InstantiationUtils.getAutomationCompositionFromResource(AC_MIGRATE_JSON, "Migrate");
 296         automationCompositionTarget.setInstanceId(instanceId);
 297         automationCompositionTarget.setCompositionId(compositionId);
 298         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplateMigration, AcTypeState.PRIMED);
 299         var compositionTargetId = acDefinitionTarget.getCompositionId();
 300         automationCompositionTarget.setCompositionTargetId(compositionTargetId);
 301         when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
 302         when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
 303         when(acProvider.updateAutomationComposition(any())).thenReturn(automationCompositionTarget);
 304
 305         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 306         var participantProvider = mock(ParticipantProvider.class);
 307         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 308         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 309                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 310                 new AcRuntimeParameterGroup(), encryptionUtils);
 311
 312         automationCompositionTarget.setPrecheck(true);
 313         var preCheckResponse = instantiationProvider.updateAutomationComposition(compositionId,
 314                 automationCompositionTarget);
 315         verify(supervisionAcHandler).migratePrecheck(any(), any(), any());
 316         InstantiationUtils.assertInstantiationResponse(preCheckResponse, automationCompositionTarget);
 317
 318         automationCompositionTarget.setPrecheck(false);
 319         AcmStateUtils.setCascadedState(automationComposition, DeployState.DEPLOYED, LockState.LOCKED,
 320                 SubState.NONE);
 321         automationComposition.getElements().values()
 322                 .forEach(el -> el.setMigrationState(MigrationState.DEFAULT));
 323         var instantiationResponse = instantiationProvider.updateAutomationComposition(compositionId,
 324                 automationCompositionTarget);
 325
 326         verify(supervisionAcHandler).migrate(any(), any(), any());
 327         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionTarget);
 328     }
 329
 330     @Test
 331     void testInstantiationMigration() {
 332         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 333         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 334         var compositionId = acDefinition.getCompositionId();
 335         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 336
 337         var automationComposition =
 338                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 339         automationComposition.setCompositionId(compositionId);
 340         automationComposition.setDeployState(DeployState.DEPLOYED);
 341         automationComposition.setLockState(LockState.LOCKED);
 342         automationComposition.setCompositionTargetId(UUID.randomUUID());
 343         when(acDefinitionProvider.getAcDefinition(automationComposition.getCompositionTargetId()))
 344                 .thenThrow(new PfModelRuntimeException(Status.NOT_FOUND,
 345                         String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId())));
 346         var acProvider = mock(AutomationCompositionProvider.class);
 347         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 348                 .thenReturn(automationComposition);
 349         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 350
 351         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 352         var participantProvider = mock(ParticipantProvider.class);
 353         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 354         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 355                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, new AcRuntimeParameterGroup(),
 356                 encryptionUtils);
 357
 358         assertThatThrownBy(() -> instantiationProvider
 359                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
 360                 .hasMessageMatching(
 361                         String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId()));
 362
 363         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 364         var compositionTargetId = acDefinitionTarget.getCompositionId();
 365         when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
 366
 367         automationComposition.setCompositionTargetId(compositionTargetId);
 368
 369         var instantiationResponse = instantiationProvider
 370                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
 371
 372         verify(supervisionAcHandler).migrate(any(), any(), any());
 373         verify(acProvider).updateAutomationComposition(automationComposition);
 374         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
 375     }
 376
 377     @Test
 378     void testInstantiationMigrationPrecheck() {
 379         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 380         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 381         var compositionId = acDefinition.getCompositionId();
 382         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 383
 384         var automationComposition =
 385                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 386         automationComposition.setCompositionId(compositionId);
 387         automationComposition.setDeployState(DeployState.DEPLOYED);
 388         automationComposition.setLockState(LockState.LOCKED);
 389         automationComposition.setCompositionTargetId(UUID.randomUUID());
 390         automationComposition.setPrecheck(true);
 391         var acProvider = mock(AutomationCompositionProvider.class);
 392         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 393                 .thenReturn(automationComposition);
 394         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 395
 396         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 397         var acmParticipantProvider = mock(ParticipantProvider.class);
 398         var encryptionUtils = mock(EncryptionUtils.class);
 399         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 400                 new AcInstanceStateResolver(), supervisionAcHandler, acmParticipantProvider,
 401                 new AcRuntimeParameterGroup(), encryptionUtils);
 402
 403         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 404         var compositionTargetId = acDefinitionTarget.getCompositionId();
 405         when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
 406         automationComposition.setCompositionTargetId(compositionTargetId);
 407
 408         var instantiationResponse = instantiationProvider
 409                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
 410
 411         verify(supervisionAcHandler).migratePrecheck(any(), any(), any());
 412         verify(acProvider).updateAutomationComposition(automationComposition);
 413         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
 414
 415         automationComposition.setSubState(SubState.NONE);
 416         when(acDefinitionProvider.getAcDefinition(compositionTargetId))
 417                 .thenThrow(new PfModelRuntimeException(Status.NOT_FOUND,
 418                         String.format(AC_DEFINITION_NOT_FOUND, compositionTargetId)));
 419         assertThatThrownBy(() -> instantiationProvider
 420                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
 421                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionTargetId));
 422     }
 423
 424     @Test
 425     void testMigrateBadRequest() {
 426         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 427         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 428         var compositionId = acDefinition.getCompositionId();
 429         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 430
 431         var automationComposition =
 432                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 433         automationComposition.setCompositionId(compositionId);
 434         automationComposition.setDeployState(DeployState.DEPLOYED);
 435         automationComposition.setLockState(LockState.LOCKED);
 436         var acProvider = mock(AutomationCompositionProvider.class);
 437         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 438                 .thenReturn(automationComposition);
 439         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 440
 441         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 442         var compositionTargetId = acDefinitionTarget.getCompositionId();
 443         when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
 444
 445         var acMigrate = new AutomationComposition(automationComposition);
 446         acMigrate.setCompositionTargetId(compositionTargetId);
 447         automationComposition.setDeployState(DeployState.DEPLOYING);
 448
 449         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 450         var participantProvider = mock(ParticipantProvider.class);
 451         var encryptionUtils = mock(EncryptionUtils.class);
 452         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 453                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 454                 new AcRuntimeParameterGroup(), encryptionUtils);
 455
 456         assertThatThrownBy(() -> instantiationProvider
 457                 .updateAutomationComposition(automationComposition.getCompositionId(), acMigrate))
 458                 .hasMessageStartingWith("Not allowed to MIGRATE in the state DEPLOYING");
 459     }
 460
 461     @Test
 462     void testMigratePreCheckBadRequest() {
 463         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 464         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 465         var compositionId = acDefinition.getCompositionId();
 466         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 467
 468         var automationComposition =
 469                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 470         automationComposition.setCompositionId(compositionId);
 471         automationComposition.setDeployState(DeployState.DEPLOYED);
 472         automationComposition.setLockState(LockState.LOCKED);
 473         automationComposition.setPrecheck(true);
 474         var acProvider = mock(AutomationCompositionProvider.class);
 475         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 476                 .thenReturn(automationComposition);
 477         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 478
 479         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 480         var compositionTargetId = acDefinitionTarget.getCompositionId();
 481         when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
 482
 483         var acMigrate = new AutomationComposition(automationComposition);
 484         acMigrate.setCompositionTargetId(compositionTargetId);
 485         automationComposition.setDeployState(DeployState.DEPLOYING);
 486         automationComposition.setPrecheck(true);
 487
 488         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 489         var participantProvider = mock(ParticipantProvider.class);
 490         var encryptionUtils = mock(EncryptionUtils.class);
 491         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 492                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 493                 new AcRuntimeParameterGroup(), encryptionUtils);
 494
 495         assertThatThrownBy(() -> instantiationProvider
 496                 .updateAutomationComposition(automationComposition.getCompositionId(), acMigrate))
 497                 .hasMessageStartingWith("Not allowed to NONE in the state DEPLOYING");
 498     }
 499
 500     @Test
 501     void testInstantiationDelete() {
 502         var automationComposition =
 503                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 504         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 505         var acProvider = mock(AutomationCompositionProvider.class);
 506         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 507         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 508         var compositionId = acDefinition.getCompositionId();
 509         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 510         automationComposition.setCompositionId(compositionId);
 511         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 512         var participantProvider = mock(ParticipantProvider.class);
 513         var acRuntimeParameterGroup = mock(AcRuntimeParameterGroup.class);
 514         var encryptionUtils = mock(EncryptionUtils.class);
 515
 516         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 517                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, acRuntimeParameterGroup,
 518                 encryptionUtils);
 519
 520         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 521                 .thenReturn(automationComposition);
 522
 523         var wrongCompositionId = UUID.randomUUID();
 524         var instanceId = automationComposition.getInstanceId();
 525         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(wrongCompositionId, instanceId))
 526                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 527
 528         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 529         automationComposition.setLockState(LockState.NONE);
 530         when(acProvider.deleteAutomationComposition(instanceId)).thenReturn(automationComposition);
 531         instantiationProvider.deleteAutomationComposition(compositionId, instanceId);
 532         verify(supervisionAcHandler).delete(any(), any());
 533     }
 534
 535     @Test
 536     void testInstantiationDeleteError() {
 537         var automationComposition =
 538                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 539         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 540         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYED, LockState.LOCKED);
 541         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYING, LockState.NONE);
 542         assertThatDeleteThrownBy(automationComposition, DeployState.UNDEPLOYING, LockState.LOCKED);
 543         assertThatDeleteThrownBy(automationComposition, DeployState.DELETING, LockState.NONE);
 544     }
 545
 546     @Test
 547     void testRollbackFailure() {
 548         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 549         var compositionId = acDefinition.getCompositionId();
 550         var automationComposition =
 551                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Rollback");
 552         automationComposition.setCompositionId(compositionId);
 553         automationComposition.setInstanceId(UUID.randomUUID());
 554         automationComposition.setDeployState(DeployState.MIGRATION_REVERTING);
 555         automationComposition.setCompositionTargetId(UUID.randomUUID());
 556
 557         var acProvider = mock(AutomationCompositionProvider.class);
 558         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 559                 .thenReturn(automationComposition);
 560         var rollbackRecord = new JpaAutomationCompositionRollback();
 561         when(acProvider.getAutomationCompositionRollback(any(UUID.class))).thenReturn(rollbackRecord.toAuthorative());
 562
 563         final var acDefinitionProvider = mock(AcDefinitionProvider.class);
 564         final var supervisionAcHandler = mock(SupervisionAcHandler.class);
 565         final var participantProvider = mock(ParticipantProvider.class);
 566         final var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 567         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 568                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, new AcRuntimeParameterGroup(),
 569                 encryptionUtils);
 570
 571         var instanceId = automationComposition.getInstanceId();
 572         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider.rollback(compositionId, instanceId));
 573
 574         // DeployState != MIGRATION_REVERTING
 575         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 576                 .thenReturn(automationComposition);
 577         when(acProvider.getAutomationCompositionRollback(any(UUID.class))).thenReturn(rollbackRecord.toAuthorative());
 578
 579         automationComposition.setDeployState(DeployState.DELETING);
 580         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider.rollback(compositionId, instanceId));
 581
 582         // SubState != NONE
 583         automationComposition.setDeployState(DeployState.DEPLOYED);
 584         automationComposition.setSubState(SubState.PREPARING);
 585         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider.rollback(compositionId, instanceId));
 586
 587         // StateChangeResult != NO_ERROR
 588         automationComposition.setSubState(SubState.NONE);
 589         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 590         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider.rollback(compositionId, instanceId));
 591
 592         // !compositionId.equals(compId)
 593         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 594         automationComposition.setCompositionId(UUID.randomUUID());
 595         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider.rollback(compositionId, instanceId));
 596         verify(acProvider, never()).updateAutomationComposition(any());
 597     }
 598
 599     @Test
 600     void testRollbackSuccess() {
 601         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 602         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 603         var compositionId = acDefinition.getCompositionId();
 604         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 605
 606         var automationComposition =
 607                 InstantiationUtils.getAutomationCompositionFromResource(AC_MIGRATE_JSON, "Crud");
 608         var instanceId = UUID.randomUUID();
 609         var compositionTargetId = UUID.randomUUID();
 610         automationComposition.setInstanceId(instanceId);
 611         automationComposition.setCompositionId(compositionId);
 612         automationComposition.setCompositionTargetId(compositionTargetId);
 613         automationComposition.setDeployState(DeployState.MIGRATING);
 614         automationComposition.setLockState(LockState.LOCKED);
 615         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 616         automationComposition.setSubState(SubState.NONE);
 617         var acProvider = mock(AutomationCompositionProvider.class);
 618         when(acProvider.getAutomationComposition(instanceId)).thenReturn(automationComposition);
 619         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 620
 621         var acRollback =
 622                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 623
 624         var rollbackRecord = new AutomationCompositionRollback();
 625         rollbackRecord.setCompositionId(compositionTargetId);
 626         rollbackRecord.setInstanceId(instanceId);
 627         rollbackRecord.setElements(acRollback.getElements());
 628         when(acProvider.getAutomationCompositionRollback(instanceId)).thenReturn(rollbackRecord);
 629
 630         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 631         var participantProvider = mock(ParticipantProvider.class);
 632         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 633         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 634                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, new AcRuntimeParameterGroup(),
 635                 encryptionUtils);
 636         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplateMigration, AcTypeState.PRIMED);
 637         when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
 638
 639         instantiationProvider.rollback(compositionId, automationComposition.getInstanceId());
 640         verify(acProvider).updateAutomationComposition(any(AutomationComposition.class));
 641
 642         when(acDefinitionProvider.getAcDefinition(compositionTargetId))
 643                 .thenThrow(new PfModelRuntimeException(Response.Status.NOT_FOUND,
 644                         String.format(AC_DEFINITION_NOT_FOUND, compositionTargetId)));
 645         assertThatThrownBy(() -> instantiationProvider.rollback(compositionId, instanceId))
 646                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionTargetId));
 647     }
 648
 649     private void assertThatDeleteThrownBy(AutomationComposition automationComposition, DeployState deployState,
 650                                           LockState lockState) {
 651         automationComposition.setDeployState(deployState);
 652         automationComposition.setLockState(lockState);
 653         var acProvider = mock(AutomationCompositionProvider.class);
 654         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 655                 .thenReturn(automationComposition);
 656         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 657         var acRuntimeParamaterGroup = mock(AcRuntimeParameterGroup.class);
 658
 659         var instantiationProvider =
 660                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 661                         new AcInstanceStateResolver(), null, mock(ParticipantProvider.class),
 662                         acRuntimeParamaterGroup, null);
 663
 664         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 665         var compositionId = acDefinition.getCompositionId();
 666         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 667         automationComposition.setCompositionId(compositionId);
 668
 669         var instanceId = automationComposition.getInstanceId();
 670         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 671                 .hasMessageStartingWith(String.format(DELETE_BAD_REQUEST));
 672     }
 673
 674     @Test
 675     void testCreateAutomationCompositions_NoDuplicates() {
 676         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 677         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 678         var compositionId = acDefinition.getCompositionId();
 679         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 680
 681         var automationCompositionCreate =
 682                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "NoDuplicates");
 683         automationCompositionCreate.setCompositionId(compositionId);
 684         automationCompositionCreate.setInstanceId(UUID.randomUUID());
 685
 686         var acProvider = mock(AutomationCompositionProvider.class);
 687         when(acProvider.createAutomationComposition(automationCompositionCreate))
 688                 .thenReturn(automationCompositionCreate);
 689         var acIdentifier = automationCompositionCreate.getKey().asIdentifier();
 690         var participantProvider = mock(ParticipantProvider.class);
 691         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 692
 693         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 694                 null, null, participantProvider,
 695                 CommonTestData.getTestParamaterGroup(), encryptionUtils);
 696
 697         var instantiationResponse = instantiationProvider.createAutomationComposition(
 698                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 699         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 700
 701         doThrow(new PfModelRuntimeException(Status.BAD_REQUEST, acIdentifier + " already defined"))
 702                 .when(acProvider).validateNameVersion(acIdentifier);
 703         assertThatThrownBy(
 704                 () -> instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate))
 705                 .hasMessageMatching(acIdentifier + " already defined");
 706     }
 707
 708     @Test
 709     void testCreateAutomationCompositions_CommissionedAcElementNotFound() {
 710         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 711         var participantProvider = mock(ParticipantProvider.class);
 712         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 713         var compositionId = acDefinition.getCompositionId();
 714         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 715         var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(
 716                 AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON, "AcElementNotFound");
 717         automationComposition.setCompositionId(compositionId);
 718
 719         var acProvider = mock(AutomationCompositionProvider.class);
 720         var encryptionUtils = mock(EncryptionUtils.class);
 721         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null,
 722                 participantProvider, CommonTestData.getTestParamaterGroup(), encryptionUtils);
 723
 724         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 725                 .hasMessageContaining(AC_ELEMENT_NAME_NOT_FOUND);
 726
 727         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 728                 .thenReturn(automationComposition);
 729
 730         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 731                 .hasMessageContaining(AC_ELEMENT_NAME_NOT_FOUND);
 732     }
 733
 734     @Test
 735     void testAcDefinitionNotFound() {
 736         var automationComposition = InstantiationUtils
 737                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 738
 739         var acProvider = mock(AutomationCompositionProvider.class);
 740         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 741                 .thenReturn(automationComposition);
 742         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 743         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 744                 null, null, null,
 745                 mock(AcRuntimeParameterGroup.class), null);
 746
 747         var compositionId = automationComposition.getCompositionId();
 748         when(acDefinitionProvider.getAcDefinition(automationComposition.getCompositionId()))
 749                 .thenThrow(new PfModelRuntimeException(Status.NOT_FOUND,
 750                         String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionId())));
 751         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 752                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
 753
 754         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 755                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
 756     }
 757
 758     @Test
 759     void testCompositionIdDoNotMatch() {
 760         var automationComposition = InstantiationUtils
 761                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 762
 763         var acProvider = mock(AutomationCompositionProvider.class);
 764         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 765                 .thenReturn(automationComposition);
 766         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 767                 null, null, null,
 768                 mock(AcRuntimeParameterGroup.class), null);
 769
 770         var compositionId = automationComposition.getCompositionId();
 771         var wrongCompositionId = UUID.randomUUID();
 772         assertThatThrownBy(() -> provider.createAutomationComposition(wrongCompositionId, automationComposition))
 773                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 774
 775         assertThatThrownBy(() -> provider.updateAutomationComposition(wrongCompositionId, automationComposition))
 776                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 777
 778         assertThatThrownBy(
 779                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 780                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 781         assertThatThrownBy(() -> provider.compositionInstanceState(wrongCompositionId,
 782                 automationComposition.getInstanceId(), new AcInstanceStateUpdate()))
 783                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 784
 785         var compositionTargetId = UUID.randomUUID();
 786         automationComposition.setCompositionTargetId(compositionTargetId);
 787         assertThatThrownBy(
 788                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 789                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 790
 791         var result = provider.getAutomationComposition(compositionTargetId, automationComposition.getInstanceId());
 792         assertThat(result).isNotNull();
 793     }
 794
 795     @Test
 796     void testCompositionNotPrimed() {
 797         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 798         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 799         var compositionId = acDefinition.getCompositionId();
 800         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 801         var acProvider = mock(AutomationCompositionProvider.class);
 802         var provider =
 803                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null,
 804                         null, null);
 805
 806         var automationComposition =
 807                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 808         automationComposition.setCompositionId(compositionId);
 809         var message = compositionId + " Commissioned automation composition definition not primed";
 810
 811         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 812                 .hasMessageMatching(message);
 813     }
 814
 815     @Test
 816     void testCompositionInstanceState() {
 817         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 818         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 819         var compositionId = acDefinition.getCompositionId();
 820         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 821
 822         var automationComposition = InstantiationUtils
 823                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 824         var instanceId = UUID.randomUUID();
 825         automationComposition.setCompositionId(compositionId);
 826         automationComposition.setInstanceId(instanceId);
 827         var acProvider = mock(AutomationCompositionProvider.class);
 828         when(acProvider.getAutomationComposition(instanceId)).thenReturn(automationComposition);
 829
 830         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 831         var participantProvider = mock(ParticipantProvider.class);
 832         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 833                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 834                 mock(AcRuntimeParameterGroup.class), null);
 835
 836         var acInstanceStateUpdate = new AcInstanceStateUpdate();
 837         acInstanceStateUpdate.setDeployOrder(DeployOrder.DEPLOY);
 838         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 839         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 840         verify(supervisionAcHandler).deploy(any(AutomationComposition.class),
 841                 any(AutomationCompositionDefinition.class));
 842
 843         automationComposition.setDeployState(DeployState.DEPLOYED);
 844         automationComposition.setLockState(LockState.LOCKED);
 845         acInstanceStateUpdate.setDeployOrder(DeployOrder.UNDEPLOY);
 846         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 847         verify(supervisionAcHandler).undeploy(any(AutomationComposition.class),
 848                 any(AutomationCompositionDefinition.class));
 849
 850         automationComposition.setDeployState(DeployState.DEPLOYED);
 851         automationComposition.setLockState(LockState.LOCKED);
 852         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 853         acInstanceStateUpdate.setLockOrder(LockOrder.UNLOCK);
 854         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 855         verify(supervisionAcHandler).unlock(any(AutomationComposition.class),
 856                 any(AutomationCompositionDefinition.class));
 857
 858         automationComposition.setDeployState(DeployState.DEPLOYED);
 859         automationComposition.setLockState(LockState.UNLOCKED);
 860         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 861         acInstanceStateUpdate.setLockOrder(LockOrder.LOCK);
 862         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 863         verify(supervisionAcHandler).lock(any(AutomationComposition.class), any(AutomationCompositionDefinition.class));
 864
 865         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 866         automationComposition.setLockState(LockState.NONE);
 867         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 868         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 869         acInstanceStateUpdate.setSubOrder(SubOrder.PREPARE);
 870         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 871         verify(supervisionAcHandler).prepare(any(AutomationComposition.class),
 872                 any(AutomationCompositionDefinition.class));
 873
 874         automationComposition.setDeployState(DeployState.DEPLOYED);
 875         automationComposition.setLockState(LockState.LOCKED);
 876         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 877         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 878         acInstanceStateUpdate.setSubOrder(SubOrder.REVIEW);
 879         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 880         verify(supervisionAcHandler).review(any(AutomationComposition.class),
 881                 any(AutomationCompositionDefinition.class));
 882     }
 883 }