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.List;
  32 import java.util.Map;
  33 import java.util.UUID;
  34 import org.junit.jupiter.api.Test;
  35 import org.junit.jupiter.api.extension.ExtendWith;
  36 import org.onap.policy.clamp.acm.participant.intermediary.comm.ParticipantMessagePublisher;
  37 import org.onap.policy.clamp.acm.participant.intermediary.main.parameters.CommonTestData;
  38 import org.onap.policy.clamp.models.acm.concepts.AcElementDeploy;
  39 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  40 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
  41 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  42 import org.onap.policy.clamp.models.acm.concepts.LockState;
  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.springframework.test.context.junit.jupiter.SpringExtension;
  52
  53 @ExtendWith(SpringExtension.class)
  54 class AutomationCompositionHandlerTest {
  55
  56     @Test
  57     void handleAutomationCompositionStateChangeNullTest() {
  58         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
  59         var cacheProvider = mock(CacheProvider.class);
  60         var ach =
  61                 new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, mock(ThreadHandler.class));
  62
  63         var automationCompositionStateChange = new AutomationCompositionStateChange();
  64         assertDoesNotThrow(() -> ach.handleAutomationCompositionStateChange(automationCompositionStateChange));
  65
  66         automationCompositionStateChange.setAutomationCompositionId(UUID.randomUUID());
  67         automationCompositionStateChange.setDeployOrderedState(DeployOrder.DELETE);
  68         assertDoesNotThrow(() -> ach.handleAutomationCompositionStateChange(automationCompositionStateChange));
  69         verify(participantMessagePublisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
  70
  71         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  72         automationCompositionStateChange.setAutomationCompositionId(automationComposition.getInstanceId());
  73         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  74                 .thenReturn(automationComposition);
  75         automationCompositionStateChange.setDeployOrderedState(DeployOrder.UPDATE);
  76         assertDoesNotThrow(() -> ach.handleAutomationCompositionStateChange(automationCompositionStateChange));
  77     }
  78
  79     @Test
  80     void handleAutomationCompositionStateChangeUndeployTest() {
  81         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  82         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
  83                 automationComposition.getInstanceId(), DeployOrder.UNDEPLOY, LockOrder.NONE);
  84         var cacheProvider = mock(CacheProvider.class);
  85         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  86                 .thenReturn(automationComposition);
  87         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
  88
  89         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
  90         var listener = mock(ThreadHandler.class);
  91         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
  92         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
  93         verify(listener, times(automationComposition.getElements().size())).undeploy(any(), any(), any());
  94         for (var element : automationComposition.getElements().values()) {
  95             assertEquals(DeployState.UNDEPLOYING, element.getDeployState());
  96         }
  97     }
  98
  99     @Test
 100     void handleAutomationCompositionStateChangeLockTest() {
 101         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 102         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
 103                 automationComposition.getInstanceId(), DeployOrder.NONE, LockOrder.LOCK);
 104         var cacheProvider = mock(CacheProvider.class);
 105         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 106                 .thenReturn(automationComposition);
 107         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
 108
 109         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 110         var listener = mock(ThreadHandler.class);
 111         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 112         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
 113         verify(listener, times(automationComposition.getElements().size())).lock(any(), any(), any());
 114         for (var element : automationComposition.getElements().values()) {
 115             assertEquals(LockState.LOCKING, element.getLockState());
 116         }
 117     }
 118
 119     @Test
 120     void handleAutomationCompositionStateChangeUnlockTest() {
 121         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 122         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
 123                 automationComposition.getInstanceId(), DeployOrder.NONE, LockOrder.UNLOCK);
 124         var cacheProvider = mock(CacheProvider.class);
 125         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 126                 .thenReturn(automationComposition);
 127         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
 128
 129         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 130         var listener = mock(ThreadHandler.class);
 131         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 132         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
 133         verify(listener, times(automationComposition.getElements().size())).unlock(any(), any(), any());
 134         for (var element : automationComposition.getElements().values()) {
 135             assertEquals(LockState.UNLOCKING, element.getLockState());
 136         }
 137     }
 138
 139     @Test
 140     void handleAutomationCompositionStateChangeDeleteTest() {
 141         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 142         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
 143                 automationComposition.getInstanceId(), DeployOrder.DELETE, LockOrder.NONE);
 144         var cacheProvider = mock(CacheProvider.class);
 145         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 146                 .thenReturn(automationComposition);
 147         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
 148
 149         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 150         var listener = mock(ThreadHandler.class);
 151         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 152         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
 153         verify(listener, times(automationComposition.getElements().size())).delete(any(), any(), any());
 154         for (var element : automationComposition.getElements().values()) {
 155             assertEquals(DeployState.DELETING, element.getDeployState());
 156         }
 157     }
 158
 159     @Test
 160     void handleAcPropertyUpdateTest() {
 161         var cacheProvider = mock(CacheProvider.class);
 162         var listener = mock(ThreadHandler.class);
 163         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 164         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 165
 166         var updateMsg = new PropertiesUpdate();
 167         assertDoesNotThrow(() -> ach.handleAcPropertyUpdate(updateMsg));
 168
 169         updateMsg.setParticipantId(CommonTestData.getParticipantId());
 170         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 171         var participantDeploy = new ParticipantDeploy();
 172         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 173         updateMsg.getParticipantUpdatesList().add(participantDeploy);
 174
 175         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 176         updateMsg.setAutomationCompositionId(automationComposition.getInstanceId());
 177         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 178                 .thenReturn(automationComposition);
 179         var acElementDeploy = new AcElementDeploy();
 180         acElementDeploy.setProperties(Map.of());
 181         acElementDeploy.setId(automationComposition.getElements().values().iterator().next().getId());
 182         participantDeploy.getAcElementList().add(acElementDeploy);
 183
 184         ach.handleAcPropertyUpdate(updateMsg);
 185         verify(listener).update(any(), any(), any(), any());
 186     }
 187
 188     @Test
 189     void handleAutomationCompositionDeployTest() {
 190         var cacheProvider = mock(CacheProvider.class);
 191         var listener = mock(ThreadHandler.class);
 192         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 193         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 194
 195         var deployMsg = new AutomationCompositionDeploy();
 196         assertDoesNotThrow(() -> ach.handleAutomationCompositionDeploy(deployMsg));
 197
 198         deployMsg.setParticipantId(CommonTestData.getParticipantId());
 199         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 200         var participantDeploy = new ParticipantDeploy();
 201         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 202         deployMsg.getParticipantUpdatesList().add(participantDeploy);
 203
 204         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 205         deployMsg.setAutomationCompositionId(automationComposition.getInstanceId());
 206         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 207                 .thenReturn(automationComposition);
 208         for (var element : automationComposition.getElements().values()) {
 209             var acElementDeploy = new AcElementDeploy();
 210             acElementDeploy.setProperties(Map.of());
 211             acElementDeploy.setId(element.getId());
 212             participantDeploy.getAcElementList().add(acElementDeploy);
 213         }
 214         ach.handleAutomationCompositionDeploy(deployMsg);
 215         verify(listener, times(automationComposition.getElements().size())).deploy(any(), any(), any(), any());
 216     }
 217
 218     @Test
 219     void handleComposiotPrimeTest() {
 220         var listener = mock(ThreadHandler.class);
 221         var ach = new AutomationCompositionHandler(mock(CacheProvider.class), mock(ParticipantMessagePublisher.class),
 222                 listener);
 223         var compositionId = UUID.randomUUID();
 224         var list = List.of(new AutomationCompositionElementDefinition());
 225         var messageId = UUID.randomUUID();
 226         ach.prime(messageId, compositionId, list);
 227         verify(listener).prime(messageId, compositionId, list);
 228     }
 229
 230     @Test
 231     void handleComposiotDeprimeTest() {
 232         var listener = mock(ThreadHandler.class);
 233         var ach = new AutomationCompositionHandler(mock(CacheProvider.class), mock(ParticipantMessagePublisher.class),
 234                 listener);
 235         var compositionId = UUID.randomUUID();
 236         var messageId = UUID.randomUUID();
 237         ach.deprime(messageId, compositionId);
 238         verify(listener).deprime(messageId, compositionId);
 239     }
 240
 241     @Test
 242     void restartedTest() {
 243         var listener = mock(ThreadHandler.class);
 244         var cacheProvider = mock(CacheProvider.class);
 245         var ach = new AutomationCompositionHandler(cacheProvider, mock(ParticipantMessagePublisher.class), listener);
 246
 247         var compositionId = UUID.randomUUID();
 248         var messageId = UUID.randomUUID();
 249         var list = List.of(new AutomationCompositionElementDefinition());
 250         var state = AcTypeState.PRIMED;
 251         var participantRestartAc = CommonTestData.createParticipantRestartAc();
 252         var automationCompositionList = List.of(participantRestartAc);
 253         ach.restarted(messageId, compositionId, list, state, automationCompositionList);
 254         verify(cacheProvider).initializeAutomationComposition(compositionId, participantRestartAc);
 255         verify(listener).restarted(messageId, compositionId, list, state, automationCompositionList);
 256     }
 257
 258     @Test
 259     void handleAutomationCompositionMigrationTest() {
 260         var listener = mock(ThreadHandler.class);
 261         var cacheProvider = mock(CacheProvider.class);
 262         var ach = new AutomationCompositionHandler(cacheProvider, mock(ParticipantMessagePublisher.class), listener);
 263         var migrationMsg = new AutomationCompositionMigration();
 264         assertDoesNotThrow(() -> ach.handleAutomationCompositionMigration(migrationMsg));
 265         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 266         migrationMsg.setCompositionTargetId(UUID.randomUUID());
 267         migrationMsg.setAutomationCompositionId(automationComposition.getInstanceId());
 268         assertDoesNotThrow(() -> ach.handleAutomationCompositionMigration(migrationMsg));
 269         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 270                 .thenReturn(automationComposition);
 271         var participantDeploy = new ParticipantDeploy();
 272         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 273         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 274         migrationMsg.getParticipantUpdatesList().add(participantDeploy);
 275         for (var element : automationComposition.getElements().values()) {
 276             var acElementDeploy = new AcElementDeploy();
 277             acElementDeploy.setProperties(Map.of());
 278             acElementDeploy.setId(element.getId());
 279             participantDeploy.getAcElementList().add(acElementDeploy);
 280         }
 281
 282         ach.handleAutomationCompositionMigration(migrationMsg);
 283         verify(listener, times(automationComposition.getElements().size())).migrate(any(), any(), any(), any(), any());
 284     }
 285 }