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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2024 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.ArrayList;
  34 import java.util.List;
  35 import java.util.Optional;
  36 import java.util.UUID;
  37 import org.junit.jupiter.api.BeforeAll;
  38 import org.junit.jupiter.api.Test;
  39 import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
  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.models.acm.concepts.AcTypeState;
  44 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  45 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
  46 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  47 import org.onap.policy.clamp.models.acm.concepts.LockState;
  48 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  49 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.AcInstanceStateUpdate;
  50 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  51 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
  52 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
  53 import org.onap.policy.clamp.models.acm.persistence.provider.AcInstanceStateResolver;
  54 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
  55 import org.onap.policy.clamp.models.acm.persistence.provider.ProviderUtils;
  56 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  57 import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
  58
  59 /**
  60  * Class to perform unit test of {@link AutomationCompositionInstantiationProvider}}.
  61  *
  62  */
  63 class AutomationCompositionInstantiationProviderTest {
  64     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  65     private static final String AC_INSTANTIATION_UPDATE_JSON =
  66             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  67
  68     private static final String AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON =
  69             "src/test/resources/rest/acm/AutomationCompositionElementsNotFound.json";
  70     private static final String AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON =
  71             "src/test/resources/rest/acm/AutomationCompositionNotFound.json";
  72     private static final String DELETE_BAD_REQUEST = "Automation composition state is still %s";
  73
  74     private static final String AC_ELEMENT_NAME_NOT_FOUND =
  75             "\"AutomationComposition\" INVALID, item has status INVALID\n"
  76                     + "  \"entry PMSHInstance0AcElementNotFound\" INVALID, item has status INVALID\n"
  77                     + "    \"entry org.onap.domain.pmsh.DCAEMicroservice\" INVALID, Not found\n"
  78                     + "    \"entry org.onap.domain.pmsh.PMSH_MonitoringPolicyAutomationCompositionElement\""
  79                     + " INVALID, Not found\n";
  80     private static final String AC_DEFINITION_NOT_FOUND = "\"AutomationComposition\" INVALID, item has status INVALID\n"
  81             + "  item \"ServiceTemplate\" value \"%s\" INVALID,"
  82             + " Commissioned automation composition definition not found\n";
  83     private static final String DO_NOT_MATCH = " do not match with ";
  84
  85     private static ToscaServiceTemplate serviceTemplate = new ToscaServiceTemplate();
  86
  87     @BeforeAll
  88     public static void setUpBeforeClass() {
  89         serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
  90         var jpa =
  91                 ProviderUtils.getJpaAndValidate(serviceTemplate, JpaToscaServiceTemplate::new, "toscaServiceTemplate");
  92         serviceTemplate = jpa.toAuthorative();
  93     }
  94
  95     @Test
  96     void testInstantiationCrud() {
  97         var acDefinitionProvider = mock(AcDefinitionProvider.class);
  98         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
  99         var compositionId = acDefinition.getCompositionId();
 100         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 101         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(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() {
 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.setInstanceId(UUID.randomUUID());
 162         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 163         automationCompositionUpdate.setLockState(LockState.LOCKED);
 164         var acProvider = mock(AutomationCompositionProvider.class);
 165         var acmFromDb = new AutomationComposition(automationCompositionUpdate);
 166         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId())).thenReturn(acmFromDb);
 167         when(acProvider.updateAutomationComposition(acmFromDb)).thenReturn(acmFromDb);
 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(acmFromDb);
 179         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
 180
 181         var elements = new ArrayList<>(automationCompositionUpdate.getElements().values());
 182         automationCompositionUpdate.getElements().clear();
 183         for (var element : elements) {
 184             element.setId(UUID.randomUUID());
 185             automationCompositionUpdate.getElements().put(element.getId(), element);
 186         }
 187         assertThatThrownBy(
 188             () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 189             .hasMessageStartingWith("Element id not present ");
 190     }
 191
 192     @Test
 193     void testUpdateBadRequest() {
 194         var automationCompositionUpdate =
 195                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 196         automationCompositionUpdate.setDeployState(DeployState.DEPLOYING);
 197         automationCompositionUpdate.setLockState(LockState.NONE);
 198         var acProvider = mock(AutomationCompositionProvider.class);
 199         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 200                 .thenReturn(automationCompositionUpdate);
 201
 202         var instantiationProvider =
 203                 new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class), null,
 204                         mock(SupervisionAcHandler.class), mock(AcmParticipantProvider.class),
 205                         mock(AcRuntimeParameterGroup.class));
 206
 207         var compositionId = automationCompositionUpdate.getCompositionId();
 208         assertThatThrownBy(
 209                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 210                         .hasMessageMatching(
 211                                 "Not allowed to update in the state " + automationCompositionUpdate.getDeployState());
 212
 213         automationCompositionUpdate.setDeployState(DeployState.UPDATING);
 214         automationCompositionUpdate.setLockState(LockState.LOCKED);
 215         automationCompositionUpdate.setCompositionTargetId(UUID.randomUUID());
 216         assertThatThrownBy(
 217                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 218                         .hasMessageMatching(
 219                                 "Not allowed to migrate in the state " + automationCompositionUpdate.getDeployState());
 220     }
 221
 222     @Test
 223     void testUpdateRestartedBadRequest() {
 224         var automationCompositionUpdate =
 225                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 226         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 227         automationCompositionUpdate.setLockState(LockState.LOCKED);
 228         automationCompositionUpdate.setRestarting(true);
 229         var acProvider = mock(AutomationCompositionProvider.class);
 230         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 231                 .thenReturn(automationCompositionUpdate);
 232
 233         var instantiationProvider =
 234                 new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class), null,
 235                         mock(SupervisionAcHandler.class), mock(AcmParticipantProvider.class),
 236                         mock(AcRuntimeParameterGroup.class));
 237
 238         var compositionId = automationCompositionUpdate.getCompositionId();
 239         assertThatThrownBy(
 240                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 241                         .hasMessageMatching("There is a restarting process, Update not allowed");
 242
 243         automationCompositionUpdate.setCompositionTargetId(UUID.randomUUID());
 244         assertThatThrownBy(
 245                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 246                 .hasMessageMatching("There is a restarting process, Migrate not allowed");
 247
 248         automationCompositionUpdate.setDeployState(DeployState.UNDEPLOYED);
 249         automationCompositionUpdate.setLockState(LockState.NONE);
 250
 251         var instanceId = automationCompositionUpdate.getInstanceId();
 252         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 253                 .hasMessageMatching("There is a restarting process, Delete not allowed");
 254     }
 255
 256     @Test
 257     void testUpdateCompositionRestartedBadRequest() {
 258         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 259         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 260         acDefinition.setRestarting(true);
 261         var compositionId = acDefinition.getCompositionId();
 262         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 263
 264         var automationCompositionUpdate =
 265                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 266         automationCompositionUpdate.setCompositionId(compositionId);
 267         automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
 268         automationCompositionUpdate.setLockState(LockState.LOCKED);
 269         var acProvider = mock(AutomationCompositionProvider.class);
 270         when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
 271                 .thenReturn(automationCompositionUpdate);
 272         when(acProvider.updateAutomationComposition(automationCompositionUpdate))
 273                 .thenReturn(automationCompositionUpdate);
 274
 275         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 276         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 277         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 278                 null, supervisionAcHandler, acmParticipantProvider,
 279                 mock(AcRuntimeParameterGroup.class));
 280         assertThatThrownBy(
 281                 () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
 282                         .hasMessageMatching("\"AutomationComposition\" INVALID, item has status INVALID\n"
 283                                 + "  item \"ServiceTemplate.restarting\" value \"true\" INVALID,"
 284                                 + " There is a restarting process in composition\n");
 285     }
 286
 287     @Test
 288     void testInstantiationMigration() {
 289         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 290         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 291         var compositionId = acDefinition.getCompositionId();
 292         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 293
 294         var automationComposition =
 295                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 296         automationComposition.setCompositionId(compositionId);
 297         automationComposition.setDeployState(DeployState.DEPLOYED);
 298         automationComposition.setLockState(LockState.LOCKED);
 299         automationComposition.setCompositionTargetId(UUID.randomUUID());
 300         var acProvider = mock(AutomationCompositionProvider.class);
 301         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 302                 .thenReturn(automationComposition);
 303         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 304
 305         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 306         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 307         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 308                 null, supervisionAcHandler, acmParticipantProvider, new AcRuntimeParameterGroup());
 309
 310         assertThatThrownBy(() -> instantiationProvider
 311                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
 312                         .hasMessageMatching(
 313                                 String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId()));
 314
 315         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 316         var compositionTargetId = acDefinitionTarget.getCompositionId();
 317         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 318
 319         automationComposition.setCompositionTargetId(compositionTargetId);
 320
 321         var instantiationResponse = instantiationProvider
 322                 .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
 323
 324         verify(supervisionAcHandler).migrate(any(), any());
 325         verify(acProvider).updateAutomationComposition(automationComposition);
 326         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
 327     }
 328
 329     @Test
 330     void testMigrateBadRequest() {
 331         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 332         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 333         var compositionId = acDefinition.getCompositionId();
 334         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 335
 336         var automationComposition =
 337                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 338         automationComposition.setCompositionId(compositionId);
 339         automationComposition.setDeployState(DeployState.DEPLOYED);
 340         automationComposition.setLockState(LockState.LOCKED);
 341         var acProvider = mock(AutomationCompositionProvider.class);
 342         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 343                 .thenReturn(automationComposition);
 344         when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
 345
 346         var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 347         var compositionTargetId = acDefinitionTarget.getCompositionId();
 348         when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
 349
 350         var acMigrate = new AutomationComposition(automationComposition);
 351         acMigrate.setCompositionTargetId(compositionTargetId);
 352         automationComposition.getElements().clear();
 353
 354         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 355         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 356         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 357                 null, supervisionAcHandler, acmParticipantProvider, new AcRuntimeParameterGroup());
 358
 359         assertThatThrownBy(() -> instantiationProvider
 360                 .updateAutomationComposition(automationComposition.getCompositionId(), acMigrate))
 361                 .hasMessageStartingWith("Element id not present");
 362     }
 363
 364     @Test
 365     void testInstantiationDelete() {
 366         var automationComposition =
 367                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Delete");
 368         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 369         var acProvider = mock(AutomationCompositionProvider.class);
 370         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 371         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 372         var compositionId = acDefinition.getCompositionId();
 373         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 374         automationComposition.setCompositionId(compositionId);
 375         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 376         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 377         var acRuntimeParameterGroup = mock(AcRuntimeParameterGroup.class);
 378
 379         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 380                 null, supervisionAcHandler, acmParticipantProvider, acRuntimeParameterGroup);
 381
 382         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 383                 .thenReturn(automationComposition);
 384
 385         var wrongCompositionId = UUID.randomUUID();
 386         var instanceId = automationComposition.getInstanceId();
 387         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(wrongCompositionId, instanceId))
 388                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 389
 390         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYED, LockState.LOCKED);
 391         assertThatDeleteThrownBy(automationComposition, DeployState.DEPLOYING, LockState.NONE);
 392         assertThatDeleteThrownBy(automationComposition, DeployState.UNDEPLOYING, LockState.LOCKED);
 393         assertThatDeleteThrownBy(automationComposition, DeployState.DELETING, LockState.NONE);
 394
 395         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 396         automationComposition.setLockState(LockState.NONE);
 397         when(acProvider.deleteAutomationComposition(instanceId)).thenReturn(automationComposition);
 398
 399         instantiationProvider.deleteAutomationComposition(compositionId, instanceId);
 400         verify(supervisionAcHandler).delete(any(), any());
 401     }
 402
 403     private void assertThatDeleteThrownBy(AutomationComposition automationComposition, DeployState deployState,
 404             LockState lockState) {
 405         automationComposition.setDeployState(deployState);
 406         automationComposition.setLockState(lockState);
 407         var acProvider = mock(AutomationCompositionProvider.class);
 408         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 409         var acRuntimeParamaterGroup = mock(AcRuntimeParameterGroup.class);
 410
 411         var instantiationProvider =
 412                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null,
 413                         acRuntimeParamaterGroup);
 414
 415         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 416                 .thenReturn(automationComposition);
 417
 418         var compositionId = automationComposition.getCompositionId();
 419         var instanceId = automationComposition.getInstanceId();
 420         assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
 421                 .hasMessageMatching(String.format(DELETE_BAD_REQUEST, deployState));
 422     }
 423
 424     @Test
 425     void testCreateAutomationCompositions_NoDuplicates() {
 426         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 427         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 428         var compositionId = acDefinition.getCompositionId();
 429         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 430
 431         var automationCompositionCreate =
 432                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "NoDuplicates");
 433         automationCompositionCreate.setCompositionId(compositionId);
 434         automationCompositionCreate.setInstanceId(UUID.randomUUID());
 435
 436         var acProvider = mock(AutomationCompositionProvider.class);
 437         when(acProvider.createAutomationComposition(automationCompositionCreate))
 438                 .thenReturn(automationCompositionCreate);
 439         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 440
 441         var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 442                 null, null, acmParticipantProvider,
 443                 CommonTestData.getTestParamaterGroup());
 444
 445         var instantiationResponse = instantiationProvider.createAutomationComposition(
 446                 automationCompositionCreate.getCompositionId(), automationCompositionCreate);
 447         InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
 448
 449         when(acProvider.findAutomationComposition(automationCompositionCreate.getKey().asIdentifier()))
 450                 .thenReturn(Optional.of(automationCompositionCreate));
 451
 452         assertThatThrownBy(
 453                 () -> instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate))
 454                         .hasMessageMatching(automationCompositionCreate.getKey().asIdentifier() + " already defined");
 455     }
 456
 457     @Test
 458     void testCreateAutomationCompositions_CommissionedAcElementNotFound() {
 459         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 460         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 461         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 462         var compositionId = acDefinition.getCompositionId();
 463         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 464         var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(
 465                 AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON, "AcElementNotFound");
 466         automationComposition.setCompositionId(compositionId);
 467
 468         var acProvider = mock(AutomationCompositionProvider.class);
 469         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null,
 470                 acmParticipantProvider, CommonTestData.getTestParamaterGroup());
 471
 472         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 473                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 474
 475         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 476                 .thenReturn(automationComposition);
 477
 478         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 479                 .hasMessageMatching(AC_ELEMENT_NAME_NOT_FOUND);
 480     }
 481
 482     @Test
 483     void testAcDefinitionNotFound() {
 484         var automationComposition = InstantiationUtils
 485                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 486
 487         var acProvider = mock(AutomationCompositionProvider.class);
 488         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 489                 .thenReturn(automationComposition);
 490         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 491                 null, null, null,
 492                 mock(AcRuntimeParameterGroup.class));
 493
 494         var compositionId = automationComposition.getCompositionId();
 495         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 496                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
 497
 498         assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
 499                 .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
 500     }
 501
 502     @Test
 503     void testCompositionIdDoNotMatch() {
 504         var automationComposition = InstantiationUtils
 505                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 506
 507         var acProvider = mock(AutomationCompositionProvider.class);
 508         when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
 509                 .thenReturn(automationComposition);
 510         var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
 511                 null, null, null,
 512                 mock(AcRuntimeParameterGroup.class));
 513
 514         var compositionId = automationComposition.getCompositionId();
 515         var wrongCompositionId = UUID.randomUUID();
 516         assertThatThrownBy(() -> provider.createAutomationComposition(wrongCompositionId, automationComposition))
 517                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 518
 519         assertThatThrownBy(() -> provider.updateAutomationComposition(wrongCompositionId, automationComposition))
 520                 .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 521
 522         assertThatThrownBy(
 523                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 524                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 525         assertThatThrownBy(() -> provider.compositionInstanceState(wrongCompositionId,
 526                 automationComposition.getInstanceId(), new AcInstanceStateUpdate()))
 527                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 528
 529         var compositionTargetId = UUID.randomUUID();
 530         automationComposition.setCompositionTargetId(compositionTargetId);
 531         assertThatThrownBy(
 532                 () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
 533                         .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
 534
 535         var result = provider.getAutomationComposition(compositionTargetId, automationComposition.getInstanceId());
 536         assertThat(result).isNotNull();
 537     }
 538
 539     @Test
 540     void testCompositionNotPrimed() {
 541         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 542         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 543         var compositionId = acDefinition.getCompositionId();
 544         when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
 545         var acProvider = mock(AutomationCompositionProvider.class);
 546         var provider =
 547                 new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null,
 548                         null);
 549
 550         var automationComposition =
 551                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 552         automationComposition.setCompositionId(compositionId);
 553         assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
 554                 .hasMessageMatching("\"AutomationComposition\" INVALID, item has status INVALID\n"
 555                         + "  item \"ServiceTemplate.state\" value \"COMMISSIONED\" INVALID,"
 556                         + " Commissioned automation composition definition not primed\n");
 557     }
 558
 559     @Test
 560     void testCompositionInstanceState() {
 561         var acDefinitionProvider = mock(AcDefinitionProvider.class);
 562         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
 563         var compositionId = acDefinition.getCompositionId();
 564         when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
 565
 566         var automationComposition = InstantiationUtils
 567                 .getAutomationCompositionFromResource(AC_INSTANTIATION_AC_DEFINITION_NOT_FOUND_JSON, "AcNotFound");
 568         var instanceId = UUID.randomUUID();
 569         automationComposition.setCompositionId(compositionId);
 570         automationComposition.setInstanceId(instanceId);
 571         var acProvider = mock(AutomationCompositionProvider.class);
 572         when(acProvider.getAutomationComposition(instanceId)).thenReturn(automationComposition);
 573
 574         var supervisionAcHandler = mock(SupervisionAcHandler.class);
 575         var acmParticipantProvider = mock(AcmParticipantProvider.class);
 576         var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
 577                 new AcInstanceStateResolver(), supervisionAcHandler, acmParticipantProvider,
 578                 mock(AcRuntimeParameterGroup.class));
 579
 580         var acInstanceStateUpdate = new AcInstanceStateUpdate();
 581         acInstanceStateUpdate.setDeployOrder(DeployOrder.DEPLOY);
 582         acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
 583         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 584         verify(supervisionAcHandler).deploy(any(AutomationComposition.class),
 585                 any(AutomationCompositionDefinition.class));
 586
 587         automationComposition.setDeployState(DeployState.DEPLOYED);
 588         automationComposition.setLockState(LockState.LOCKED);
 589         acInstanceStateUpdate.setDeployOrder(DeployOrder.UNDEPLOY);
 590         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 591         verify(supervisionAcHandler).undeploy(any(AutomationComposition.class),
 592                 any(AutomationCompositionDefinition.class));
 593
 594         automationComposition.setDeployState(DeployState.DEPLOYED);
 595         automationComposition.setLockState(LockState.LOCKED);
 596         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 597         acInstanceStateUpdate.setLockOrder(LockOrder.UNLOCK);
 598         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 599         verify(supervisionAcHandler).unlock(any(AutomationComposition.class),
 600                 any(AutomationCompositionDefinition.class));
 601
 602         automationComposition.setDeployState(DeployState.DEPLOYED);
 603         automationComposition.setLockState(LockState.UNLOCKED);
 604         acInstanceStateUpdate.setDeployOrder(DeployOrder.NONE);
 605         acInstanceStateUpdate.setLockOrder(LockOrder.LOCK);
 606         provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
 607         verify(supervisionAcHandler).lock(any(AutomationComposition.class), any(AutomationCompositionDefinition.class));
 608     }
 609 }