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