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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2025 OpenInfra Foundation Europe. All rights reserved.
   4  *  Modifications Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.clamp.acm.runtime.supervision.comm;
  23
  24 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  25 import static org.mockito.ArgumentMatchers.anyString;
  26 import static org.mockito.Mockito.clearInvocations;
  27 import static org.mockito.Mockito.mock;
  28 import static org.mockito.Mockito.verify;
  29 import static org.mockito.Mockito.when;
  30 import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVICE_TEMPLATE_YAML;
  31
  32 import java.util.HashMap;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Set;
  36 import java.util.UUID;
  37 import org.junit.jupiter.api.Test;
  38 import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
  39 import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
  40 import org.onap.policy.clamp.acm.runtime.supervision.SupervisionAcHandler;
  41 import org.onap.policy.clamp.acm.runtime.supervision.SupervisionHandler;
  42 import org.onap.policy.clamp.acm.runtime.supervision.SupervisionParticipantHandler;
  43 import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
  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.AutomationCompositionDefinition;
  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.messages.kafka.participant.AutomationCompositionDeployAck;
  50 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantDeregister;
  51 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantDeregisterAck;
  52 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantMessageType;
  53 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantPrimeAck;
  54 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantRegister;
  55 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantRegisterAck;
  56 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantStatus;
  57 import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
  58 import org.onap.policy.clamp.models.acm.utils.AcmUtils;
  59 import org.onap.policy.common.message.bus.event.Topic.CommInfrastructure;
  60 import org.onap.policy.common.message.bus.event.TopicSink;
  61 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  62
  63 class SupervisionMessagesTest {
  64
  65     private static final String AC_INSTANTIATION_UPDATE_JSON =
  66             "src/test/resources/rest/acm/AutomationCompositionUpdate.json";
  67     private static final String NOT_ACTIVE = "Not Active!";
  68     private static final CommInfrastructure INFRA = CommInfrastructure.NOOP;
  69     private static final String TOPIC = "my-topic";
  70
  71     private static final String TOSCA_ELEMENT_NAME = "org.onap.policy.clamp.acm.AutomationCompositionElement";
  72
  73     @Test
  74     void testSendParticipantRegisterAck() {
  75         var acRegisterAckPublisher = new ParticipantRegisterAckPublisher();
  76         var topicSink = mock(TopicSink.class);
  77         acRegisterAckPublisher.active(topicSink);
  78         acRegisterAckPublisher.send(new ParticipantRegisterAck());
  79         verify(topicSink).send(anyString());
  80         acRegisterAckPublisher.stop();
  81     }
  82
  83     @Test
  84     void testSendParticipantRegisterAckNoActive() {
  85         var acRegisterAckPublisher = new ParticipantRegisterAckPublisher();
  86         assertThatThrownBy(() -> acRegisterAckPublisher.send(new ParticipantRegisterAck()))
  87                 .hasMessageMatching(NOT_ACTIVE);
  88     }
  89
  90     @Test
  91     void testReceiveParticipantDeregister() {
  92         final var participantDeregisterMsg = new ParticipantDeregister();
  93         var supervisionHandler = mock(SupervisionParticipantHandler.class);
  94         var participantDeregisterListener = new ParticipantDeregisterListener(supervisionHandler);
  95         participantDeregisterListener.onTopicEvent(INFRA, TOPIC, null, participantDeregisterMsg);
  96         verify(supervisionHandler).handleParticipantMessage(participantDeregisterMsg);
  97     }
  98
  99     @Test
 100     void testSendParticipantDeregisterAck() {
 101         var acDeregisterAckPublisher = new ParticipantDeregisterAckPublisher();
 102         var topicSink = mock(TopicSink.class);
 103         acDeregisterAckPublisher.active(topicSink);
 104         acDeregisterAckPublisher.send(new ParticipantDeregisterAck());
 105         verify(topicSink).send(anyString());
 106         acDeregisterAckPublisher.stop();
 107     }
 108
 109     @Test
 110     void testSendParticipantDeregisterAckNoActive() {
 111         var acDeregisterAckPublisher = new ParticipantDeregisterAckPublisher();
 112         assertThatThrownBy(() -> acDeregisterAckPublisher.send(new ParticipantDeregisterAck()))
 113                 .hasMessageMatching(NOT_ACTIVE);
 114     }
 115
 116     @Test
 117     void testReceiveParticipantPrimeAckMessage() {
 118         final var participantPrimeAckMsg = new ParticipantPrimeAck();
 119         var supervisionHandler = mock(SupervisionHandler.class);
 120         var participantPrimeAckListener = new ParticipantPrimeAckListener(supervisionHandler);
 121         participantPrimeAckListener.onTopicEvent(INFRA, TOPIC, null, participantPrimeAckMsg);
 122         verify(supervisionHandler).handleParticipantMessage(participantPrimeAckMsg);
 123     }
 124
 125     @Test
 126     void testSendAutomationCompositionStateChangePublisherNotActive() {
 127         var publisher = new AutomationCompositionStateChangePublisher();
 128         assertThatThrownBy(() -> publisher.send(getAutomationComposition(), 0, true, UUID.randomUUID()))
 129                 .hasMessage(NOT_ACTIVE);
 130     }
 131
 132     private AutomationComposition getAutomationComposition() {
 133         var automationComposition = new AutomationComposition();
 134         automationComposition.setName("NAME");
 135         automationComposition.setVersion("0.0.1");
 136         automationComposition.setDeployState(DeployState.DEPLOYED);
 137         automationComposition.setLockState(LockState.UNLOCKING);
 138         automationComposition.setElements(new HashMap<>());
 139         return automationComposition;
 140     }
 141
 142     @Test
 143     void testSendAutomationCompositionStateChangePublisher() {
 144         var publisher = new AutomationCompositionStateChangePublisher();
 145         var topicSink = mock(TopicSink.class);
 146         publisher.active(topicSink);
 147         publisher.send(getAutomationComposition(), 0, true, UUID.randomUUID());
 148         verify(topicSink).send(anyString());
 149         publisher.stop();
 150     }
 151
 152     @Test
 153     void testParticipantPrimePublisherDecommissioning() {
 154         var publisher = new ParticipantPrimePublisher(mock(ParticipantProvider.class),
 155                 mock(AcRuntimeParameterGroup.class));
 156         var topicSink = mock(TopicSink.class);
 157         publisher.active(topicSink);
 158         publisher.sendDepriming(UUID.randomUUID(), Set.of(UUID.randomUUID()), UUID.randomUUID());
 159         verify(topicSink).send(anyString());
 160     }
 161
 162     @Test
 163     void testParticipantPrimePublisherPriming() {
 164         var participantId = UUID.randomUUID();
 165         Map<ToscaConceptIdentifier, UUID> supportedElementMap = new HashMap<>();
 166         supportedElementMap.put(
 167                 new ToscaConceptIdentifier("org.onap.policy.clamp.acm.PolicyAutomationCompositionElement", "1.0.0"),
 168                 participantId);
 169         supportedElementMap.put(new ToscaConceptIdentifier(
 170                 "org.onap.policy.clamp.acm.K8SMicroserviceAutomationCompositionElement", "1.0.0"), participantId);
 171         supportedElementMap.put(
 172                 new ToscaConceptIdentifier("org.onap.policy.clamp.acm.HttpAutomationCompositionElement", "1.0.0"),
 173                 participantId);
 174         var participantProvider = mock(ParticipantProvider.class);
 175         when(participantProvider.getSupportedElementMap()).thenReturn(supportedElementMap);
 176         var publisher = new ParticipantPrimePublisher(participantProvider, CommonTestData.getTestParamaterGroup());
 177         var topicSink = mock(TopicSink.class);
 178         publisher.active(topicSink);
 179         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 180         serviceTemplate.setName("Name");
 181         serviceTemplate.setVersion("1.0.0");
 182         var acmDefinition = new AutomationCompositionDefinition();
 183         acmDefinition.setCompositionId(UUID.randomUUID());
 184         acmDefinition.setServiceTemplate(serviceTemplate);
 185         var acElements = AcmUtils
 186                 .extractAcElementsFromServiceTemplate(serviceTemplate, TOSCA_ELEMENT_NAME);
 187         acmDefinition.setElementStateMap(AcmUtils.createElementStateMap(acElements, AcTypeState.COMMISSIONED));
 188         var preparation = publisher.prepareParticipantPriming(acmDefinition);
 189         publisher.sendPriming(preparation, acmDefinition.getCompositionId(), acmDefinition.getRevisionId());
 190         verify(topicSink).send(anyString());
 191     }
 192
 193     @Test
 194     void testParticipantStatusReqPublisher() {
 195         var publisher = new ParticipantStatusReqPublisher();
 196         var topicSink = mock(TopicSink.class);
 197         publisher.active(topicSink);
 198         publisher.send(CommonTestData.getParticipantId());
 199         verify(topicSink).send(anyString());
 200     }
 201
 202     @Test
 203     void testParticipantRegisterAckPublisher() {
 204         var publisher = new ParticipantRegisterAckPublisher();
 205         var topicSink = mock(TopicSink.class);
 206         publisher.active(topicSink);
 207         publisher.send(UUID.randomUUID(), CommonTestData.getParticipantId(), CommonTestData.getReplicaId());
 208         verify(topicSink).send(anyString());
 209     }
 210
 211     @Test
 212     void testParticipantDeregisterAckPublisher() {
 213         var publisher = new ParticipantDeregisterAckPublisher();
 214         var topicSink = mock(TopicSink.class);
 215         publisher.active(topicSink);
 216         publisher.send(UUID.randomUUID());
 217         verify(topicSink).send(anyString());
 218     }
 219
 220     @Test
 221     void testAcElementPropertiesPublisher() {
 222         var publisher = new AcElementPropertiesPublisher();
 223         var topicSink = mock(TopicSink.class);
 224         publisher.active(topicSink);
 225         var automationComposition =
 226                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 227         publisher.send(automationComposition, UUID.randomUUID());
 228         verify(topicSink).send(anyString());
 229     }
 230
 231     @Test
 232     void testAutomationCompositionMigrationPublisher() {
 233         var publisher = new AutomationCompositionMigrationPublisher();
 234         var topicSink = mock(TopicSink.class);
 235         publisher.active(topicSink);
 236         var automationComposition =
 237                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 238         publisher.send(automationComposition, 0, UUID.randomUUID(), UUID.randomUUID());
 239         verify(topicSink).send(anyString());
 240     }
 241
 242     @Test
 243     void testAcPreparePublisher() {
 244         var publisher = new AcPreparePublisher();
 245         var topicSink = mock(TopicSink.class);
 246         publisher.active(topicSink);
 247         var automationComposition =
 248                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 249         publisher.sendPrepare(automationComposition, 0, UUID.randomUUID());
 250         verify(topicSink).send(anyString());
 251     }
 252
 253     @Test
 254     void testAcReviewPublisher() {
 255         var publisher = new AcPreparePublisher();
 256         var topicSink = mock(TopicSink.class);
 257         publisher.active(topicSink);
 258         var automationComposition =
 259                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 260         publisher.sendReview(automationComposition, UUID.randomUUID());
 261         verify(topicSink).send(anyString());
 262     }
 263
 264     @Test
 265     void testParticipantSyncPublisherAutomationComposition() {
 266         var publisher = new ParticipantSyncPublisher(CommonTestData.getTestParamaterGroup());
 267         var topicSink = mock(TopicSink.class);
 268         publisher.active(topicSink);
 269
 270         var automationComposition =
 271                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 272         publisher.sendSync(automationComposition);
 273         verify(topicSink).send(anyString());
 274
 275         clearInvocations(topicSink);
 276         automationComposition.setDeployState(DeployState.DELETED);
 277         publisher.sendSync(automationComposition);
 278         verify(topicSink).send(anyString());
 279     }
 280
 281     @Test
 282     void testParticipantSyncPublisherAcDefinition() {
 283         var publisher = new ParticipantSyncPublisher(CommonTestData.getTestParamaterGroup());
 284         var topicSink = mock(TopicSink.class);
 285         publisher.active(topicSink);
 286
 287         var acmDefinition = getAcmDefinition();
 288         publisher.sendSync(acmDefinition, null);
 289         verify(topicSink).send(anyString());
 290     }
 291
 292     @Test
 293     void testParticipantSyncPublisherAcDefinitionCommissioned() {
 294         var publisher = new ParticipantSyncPublisher(CommonTestData.getTestParamaterGroup());
 295         var topicSink = mock(TopicSink.class);
 296         publisher.active(topicSink);
 297
 298         var acmDefinition = getAcmDefinition();
 299         acmDefinition.setState(AcTypeState.COMMISSIONED);
 300         publisher.sendSync(acmDefinition, UUID.randomUUID());
 301         verify(topicSink).send(anyString());
 302     }
 303
 304     @Test
 305     void testParticipantSyncPublisherRestart() {
 306         var publisher = new ParticipantSyncPublisher(CommonTestData.getTestParamaterGroup());
 307         var topicSink = mock(TopicSink.class);
 308         publisher.active(topicSink);
 309
 310         var automationComposition =
 311                 InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
 312         var participantId = automationComposition.getElements().values().iterator().next().getParticipantId();
 313         var acmDefinition = getAcmDefinition();
 314         acmDefinition.getElementStateMap().values().iterator().next().setParticipantId(participantId);
 315         var replicaId = UUID.randomUUID();
 316         publisher.sendRestartMsg(participantId, replicaId, acmDefinition, List.of(automationComposition));
 317         verify(topicSink).send(anyString());
 318     }
 319
 320     private AutomationCompositionDefinition getAcmDefinition() {
 321         var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
 322         var acmDefinition = new AutomationCompositionDefinition();
 323         acmDefinition.setCompositionId(UUID.randomUUID());
 324         acmDefinition.setState(AcTypeState.PRIMED);
 325         acmDefinition.setServiceTemplate(serviceTemplate);
 326         var acElements = AcmUtils
 327                 .extractAcElementsFromServiceTemplate(serviceTemplate, TOSCA_ELEMENT_NAME);
 328         acmDefinition.setElementStateMap(AcmUtils.createElementStateMap(acElements, AcTypeState.PRIMED));
 329         acmDefinition.getElementStateMap().values().forEach(element -> element.setParticipantId(UUID.randomUUID()));
 330         return acmDefinition;
 331     }
 332
 333     @Test
 334     void testParticipantRegisterListener() {
 335         final var participantRegister = new ParticipantRegister();
 336         var supervisionHandler = mock(SupervisionParticipantHandler.class);
 337         var participantRegisterListener = new ParticipantRegisterListener(supervisionHandler);
 338         participantRegisterListener.onTopicEvent(INFRA, TOPIC, null, participantRegister);
 339         verify(supervisionHandler).handleParticipantMessage(participantRegister);
 340     }
 341
 342     @Test
 343     void testParticipantStatusListener() {
 344         final var participantStatus = new ParticipantStatus();
 345         var supervisionHandler = mock(SupervisionParticipantHandler.class);
 346         var participantStatusListener = new ParticipantStatusListener(supervisionHandler);
 347         participantStatusListener.onTopicEvent(INFRA, TOPIC, null, participantStatus);
 348         verify(supervisionHandler).handleParticipantMessage(participantStatus);
 349     }
 350
 351     @Test
 352     void testAutomationCompositionUpdateAckListener() {
 353         final var automationCompositionAck =
 354                 new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY);
 355         var supervisionHandler = mock(SupervisionAcHandler.class);
 356         var acUpdateAckListener = new AutomationCompositionUpdateAckListener(supervisionHandler);
 357         acUpdateAckListener.onTopicEvent(INFRA, TOPIC, null, automationCompositionAck);
 358         verify(supervisionHandler).handleAutomationCompositionUpdateAckMessage(automationCompositionAck);
 359     }
 360
 361     @Test
 362     void testAutomationCompositionStateChangeAckListener() {
 363         final var automationCompositionAck =
 364                 new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATE_CHANGE);
 365         var supervisionHandler = mock(SupervisionAcHandler.class);
 366         var acStateChangeAckListener = new AutomationCompositionStateChangeAckListener(supervisionHandler);
 367         acStateChangeAckListener.onTopicEvent(INFRA, TOPIC, null, automationCompositionAck);
 368         verify(supervisionHandler).handleAutomationCompositionStateChangeAckMessage(automationCompositionAck);
 369     }
 370 }