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