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