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