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     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  81     private static final String AC_INSTANTIATION_UPDATE_JSON =
  82             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  83     private static final String AC_MIGRATE_JSON = "src/test/resources/rest/acm/AutomationCompositionMigrate.json";
  84
  85     private static final String AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON =
  86             "src/test/resources/rest/acm/AutomationCompositionElementsNotFound.json";
  87     private static final String AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON =
  88             "src/test/resources/rest/acm/AutomationCompositionNotFound.json";
  89     private static final String DELETE_BAD_REQUEST = "Not valid order DELETE;";
  90
  91     private static final String AC_ELEMENT_NAME_NOT_FOUND = """
  92             "AutomationComposition" INVALID, item has status INVALID
  93               "entry PMSHInstance0AcElementNotFound" INVALID, item has status INVALID
  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
 106     @BeforeAll
 107     public static void setUpBeforeClass() {
 108         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 109         var jpa =
 110                 ProviderUtils.getJpaAndValidate(serviceTemplate, JpaToscaServiceTemplate::new, "toscaServiceTemplate");
 111         serviceTemplate = 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_MIGRATE_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 = new AutomationComposition(automationComposition);
 282         automationCompositionTarget.setInstanceId(instanceId);
 283         automationCompositionTarget.setCompositionId(compositionId);
 284         // Add a new element
 285         var uuid = UUID.randomUUID();
 286         var newElement = new AutomationCompositionElement();
 287         newElement.setId(uuid);
 288         newElement.setDefinition(new ToscaConceptIdentifier(
 289                 "org.onap.domain.pmsh.PMSH_OperationalPolicyAutomationCompositionElement", "1.2.3"));
 290         newElement.setProperties(Map.of("testVar", "1", "testVar2", "2"));
 291         automationCompositionTarget.getElements().put(uuid, newElement);
 292
 293         //Remove an existing element
 294         var elementIdToRemove = UUID.randomUUID();
 295         for (var element : automationCompositionTarget.getElements().values()) {
 296             if (element.getDefinition().getName()
 297                     .equals("org.onap.domain.database.Http_PMSHMicroserviceAutomationCompositionElement")) {
 298                 elementIdToRemove = element.getId();
 299             }
 300         }
 301         automationCompositionTarget.getElements().remove(elementIdToRemove);
 302
 303         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 304         var compositionTargetId = acDefinitionTarget.getCompositionId();
 305         automationCompositionTarget.setCompositionTargetId(compositionTargetId);
 306         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 307         when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
 308         when(acProvider.updateAutomationComposition(any())).thenReturn(automationCompositionTarget);
 309
 310         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 311         var participantProvider = mock(ParticipantProvider.class);
 312         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 313         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 314                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 315                 new AcRuntimeParameterGroup(), encryptionUtils);
 316
 317         automationCompositionTarget.setPrecheck(true);
 318         var preCheckResponse = instantiationProvider.updateAutomationComposition(compositionId,
 319                 automationCompositionTarget);
 320         verify(supervisionAcHandler).migratePrecheck(any());
 321         InstantiationUtils.assertInstantiationResponse(preCheckResponse, automationCompositionTarget);
 322
 323         automationCompositionTarget.setPrecheck(false);
 324         AcmUtils.setCascadedState(automationComposition, DeployState.DEPLOYED, LockState.LOCKED,
 325                 SubState.NONE);
 326         var instantiationResponse = instantiationProvider.updateAutomationComposition(compositionId,
 327                         automationCompositionTarget);
 328
 329         verify(supervisionAcHandler).migrate(any());
 330         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionTarget);
 331     }
 332
 333     @Test
 334     void testVersionCompatibility() {
 335         var acProvider = mock(AutomationCompositionProvider.class);
 336         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 337         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 338         var participantProvider = mock(ParticipantProvider.class);
 339         var newDefinition = new PfConceptKey("policy.clamp.element", "1.2.3");
 340         var oldDefinition = new PfConceptKey("policy.clamp.element", "2.2.3");
 341
 342         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 343                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 344                 new AcRuntimeParameterGroup(), null);
 345         var instanceId = UUID.randomUUID();
 346         assertDoesNotThrow(() -> {
 347             instantiationProvider.checkCompatibility(newDefinition, oldDefinition, instanceId);
 348         }, "No exception for major version update");
 349
 350         // Not compatible
 351         newDefinition.setName("policy.clamp.newElement");
 352         newDefinition.setVersion("2.2.4");
 353
 354         assertThatThrownBy(() -> instantiationProvider
 355                 .checkCompatibility(newDefinition, oldDefinition, instanceId))
 356                 .hasMessageContaining("is not compatible");
 357     }
 358
 359     @Test
 360     void testInstantiationMigration() {
 361         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 362         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 363         var compositionId = acDefinition.getCompositionId();
 364         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 365
 366         var automationComposition =
 367                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 368         automationComposition.setCompositionId(compositionId);
 369         automationComposition.setDeployState(DeployState.DEPLOYED);
 370         automationComposition.setLockState(LockState.LOCKED);
 371         automationComposition.setCompositionTargetId(UUID.randomUUID());
 372         var acProvider = mock(AutomationCompositionProvider.class);
 373         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 374                 .thenReturn(automationComposition);
 375         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 376
 377         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 378         var participantProvider = mock(ParticipantProvider.class);
 379         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 380         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 381             new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, new AcRuntimeParameterGroup(),
 382                 encryptionUtils);
 383
 384         assertThatThrownBy(() -> instantiationProvider
 385                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
 386                         .hasMessageMatching(
 387                                 String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId()));
 388
 389         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 390         var compositionTargetId = acDefinitionTarget.getCompositionId();
 391         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 392         when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
 393
 394         automationComposition.setCompositionTargetId(compositionTargetId);
 395
 396         var instantiationResponse = instantiationProvider
 397                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
 398
 399         verify(supervisionAcHandler).migrate(any());
 400         verify(acProvider).updateAutomationComposition(automationComposition);
 401         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
 402     }
 403
 404     @Test
 405     void testInstantiationMigrationPrecheck() {
 406         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 407         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 408         var compositionId = acDefinition.getCompositionId();
 409         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 410
 411         var automationComposition =
 412             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 413         automationComposition.setCompositionId(compositionId);
 414         automationComposition.setDeployState(DeployState.DEPLOYED);
 415         automationComposition.setLockState(LockState.LOCKED);
 416         automationComposition.setCompositionTargetId(UUID.randomUUID());
 417         automationComposition.setPrecheck(true);
 418         var acProvider = mock(AutomationCompositionProvider.class);
 419         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 420             .thenReturn(automationComposition);
 421         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 422
 423         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 424         var acmParticipantProvider = mock(ParticipantProvider.class);
 425         var encryptionUtils = mock(EncryptionUtils.class);
 426         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 427             new AcInstanceStateResolver(), supervisionAcHandler, acmParticipantProvider, new AcRuntimeParameterGroup(),
 428                 encryptionUtils);
 429
 430         assertThatThrownBy(() -> instantiationProvider
 431             .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
 432             .hasMessageMatching(
 433                 String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId()));
 434
 435         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 436         var compositionTargetId = acDefinitionTarget.getCompositionId();
 437         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 438
 439         automationComposition.setCompositionTargetId(compositionTargetId);
 440
 441         var instantiationResponse = instantiationProvider
 442             .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
 443
 444         verify(supervisionAcHandler).migratePrecheck(any());
 445         verify(acProvider).updateAutomationComposition(automationComposition);
 446         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
 447     }
 448
 449     @Test
 450     void testMigrateBadRequest() {
 451         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 452         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 453         var compositionId = acDefinition.getCompositionId();
 454         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 455
 456         var automationComposition =
 457                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 458         automationComposition.setCompositionId(compositionId);
 459         automationComposition.setDeployState(DeployState.DEPLOYED);
 460         automationComposition.setLockState(LockState.LOCKED);
 461         var acProvider = mock(AutomationCompositionProvider.class);
 462         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 463                 .thenReturn(automationComposition);
 464         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 465
 466         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 467         var compositionTargetId = acDefinitionTarget.getCompositionId();
 468         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 469
 470         var acMigrate = new AutomationComposition(automationComposition);
 471         acMigrate.setCompositionTargetId(compositionTargetId);
 472         automationComposition.setDeployState(DeployState.DEPLOYING);
 473
 474         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 475         var participantProvider = mock(ParticipantProvider.class);
 476         var encryptionUtils = mock(EncryptionUtils.class);
 477         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 478                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 479                 new AcRuntimeParameterGroup(), encryptionUtils);
 480
 481         assertThatThrownBy(() -> instantiationProvider
 482                 .updateAutomationComposition(automationComposition.getCompositionId(), acMigrate))
 483                 .hasMessageStartingWith("Not allowed to MIGRATE in the state DEPLOYING");
 484     }
 485
 486     @Test
 487     void testMigratePreCheckBadRequest() {
 488         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 489         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 490         var compositionId = acDefinition.getCompositionId();
 491         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 492
 493         var automationComposition =
 494                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 495         automationComposition.setCompositionId(compositionId);
 496         automationComposition.setDeployState(DeployState.DEPLOYED);
 497         automationComposition.setLockState(LockState.LOCKED);
 498         automationComposition.setPrecheck(true);
 499         var acProvider = mock(AutomationCompositionProvider.class);
 500         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 501                 .thenReturn(automationComposition);
 502         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 503
 504         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 505         var compositionTargetId = acDefinitionTarget.getCompositionId();
 506         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 507
 508         var acMigrate = new AutomationComposition(automationComposition);
 509         acMigrate.setCompositionTargetId(compositionTargetId);
 510         automationComposition.setDeployState(DeployState.DEPLOYING);
 511         automationComposition.setPrecheck(true);
 512
 513         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 514         var participantProvider = mock(ParticipantProvider.class);
 515         var encryptionUtils = mock(EncryptionUtils.class);
 516         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 517                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 518                 new AcRuntimeParameterGroup(), encryptionUtils);
 519
 520         assertThatThrownBy(() -> instantiationProvider
 521                 .updateAutomationComposition(automationComposition.getCompositionId(), acMigrate))
 522                 .hasMessageStartingWith("Not allowed to NONE in the state DEPLOYING");
 523     }
 524
 525     @Test
 526     void testInstantiationDelete() {
 527         var automationComposition =
 528                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 529         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 530         var acProvider = mock(AutomationCompositionProvider.class);
 531         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 532         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 533         var compositionId = acDefinition.getCompositionId();
 534         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 535         automationComposition.setCompositionId(compositionId);
 536         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 537         var participantProvider = mock(ParticipantProvider.class);
 538         var acRuntimeParameterGroup = mock(AcRuntimeParameterGroup.class);
 539         var encryptionUtils = mock(EncryptionUtils.class);
 540
 541         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 542                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, acRuntimeParameterGroup,
 543                 encryptionUtils);
 544
 545         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 546                 .thenReturn(automationComposition);
 547
 548         var wrongCompositionId = UUID.randomUUID();
 549         var instanceId = automationComposition.getInstanceId();
 550         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(wrongCompositionId, instanceId))
 551                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 552
 553         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 554         automationComposition.setLockState(LockState.NONE);
 555         when(acProvider.deleteAutomationComposition(instanceId)).thenReturn(automationComposition);
 556         instantiationProvider.deleteAutomationComposition(compositionId, instanceId);
 557         verify(supervisionAcHandler).delete(any(), any());
 558     }
 559
 560     @Test
 561     void testInstantiationDeleteError() {
 562         var automationComposition =
 563                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 564         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 565         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYED, LockState.LOCKED);
 566         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYING, LockState.NONE);
 567         assertThatDeleteThrownBy(automationComposition, DeployState.UNDEPLOYING, LockState.LOCKED);
 568         assertThatDeleteThrownBy(automationComposition, DeployState.DELETING, LockState.NONE);
 569     }
 570
 571     @Test
 572     void testRollbackFailure() {
 573         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 574         var compositionId = acDefinition.getCompositionId();
 575         var automationComposition =
 576             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Rollback");
 577         automationComposition.setCompositionId(compositionId);
 578         automationComposition.setInstanceId(UUID.randomUUID());
 579         automationComposition.setDeployState(DeployState.MIGRATION_REVERTING);
 580         automationComposition.setCompositionTargetId(UUID.randomUUID());
 581
 582         var acProvider = mock(AutomationCompositionProvider.class);
 583         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 584             .thenReturn(automationComposition);
 585         var rollbackRecord = mock(JpaAutomationCompositionRollback.class);
 586         when(acProvider.getAutomationCompositionRollback(anyString())).thenReturn(rollbackRecord);
 587
 588         final var acDefinitionProvider = mock(AcDefinitionProvider.class);
 589         final var supervisionAcHandler = mock(SupervisionAcHandler.class);
 590         final var participantProvider = mock(ParticipantProvider.class);
 591         final var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 592         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 593             new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, new AcRuntimeParameterGroup(),
 594             encryptionUtils);
 595
 596         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider
 597             .rollback(automationComposition.getInstanceId()));
 598
 599         // DeployState != MIGRATION_REVERTING
 600         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 601             .thenReturn(automationComposition);
 602         when(acProvider.getAutomationCompositionRollback(anyString())).thenReturn(rollbackRecord);
 603
 604         automationComposition.setDeployState(DeployState.DELETING);
 605         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider
 606             .rollback(automationComposition.getInstanceId()));
 607
 608         // SubState != NONE
 609         automationComposition.setDeployState(DeployState.DEPLOYED);
 610         automationComposition.setSubState(SubState.PREPARING);
 611         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider
 612             .rollback(automationComposition.getInstanceId()));
 613
 614         // StateChangeResult != NO_ERROR
 615         automationComposition.setSubState(SubState.NONE);
 616         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 617         assertThrows(PfModelRuntimeException.class, () -> instantiationProvider
 618             .rollback(automationComposition.getInstanceId()));
 619
 620         verify(acProvider, never()).updateAutomationComposition(any());
 621     }
 622
 623     @Test
 624     void testRollbackSuccess() {
 625         final var acDefinitionProvider = mock(AcDefinitionProvider.class);
 626         final var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 627         final var compositionId = acDefinition.getCompositionId();
 628
 629         var automationComposition =
 630             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Rollback");
 631         automationComposition.setInstanceId(UUID.randomUUID());
 632         automationComposition.setCompositionId(compositionId);
 633         automationComposition.setDeployState(DeployState.DEPLOYED);
 634         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 635         automationComposition.setSubState(SubState.NONE);
 636         automationComposition.setCompositionTargetId(UUID.randomUUID());
 637
 638         var acProvider = mock(AutomationCompositionProvider.class);
 639         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 640             .thenReturn(automationComposition);
 641         final var supervisionAcHandler = mock(SupervisionAcHandler.class);
 642         final var participantProvider = mock(ParticipantProvider.class);
 643         final var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 644         final var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider,
 645             acDefinitionProvider, new AcInstanceStateResolver(), supervisionAcHandler,
 646             participantProvider, new AcRuntimeParameterGroup(), encryptionUtils);
 647
 648         var rollbackRecord = new JpaAutomationCompositionRollback();
 649         rollbackRecord.setCompositionId(automationComposition.getCompositionId().toString());
 650
 651         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 652             .thenReturn(automationComposition);
 653         when(acProvider.getAutomationCompositionRollback(anyString())).thenReturn(rollbackRecord);
 654
 655         instantiationProvider.rollback(automationComposition.getInstanceId());
 656
 657         verify(acProvider).updateAutomationComposition(automationComposition);
 658         assertEquals(DeployState.MIGRATION_REVERTING, automationComposition.getDeployState());
 659     }
 660
 661     private void assertThatDeleteThrownBy(AutomationComposition automationComposition, DeployState deployState,
 662             LockState lockState) {
 663         automationComposition.setDeployState(deployState);
 664         automationComposition.setLockState(lockState);
 665         var acProvider = mock(AutomationCompositionProvider.class);
 666         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 667                 .thenReturn(automationComposition);
 668         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 669         var acRuntimeParamaterGroup = mock(AcRuntimeParameterGroup.class);
 670
 671         var instantiationProvider =
 672                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 673                         new AcInstanceStateResolver(), null, mock(ParticipantProvider.class),
 674                         acRuntimeParamaterGroup, null);
 675
 676         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 677         var compositionId = acDefinition.getCompositionId();
 678         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 679         automationComposition.setCompositionId(compositionId);
 680
 681         var instanceId = automationComposition.getInstanceId();
 682         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 683                 .hasMessageStartingWith(String.format(DELETE_BAD_REQUEST));
 684     }
 685
 686     @Test
 687     void testCreateAutomationCompositions_NoDuplicates() {
 688         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 689         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 690         var compositionId = acDefinition.getCompositionId();
 691         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 692
 693         var automationCompositionCreate =
 694                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "NoDuplicates");
 695         automationCompositionCreate.setCompositionId(compositionId);
 696         automationCompositionCreate.setInstanceId(UUID.randomUUID());
 697
 698         var acProvider = mock(AutomationCompositionProvider.class);
 699         when(acProvider.createAutomationComposition(automationCompositionCreate))
 700                 .thenReturn(automationCompositionCreate);
 701         var participantProvider = mock(ParticipantProvider.class);
 702         var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
 703
 704         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 705                 null, null, participantProvider,
 706                 CommonTestData.getTestParamaterGroup(), encryptionUtils);
 707
 708         var instantiationResponse = instantiationProvider.createAutomationComposition(
 709                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 710         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 711
 712         when(acProvider.findAutomationComposition(automationCompositionCreate.getKey().asIdentifier()))
 713                 .thenReturn(Optional.of(automationCompositionCreate));
 714
 715         assertThatThrownBy(
 716                 () -> instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate))
 717                         .hasMessageMatching(automationCompositionCreate.getKey().asIdentifier() + " already defined");
 718     }
 719
 720     @Test
 721     void testCreateAutomationCompositions_CommissionedAcElementNotFound() {
 722         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 723         var participantProvider = mock(ParticipantProvider.class);
 724         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 725         var compositionId = acDefinition.getCompositionId();
 726         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 727         var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(
 728                 AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON, "AcElementNotFound");
 729         automationComposition.setCompositionId(compositionId);
 730
 731         var acProvider = mock(AutomationCompositionProvider.class);
 732         var encryptionUtils = mock(EncryptionUtils.class);
 733         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null,
 734                 participantProvider, CommonTestData.getTestParamaterGroup(), encryptionUtils);
 735
 736         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 737                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 738
 739         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 740                 .thenReturn(automationComposition);
 741
 742         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 743                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 744     }
 745
 746     @Test
 747     void testAcDefinitionNotFound() {
 748         var automationComposition = InstantiationUtils
 749                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 750
 751         var acProvider = mock(AutomationCompositionProvider.class);
 752         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 753                 .thenReturn(automationComposition);
 754         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 755                 null, null, null,
 756                 mock(AcRuntimeParameterGroup.class), null);
 757
 758         var compositionId = automationComposition.getCompositionId();
 759         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 760                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
 761
 762         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 763                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
 764     }
 765
 766     @Test
 767     void testCompositionIdDoNotMatch() {
 768         var automationComposition = InstantiationUtils
 769                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 770
 771         var acProvider = mock(AutomationCompositionProvider.class);
 772         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 773                 .thenReturn(automationComposition);
 774         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 775                 null, null, null,
 776                 mock(AcRuntimeParameterGroup.class), null);
 777
 778         var compositionId = automationComposition.getCompositionId();
 779         var wrongCompositionId = UUID.randomUUID();
 780         assertThatThrownBy(() -> provider.createAutomationComposition(wrongCompositionId, automationComposition))
 781                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 782
 783         assertThatThrownBy(() -> provider.updateAutomationComposition(wrongCompositionId, automationComposition))
 784                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 785
 786         assertThatThrownBy(
 787                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 788                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 789         assertThatThrownBy(() -> provider.compositionInstanceState(wrongCompositionId,
 790                 automationComposition.getInstanceId(), new AcInstanceStateUpdate()))
 791                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 792
 793         var compositionTargetId = UUID.randomUUID();
 794         automationComposition.setCompositionTargetId(compositionTargetId);
 795         assertThatThrownBy(
 796                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 797                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 798
 799         var result = provider.getAutomationComposition(compositionTargetId, automationComposition.getInstanceId());
 800         assertThat(result).isNotNull();
 801     }
 802
 803     @Test
 804     void testCompositionNotPrimed() {
 805         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 806         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 807         var compositionId = acDefinition.getCompositionId();
 808         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 809         var acProvider = mock(AutomationCompositionProvider.class);
 810         var provider =
 811                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null,
 812                         null, null);
 813
 814         var automationComposition =
 815                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 816         automationComposition.setCompositionId(compositionId);
 817         var message = """
 818                       "AutomationComposition" INVALID, item has status INVALID
 819                         item "ServiceTemplate.state" value "COMMISSIONED" INVALID, Commissioned automation composition \
 820                       definition not primed
 821                       """;
 822
 823         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 824                 .hasMessageMatching(message);
 825     }
 826
 827     @Test
 828     void testCompositionInstanceState() {
 829         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 830         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 831         var compositionId = acDefinition.getCompositionId();
 832         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 833
 834         var automationComposition = InstantiationUtils
 835                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 836         var instanceId = UUID.randomUUID();
 837         automationComposition.setCompositionId(compositionId);
 838         automationComposition.setInstanceId(instanceId);
 839         var acProvider = mock(AutomationCompositionProvider.class);
 840         when(acProvider.getAutomationComposition(instanceId)).thenReturn(automationComposition);
 841
 842         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 843         var participantProvider = mock(ParticipantProvider.class);
 844         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 845                 new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
 846                 mock(AcRuntimeParameterGroup.class), null);
 847
 848         var acInstanceStateUpdate = new AcInstanceStateUpdate();
 849         acInstanceStateUpdate.setDeployOrder(DeployOrder.DEPLOY);
 850         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 851         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 852         verify(supervisionAcHandler).deploy(any(AutomationComposition.class),
 853                 any(AutomationCompositionDefinition.class));
 854
 855         automationComposition.setDeployState(DeployState.DEPLOYED);
 856         automationComposition.setLockState(LockState.LOCKED);
 857         acInstanceStateUpdate.setDeployOrder(DeployOrder.UNDEPLOY);
 858         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 859         verify(supervisionAcHandler).undeploy(any(AutomationComposition.class),
 860                 any(AutomationCompositionDefinition.class));
 861
 862         automationComposition.setDeployState(DeployState.DEPLOYED);
 863         automationComposition.setLockState(LockState.LOCKED);
 864         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 865         acInstanceStateUpdate.setLockOrder(LockOrder.UNLOCK);
 866         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 867         verify(supervisionAcHandler).unlock(any(AutomationComposition.class),
 868                 any(AutomationCompositionDefinition.class));
 869
 870         automationComposition.setDeployState(DeployState.DEPLOYED);
 871         automationComposition.setLockState(LockState.UNLOCKED);
 872         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 873         acInstanceStateUpdate.setLockOrder(LockOrder.LOCK);
 874         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 875         verify(supervisionAcHandler).lock(any(AutomationComposition.class), any(AutomationCompositionDefinition.class));
 876
 877         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 878         automationComposition.setLockState(LockState.NONE);
 879         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 880         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 881         acInstanceStateUpdate.setSubOrder(SubOrder.PREPARE);
 882         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 883         verify(supervisionAcHandler).prepare(any(AutomationComposition.class), any());
 884
 885         automationComposition.setDeployState(DeployState.DEPLOYED);
 886         automationComposition.setLockState(LockState.LOCKED);
 887         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 888         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 889         acInstanceStateUpdate.setSubOrder(SubOrder.REVIEW);
 890         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 891         verify(supervisionAcHandler).review(any(AutomationComposition.class));
 892     }
 893 }