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