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 UUID IDENTIFIER = UUID.randomUUID();
  59
  60     @Test
  61     void testAutomationCompositionDeployAckValidation() {
  62         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
  63         var messageProvider = mock(MessageProvider.class);
  64         var handler = new SupervisionAcHandler(automationCompositionProvider,
  65                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
  66                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
  67                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
  68
  69         var automationComposition =
  70                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
  71         automationComposition.setInstanceId(IDENTIFIER);
  72         var automationCompositionAckMessage =
  73                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
  74                         automationComposition, DeployState.DEPLOYED, LockState.UNLOCKED);
  75         automationCompositionAckMessage.setStateChangeResult(null);
  76         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  77
  78         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.TIMEOUT);
  79         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  80
  81         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
  82         automationCompositionAckMessage.setAutomationCompositionId(null);
  83         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  84
  85         automationCompositionAckMessage.setAutomationCompositionId(automationComposition.getInstanceId());
  86         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  87
  88         automationCompositionAckMessage =
  89                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
  90                         automationComposition, DeployState.DEPLOYING, LockState.UNLOCKED);
  91         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  92
  93         verify(messageProvider, times(0)).save(any(AutomationCompositionDeployAck.class));
  94
  95         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
  96                 .thenReturn(Optional.of(automationComposition));
  97         automationCompositionAckMessage.setAutomationCompositionResultMap(null);
  98         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  99         verify(messageProvider, times(0)).save(any(AutomationCompositionDeployAck.class));
 100     }
 101
 102     @Test
 103     void testHandleAcMigrationWithStage() {
 104         var automationComposition =
 105                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 106         automationComposition.setInstanceId(IDENTIFIER);
 107         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 108         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 109                 .thenReturn(Optional.of(automationComposition));
 110         var messageProvider = mock(MessageProvider.class);
 111
 112         var handler = new SupervisionAcHandler(automationCompositionProvider,
 113                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 114                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 115                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 116
 117         var automationCompositionAckMessage =
 118                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
 119                         automationComposition, DeployState.MIGRATING, LockState.LOCKED);
 120         automationCompositionAckMessage.setStage(1);
 121         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
 122
 123         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 124     }
 125
 126     @Test
 127     void testHandleAutomationCompositionStateChangeAckMessage() {
 128         var automationComposition =
 129                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 130         automationComposition.setInstanceId(IDENTIFIER);
 131         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 132         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 133                 .thenReturn(Optional.of(automationComposition));
 134         var messageProvider = mock(MessageProvider.class);
 135
 136         var handler = new SupervisionAcHandler(automationCompositionProvider,
 137                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 138                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 139                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 140
 141         var automationCompositionAckMessage =
 142                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
 143                         automationComposition, DeployState.DEPLOYED, LockState.UNLOCKED);
 144         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
 145
 146         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 147     }
 148
 149     private AutomationCompositionDeployAck getAutomationCompositionDeployAck(ParticipantMessageType messageType,
 150             AutomationComposition automationComposition, DeployState deployState, LockState lockState) {
 151         var automationCompositionAckMessage = new AutomationCompositionDeployAck(messageType);
 152         for (var elementEntry : automationComposition.getElements().entrySet()) {
 153             var acElementDeployAck = new AcElementDeployAck(deployState, lockState, "", "", Map.of(), true, "");
 154             automationCompositionAckMessage.getAutomationCompositionResultMap().put(elementEntry.getKey(),
 155                     acElementDeployAck);
 156         }
 157         automationCompositionAckMessage.setAutomationCompositionId(automationComposition.getInstanceId());
 158         automationCompositionAckMessage.setParticipantId(CommonTestData.getParticipantId());
 159         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
 160         return automationCompositionAckMessage;
 161     }
 162
 163     @Test
 164     void testHandleAutomationCompositionUpdateAckMessage() {
 165         var automationComposition =
 166                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 167         automationComposition.setInstanceId(IDENTIFIER);
 168         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 169         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 170                 .thenReturn(Optional.of(automationComposition));
 171         var messageProvider = mock(MessageProvider.class);
 172
 173         var automationCompositionAckMessage =
 174                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK,
 175                         automationComposition, DeployState.DEPLOYED, LockState.LOCKED);
 176         automationCompositionAckMessage.setParticipantId(CommonTestData.getParticipantId());
 177
 178         var handler = new SupervisionAcHandler(automationCompositionProvider,
 179                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 180                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 181                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 182
 183         handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
 184
 185         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 186     }
 187
 188     @Test
 189     void testHandleAcUpdateAckFailedMessage() {
 190         var automationComposition =
 191                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 192         automationComposition.setDeployState(DeployState.DEPLOYING);
 193         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 194         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 195         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 196                 .thenReturn(Optional.of(automationComposition));
 197
 198         var automationCompositionAckMessage =
 199                 new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK);
 200         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
 201         for (var element : automationComposition.getElements().values()) {
 202             element.setDeployState(DeployState.DEPLOYED);
 203         }
 204         var elementEntry = automationComposition.getElements().entrySet().iterator().next();
 205         elementEntry.getValue().setDeployState(DeployState.DEPLOYING);
 206         var acElementDeployAck =
 207                 new AcElementDeployAck(DeployState.UNDEPLOYED, LockState.NONE, "", "", Map.of(), true, "Error");
 208         automationCompositionAckMessage
 209                 .setAutomationCompositionResultMap(Map.of(elementEntry.getKey(), acElementDeployAck));
 210
 211         automationCompositionAckMessage.setParticipantId(CommonTestData.getParticipantId());
 212         automationCompositionAckMessage.setAutomationCompositionId(IDENTIFIER);
 213
 214         var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 215         var messageProvider = mock(MessageProvider.class);
 216
 217         var handler = new SupervisionAcHandler(automationCompositionProvider,
 218                 mock(AutomationCompositionDeployPublisher.class), automationCompositionStateChangePublisher,
 219                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 220                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 221
 222         handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
 223
 224         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 225     }
 226
 227     @Test
 228     void testDeployFailed() {
 229         var automationCompositionDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
 230         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 231         var handler = new SupervisionAcHandler(automationCompositionProvider,
 232                 automationCompositionDeployPublisher, mock(AutomationCompositionStateChangePublisher.class),
 233                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 234                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 235
 236         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 237         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 238         var automationComposition =
 239                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Deploy");
 240         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 241         handler.deploy(automationComposition, acDefinition);
 242         verify(automationCompositionProvider).updateAutomationComposition(automationComposition);
 243         verify(automationCompositionDeployPublisher, timeout(1000)).send(automationComposition, 0, true);
 244     }
 245
 246     @Test
 247     void testUndeploy() {
 248         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 249         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 250         var handler = new SupervisionAcHandler(automationCompositionProvider,
 251                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 252                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 253                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 254         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 255         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 256         var automationComposition =
 257                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Undeploy");
 258         handler.undeploy(automationComposition, acDefinition);
 259
 260         verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
 261         verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
 262     }
 263
 264     @Test
 265     void testUndeployFailed() {
 266         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 267         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 268         var handler = new SupervisionAcHandler(automationCompositionProvider,
 269                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 270                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 271                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 272
 273         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 274         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 275         var automationComposition =
 276                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "UnDeploy");
 277         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 278         automationComposition.getElements().values()
 279                 .forEach(element -> element.setDeployState(DeployState.UNDEPLOYING));
 280         handler.undeploy(automationComposition, acDefinition);
 281         verify(automationCompositionProvider).updateAutomationComposition(automationComposition);
 282         verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
 283     }
 284
 285     @Test
 286     void testUnlock() {
 287         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 288         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 289         var handler = new SupervisionAcHandler(automationCompositionProvider,
 290                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 291                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 292                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 293         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 294         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 295         var automationComposition =
 296                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "UnLock");
 297         handler.unlock(automationComposition, acDefinition);
 298
 299         verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
 300         verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
 301     }
 302
 303     @Test
 304     void testUnlockFailed() {
 305         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 306         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 307         var handler = new SupervisionAcHandler(automationCompositionProvider,
 308                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 309                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 310                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 311         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 312         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 313         var automationComposition =
 314                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "UnLock");
 315         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 316         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.UNLOCKING));
 317         handler.unlock(automationComposition, acDefinition);
 318
 319         verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
 320         verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
 321     }
 322
 323     @Test
 324     void testLock() {
 325         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 326         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 327         var handler = new SupervisionAcHandler(automationCompositionProvider,
 328                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 329                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 330                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 331         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 332         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 333         var automationComposition =
 334                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Lock");
 335         handler.lock(automationComposition, acDefinition);
 336
 337         verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
 338         verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
 339     }
 340
 341     @Test
 342     void testLockFailed() {
 343         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 344         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 345         var handler = new SupervisionAcHandler(automationCompositionProvider,
 346                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 347                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 348                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 349         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 350         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 351         var automationComposition =
 352                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Lock");
 353         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 354         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.LOCKING));
 355         handler.lock(automationComposition, acDefinition);
 356
 357         verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
 358         verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
 359     }
 360
 361     @Test
 362     void testDeleteAck() {
 363         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 364         var automationComposition =
 365                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 366         automationComposition.setDeployState(DeployState.DELETING);
 367         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 368                 .thenReturn(Optional.of(automationComposition));
 369
 370         var automationCompositionAckMessage =
 371                 new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK);
 372         automationCompositionAckMessage
 373                 .setParticipantId(automationComposition.getElements().values().iterator().next().getParticipantId());
 374         automationCompositionAckMessage.setAutomationCompositionId(IDENTIFIER);
 375         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
 376         var messageProvider = mock(MessageProvider.class);
 377
 378         var handler = new SupervisionAcHandler(automationCompositionProvider,
 379                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 380                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 381                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 382
 383         handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
 384
 385         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 386     }
 387
 388     @Test
 389     void testUpdate() {
 390         var acElementPropertiesPublisher = mock(AcElementPropertiesPublisher.class);
 391         var handler = new SupervisionAcHandler(mock(AutomationCompositionProvider.class),
 392                 mock(AutomationCompositionDeployPublisher.class),
 393                 mock(AutomationCompositionStateChangePublisher.class), acElementPropertiesPublisher,
 394                 mock(AutomationCompositionMigrationPublisher.class),
 395                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 396         var automationComposition =
 397                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Lock");
 398         handler.update(automationComposition);
 399         verify(acElementPropertiesPublisher, timeout(1000)).send(any(AutomationComposition.class));
 400     }
 401
 402     @Test
 403     void testMigrate() {
 404         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 405         var acCompositionMigrationPublisher = mock(AutomationCompositionMigrationPublisher.class);
 406         var handler = new SupervisionAcHandler(automationCompositionProvider,
 407                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 408                 mock(AcElementPropertiesPublisher.class), acCompositionMigrationPublisher,
 409                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 410         var automationComposition =
 411                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 412         assert automationComposition != null;
 413         automationComposition.setPhase(0);
 414         handler.migrate(automationComposition);
 415         verify(acCompositionMigrationPublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt());
 416     }
 417
 418     @Test
 419     void testMigratePrecheck() {
 420         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 421         var acCompositionMigrationPublisher = mock(AutomationCompositionMigrationPublisher.class);
 422         var handler = new SupervisionAcHandler(automationCompositionProvider,
 423                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 424                 mock(AcElementPropertiesPublisher.class), acCompositionMigrationPublisher,
 425                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 426         var automationComposition =
 427                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 428         handler.migratePrecheck(automationComposition);
 429         verify(acCompositionMigrationPublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt());
 430     }
 431
 432     @Test
 433     void testPrepare() {
 434         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 435         var acPreparePublisher = mock(AcPreparePublisher.class);
 436         var handler = new SupervisionAcHandler(automationCompositionProvider,
 437                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 438                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 439                 acPreparePublisher, mock(MessageProvider.class), mock(EncryptionUtils.class));
 440         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 441         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 442         var automationComposition =
 443                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 444         handler.prepare(automationComposition, acDefinition);
 445         verify(acPreparePublisher, timeout(1000)).sendPrepare(any(AutomationComposition.class), anyInt());
 446     }
 447
 448     @Test
 449     void testReview() {
 450         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 451         var acPreparePublisher = mock(AcPreparePublisher.class);
 452         var handler = new SupervisionAcHandler(automationCompositionProvider,
 453                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 454                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 455                 acPreparePublisher, mock(MessageProvider.class), mock(EncryptionUtils.class));
 456         var automationComposition =
 457                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 458         handler.review(automationComposition);
 459         verify(acPreparePublisher, timeout(1000)).sendRevew(any(AutomationComposition.class));
 460     }
 461 }