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