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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2023-2025 OpenInfra Foundation Europe. All rights reserved.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.clamp.acm.runtime.supervision;
  22
  23 import static org.junit.jupiter.api.Assertions.assertNotNull;
  24 import static org.junit.jupiter.api.Assertions.assertThrows;
  25 import static org.mockito.ArgumentMatchers.any;
  26 import static org.mockito.ArgumentMatchers.anyBoolean;
  27 import static org.mockito.ArgumentMatchers.anyInt;
  28 import static org.mockito.Mockito.doCallRealMethod;
  29 import static org.mockito.Mockito.mock;
  30 import static org.mockito.Mockito.timeout;
  31 import static org.mockito.Mockito.times;
  32 import static org.mockito.Mockito.verify;
  33 import static org.mockito.Mockito.when;
  34 import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVICE_TEMPLATE_YAML;
  35
  36 import java.util.Map;
  37 import java.util.Optional;
  38 import java.util.UUID;
  39 import org.junit.jupiter.api.Test;
  40 import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
  41 import org.onap.policy.clamp.acm.runtime.main.utils.EncryptionUtils;
  42 import org.onap.policy.clamp.acm.runtime.supervision.comm.AcElementPropertiesPublisher;
  43 import org.onap.policy.clamp.acm.runtime.supervision.comm.AcPreparePublisher;
  44 import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionDeployPublisher;
  45 import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionMigrationPublisher;
  46 import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionStateChangePublisher;
  47 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
  48 import org.onap.policy.clamp.models.acm.concepts.AcElementDeployAck;
  49 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  50 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  51 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
  52 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElement;
  53 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  54 import org.onap.policy.clamp.models.acm.concepts.LockState;
  55 import org.onap.policy.clamp.models.acm.concepts.MigrationState;
  56 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  57 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionDeployAck;
  58 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantMessageType;
  59 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
  60 import org.onap.policy.clamp.models.acm.persistence.provider.MessageProvider;
  61 import org.onap.policy.models.base.PfModelRuntimeException;
  62
  63 class SupervisionAcHandlerTest {
  64     private static final String AC_INSTANTIATION_CREATE_JSON = "src/test/resources/rest/acm/AutomationComposition.json";
  65     private static final String AC_INSTANTIATION_SIMPLE_JSON =
  66             "src/test/resources/rest/acm/AutomationCompositionSimple.json";
  67     private static final UUID IDENTIFIER = UUID.randomUUID();
  68
  69     @Test
  70     void testAutomationCompositionDeployAckValidation() {
  71         var automationComposition =
  72             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
  73         assertNotNull(automationComposition);
  74
  75         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
  76         var messageProvider = mock(MessageProvider.class);
  77         var handler = new SupervisionAcHandler(automationCompositionProvider,
  78                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
  79                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
  80                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
  81
  82         automationComposition.setInstanceId(IDENTIFIER);
  83         var automationCompositionAckMessage =
  84                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
  85                         automationComposition, DeployState.DEPLOYED, LockState.UNLOCKED);
  86         automationCompositionAckMessage.setStateChangeResult(null);
  87         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  88
  89         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.TIMEOUT);
  90         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  91
  92         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
  93         automationCompositionAckMessage.setAutomationCompositionId(null);
  94         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  95
  96         automationCompositionAckMessage.setAutomationCompositionId(automationComposition.getInstanceId());
  97         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
  98
  99         automationCompositionAckMessage =
 100                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
 101                         automationComposition, DeployState.DEPLOYING, LockState.UNLOCKED);
 102         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
 103
 104         verify(messageProvider, times(0)).save(any(AutomationCompositionDeployAck.class));
 105
 106         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 107                 .thenReturn(Optional.of(automationComposition));
 108         automationCompositionAckMessage.setAutomationCompositionResultMap(null);
 109         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
 110         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 111     }
 112
 113     @Test
 114     void testHandleAcMigrationWithStage() {
 115         var automationComposition =
 116                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 117         assertNotNull(automationComposition);
 118         automationComposition.setInstanceId(IDENTIFIER);
 119         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 120         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 121                 .thenReturn(Optional.of(automationComposition));
 122         var messageProvider = mock(MessageProvider.class);
 123
 124         var handler = new SupervisionAcHandler(automationCompositionProvider,
 125                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 126                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 127                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 128
 129         var automationCompositionAckMessage =
 130                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
 131                         automationComposition, DeployState.MIGRATING, LockState.LOCKED);
 132         automationCompositionAckMessage.setStage(1);
 133         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
 134
 135         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 136     }
 137
 138     @Test
 139     void testHandleAutomationCompositionStateChangeAckMessage() {
 140         var automationComposition =
 141                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 142         assertNotNull(automationComposition);
 143         automationComposition.setInstanceId(IDENTIFIER);
 144         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 145         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 146                 .thenReturn(Optional.of(automationComposition));
 147         var messageProvider = mock(MessageProvider.class);
 148
 149         var handler = new SupervisionAcHandler(automationCompositionProvider,
 150                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 151                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 152                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 153
 154         var automationCompositionAckMessage =
 155                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
 156                         automationComposition, DeployState.DEPLOYED, LockState.UNLOCKED);
 157         handler.handleAutomationCompositionStateChangeAckMessage(automationCompositionAckMessage);
 158
 159         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 160     }
 161
 162     private AutomationCompositionDeployAck getAutomationCompositionDeployAck(ParticipantMessageType messageType,
 163             AutomationComposition automationComposition, DeployState deployState, LockState lockState) {
 164         var automationCompositionAckMessage = new AutomationCompositionDeployAck(messageType);
 165         for (var elementEntry : automationComposition.getElements().entrySet()) {
 166             var acElementDeployAck = new AcElementDeployAck(deployState, lockState, "", "", Map.of(), true, "");
 167             automationCompositionAckMessage.getAutomationCompositionResultMap().put(elementEntry.getKey(),
 168                     acElementDeployAck);
 169         }
 170         automationCompositionAckMessage.setAutomationCompositionId(automationComposition.getInstanceId());
 171         automationCompositionAckMessage.setParticipantId(CommonTestData.getParticipantId());
 172         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
 173         return automationCompositionAckMessage;
 174     }
 175
 176     @Test
 177     void testHandleAutomationCompositionUpdateAckMessage() {
 178         var automationComposition =
 179                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 180         assertNotNull(automationComposition);
 181         automationComposition.setInstanceId(IDENTIFIER);
 182         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 183         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 184                 .thenReturn(Optional.of(automationComposition));
 185         var messageProvider = mock(MessageProvider.class);
 186
 187         var automationCompositionAckMessage =
 188                 getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK,
 189                         automationComposition, DeployState.DEPLOYED, LockState.LOCKED);
 190         automationCompositionAckMessage.setParticipantId(CommonTestData.getParticipantId());
 191
 192         var handler = new SupervisionAcHandler(automationCompositionProvider,
 193                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 194                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 195                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 196
 197         handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
 198
 199         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 200     }
 201
 202     @Test
 203     void testHandleAcUpdateAckFailedMessage() {
 204         var automationComposition =
 205                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 206         assertNotNull(automationComposition);
 207         automationComposition.setDeployState(DeployState.DEPLOYING);
 208         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 209         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 210         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 211                 .thenReturn(Optional.of(automationComposition));
 212
 213         var automationCompositionAckMessage =
 214                 new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK);
 215         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
 216         for (var element : automationComposition.getElements().values()) {
 217             element.setDeployState(DeployState.DEPLOYED);
 218         }
 219         var elementEntry = automationComposition.getElements().entrySet().iterator().next();
 220         elementEntry.getValue().setDeployState(DeployState.DEPLOYING);
 221         var acElementDeployAck =
 222                 new AcElementDeployAck(DeployState.UNDEPLOYED, LockState.NONE, "", "", Map.of(), true, "Error");
 223         automationCompositionAckMessage
 224                 .setAutomationCompositionResultMap(Map.of(elementEntry.getKey(), acElementDeployAck));
 225
 226         automationCompositionAckMessage.setParticipantId(CommonTestData.getParticipantId());
 227         automationCompositionAckMessage.setAutomationCompositionId(IDENTIFIER);
 228
 229         var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 230         var messageProvider = mock(MessageProvider.class);
 231
 232         var handler = new SupervisionAcHandler(automationCompositionProvider,
 233                 mock(AutomationCompositionDeployPublisher.class), automationCompositionStateChangePublisher,
 234                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 235                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 236
 237         handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
 238
 239         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 240     }
 241
 242     @Test
 243     void testDeploy() {
 244         var automationComposition =
 245                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Deploy");
 246         assertNotNull(automationComposition);
 247         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 248         deploy(automationComposition);
 249     }
 250
 251     @Test
 252     void testDeployFailed() {
 253         var automationComposition =
 254                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Deploy");
 255         assertNotNull(automationComposition);
 256         automationComposition.setDeployState(DeployState.UNDEPLOYING);
 257         automationComposition.getElements().values()
 258                 .forEach(element -> element.setDeployState(DeployState.UNDEPLOYING));
 259         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 260         deploy(automationComposition);
 261
 262         automationComposition.setDeployState(DeployState.DEPLOYING);
 263         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 264         automationComposition.getElements().values()
 265                 .forEach(element -> element.setDeployState(DeployState.DEPLOYING));
 266         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.DEPLOYED);
 267         deploy(automationComposition);
 268     }
 269
 270     @Test
 271     void testDeployFailedSimple() {
 272         var automationComposition =
 273                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_SIMPLE_JSON, "Deploy");
 274         assertNotNull(automationComposition);
 275         automationComposition.setDeployState(DeployState.UNDEPLOYED);
 276         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.UNDEPLOYED);
 277         deploy(automationComposition);
 278
 279         automationComposition.setDeployState(DeployState.UNDEPLOYING);
 280         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 281         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.DEPLOYED);
 282         deploy(automationComposition);
 283
 284         automationComposition.setDeployState(DeployState.DEPLOYING);
 285         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 286         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.UNDEPLOYED);
 287         deploy(automationComposition);
 288     }
 289
 290     private void deploy(AutomationComposition automationComposition) {
 291         var acDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
 292         var acProvider = mock(AutomationCompositionProvider.class);
 293         var handler = new SupervisionAcHandler(acProvider, acDeployPublisher,
 294                 mock(AutomationCompositionStateChangePublisher.class),
 295                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 296                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 297         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 298         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 299         handler.deploy(automationComposition, acDefinition);
 300         verify(acProvider).updateAutomationComposition(automationComposition);
 301         verify(acDeployPublisher, timeout(1000)).send(automationComposition, 0, true, acDefinition.getRevisionId());
 302     }
 303
 304     @Test
 305     void testUndeploy() {
 306         var automationComposition =
 307                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Undeploy");
 308         assertNotNull(automationComposition);
 309         automationComposition.setDeployState(DeployState.DEPLOYED);
 310         automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
 311         automationComposition.getElements().values()
 312                 .forEach(element -> element.setDeployState(DeployState.DEPLOYED));
 313         undeploy(automationComposition);
 314     }
 315
 316     private void undeploy(AutomationComposition automationComposition) {
 317         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 318         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 319         var handler = new SupervisionAcHandler(automationCompositionProvider,
 320                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 321                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 322                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 323         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 324         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 325         handler.undeploy(automationComposition, acDefinition);
 326
 327         verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
 328         verify(acStateChangePublisher, timeout(1000))
 329                 .send(any(AutomationComposition.class), anyInt(), anyBoolean(), any(UUID.class));
 330     }
 331
 332     @Test
 333     void testUndeployFailed() {
 334         var automationComposition =
 335                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "UnDeploy");
 336         assertNotNull(automationComposition);
 337         automationComposition.setDeployState(DeployState.DEPLOYING);
 338         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 339         automationComposition.getElements().values()
 340                 .forEach(element -> element.setDeployState(DeployState.UNDEPLOYED));
 341         undeploy(automationComposition);
 342
 343         automationComposition.setDeployState(DeployState.UNDEPLOYING);
 344         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 345         automationComposition.getElements().values()
 346                 .forEach(element -> element.setDeployState(DeployState.DEPLOYING));
 347         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.UNDEPLOYED);
 348         undeploy(automationComposition);
 349     }
 350
 351     @Test
 352     void testUndeployFailedSimple() {
 353         var automationComposition =
 354                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_SIMPLE_JSON, "UnDeploy");
 355         assertNotNull(automationComposition);
 356         automationComposition.setDeployState(DeployState.DEPLOYING);
 357         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 358         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.UNDEPLOYED);
 359         undeploy(automationComposition);
 360
 361         automationComposition.setDeployState(DeployState.UNDEPLOYING);
 362         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 363         automationComposition.getElements().values().iterator().next().setDeployState(DeployState.DEPLOYED);
 364         undeploy(automationComposition);
 365     }
 366
 367     @Test
 368     void testUnlock() {
 369         var automationComposition =
 370                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "UnLock");
 371         assertNotNull(automationComposition);
 372         automationComposition.setLockState(LockState.LOCKED);
 373         automationComposition.getElements().values()
 374                 .forEach(element -> element.setLockState(LockState.LOCKED));
 375         unlock(automationComposition);
 376     }
 377
 378     private void unlock(AutomationComposition automationComposition) {
 379         var acProvider = mock(AutomationCompositionProvider.class);
 380         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 381         var handler = new SupervisionAcHandler(acProvider,
 382                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 383                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 384                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 385         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 386         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 387         handler.unlock(automationComposition, acDefinition);
 388
 389         verify(acProvider).updateAutomationComposition(any(AutomationComposition.class));
 390         verify(acStateChangePublisher, timeout(1000))
 391                 .send(any(AutomationComposition.class), anyInt(), anyBoolean(), any(UUID.class));
 392     }
 393
 394     @Test
 395     void testUnlockFailed() {
 396         var automationComposition =
 397                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "UnLock");
 398         assertNotNull(automationComposition);
 399         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 400         automationComposition.setLockState(LockState.LOCKING);
 401         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.LOCKING));
 402         unlock(automationComposition);
 403
 404         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 405         automationComposition.setLockState(LockState.UNLOCKING);
 406         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.UNLOCKING));
 407         automationComposition.getElements().values().iterator().next().setLockState(LockState.UNLOCKED);
 408         unlock(automationComposition);
 409     }
 410
 411     @Test
 412     void testUnlockSimple() {
 413         var automationComposition =
 414                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_SIMPLE_JSON, "UnLock");
 415         assertNotNull(automationComposition);
 416         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 417         automationComposition.setLockState(LockState.LOCKING);
 418         automationComposition.getElements().values().iterator().next().setLockState(LockState.UNLOCKED);
 419         unlock(automationComposition);
 420
 421         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 422         automationComposition.setLockState(LockState.UNLOCKING);
 423         automationComposition.getElements().values().iterator().next().setLockState(LockState.LOCKED);
 424         unlock(automationComposition);
 425     }
 426
 427     @Test
 428     void testLock() {
 429         var automationComposition =
 430                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Lock");
 431         assertNotNull(automationComposition);
 432         automationComposition.setLockState(LockState.UNLOCKED);
 433         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.UNLOCKED));
 434         lock(automationComposition);
 435     }
 436
 437     private void lock(AutomationComposition automationComposition) {
 438         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 439         var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
 440         var handler = new SupervisionAcHandler(automationCompositionProvider,
 441                 mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
 442                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 443                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 444         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 445         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 446         handler.lock(automationComposition, acDefinition);
 447
 448         verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
 449         verify(acStateChangePublisher, timeout(1000))
 450                 .send(any(AutomationComposition.class), anyInt(), anyBoolean(), any(UUID.class));
 451     }
 452
 453     @Test
 454     void testLockFailed() {
 455         var automationComposition =
 456                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Lock");
 457         assertNotNull(automationComposition);
 458         automationComposition.setLockState(LockState.UNLOCKING);
 459         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 460         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.UNLOCKING));
 461         lock(automationComposition);
 462
 463         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 464         automationComposition.setLockState(LockState.LOCKING);
 465         automationComposition.getElements().values().forEach(element -> element.setLockState(LockState.LOCKING));
 466         automationComposition.getElements().values().iterator().next().setLockState(LockState.LOCKED);
 467         lock(automationComposition);
 468     }
 469
 470     @Test
 471     void testLockSimple() {
 472         var automationComposition =
 473                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_SIMPLE_JSON, "Lock");
 474         assertNotNull(automationComposition);
 475         automationComposition.setLockState(LockState.UNLOCKING);
 476         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 477         automationComposition.getElements().values().iterator().next().setLockState(LockState.LOCKED);
 478         lock(automationComposition);
 479
 480         automationComposition.setStateChangeResult(StateChangeResult.FAILED);
 481         automationComposition.setLockState(LockState.LOCKING);
 482         automationComposition.getElements().values().iterator().next().setLockState(LockState.UNLOCKED);
 483         lock(automationComposition);
 484     }
 485
 486     @Test
 487     void testDeleteAck() {
 488         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 489         var automationComposition =
 490                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
 491         assertNotNull(automationComposition);
 492         automationComposition.setDeployState(DeployState.DELETING);
 493         when(automationCompositionProvider.findAutomationComposition(IDENTIFIER))
 494                 .thenReturn(Optional.of(automationComposition));
 495
 496         var automationCompositionAckMessage =
 497                 new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK);
 498         automationCompositionAckMessage
 499                 .setParticipantId(automationComposition.getElements().values().iterator().next().getParticipantId());
 500         automationCompositionAckMessage.setAutomationCompositionId(IDENTIFIER);
 501         automationCompositionAckMessage.setStateChangeResult(StateChangeResult.NO_ERROR);
 502         var messageProvider = mock(MessageProvider.class);
 503
 504         var handler = new SupervisionAcHandler(automationCompositionProvider,
 505                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 506                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 507                 mock(AcPreparePublisher.class), messageProvider, mock(EncryptionUtils.class));
 508
 509         handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
 510
 511         verify(messageProvider).save(any(AutomationCompositionDeployAck.class));
 512     }
 513
 514     @Test
 515     void testUpdate() {
 516         var acElementPropertiesPublisher = mock(AcElementPropertiesPublisher.class);
 517         var handler = new SupervisionAcHandler(mock(AutomationCompositionProvider.class),
 518                 mock(AutomationCompositionDeployPublisher.class),
 519                 mock(AutomationCompositionStateChangePublisher.class), acElementPropertiesPublisher,
 520                 mock(AutomationCompositionMigrationPublisher.class),
 521                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 522         var automationComposition =
 523                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Lock");
 524         handler.update(automationComposition, UUID.randomUUID());
 525         verify(acElementPropertiesPublisher, timeout(1000)).send(any(AutomationComposition.class),
 526                 any(UUID.class));
 527     }
 528
 529     @Test
 530     void testMigrate() {
 531         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 532         var acCompositionMigrationPublisher = mock(AutomationCompositionMigrationPublisher.class);
 533         var handler = new SupervisionAcHandler(automationCompositionProvider,
 534                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 535                 mock(AcElementPropertiesPublisher.class), acCompositionMigrationPublisher,
 536                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 537         var automationComposition =
 538                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 539         assert automationComposition != null;
 540         automationComposition.setPhase(0);
 541         handler.migrate(automationComposition, UUID.randomUUID(), UUID.randomUUID());
 542         verify(acCompositionMigrationPublisher, timeout(1000))
 543                 .send(any(AutomationComposition.class), anyInt(), any(UUID.class), any(UUID.class));
 544     }
 545
 546     @Test
 547     void testMigratePrecheck() {
 548         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 549         var acCompositionMigrationPublisher = mock(AutomationCompositionMigrationPublisher.class);
 550         var handler = new SupervisionAcHandler(automationCompositionProvider,
 551                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 552                 mock(AcElementPropertiesPublisher.class), acCompositionMigrationPublisher,
 553                 mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
 554         var automationComposition =
 555                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 556         handler.migratePrecheck(automationComposition, UUID.randomUUID(), UUID.randomUUID());
 557         verify(acCompositionMigrationPublisher, timeout(1000))
 558                 .send(any(AutomationComposition.class), anyInt(), any(UUID.class), any(UUID.class));
 559     }
 560
 561     @Test
 562     void testPrepare() {
 563         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 564         var acPreparePublisher = mock(AcPreparePublisher.class);
 565         var handler = new SupervisionAcHandler(automationCompositionProvider,
 566                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 567                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 568                 acPreparePublisher, mock(MessageProvider.class), mock(EncryptionUtils.class));
 569         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 570         var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
 571         var automationComposition =
 572                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 573         assertNotNull(automationComposition);
 574         handler.prepare(automationComposition, acDefinition);
 575         verify(acPreparePublisher, timeout(1000)).sendPrepare(any(AutomationComposition.class), anyInt(),
 576                 any(UUID.class));
 577     }
 578
 579     @Test
 580     void testReview() {
 581         var automationCompositionProvider = mock(AutomationCompositionProvider.class);
 582         var acPreparePublisher = mock(AcPreparePublisher.class);
 583         var handler = new SupervisionAcHandler(automationCompositionProvider,
 584                 mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
 585                 mock(AcElementPropertiesPublisher.class), mock(AutomationCompositionMigrationPublisher.class),
 586                 acPreparePublisher, mock(MessageProvider.class), mock(EncryptionUtils.class));
 587         var automationComposition =
 588                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
 589         assertNotNull(automationComposition);
 590         handler.review(automationComposition, new AutomationCompositionDefinition());
 591         verify(acPreparePublisher, timeout(1000)).sendReview(any(AutomationComposition.class), any(UUID.class));
 592     }
 593
 594     @Test
 595     void testDeployWithInvalidElement_NewState() {
 596         var elementNew = new AutomationCompositionElement();
 597         elementNew.setDeployState(DeployState.UNDEPLOYED);
 598         elementNew.setMigrationState(MigrationState.NEW);
 599
 600         var automationComposition =
 601                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Deploy");
 602         assertNotNull(automationComposition);
 603         automationComposition.setDeployState(DeployState.DEPLOYING);
 604         automationComposition.getElements().put(elementNew.getParticipantId(), elementNew);
 605
 606         var mockHandler = mock(SupervisionAcHandler.class);
 607         var acDefinition = new AutomationCompositionDefinition();
 608         doCallRealMethod().when(mockHandler).deploy(automationComposition, acDefinition);
 609
 610         assertThrows(PfModelRuntimeException.class,
 611             () -> mockHandler.deploy(automationComposition, acDefinition));
 612     }
 613
 614     @Test
 615     void testDeployWithInvalidElement_RemovedState() {
 616         var elementRemoved = new AutomationCompositionElement();
 617         elementRemoved.setDeployState(DeployState.UNDEPLOYED);
 618         elementRemoved.setMigrationState(MigrationState.REMOVED);
 619
 620         var automationComposition =
 621             InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Deploy");
 622         assertNotNull(automationComposition);
 623         automationComposition.setDeployState(DeployState.DEPLOYING);
 624         automationComposition.getElements().put(elementRemoved.getParticipantId(), elementRemoved);
 625
 626         var mockHandler = mock(SupervisionAcHandler.class);
 627         var acDefinition = new AutomationCompositionDefinition();
 628         doCallRealMethod().when(mockHandler).deploy(automationComposition, acDefinition);
 629
 630         assertThrows(PfModelRuntimeException.class,
 631             () -> mockHandler.deploy(automationComposition, acDefinition));
 632     }
 633 }