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

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