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