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