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

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