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