gerrit.onap Code Review - policy/clamp.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2023 Nordix Foundation.
   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.mockito.ArgumentMatchers.any;
  27 import static org.mockito.Mockito.doNothing;
  28 import static org.mockito.Mockito.mock;
  29 import static org.mockito.Mockito.verify;
  30 import static org.mockito.Mockito.when;
  31 import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVICE_TEMPLATE_YAML;
  32
  33 import java.util.List;
  34 import java.util.Optional;
  35 import java.util.UUID;
  36 import org.junit.jupiter.api.BeforeAll;
  37 import org.junit.jupiter.api.Test;
  38 import org.onap.policy.clamp.acm.runtime.participants.AcmParticipantProvider;
  39 import org.onap.policy.clamp.acm.runtime.supervision.SupervisionAcHandler;
  40 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
  41 import org.onap.policy.clamp.common.acm.exception.AutomationCompositionException;
  42 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  43 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  44 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
  45 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  46 import org.onap.policy.clamp.models.acm.concepts.LockState;
  47 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.AcInstanceStateUpdate;
  48 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  49 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
  50 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
  51 import org.onap.policy.clamp.models.acm.persistence.provider.AcInstanceStateResolver;
  52 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
  53 import org.onap.policy.clamp.models.acm.persistence.provider.ProviderUtils;
  54 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  55 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
  56
  57 /**
  58  * Class to perform unit test of {@link AutomationCompositionInstantiationProvider}}.
  59  *
  60  */
  61 class AutomationCompositionInstantiationProviderTest {
  62     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  63     private static final String AC_INSTANTIATION_UPDATE_JSON =
  64             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  65
  66     private static final String AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON =
  67             "src/test/resources/rest/acm/AutomationCompositionElementsNotFound.json";
  68     private static final String AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON =
  69             "src/test/resources/rest/acm/AutomationCompositionNotFound.json";
  70     private static final String DELETE_BAD_REQUEST = "Automation composition state is still %s";
  71
  72     private static final String AC_ELEMENT_NAME_NOT_FOUND =
  73             "\"AutomationComposition\" INVALID, item has status INVALID\n"
  74                     + "  \"entry PMSHInstance0AcElementNotFound\" INVALID, item has status INVALID\n"
  75                     + "    \"entry org.onap.domain.pmsh.DCAEMicroservice\" INVALID, Not found\n"
  76                     + "    \"entry org.onap.domain.pmsh.PMSH_MonitoringPolicyAutomationCompositionElement\""
  77                     + " INVALID, Not found\n";
  78     private static final String AC_DEFINITION_NOT_FOUND = "\"AutomationComposition\" INVALID, item has status INVALID\n"
  79             + "  item \"ServiceTemplate\" value \"\" INVALID,"
  80             + " Commissioned automation composition definition not found\n";
  81     private static final String DO_NOT_MATCH = " do not match with ";
  82
  83     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
  84
  85     @BeforeAll
  86     public static void setUpBeforeClass() {
  87         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
  88         var jpa =
  89                 ProviderUtils.getJpaAndValidate(serviceTemplate, JpaToscaServiceTemplate::new, "toscaServiceTemplate");
  90         serviceTemplate = jpa.toAuthorative();
  91     }
  92
  93     @Test
  94     void testInstantiationCrud() throws AutomationCompositionException {
  95         var acDefinitionProvider = mock(AcDefinitionProvider.class);
  96         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
  97         var compositionId = acDefinition.getCompositionId();
  98         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
  99         var acProvider = mock(AutomationCompositionProvider.class);
 100         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 101         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 102         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 103                 null, supervisionAcHandler, acmParticipantProvider);
 104         var automationCompositionCreate =
 105                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 106         automationCompositionCreate.setCompositionId(compositionId);
 107         when(acProvider.createAutomationComposition(automationCompositionCreate))
 108                 .thenReturn(automationCompositionCreate);
 109
 110         var instantiationResponse = instantiationProvider.createAutomationComposition(
 111                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 112         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 113
 114         verify(acProvider).createAutomationComposition(automationCompositionCreate);
 115
 116         when(acProvider.getAutomationCompositions(compositionId, automationCompositionCreate.getName(),
 117                 automationCompositionCreate.getVersion())).thenReturn(List.of(automationCompositionCreate));
 118
 119         var automationCompositionsGet = instantiationProvider.getAutomationCompositions(compositionId,
 120                 automationCompositionCreate.getName(), automationCompositionCreate.getVersion());
 121         assertThat(automationCompositionCreate)
 122                 .isEqualTo(automationCompositionsGet.getAutomationCompositionList().get(0));
 123
 124         var automationCompositionUpdate =
 125                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 126         automationCompositionUpdate.setCompositionId(compositionId);
 127         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 128                 .thenReturn(automationCompositionUpdate);
 129         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 130                 .thenReturn(automationCompositionUpdate);
 131
 132         instantiationResponse = instantiationProvider.updateAutomationComposition(
 133                 automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
 134         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 135
 136         verify(acProvider).updateAutomationComposition(automationCompositionUpdate);
 137
 138         when(acProvider.deleteAutomationComposition(automationCompositionUpdate.getInstanceId()))
 139                 .thenReturn(automationCompositionUpdate);
 140         doNothing().when(acmParticipantProvider).verifyParticipantState(any());
 141         instantiationProvider.deleteAutomationComposition(automationCompositionCreate.getCompositionId(),
 142                 automationCompositionCreate.getInstanceId());
 143
 144         verify(supervisionAcHandler).delete(any(), any());
 145     }
 146
 147     @Test
 148     void testInstantiationUpdate() throws AutomationCompositionException {
 149         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 150         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 151         var compositionId = acDefinition.getCompositionId();
 152         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 153
 154         var automationCompositionUpdate =
 155                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 156         automationCompositionUpdate.setCompositionId(compositionId);
 157         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 158         automationCompositionUpdate.setLockState(LockState.LOCKED);
 159         var acProvider = mock(AutomationCompositionProvider.class);
 160         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 161                 .thenReturn(automationCompositionUpdate);
 162         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 163                 .thenReturn(automationCompositionUpdate);
 164
 165         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 166         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 167         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 168                 null, supervisionAcHandler, acmParticipantProvider);
 169         var instantiationResponse = instantiationProvider.updateAutomationComposition(
 170                 automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
 171
 172         verify(supervisionAcHandler).update(any());
 173         verify(acProvider).updateAutomationComposition(automationCompositionUpdate);
 174         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 175     }
 176
 177     @Test
 178     void testUpdateBadRequest() throws AutomationCompositionException {
 179         var automationCompositionUpdate =
 180                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 181         automationCompositionUpdate.setDeployState(DeployState.DEPLOYING);
 182         automationCompositionUpdate.setLockState(LockState.NONE);
 183         var acProvider = mock(AutomationCompositionProvider.class);
 184         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 185                 .thenReturn(automationCompositionUpdate);
 186
 187         var instantiationProvider =
 188                 new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class), null,
 189                         mock(SupervisionAcHandler.class), mock(AcmParticipantProvider.class));
 190
 191         var compositionId = automationCompositionUpdate.getCompositionId();
 192         assertThatThrownBy(
 193                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 194                         .hasMessageMatching(
 195                                 "Not allowed to update in the state " + automationCompositionUpdate.getDeployState());
 196     }
 197
 198     @Test
 199     void testUpdateRestartedBadRequest() throws AutomationCompositionException {
 200         var automationCompositionUpdate =
 201                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 202         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 203         automationCompositionUpdate.setLockState(LockState.LOCKED);
 204         automationCompositionUpdate.setRestarting(true);
 205         var acProvider = mock(AutomationCompositionProvider.class);
 206         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 207                 .thenReturn(automationCompositionUpdate);
 208
 209         var instantiationProvider =
 210                 new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class), null,
 211                         mock(SupervisionAcHandler.class), mock(AcmParticipantProvider.class));
 212
 213         var compositionId = automationCompositionUpdate.getCompositionId();
 214         assertThatThrownBy(
 215                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 216                         .hasMessageMatching("There is a restarting process, Update not allowed");
 217
 218         automationCompositionUpdate.setDeployState(DeployState.UNDEPLOYED);
 219         automationCompositionUpdate.setLockState(LockState.NONE);
 220
 221         var instanceId = automationCompositionUpdate.getInstanceId();
 222         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 223                 .hasMessageMatching("There is a restarting process, Delete not allowed");
 224     }
 225
 226     @Test
 227     void testUpdateCompositionRestartedBadRequest() throws AutomationCompositionException {
 228         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 229         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 230         acDefinition.setRestarting(true);
 231         var compositionId = acDefinition.getCompositionId();
 232         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 233
 234         var automationCompositionUpdate =
 235                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 236         automationCompositionUpdate.setCompositionId(compositionId);
 237         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 238         automationCompositionUpdate.setLockState(LockState.LOCKED);
 239         var acProvider = mock(AutomationCompositionProvider.class);
 240         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 241                 .thenReturn(automationCompositionUpdate);
 242         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 243                 .thenReturn(automationCompositionUpdate);
 244
 245         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 246         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 247         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 248                 null, supervisionAcHandler, acmParticipantProvider);
 249         assertThatThrownBy(
 250                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 251                         .hasMessageMatching("\"AutomationComposition\" INVALID, item has status INVALID\n"
 252                                 + "  item \"ServiceTemplate.restarting\" value \"true\" INVALID,"
 253                                 + " There is a restarting process in composition\n");
 254     }
 255
 256     @Test
 257     void testInstantiationDelete() {
 258         var automationComposition =
 259                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 260
 261         var acProvider = mock(AutomationCompositionProvider.class);
 262         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 263         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 264         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 265
 266         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 267                 null, supervisionAcHandler, acmParticipantProvider);
 268
 269         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 270                 .thenReturn(automationComposition);
 271
 272         var wrongCompositionId = UUID.randomUUID();
 273         var instanceId = automationComposition.getInstanceId();
 274         var compositionId = automationComposition.getCompositionId();
 275         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(wrongCompositionId, instanceId))
 276                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 277
 278         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYED, LockState.LOCKED);
 279         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYING, LockState.NONE);
 280         assertThatDeleteThrownBy(automationComposition, DeployState.UNDEPLOYING, LockState.LOCKED);
 281
 282         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 283         automationComposition.setLockState(LockState.NONE);
 284         when(acProvider.deleteAutomationComposition(instanceId)).thenReturn(automationComposition);
 285
 286         instantiationProvider.deleteAutomationComposition(compositionId, instanceId);
 287         verify(supervisionAcHandler).delete(any(), any());
 288     }
 289
 290     private void assertThatDeleteThrownBy(AutomationComposition automationComposition, DeployState deployState,
 291             LockState lockState) {
 292         automationComposition.setDeployState(deployState);
 293         automationComposition.setLockState(lockState);
 294         var acProvider = mock(AutomationCompositionProvider.class);
 295         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 296
 297         var instantiationProvider =
 298                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null);
 299
 300         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 301                 .thenReturn(automationComposition);
 302
 303         var compositionId = automationComposition.getCompositionId();
 304         var instanceId = automationComposition.getInstanceId();
 305         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 306                 .hasMessageMatching(String.format(DELETE_BAD_REQUEST, deployState));
 307     }
 308
 309     @Test
 310     void testCreateAutomationCompositions_NoDuplicates() {
 311         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 312         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 313         var compositionId = acDefinition.getCompositionId();
 314         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 315
 316         var automationCompositionCreate =
 317                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "NoDuplicates");
 318         automationCompositionCreate.setCompositionId(compositionId);
 319         automationCompositionCreate.setInstanceId(UUID.randomUUID());
 320
 321         var acProvider = mock(AutomationCompositionProvider.class);
 322         when(acProvider.createAutomationComposition(automationCompositionCreate))
 323                 .thenReturn(automationCompositionCreate);
 324         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 325
 326         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 327                 null, null, acmParticipantProvider);
 328
 329         var instantiationResponse = instantiationProvider.createAutomationComposition(
 330                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 331         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 332
 333         when(acProvider.findAutomationComposition(automationCompositionCreate.getKey().asIdentifier()))
 334                 .thenReturn(Optional.of(automationCompositionCreate));
 335
 336         assertThatThrownBy(
 337                 () -> instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate))
 338                         .hasMessageMatching(automationCompositionCreate.getKey().asIdentifier() + " already defined");
 339     }
 340
 341     @Test
 342     void testCreateAutomationCompositions_CommissionedAcElementNotFound() {
 343         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 344         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 345         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 346         var compositionId = acDefinition.getCompositionId();
 347         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 348         var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(
 349                 AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON, "AcElementNotFound");
 350         automationComposition.setCompositionId(compositionId);
 351
 352         var acProvider = mock(AutomationCompositionProvider.class);
 353         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null,
 354                 acmParticipantProvider);
 355
 356         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 357                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 358
 359         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 360                 .thenReturn(automationComposition);
 361
 362         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 363                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 364     }
 365
 366     @Test
 367     void testAcDefinitionNotFound() {
 368         var automationComposition = InstantiationUtils
 369                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 370
 371         var acProvider = mock(AutomationCompositionProvider.class);
 372         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 373                 .thenReturn(automationComposition);
 374         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 375                 null, null, null);
 376
 377         var compositionId = automationComposition.getCompositionId();
 378         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 379                 .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
 380
 381         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 382                 .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
 383     }
 384
 385     @Test
 386     void testCompositionIdDoNotMatch() {
 387         var automationComposition = InstantiationUtils
 388                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 389
 390         var acProvider = mock(AutomationCompositionProvider.class);
 391         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 392                 .thenReturn(automationComposition);
 393         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 394                 null, null, null);
 395
 396         var compositionId = automationComposition.getCompositionId();
 397         var wrongCompositionId = UUID.randomUUID();
 398         assertThatThrownBy(() -> provider.createAutomationComposition(wrongCompositionId, automationComposition))
 399                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 400
 401         assertThatThrownBy(() -> provider.updateAutomationComposition(wrongCompositionId, automationComposition))
 402                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 403
 404         assertThatThrownBy(
 405                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 406                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 407         assertThatThrownBy(() -> provider.compositionInstanceState(wrongCompositionId,
 408                 automationComposition.getInstanceId(), new AcInstanceStateUpdate()))
 409                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 410     }
 411
 412     @Test
 413     void testCompositionNotPrimed() {
 414         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 415         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 416         var compositionId = acDefinition.getCompositionId();
 417         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 418         var acProvider = mock(AutomationCompositionProvider.class);
 419         var provider =
 420                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null);
 421
 422         var automationComposition =
 423                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 424         automationComposition.setCompositionId(compositionId);
 425         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 426                 .hasMessageMatching("\"AutomationComposition\" INVALID, item has status INVALID\n"
 427                         + "  item \"ServiceTemplate.state\" value \"COMMISSIONED\" INVALID,"
 428                         + " Commissioned automation composition definition not primed\n");
 429     }
 430
 431     @Test
 432     void testCompositionInstanceState() {
 433         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 434         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 435         var compositionId = acDefinition.getCompositionId();
 436         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 437
 438         var automationComposition = InstantiationUtils
 439                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 440         var instanceId = UUID.randomUUID();
 441         automationComposition.setCompositionId(compositionId);
 442         automationComposition.setInstanceId(instanceId);
 443         var acProvider = mock(AutomationCompositionProvider.class);
 444         when(acProvider.getAutomationComposition(instanceId)).thenReturn(automationComposition);
 445
 446         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 447         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 448         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 449                 new AcInstanceStateResolver(), supervisionAcHandler, acmParticipantProvider);
 450
 451         var acInstanceStateUpdate = new AcInstanceStateUpdate();
 452         acInstanceStateUpdate.setDeployOrder(DeployOrder.DEPLOY);
 453         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 454         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 455         verify(supervisionAcHandler).deploy(any(AutomationComposition.class),
 456                 any(AutomationCompositionDefinition.class));
 457
 458         automationComposition.setDeployState(DeployState.DEPLOYED);
 459         automationComposition.setLockState(LockState.LOCKED);
 460         acInstanceStateUpdate.setDeployOrder(DeployOrder.UNDEPLOY);
 461         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 462         verify(supervisionAcHandler).undeploy(any(AutomationComposition.class),
 463                 any(AutomationCompositionDefinition.class));
 464
 465         automationComposition.setDeployState(DeployState.DEPLOYED);
 466         automationComposition.setLockState(LockState.LOCKED);
 467         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 468         acInstanceStateUpdate.setLockOrder(LockOrder.UNLOCK);
 469         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 470         verify(supervisionAcHandler).unlock(any(AutomationComposition.class),
 471                 any(AutomationCompositionDefinition.class));
 472
 473         automationComposition.setDeployState(DeployState.DEPLOYED);
 474         automationComposition.setLockState(LockState.UNLOCKED);
 475         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 476         acInstanceStateUpdate.setLockOrder(LockOrder.LOCK);
 477         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 478         verify(supervisionAcHandler).lock(any(AutomationComposition.class), any(AutomationCompositionDefinition.class));
 479     }
 480 }