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