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