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