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