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