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