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