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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-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.participant.intermediary.handler;
  22
  23 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
  24 import static org.junit.jupiter.api.Assertions.assertEquals;
  25 import static org.mockito.ArgumentMatchers.any;
  26 import static org.mockito.Mockito.mock;
  27 import static org.mockito.Mockito.times;
  28 import static org.mockito.Mockito.verify;
  29 import static org.mockito.Mockito.when;
  30
  31 import java.util.HashMap;
  32 import java.util.Map;
  33 import java.util.UUID;
  34 import org.junit.jupiter.api.Test;
  35 import org.onap.policy.clamp.acm.participant.intermediary.comm.ParticipantMessagePublisher;
  36 import org.onap.policy.clamp.acm.participant.intermediary.main.parameters.CommonTestData;
  37 import org.onap.policy.clamp.models.acm.concepts.AcElementDeploy;
  38 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  39 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
  40 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  41 import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
  42 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionDeploy;
  43 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionDeployAck;
  44 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionMigration;
  45 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionStateChange;
  46 import org.onap.policy.clamp.models.acm.messages.kafka.participant.PropertiesUpdate;
  47 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  48 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
  49 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  50
  51 class AutomationCompositionHandlerTest {
  52
  53     @Test
  54     void handleAutomationCompositionStateChangeNullTest() {
  55         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
  56         var cacheProvider = mock(CacheProvider.class);
  57         var ach =
  58                 new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, mock(ThreadHandler.class));
  59
  60         var automationCompositionStateChange = new AutomationCompositionStateChange();
  61         assertDoesNotThrow(() -> ach.handleAutomationCompositionStateChange(automationCompositionStateChange));
  62
  63         automationCompositionStateChange.setAutomationCompositionId(UUID.randomUUID());
  64         automationCompositionStateChange.setDeployOrderedState(DeployOrder.DELETE);
  65         assertDoesNotThrow(() -> ach.handleAutomationCompositionStateChange(automationCompositionStateChange));
  66         verify(participantMessagePublisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
  67
  68         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  69         automationCompositionStateChange.setAutomationCompositionId(automationComposition.getInstanceId());
  70         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  71                 .thenReturn(automationComposition);
  72         automationCompositionStateChange.setDeployOrderedState(DeployOrder.UPDATE);
  73         assertDoesNotThrow(() -> ach.handleAutomationCompositionStateChange(automationCompositionStateChange));
  74     }
  75
  76     @Test
  77     void handleAutomationCompositionStateChangeUndeployTest() {
  78         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  79         var cacheProvider = mock(CacheProvider.class);
  80         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  81                 .thenReturn(automationComposition);
  82         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
  83
  84         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
  85         var listener = mock(ThreadHandler.class);
  86         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
  87         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
  88         for (var element : automationComposition.getElements().values()) {
  89             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
  90         }
  91         when(cacheProvider.getAcElementsDefinitions())
  92             .thenReturn(Map.of(automationComposition.getCompositionId(), map));
  93         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
  94             automationComposition.getInstanceId(), DeployOrder.UNDEPLOY, LockOrder.NONE);
  95
  96         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
  97         verify(listener, times(automationComposition.getElements().size())).undeploy(any(), any(), any());
  98         for (var element : automationComposition.getElements().values()) {
  99             assertEquals(DeployState.UNDEPLOYING, element.getDeployState());
 100         }
 101     }
 102
 103     @Test
 104     void handleAutomationCompositionStateChangeDeleteTest() {
 105         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 106         var cacheProvider = mock(CacheProvider.class);
 107         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 108                 .thenReturn(automationComposition);
 109         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
 110
 111         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 112         var listener = mock(ThreadHandler.class);
 113         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 114         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
 115         for (var element : automationComposition.getElements().values()) {
 116             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
 117         }
 118         when(cacheProvider.getAcElementsDefinitions())
 119             .thenReturn(Map.of(automationComposition.getCompositionId(), map));
 120         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
 121             automationComposition.getInstanceId(), DeployOrder.DELETE, LockOrder.NONE);
 122         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
 123         verify(listener, times(automationComposition.getElements().size())).delete(any(), any(), any());
 124         for (var element : automationComposition.getElements().values()) {
 125             assertEquals(DeployState.DELETING, element.getDeployState());
 126         }
 127     }
 128
 129     @Test
 130     void handleAcPropertyUpdateTest() {
 131         var cacheProvider = mock(CacheProvider.class);
 132         var listener = mock(ThreadHandler.class);
 133         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 134         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 135
 136         var updateMsg = new PropertiesUpdate();
 137         assertDoesNotThrow(() -> ach.handleAcPropertyUpdate(updateMsg));
 138
 139         updateMsg.setParticipantId(CommonTestData.getParticipantId());
 140         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 141         var participantDeploy = new ParticipantDeploy();
 142         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 143         updateMsg.getParticipantUpdatesList().add(participantDeploy);
 144
 145         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 146         updateMsg.setAutomationCompositionId(automationComposition.getInstanceId());
 147         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 148                 .thenReturn(automationComposition);
 149         var acElementDeploy = new AcElementDeploy();
 150         acElementDeploy.setProperties(Map.of());
 151         acElementDeploy.setId(automationComposition.getElements().values().iterator().next().getId());
 152         participantDeploy.getAcElementList().add(acElementDeploy);
 153
 154         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
 155         for (var element : automationComposition.getElements().values()) {
 156             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
 157         }
 158         when(cacheProvider.getAcElementsDefinitions())
 159             .thenReturn(Map.of(automationComposition.getCompositionId(), map));
 160         ach.handleAcPropertyUpdate(updateMsg);
 161         verify(listener).update(any(), any(), any(), any());
 162     }
 163
 164     @Test
 165     void handleAutomationCompositionDeployTest() {
 166         var cacheProvider = mock(CacheProvider.class);
 167         var listener = mock(ThreadHandler.class);
 168         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 169         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 170
 171         var deployMsg = new AutomationCompositionDeploy();
 172         assertDoesNotThrow(() -> ach.handleAutomationCompositionDeploy(deployMsg));
 173
 174         deployMsg.setParticipantId(CommonTestData.getParticipantId());
 175         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 176         var participantDeploy = new ParticipantDeploy();
 177         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 178         deployMsg.getParticipantUpdatesList().add(participantDeploy);
 179
 180         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 181         deployMsg.setAutomationCompositionId(automationComposition.getInstanceId());
 182         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 183                 .thenReturn(automationComposition);
 184         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
 185         for (var element : automationComposition.getElements().values()) {
 186             var acElementDeploy = new AcElementDeploy();
 187             acElementDeploy.setProperties(Map.of());
 188             acElementDeploy.setId(element.getId());
 189             participantDeploy.getAcElementList().add(acElementDeploy);
 190             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
 191         }
 192         when(cacheProvider.getAcElementsDefinitions())
 193             .thenReturn(Map.of(automationComposition.getCompositionId(), map));
 194
 195         ach.handleAutomationCompositionDeploy(deployMsg);
 196         verify(listener, times(automationComposition.getElements().size())).deploy(any(), any(), any());
 197     }
 198
 199     @Test
 200     void handleAutomationCompositionMigrationTest() {
 201         var listener = mock(ThreadHandler.class);
 202         var cacheProvider = mock(CacheProvider.class);
 203         var ach = new AutomationCompositionHandler(cacheProvider, mock(ParticipantMessagePublisher.class), listener);
 204         var migrationMsg = new AutomationCompositionMigration();
 205         assertDoesNotThrow(() -> ach.handleAutomationCompositionMigration(migrationMsg));
 206         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 207
 208         assertDoesNotThrow(() -> ach.handleAutomationCompositionMigration(migrationMsg));
 209         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 210                 .thenReturn(automationComposition);
 211         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 212
 213         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
 214         var participantDeploy = new ParticipantDeploy();
 215         populateMigrationMsg(automationComposition, migrationMsg, map, participantDeploy);
 216         when(cacheProvider.getAcElementsDefinitions())
 217                 .thenReturn(Map.of(automationComposition.getCompositionId(), map,
 218                         migrationMsg.getCompositionTargetId(), map));
 219
 220         ach.handleAutomationCompositionMigration(migrationMsg);
 221         verify(listener, times(automationComposition.getElements().size() + 1))
 222                 .migrate(any(), any(), any(), any(), any());
 223     }
 224
 225     private void populateMigrationMsg(AutomationComposition automationComposition,
 226                                       AutomationCompositionMigration migrationMsg,
 227                                       Map<ToscaConceptIdentifier,
 228                                               AutomationCompositionElementDefinition> map,
 229                                       ParticipantDeploy participantDeploy) {
 230
 231         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 232         migrationMsg.setCompositionTargetId(UUID.randomUUID());
 233         migrationMsg.setAutomationCompositionId(automationComposition.getInstanceId());
 234         migrationMsg.getParticipantUpdatesList().add(participantDeploy);
 235         for (var element : automationComposition.getElements().values()) {
 236             var acElementDeploy = new AcElementDeploy();
 237             acElementDeploy.setProperties(Map.of());
 238             acElementDeploy.setId(element.getId());
 239             acElementDeploy.setDefinition(element.getDefinition());
 240             participantDeploy.getAcElementList().add(acElementDeploy);
 241             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
 242         }
 243         // remove an element
 244         participantDeploy.getAcElementList().remove(0);
 245         // Add a new element
 246         var acElementDeploy = new AcElementDeploy();
 247         acElementDeploy.setProperties(Map.of());
 248         acElementDeploy.setId(UUID.randomUUID());
 249         acElementDeploy.setDefinition(new ToscaConceptIdentifier("1.2.3", "policy.clamp.new.element"));
 250         participantDeploy.getAcElementList().add(acElementDeploy);
 251
 252     }
 253 }