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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2023-2025 OpenInfra Foundation Europe. All rights reserved.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.clamp.acm.runtime.supervision;
  22
  23 import static org.mockito.ArgumentMatchers.any;
  24 import static org.mockito.ArgumentMatchers.anyBoolean;
  25 import static org.mockito.ArgumentMatchers.anyInt;
  26 import static org.mockito.Mockito.mock;
  27 import static org.mockito.Mockito.timeout;
  28 import static org.mockito.Mockito.times;
  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.Map;
  34 import java.util.Optional;
  35 import java.util.UUID;
  36 import org.junit.jupiter.api.Test;
  37 import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
  38 import org.onap.policy.clamp.acm.runtime.main.utils.EncryptionUtils;
  39 import org.onap.policy.clamp.acm.runtime.supervision.comm.AcElementPropertiesPublisher;
  40 import org.onap.policy.clamp.acm.runtime.supervision.comm.AcPreparePublisher;
  41 import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionDeployPublisher;
  42 import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionMigrationPublisher;
  43 import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionStateChangePublisher;
  44 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
  45 import org.onap.policy.clamp.models.acm.concepts.AcElementDeployAck;
  46 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  47 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  48 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  49 import org.onap.policy.clamp.models.acm.concepts.LockState;
  50 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  51 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionDeployAck;
  52 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantMessageType;
  53 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
  54 import org.onap.policy.clamp.models.acm.persistence.provider.MessageProvider;
  55
  56 class SupervisionAcHandlerTest {
  57     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  58     private static final String AC_INSTANTIATION_SIMPLE_JSON =
  59             "src/test/resources/rest/acm/AutomationCompositionSimple.json";
  60     private static final UUID IDENTIFIER = UUID.randomUUID();
  61
  62     @Test
  63     void testAutomationCompositionDeployAckValidation() {
  64         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
  65         var messageProvider = mock(MessageProvider.class);
  66         var handler = new SupervisionAcHandler(automationCompositionProvider,
  67                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
  68                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
  69                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
  70
  71         var automationComposition =
  72                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
  73         automationComposition.setInstanceId(IDENTIFIER);
  74         var automationCompositionAckMessage =
  75                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
  76                         automationComposition, DeployState.DEPLOYED, LockState.UNLOCKED);
  77         automationCompositionAckMessage.setStateChangeResult(null);
  78         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  79
  80         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.TIMEOUT);
  81         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  82
  83         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
  84         automationCompositionAckMessage.setAutomationCompositionId(null);
  85         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  86
  87         automationCompositionAckMessage.setAutomationCompositionId(automationComposition.getInstanceId());
  88         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  89
  90         automationCompositionAckMessage =
  91                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
  92                         automationComposition, DeployState.DEPLOYING, LockState.UNLOCKED);
  93         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  94
  95         verify(messageProvider, times(0)).save(any(AutomationCompositionDeployAck.class));
  96
  97         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
  98                 .thenReturn(Optional.of(automationComposition));
  99         automationCompositionAckMessage.setAutomationCompositionResultMap(null);
 100         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
 101         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 102     }
 103
 104     @Test
 105     void testHandleAcMigrationWithStage() {
 106         var automationComposition =
 107                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 108         automationComposition.setInstanceId(IDENTIFIER);
 109         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 110         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 111                 .thenReturn(Optional.of(automationComposition));
 112         var messageProvider = mock(MessageProvider.class);
 113
 114         var handler = new SupervisionAcHandler(automationCompositionProvider,
 115                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 116                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 117                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 118
 119         var automationCompositionAckMessage =
 120                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
 121                         automationComposition, DeployState.MIGRATING, LockState.LOCKED);
 122         automationCompositionAckMessage.setStage(1);
 123         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
 124
 125         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 126     }
 127
 128     @Test
 129     void testHandleAutomationCompositionStateChangeAckMessage() {
 130         var automationComposition =
 131                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 132         automationComposition.setInstanceId(IDENTIFIER);
 133         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 134         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 135                 .thenReturn(Optional.of(automationComposition));
 136         var messageProvider = mock(MessageProvider.class);
 137
 138         var handler = new SupervisionAcHandler(automationCompositionProvider,
 139                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 140                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 141                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 142
 143         var automationCompositionAckMessage =
 144                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
 145                         automationComposition, DeployState.DEPLOYED, LockState.UNLOCKED);
 146         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
 147
 148         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 149     }
 150
 151     private AutomationCompositionDeployAck getAutomationCompositionDeployAck(ParticipantMessageType messageType,
 152             AutomationComposition automationComposition, DeployState deployState, LockState lockState) {
 153         var automationCompositionAckMessage = new AutomationCompositionDeployAck(messageType);
 154         for (var elementEntry : automationComposition.getElements().entrySet()) {
 155             var acElementDeployAck = new AcElementDeployAck(deployState, lockState, "", "", Map.of(), true, "");
 156             automationCompositionAckMessage.getAutomationCompositionResultMap().put(elementEntry.getKey(),
 157                     acElementDeployAck);
 158         }
 159         automationCompositionAckMessage.setAutomationCompositionId(automationComposition.getInstanceId());
 160         automationCompositionAckMessage.setParticipantId(CommonTestData.getParticipantId());
 161         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
 162         return automationCompositionAckMessage;
 163     }
 164
 165     @Test
 166     void testHandleAutomationCompositionUpdateAckMessage() {
 167         var automationComposition =
 168                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 169         automationComposition.setInstanceId(IDENTIFIER);
 170         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 171         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 172                 .thenReturn(Optional.of(automationComposition));
 173         var messageProvider = mock(MessageProvider.class);
 174
 175         var automationCompositionAckMessage =
 176                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK,
 177                         automationComposition, DeployState.DEPLOYED, LockState.LOCKED);
 178         automationCompositionAckMessage.setParticipantId(CommonTestData.getParticipantId());
 179
 180         var handler = new SupervisionAcHandler(automationCompositionProvider,
 181                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 182                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 183                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 184
 185         handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
 186
 187         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 188     }
 189
 190     @Test
 191     void testHandleAcUpdateAckFailedMessage() {
 192         var automationComposition =
 193                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 194         automationComposition.setDeployState(DeployState.DEPLOYING);
 195         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 196         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 197         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 198                 .thenReturn(Optional.of(automationComposition));
 199
 200         var automationCompositionAckMessage =
 201                 new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK);
 202         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
 203         for (var element : automationComposition.getElements().values()) {
 204             element.setDeployState(DeployState.DEPLOYED);
 205         }
 206         var elementEntry = automationComposition.getElements().entrySet().iterator().next();
 207         elementEntry.getValue().setDeployState(DeployState.DEPLOYING);
 208         var acElementDeployAck =
 209                 new AcElementDeployAck(DeployState.UNDEPLOYED, LockState.NONE, "", "", Map.of(), true, "Error");
 210         automationCompositionAckMessage
 211                 .setAutomationCompositionResultMap(Map.of(elementEntry.getKey(), acElementDeployAck));
 212
 213         automationCompositionAckMessage.setParticipantId(CommonTestData.getParticipantId());
 214         automationCompositionAckMessage.setAutomationCompositionId(IDENTIFIER);
 215
 216         var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 217         var messageProvider = mock(MessageProvider.class);
 218
 219         var handler = new SupervisionAcHandler(automationCompositionProvider,
 220                 mock(AutomationCompositionDeployPublisher.class), automationCompositionStateChangePublisher,
 221                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 222                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 223
 224         handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
 225
 226         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 227     }
 228
 229     @Test
 230     void testDeploy() {
 231         var automationComposition =
 232                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Deploy");
 233         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 234         deploy(automationComposition);
 235     }
 236
 237     @Test
 238     void testDeployFailed() {
 239         var automationComposition =
 240                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Deploy");
 241         automationComposition.setDeployState(DeployState.UNDEPLOYING);
 242         automationComposition.getElements().values()
 243                 .forEach(element -> element.setDeployState(DeployState.UNDEPLOYING));
 244         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 245         deploy(automationComposition);
 246
 247         automationComposition.setDeployState(DeployState.DEPLOYING);
 248         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 249         automationComposition.getElements().values()
 250                 .forEach(element -> element.setDeployState(DeployState.DEPLOYING));
 251         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.DEPLOYED);
 252         deploy(automationComposition);
 253     }
 254
 255     @Test
 256     void testDeployFailedSimple() {
 257         var automationComposition =
 258                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_SIMPLE_JSON, "Deploy");
 259         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 260         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.UNDEPLOYED);
 261         deploy(automationComposition);
 262
 263         automationComposition.setDeployState(DeployState.UNDEPLOYING);
 264         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 265         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.DEPLOYED);
 266         deploy(automationComposition);
 267
 268         automationComposition.setDeployState(DeployState.DEPLOYING);
 269         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 270         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.UNDEPLOYED);
 271         deploy(automationComposition);
 272     }
 273
 274     private void deploy(AutomationComposition automationComposition) {
 275         var acDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
 276         var acProvider = mock(AutomationCompositionProvider.class);
 277         var handler = new SupervisionAcHandler(acProvider, acDeployPublisher,
 278                 mock(AutomationCompositionStateChangePublisher.class),
 279                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 280                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 281         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 282         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 283         handler.deploy(automationComposition, acDefinition);
 284         verify(acProvider).updateAutomationComposition(automationComposition);
 285         verify(acDeployPublisher, timeout(1000)).send(automationComposition, 0, true);
 286     }
 287
 288     @Test
 289     void testUndeploy() {
 290         var automationComposition =
 291                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Undeploy");
 292         automationComposition.setDeployState(DeployState.DEPLOYED);
 293         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 294         automationComposition.getElements().values()
 295                 .forEach(element -> element.setDeployState(DeployState.DEPLOYED));
 296         undeploy(automationComposition);
 297     }
 298
 299     private void undeploy(AutomationComposition automationComposition) {
 300         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 301         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 302         var handler = new SupervisionAcHandler(automationCompositionProvider,
 303                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 304                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 305                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 306         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 307         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 308         handler.undeploy(automationComposition, acDefinition);
 309
 310         verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
 311         verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
 312     }
 313
 314     @Test
 315     void testUndeployFailed() {
 316         var automationComposition =
 317                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "UnDeploy");
 318         automationComposition.setDeployState(DeployState.DEPLOYING);
 319         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 320         automationComposition.getElements().values()
 321                 .forEach(element -> element.setDeployState(DeployState.UNDEPLOYED));
 322         undeploy(automationComposition);
 323
 324         automationComposition.setDeployState(DeployState.UNDEPLOYING);
 325         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 326         automationComposition.getElements().values()
 327                 .forEach(element -> element.setDeployState(DeployState.DEPLOYING));
 328         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.UNDEPLOYED);
 329         undeploy(automationComposition);
 330     }
 331
 332     @Test
 333     void testUndeployFailedSimple() {
 334         var automationComposition =
 335                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_SIMPLE_JSON, "UnDeploy");
 336         automationComposition.setDeployState(DeployState.DEPLOYING);
 337         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 338         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.UNDEPLOYED);
 339         undeploy(automationComposition);
 340
 341         automationComposition.setDeployState(DeployState.UNDEPLOYING);
 342         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 343         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.DEPLOYED);
 344         undeploy(automationComposition);
 345     }
 346
 347     @Test
 348     void testUnlock() {
 349         var automationComposition =
 350                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "UnLock");
 351         automationComposition.setLockState(LockState.LOCKED);
 352         automationComposition.getElements().values()
 353                 .forEach(element -> element.setLockState(LockState.LOCKED));
 354         unlock(automationComposition);
 355     }
 356
 357     private void unlock(AutomationComposition automationComposition) {
 358         var acProvider = mock(AutomationCompositionProvider.class);
 359         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 360         var handler = new SupervisionAcHandler(acProvider,
 361                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 362                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 363                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 364         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 365         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 366         handler.unlock(automationComposition, acDefinition);
 367
 368         verify(acProvider).updateAutomationComposition(any(AutomationComposition.class));
 369         verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
 370     }
 371
 372     @Test
 373     void testUnlockFailed() {
 374         var automationComposition =
 375                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "UnLock");
 376         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 377         automationComposition.setLockState(LockState.LOCKING);
 378         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.LOCKING));
 379         unlock(automationComposition);
 380
 381         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 382         automationComposition.setLockState(LockState.UNLOCKING);
 383         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.UNLOCKING));
 384         automationComposition.getElements().values().iterator().next().setLockState(LockState.UNLOCKED);
 385         unlock(automationComposition);
 386     }
 387
 388     @Test
 389     void testUnlockSimple() {
 390         var automationComposition =
 391                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_SIMPLE_JSON, "UnLock");
 392         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 393         automationComposition.setLockState(LockState.LOCKING);
 394         automationComposition.getElements().values().iterator().next().setLockState(LockState.UNLOCKED);
 395         unlock(automationComposition);
 396
 397         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 398         automationComposition.setLockState(LockState.UNLOCKING);
 399         automationComposition.getElements().values().iterator().next().setLockState(LockState.LOCKED);
 400         unlock(automationComposition);
 401     }
 402
 403     @Test
 404     void testLock() {
 405         var automationComposition =
 406                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Lock");
 407         automationComposition.setLockState(LockState.UNLOCKED);
 408         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.UNLOCKED));
 409         lock(automationComposition);
 410     }
 411
 412     private void lock(AutomationComposition automationComposition) {
 413         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 414         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 415         var handler = new SupervisionAcHandler(automationCompositionProvider,
 416                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 417                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 418                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 419         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 420         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 421         handler.lock(automationComposition, acDefinition);
 422
 423         verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
 424         verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
 425     }
 426
 427     @Test
 428     void testLockFailed() {
 429         var automationComposition =
 430                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Lock");
 431         automationComposition.setLockState(LockState.UNLOCKING);
 432         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 433         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.UNLOCKING));
 434         lock(automationComposition);
 435
 436         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 437         automationComposition.setLockState(LockState.LOCKING);
 438         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.LOCKING));
 439         automationComposition.getElements().values().iterator().next().setLockState(LockState.LOCKED);
 440         lock(automationComposition);
 441     }
 442
 443     @Test
 444     void testLockSimple() {
 445         var automationComposition =
 446                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_SIMPLE_JSON, "Lock");
 447         automationComposition.setLockState(LockState.UNLOCKING);
 448         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 449         automationComposition.getElements().values().iterator().next().setLockState(LockState.LOCKED);
 450         lock(automationComposition);
 451
 452         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 453         automationComposition.setLockState(LockState.LOCKING);
 454         automationComposition.getElements().values().iterator().next().setLockState(LockState.UNLOCKED);
 455         lock(automationComposition);
 456     }
 457
 458     @Test
 459     void testDeleteAck() {
 460         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 461         var automationComposition =
 462                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 463         automationComposition.setDeployState(DeployState.DELETING);
 464         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 465                 .thenReturn(Optional.of(automationComposition));
 466
 467         var automationCompositionAckMessage =
 468                 new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK);
 469         automationCompositionAckMessage
 470                 .setParticipantId(automationComposition.getElements().values().iterator().next().getParticipantId());
 471         automationCompositionAckMessage.setAutomationCompositionId(IDENTIFIER);
 472         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
 473         var messageProvider = mock(MessageProvider.class);
 474
 475         var handler = new SupervisionAcHandler(automationCompositionProvider,
 476                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 477                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 478                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 479
 480         handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
 481
 482         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 483     }
 484
 485     @Test
 486     void testUpdate() {
 487         var acElementPropertiesPublisher = mock(AcElementPropertiesPublisher.class);
 488         var handler = new SupervisionAcHandler(mock(AutomationCompositionProvider.class),
 489                 mock(AutomationCompositionDeployPublisher.class),
 490                 mock(AutomationCompositionStateChangePublisher.class), acElementPropertiesPublisher,
 491                 mock(AutomationCompositionMigrationPublisher.class),
 492                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 493         var automationComposition =
 494                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Lock");
 495         handler.update(automationComposition);
 496         verify(acElementPropertiesPublisher, timeout(1000)).send(any(AutomationComposition.class));
 497     }
 498
 499     @Test
 500     void testMigrate() {
 501         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 502         var acCompositionMigrationPublisher = mock(AutomationCompositionMigrationPublisher.class);
 503         var handler = new SupervisionAcHandler(automationCompositionProvider,
 504                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 505                 mock(AcElementPropertiesPublisher.class), acCompositionMigrationPublisher,
 506                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 507         var automationComposition =
 508                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 509         assert automationComposition != null;
 510         automationComposition.setPhase(0);
 511         handler.migrate(automationComposition);
 512         verify(acCompositionMigrationPublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt());
 513     }
 514
 515     @Test
 516     void testMigratePrecheck() {
 517         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 518         var acCompositionMigrationPublisher = mock(AutomationCompositionMigrationPublisher.class);
 519         var handler = new SupervisionAcHandler(automationCompositionProvider,
 520                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 521                 mock(AcElementPropertiesPublisher.class), acCompositionMigrationPublisher,
 522                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 523         var automationComposition =
 524                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 525         handler.migratePrecheck(automationComposition);
 526         verify(acCompositionMigrationPublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt());
 527     }
 528
 529     @Test
 530     void testPrepare() {
 531         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 532         var acPreparePublisher = mock(AcPreparePublisher.class);
 533         var handler = new SupervisionAcHandler(automationCompositionProvider,
 534                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 535                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 536                 acPreparePublisher, mock(MessageProvider.class), mock(EncryptionUtils.class));
 537         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 538         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 539         var automationComposition =
 540                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 541         handler.prepare(automationComposition, acDefinition);
 542         verify(acPreparePublisher, timeout(1000)).sendPrepare(any(AutomationComposition.class), anyInt());
 543     }
 544
 545     @Test
 546     void testReview() {
 547         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 548         var acPreparePublisher = mock(AcPreparePublisher.class);
 549         var handler = new SupervisionAcHandler(automationCompositionProvider,
 550                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 551                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 552                 acPreparePublisher, mock(MessageProvider.class), mock(EncryptionUtils.class));
 553         var automationComposition =
 554                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 555         handler.review(automationComposition);
 556         verify(acPreparePublisher, timeout(1000)).sendRevew(any(AutomationComposition.class));
 557     }
 558 }