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

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