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 \"%s\" 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() {
  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         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 103         var acProvider = mock(AutomationCompositionProvider.class);
 104         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 105         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 106         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 107                 null, supervisionAcHandler, acmParticipantProvider,
 108                 CommonTestData.getTestParamaterGroup());
 109         var automationCompositionCreate =
 110                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 111         automationCompositionCreate.setCompositionId(compositionId);
 112         when(acProvider.createAutomationComposition(automationCompositionCreate))
 113                 .thenReturn(automationCompositionCreate);
 114
 115         var instantiationResponse = instantiationProvider.createAutomationComposition(
 116                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 117         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 118
 119         verify(acProvider).createAutomationComposition(automationCompositionCreate);
 120
 121         when(acProvider.getAutomationCompositions(compositionId, automationCompositionCreate.getName(),
 122                 automationCompositionCreate.getVersion())).thenReturn(List.of(automationCompositionCreate));
 123
 124         var automationCompositionsGet = instantiationProvider.getAutomationCompositions(compositionId,
 125                 automationCompositionCreate.getName(), automationCompositionCreate.getVersion());
 126         assertThat(automationCompositionCreate)
 127                 .isEqualTo(automationCompositionsGet.getAutomationCompositionList().get(0));
 128
 129         var automationCompositionUpdate =
 130                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 131         automationCompositionUpdate.setCompositionId(compositionId);
 132         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 133                 .thenReturn(automationCompositionUpdate);
 134         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 135                 .thenReturn(automationCompositionUpdate);
 136
 137         instantiationResponse = instantiationProvider.updateAutomationComposition(
 138                 automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
 139         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 140
 141         verify(acProvider).updateAutomationComposition(automationCompositionUpdate);
 142
 143         when(acProvider.deleteAutomationComposition(automationCompositionUpdate.getInstanceId()))
 144                 .thenReturn(automationCompositionUpdate);
 145         doNothing().when(acmParticipantProvider).verifyParticipantState(any());
 146         instantiationProvider.deleteAutomationComposition(automationCompositionCreate.getCompositionId(),
 147                 automationCompositionCreate.getInstanceId());
 148
 149         verify(supervisionAcHandler).delete(any(), any());
 150     }
 151
 152     @Test
 153     void testInstantiationUpdate() throws AutomationCompositionException {
 154         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 155         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 156         var compositionId = acDefinition.getCompositionId();
 157         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 158
 159         var automationCompositionUpdate =
 160                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 161         automationCompositionUpdate.setCompositionId(compositionId);
 162         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 163         automationCompositionUpdate.setLockState(LockState.LOCKED);
 164         var acProvider = mock(AutomationCompositionProvider.class);
 165         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 166                 .thenReturn(automationCompositionUpdate);
 167         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 168                 .thenReturn(automationCompositionUpdate);
 169
 170         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 171         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 172         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 173                 null, supervisionAcHandler, acmParticipantProvider,
 174                 CommonTestData.getTestParamaterGroup());
 175         var instantiationResponse = instantiationProvider.updateAutomationComposition(
 176                 automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
 177
 178         verify(supervisionAcHandler).update(any());
 179         verify(acProvider).updateAutomationComposition(automationCompositionUpdate);
 180         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 181     }
 182
 183     @Test
 184     void testUpdateBadRequest() throws AutomationCompositionException {
 185         var automationCompositionUpdate =
 186                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 187         automationCompositionUpdate.setDeployState(DeployState.DEPLOYING);
 188         automationCompositionUpdate.setLockState(LockState.NONE);
 189         var acProvider = mock(AutomationCompositionProvider.class);
 190         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 191                 .thenReturn(automationCompositionUpdate);
 192
 193         var instantiationProvider =
 194                 new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class), null,
 195                         mock(SupervisionAcHandler.class), mock(AcmParticipantProvider.class),
 196                         mock(AcRuntimeParameterGroup.class));
 197
 198         var compositionId = automationCompositionUpdate.getCompositionId();
 199         assertThatThrownBy(
 200                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 201                         .hasMessageMatching(
 202                                 "Not allowed to update in the state " + automationCompositionUpdate.getDeployState());
 203
 204         automationCompositionUpdate.setDeployState(DeployState.UPDATING);
 205         automationCompositionUpdate.setLockState(LockState.LOCKED);
 206         automationCompositionUpdate.setCompositionTargetId(UUID.randomUUID());
 207         assertThatThrownBy(
 208                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 209                         .hasMessageMatching(
 210                                 "Not allowed to migrate in the state " + automationCompositionUpdate.getDeployState());
 211     }
 212
 213     @Test
 214     void testUpdateRestartedBadRequest() throws AutomationCompositionException {
 215         var automationCompositionUpdate =
 216                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 217         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 218         automationCompositionUpdate.setLockState(LockState.LOCKED);
 219         automationCompositionUpdate.setRestarting(true);
 220         var acProvider = mock(AutomationCompositionProvider.class);
 221         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 222                 .thenReturn(automationCompositionUpdate);
 223
 224         var instantiationProvider =
 225                 new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class), null,
 226                         mock(SupervisionAcHandler.class), mock(AcmParticipantProvider.class),
 227                         mock(AcRuntimeParameterGroup.class));
 228
 229         var compositionId = automationCompositionUpdate.getCompositionId();
 230         assertThatThrownBy(
 231                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 232                         .hasMessageMatching("There is a restarting process, Update not allowed");
 233
 234         automationCompositionUpdate.setDeployState(DeployState.UNDEPLOYED);
 235         automationCompositionUpdate.setLockState(LockState.NONE);
 236
 237         var instanceId = automationCompositionUpdate.getInstanceId();
 238         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 239                 .hasMessageMatching("There is a restarting process, Delete not allowed");
 240     }
 241
 242     @Test
 243     void testUpdateCompositionRestartedBadRequest() throws AutomationCompositionException {
 244         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 245         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 246         acDefinition.setRestarting(true);
 247         var compositionId = acDefinition.getCompositionId();
 248         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 249
 250         var automationCompositionUpdate =
 251                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 252         automationCompositionUpdate.setCompositionId(compositionId);
 253         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 254         automationCompositionUpdate.setLockState(LockState.LOCKED);
 255         var acProvider = mock(AutomationCompositionProvider.class);
 256         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 257                 .thenReturn(automationCompositionUpdate);
 258         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 259                 .thenReturn(automationCompositionUpdate);
 260
 261         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 262         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 263         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 264                 null, supervisionAcHandler, acmParticipantProvider,
 265                 mock(AcRuntimeParameterGroup.class));
 266         assertThatThrownBy(
 267                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 268                         .hasMessageMatching("\"AutomationComposition\" INVALID, item has status INVALID\n"
 269                                 + "  item \"ServiceTemplate.restarting\" value \"true\" INVALID,"
 270                                 + " There is a restarting process in composition\n");
 271     }
 272
 273     @Test
 274     void testInstantiationMigration() {
 275         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 276         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 277         var compositionId = acDefinition.getCompositionId();
 278         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 279
 280         var automationComposition =
 281                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 282         automationComposition.setCompositionId(compositionId);
 283         automationComposition.setDeployState(DeployState.DEPLOYED);
 284         automationComposition.setLockState(LockState.LOCKED);
 285         automationComposition.setCompositionTargetId(UUID.randomUUID());
 286         var acProvider = mock(AutomationCompositionProvider.class);
 287         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 288                 .thenReturn(automationComposition);
 289         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 290
 291         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 292         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 293         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 294                 null, supervisionAcHandler, acmParticipantProvider, new AcRuntimeParameterGroup());
 295
 296         assertThatThrownBy(() -> instantiationProvider
 297                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
 298                         .hasMessageMatching(
 299                                 String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId()));
 300
 301         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 302         var compositionTargetId = acDefinitionTarget.getCompositionId();
 303         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 304
 305         automationComposition.setCompositionTargetId(compositionTargetId);
 306
 307         var instantiationResponse = instantiationProvider
 308                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
 309
 310         verify(supervisionAcHandler).migrate(any(), any());
 311         verify(acProvider).updateAutomationComposition(automationComposition);
 312         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
 313     }
 314
 315     @Test
 316     void testInstantiationDelete() {
 317         var automationComposition =
 318                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 319         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 320         var acProvider = mock(AutomationCompositionProvider.class);
 321         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 322         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 323         var compositionId = acDefinition.getCompositionId();
 324         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 325         automationComposition.setCompositionId(compositionId);
 326         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 327         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 328         var acRuntimeParameterGroup = mock(AcRuntimeParameterGroup.class);
 329
 330         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 331                 null, supervisionAcHandler, acmParticipantProvider, acRuntimeParameterGroup);
 332
 333         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 334                 .thenReturn(automationComposition);
 335
 336         var wrongCompositionId = UUID.randomUUID();
 337         var instanceId = automationComposition.getInstanceId();
 338         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(wrongCompositionId, instanceId))
 339                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 340
 341         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYED, LockState.LOCKED);
 342         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYING, LockState.NONE);
 343         assertThatDeleteThrownBy(automationComposition, DeployState.UNDEPLOYING, LockState.LOCKED);
 344         assertThatDeleteThrownBy(automationComposition, DeployState.DELETING, LockState.NONE);
 345
 346         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 347         automationComposition.setLockState(LockState.NONE);
 348         when(acProvider.deleteAutomationComposition(instanceId)).thenReturn(automationComposition);
 349
 350         instantiationProvider.deleteAutomationComposition(compositionId, instanceId);
 351         verify(supervisionAcHandler).delete(any(), any());
 352     }
 353
 354     private void assertThatDeleteThrownBy(AutomationComposition automationComposition, DeployState deployState,
 355             LockState lockState) {
 356         automationComposition.setDeployState(deployState);
 357         automationComposition.setLockState(lockState);
 358         var acProvider = mock(AutomationCompositionProvider.class);
 359         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 360         var acRuntimeParamaterGroup = mock(AcRuntimeParameterGroup.class);
 361
 362         var instantiationProvider =
 363                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null,
 364                         acRuntimeParamaterGroup);
 365
 366         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 367                 .thenReturn(automationComposition);
 368
 369         var compositionId = automationComposition.getCompositionId();
 370         var instanceId = automationComposition.getInstanceId();
 371         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 372                 .hasMessageMatching(String.format(DELETE_BAD_REQUEST, deployState));
 373     }
 374
 375     @Test
 376     void testCreateAutomationCompositions_NoDuplicates() {
 377         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 378         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 379         var compositionId = acDefinition.getCompositionId();
 380         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 381
 382         var automationCompositionCreate =
 383                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "NoDuplicates");
 384         automationCompositionCreate.setCompositionId(compositionId);
 385         automationCompositionCreate.setInstanceId(UUID.randomUUID());
 386
 387         var acProvider = mock(AutomationCompositionProvider.class);
 388         when(acProvider.createAutomationComposition(automationCompositionCreate))
 389                 .thenReturn(automationCompositionCreate);
 390         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 391
 392         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 393                 null, null, acmParticipantProvider,
 394                 CommonTestData.getTestParamaterGroup());
 395
 396         var instantiationResponse = instantiationProvider.createAutomationComposition(
 397                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 398         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 399
 400         when(acProvider.findAutomationComposition(automationCompositionCreate.getKey().asIdentifier()))
 401                 .thenReturn(Optional.of(automationCompositionCreate));
 402
 403         assertThatThrownBy(
 404                 () -> instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate))
 405                         .hasMessageMatching(automationCompositionCreate.getKey().asIdentifier() + " already defined");
 406     }
 407
 408     @Test
 409     void testCreateAutomationCompositions_CommissionedAcElementNotFound() {
 410         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 411         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 412         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 413         var compositionId = acDefinition.getCompositionId();
 414         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 415         var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(
 416                 AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON, "AcElementNotFound");
 417         automationComposition.setCompositionId(compositionId);
 418
 419         var acProvider = mock(AutomationCompositionProvider.class);
 420         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null,
 421                 acmParticipantProvider, CommonTestData.getTestParamaterGroup());
 422
 423         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 424                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 425
 426         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 427                 .thenReturn(automationComposition);
 428
 429         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 430                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 431     }
 432
 433     @Test
 434     void testAcDefinitionNotFound() {
 435         var automationComposition = InstantiationUtils
 436                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 437
 438         var acProvider = mock(AutomationCompositionProvider.class);
 439         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 440                 .thenReturn(automationComposition);
 441         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 442                 null, null, null,
 443                 mock(AcRuntimeParameterGroup.class));
 444
 445         var compositionId = automationComposition.getCompositionId();
 446         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 447                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
 448
 449         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 450                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
 451     }
 452
 453     @Test
 454     void testCompositionIdDoNotMatch() {
 455         var automationComposition = InstantiationUtils
 456                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 457
 458         var acProvider = mock(AutomationCompositionProvider.class);
 459         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 460                 .thenReturn(automationComposition);
 461         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 462                 null, null, null,
 463                 mock(AcRuntimeParameterGroup.class));
 464
 465         var compositionId = automationComposition.getCompositionId();
 466         var wrongCompositionId = UUID.randomUUID();
 467         assertThatThrownBy(() -> provider.createAutomationComposition(wrongCompositionId, automationComposition))
 468                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 469
 470         assertThatThrownBy(() -> provider.updateAutomationComposition(wrongCompositionId, automationComposition))
 471                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 472
 473         assertThatThrownBy(
 474                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 475                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 476         assertThatThrownBy(() -> provider.compositionInstanceState(wrongCompositionId,
 477                 automationComposition.getInstanceId(), new AcInstanceStateUpdate()))
 478                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 479
 480         var compositionTargetId = UUID.randomUUID();
 481         automationComposition.setCompositionTargetId(compositionTargetId);
 482         assertThatThrownBy(
 483                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 484                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 485
 486         var result = provider.getAutomationComposition(compositionTargetId, automationComposition.getInstanceId());
 487         assertThat(result).isNotNull();
 488     }
 489
 490     @Test
 491     void testCompositionNotPrimed() {
 492         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 493         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 494         var compositionId = acDefinition.getCompositionId();
 495         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 496         var acProvider = mock(AutomationCompositionProvider.class);
 497         var provider =
 498                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null,
 499                         null);
 500
 501         var automationComposition =
 502                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 503         automationComposition.setCompositionId(compositionId);
 504         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 505                 .hasMessageMatching("\"AutomationComposition\" INVALID, item has status INVALID\n"
 506                         + "  item \"ServiceTemplate.state\" value \"COMMISSIONED\" INVALID,"
 507                         + " Commissioned automation composition definition not primed\n");
 508     }
 509
 510     @Test
 511     void testCompositionInstanceState() {
 512         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 513         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 514         var compositionId = acDefinition.getCompositionId();
 515         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 516
 517         var automationComposition = InstantiationUtils
 518                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 519         var instanceId = UUID.randomUUID();
 520         automationComposition.setCompositionId(compositionId);
 521         automationComposition.setInstanceId(instanceId);
 522         var acProvider = mock(AutomationCompositionProvider.class);
 523         when(acProvider.getAutomationComposition(instanceId)).thenReturn(automationComposition);
 524
 525         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 526         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 527         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 528                 new AcInstanceStateResolver(), supervisionAcHandler, acmParticipantProvider,
 529                 mock(AcRuntimeParameterGroup.class));
 530
 531         var acInstanceStateUpdate = new AcInstanceStateUpdate();
 532         acInstanceStateUpdate.setDeployOrder(DeployOrder.DEPLOY);
 533         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 534         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 535         verify(supervisionAcHandler).deploy(any(AutomationComposition.class),
 536                 any(AutomationCompositionDefinition.class));
 537
 538         automationComposition.setDeployState(DeployState.DEPLOYED);
 539         automationComposition.setLockState(LockState.LOCKED);
 540         acInstanceStateUpdate.setDeployOrder(DeployOrder.UNDEPLOY);
 541         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 542         verify(supervisionAcHandler).undeploy(any(AutomationComposition.class),
 543                 any(AutomationCompositionDefinition.class));
 544
 545         automationComposition.setDeployState(DeployState.DEPLOYED);
 546         automationComposition.setLockState(LockState.LOCKED);
 547         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 548         acInstanceStateUpdate.setLockOrder(LockOrder.UNLOCK);
 549         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 550         verify(supervisionAcHandler).unlock(any(AutomationComposition.class),
 551                 any(AutomationCompositionDefinition.class));
 552
 553         automationComposition.setDeployState(DeployState.DEPLOYED);
 554         automationComposition.setLockState(LockState.UNLOCKED);
 555         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 556         acInstanceStateUpdate.setLockOrder(LockOrder.LOCK);
 557         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 558         verify(supervisionAcHandler).lock(any(AutomationComposition.class), any(AutomationCompositionDefinition.class));
 559     }
 560 }