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.List;
  33 import java.util.Map;
  34 import java.util.UUID;
  35 import org.junit.jupiter.api.Test;
  36 import org.junit.jupiter.api.extension.ExtendWith;
  37 import org.onap.policy.clamp.acm.participant.intermediary.api.CompositionDto;
  38 import org.onap.policy.clamp.acm.participant.intermediary.comm.ParticipantMessagePublisher;
  39 import org.onap.policy.clamp.acm.participant.intermediary.main.parameters.CommonTestData;
  40 import org.onap.policy.clamp.models.acm.concepts.AcElementDeploy;
  41 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  42 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
  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.ParticipantDeploy;
  46 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionDeploy;
  47 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionDeployAck;
  48 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionMigration;
  49 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionStateChange;
  50 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantPrimeAck;
  51 import org.onap.policy.clamp.models.acm.messages.kafka.participant.PropertiesUpdate;
  52 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  53 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
  54 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  55 import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
  56 import org.springframework.test.context.junit.jupiter.SpringExtension;
  57
  58 @ExtendWith(SpringExtension.class)
  59 class AutomationCompositionHandlerTest {
  60
  61     @Test
  62     void handleAutomationCompositionStateChangeNullTest() {
  63         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
  64         var cacheProvider = mock(CacheProvider.class);
  65         var ach =
  66                 new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, mock(ThreadHandler.class));
  67
  68         var automationCompositionStateChange = new AutomationCompositionStateChange();
  69         assertDoesNotThrow(() -> ach.handleAutomationCompositionStateChange(automationCompositionStateChange));
  70
  71         automationCompositionStateChange.setAutomationCompositionId(UUID.randomUUID());
  72         automationCompositionStateChange.setDeployOrderedState(DeployOrder.DELETE);
  73         assertDoesNotThrow(() -> ach.handleAutomationCompositionStateChange(automationCompositionStateChange));
  74         verify(participantMessagePublisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
  75
  76         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  77         automationCompositionStateChange.setAutomationCompositionId(automationComposition.getInstanceId());
  78         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  79                 .thenReturn(automationComposition);
  80         automationCompositionStateChange.setDeployOrderedState(DeployOrder.UPDATE);
  81         assertDoesNotThrow(() -> ach.handleAutomationCompositionStateChange(automationCompositionStateChange));
  82     }
  83
  84     @Test
  85     void handleAutomationCompositionStateChangeUndeployTest() {
  86         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  87         var cacheProvider = mock(CacheProvider.class);
  88         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  89                 .thenReturn(automationComposition);
  90         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
  91
  92         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
  93         var listener = mock(ThreadHandler.class);
  94         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
  95         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
  96         for (var element : automationComposition.getElements().values()) {
  97             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
  98         }
  99         when(cacheProvider.getAcElementsDefinitions())
 100             .thenReturn(Map.of(automationComposition.getCompositionId(), map));
 101         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
 102             automationComposition.getInstanceId(), DeployOrder.UNDEPLOY, LockOrder.NONE);
 103
 104         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
 105         verify(listener, times(automationComposition.getElements().size())).undeploy(any(), any(), any());
 106         for (var element : automationComposition.getElements().values()) {
 107             assertEquals(DeployState.UNDEPLOYING, element.getDeployState());
 108         }
 109     }
 110
 111     @Test
 112     void handleAutomationCompositionStateChangeLockTest() {
 113         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 114         var cacheProvider = mock(CacheProvider.class);
 115         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 116                 .thenReturn(automationComposition);
 117         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
 118
 119         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 120         var listener = mock(ThreadHandler.class);
 121         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 122         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
 123         for (var element : automationComposition.getElements().values()) {
 124             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
 125         }
 126         when(cacheProvider.getAcElementsDefinitions())
 127             .thenReturn(Map.of(automationComposition.getCompositionId(), map));
 128         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
 129             automationComposition.getInstanceId(), DeployOrder.NONE, LockOrder.LOCK);
 130         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
 131         verify(listener, times(automationComposition.getElements().size())).lock(any(), any(), any());
 132         for (var element : automationComposition.getElements().values()) {
 133             assertEquals(LockState.LOCKING, element.getLockState());
 134         }
 135     }
 136
 137     @Test
 138     void handleAutomationCompositionStateChangeUnlockTest() {
 139         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 140         var cacheProvider = mock(CacheProvider.class);
 141         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 142                 .thenReturn(automationComposition);
 143         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
 144
 145         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 146         var listener = mock(ThreadHandler.class);
 147         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 148         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
 149         for (var element : automationComposition.getElements().values()) {
 150             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
 151         }
 152         when(cacheProvider.getAcElementsDefinitions())
 153             .thenReturn(Map.of(automationComposition.getCompositionId(), map));
 154         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
 155             automationComposition.getInstanceId(), DeployOrder.NONE, LockOrder.UNLOCK);
 156         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
 157         verify(listener, times(automationComposition.getElements().size())).unlock(any(), any(), any());
 158         for (var element : automationComposition.getElements().values()) {
 159             assertEquals(LockState.UNLOCKING, element.getLockState());
 160         }
 161     }
 162
 163     @Test
 164     void handleAutomationCompositionStateChangeDeleteTest() {
 165         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 166         var cacheProvider = mock(CacheProvider.class);
 167         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 168                 .thenReturn(automationComposition);
 169         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
 170
 171         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 172         var listener = mock(ThreadHandler.class);
 173         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 174         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
 175         for (var element : automationComposition.getElements().values()) {
 176             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
 177         }
 178         when(cacheProvider.getAcElementsDefinitions())
 179             .thenReturn(Map.of(automationComposition.getCompositionId(), map));
 180         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
 181             automationComposition.getInstanceId(), DeployOrder.DELETE, LockOrder.NONE);
 182         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
 183         verify(listener, times(automationComposition.getElements().size())).delete(any(), any(), any());
 184         for (var element : automationComposition.getElements().values()) {
 185             assertEquals(DeployState.DELETING, element.getDeployState());
 186         }
 187     }
 188
 189     @Test
 190     void handleAcPropertyUpdateTest() {
 191         var cacheProvider = mock(CacheProvider.class);
 192         var listener = mock(ThreadHandler.class);
 193         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 194         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 195
 196         var updateMsg = new PropertiesUpdate();
 197         assertDoesNotThrow(() -> ach.handleAcPropertyUpdate(updateMsg));
 198
 199         updateMsg.setParticipantId(CommonTestData.getParticipantId());
 200         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 201         var participantDeploy = new ParticipantDeploy();
 202         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 203         updateMsg.getParticipantUpdatesList().add(participantDeploy);
 204
 205         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 206         updateMsg.setAutomationCompositionId(automationComposition.getInstanceId());
 207         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 208                 .thenReturn(automationComposition);
 209         var acElementDeploy = new AcElementDeploy();
 210         acElementDeploy.setProperties(Map.of());
 211         acElementDeploy.setId(automationComposition.getElements().values().iterator().next().getId());
 212         participantDeploy.getAcElementList().add(acElementDeploy);
 213
 214         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
 215         for (var element : automationComposition.getElements().values()) {
 216             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
 217         }
 218         when(cacheProvider.getAcElementsDefinitions())
 219             .thenReturn(Map.of(automationComposition.getCompositionId(), map));
 220         ach.handleAcPropertyUpdate(updateMsg);
 221         verify(listener).update(any(), any(), any(), any());
 222     }
 223
 224     @Test
 225     void handleAutomationCompositionDeployTest() {
 226         var cacheProvider = mock(CacheProvider.class);
 227         var listener = mock(ThreadHandler.class);
 228         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 229         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 230
 231         var deployMsg = new AutomationCompositionDeploy();
 232         assertDoesNotThrow(() -> ach.handleAutomationCompositionDeploy(deployMsg));
 233
 234         deployMsg.setParticipantId(CommonTestData.getParticipantId());
 235         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 236         var participantDeploy = new ParticipantDeploy();
 237         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 238         deployMsg.getParticipantUpdatesList().add(participantDeploy);
 239
 240         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 241         deployMsg.setAutomationCompositionId(automationComposition.getInstanceId());
 242         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 243                 .thenReturn(automationComposition);
 244         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
 245         for (var element : automationComposition.getElements().values()) {
 246             var acElementDeploy = new AcElementDeploy();
 247             acElementDeploy.setProperties(Map.of());
 248             acElementDeploy.setId(element.getId());
 249             participantDeploy.getAcElementList().add(acElementDeploy);
 250             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
 251         }
 252         when(cacheProvider.getAcElementsDefinitions())
 253             .thenReturn(Map.of(automationComposition.getCompositionId(), map));
 254
 255         ach.handleAutomationCompositionDeploy(deployMsg);
 256         verify(listener, times(automationComposition.getElements().size())).deploy(any(), any(), any());
 257     }
 258
 259     @Test
 260     void handleComposiotPrimeTest() {
 261         var acElementDefinition = new AutomationCompositionElementDefinition();
 262         acElementDefinition.setAcElementDefinitionId(new ToscaConceptIdentifier("key", "1.0.0"));
 263         var toscaNodeTemplate = new ToscaNodeTemplate();
 264         toscaNodeTemplate.setProperties(Map.of());
 265         acElementDefinition.setAutomationCompositionElementToscaNodeTemplate(toscaNodeTemplate);
 266         var list = List.of(acElementDefinition);
 267         var compositionId = UUID.randomUUID();
 268         var messageId = UUID.randomUUID();
 269         var listener = mock(ThreadHandler.class);
 270         var ach = new AutomationCompositionHandler(mock(CacheProvider.class), mock(ParticipantMessagePublisher.class),
 271             listener);
 272         ach.prime(messageId, compositionId, list);
 273         verify(listener).prime(any(UUID.class), any(CompositionDto.class));
 274     }
 275
 276     @Test
 277     void handleCompositionDeprimeTest() {
 278         var acElementDefinition = new AutomationCompositionElementDefinition();
 279         acElementDefinition.setAcElementDefinitionId(new ToscaConceptIdentifier("key", "1.0.0"));
 280         var toscaNodeTemplate = new ToscaNodeTemplate();
 281         toscaNodeTemplate.setProperties(Map.of());
 282         acElementDefinition.setAutomationCompositionElementToscaNodeTemplate(toscaNodeTemplate);
 283         var compositionId = UUID.randomUUID();
 284         var listener = mock(ThreadHandler.class);
 285         var cacheProvider = mock(CacheProvider.class);
 286         var ach = new AutomationCompositionHandler(cacheProvider, mock(ParticipantMessagePublisher.class),
 287             listener);
 288         when(cacheProvider.getAcElementsDefinitions())
 289             .thenReturn(Map.of(compositionId, Map.of(new ToscaConceptIdentifier(), acElementDefinition)));
 290         var messageId = UUID.randomUUID();
 291         ach.deprime(messageId, compositionId);
 292         verify(listener).deprime(any(UUID.class), any(CompositionDto.class));
 293     }
 294
 295     @Test
 296     void handleCompositionAlreadyDeprimedTest() {
 297         var messageId = UUID.randomUUID();
 298         var compositionId = UUID.randomUUID();
 299         var participantMessagePublisher =  mock(ParticipantMessagePublisher.class);
 300         var ach = new AutomationCompositionHandler(mock(CacheProvider.class), participantMessagePublisher,
 301             mock(ThreadHandler.class));
 302         ach.deprime(messageId, compositionId);
 303         verify(participantMessagePublisher).sendParticipantPrimeAck(any(ParticipantPrimeAck.class));
 304     }
 305
 306     @Test
 307     void restartedTest() {
 308         var acElementDefinition = new AutomationCompositionElementDefinition();
 309         acElementDefinition.setAcElementDefinitionId(new ToscaConceptIdentifier("key", "1.0.0"));
 310         var toscaNodeTemplate = new ToscaNodeTemplate();
 311         toscaNodeTemplate.setProperties(Map.of());
 312         acElementDefinition.setAutomationCompositionElementToscaNodeTemplate(toscaNodeTemplate);
 313         var list = List.of(acElementDefinition);
 314         var state = AcTypeState.PRIMED;
 315         var participantRestartAc = CommonTestData.createParticipantRestartAc();
 316         var automationCompositionList = List.of(participantRestartAc);
 317         var listener = mock(ThreadHandler.class);
 318         var cacheProvider = mock(CacheProvider.class);
 319         var ach = new AutomationCompositionHandler(cacheProvider, mock(ParticipantMessagePublisher.class), listener);
 320         var compositionId = UUID.randomUUID();
 321         var messageId = UUID.randomUUID();
 322         ach.restarted(messageId, compositionId, list, state, automationCompositionList);
 323         verify(cacheProvider).initializeAutomationComposition(compositionId, participantRestartAc);
 324         verify(listener).restarted(any(), any(), any(), any());
 325     }
 326
 327     @Test
 328     void handleAutomationCompositionMigrationTest() {
 329         var listener = mock(ThreadHandler.class);
 330         var cacheProvider = mock(CacheProvider.class);
 331         var ach = new AutomationCompositionHandler(cacheProvider, mock(ParticipantMessagePublisher.class), listener);
 332         var migrationMsg = new AutomationCompositionMigration();
 333         assertDoesNotThrow(() -> ach.handleAutomationCompositionMigration(migrationMsg));
 334         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 335         migrationMsg.setCompositionTargetId(UUID.randomUUID());
 336         migrationMsg.setAutomationCompositionId(automationComposition.getInstanceId());
 337         assertDoesNotThrow(() -> ach.handleAutomationCompositionMigration(migrationMsg));
 338         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 339                 .thenReturn(automationComposition);
 340         var participantDeploy = new ParticipantDeploy();
 341         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 342         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 343         migrationMsg.getParticipantUpdatesList().add(participantDeploy);
 344         Map<ToscaConceptIdentifier, AutomationCompositionElementDefinition> map = new HashMap<>();
 345         for (var element : automationComposition.getElements().values()) {
 346             var acElementDeploy = new AcElementDeploy();
 347             acElementDeploy.setProperties(Map.of());
 348             acElementDeploy.setId(element.getId());
 349             acElementDeploy.setDefinition(element.getDefinition());
 350             participantDeploy.getAcElementList().add(acElementDeploy);
 351             map.put(element.getDefinition(), new AutomationCompositionElementDefinition());
 352         }
 353         when(cacheProvider.getAcElementsDefinitions())
 354             .thenReturn(Map.of(automationComposition.getCompositionId(), map,
 355                 migrationMsg.getCompositionTargetId(), map));
 356
 357         ach.handleAutomationCompositionMigration(migrationMsg);
 358         verify(listener, times(automationComposition.getElements().size())).migrate(any(), any(), any(), any(), any());
 359     }
 360 }