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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2023 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.dmaap.participant.AutomationCompositionDeploy;
  45 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeployAck;
  46 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionStateChange;
  47 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.PropertiesUpdate;
  48 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  49 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
  50 import org.springframework.test.context.junit.jupiter.SpringExtension;
  51
  52 @ExtendWith(SpringExtension.class)
  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 automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
  82                 automationComposition.getInstanceId(), DeployOrder.UNDEPLOY, LockOrder.NONE);
  83         var cacheProvider = mock(CacheProvider.class);
  84         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  85                 .thenReturn(automationComposition);
  86         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
  87
  88         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
  89         var listener = mock(ThreadHandler.class);
  90         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
  91         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
  92         verify(listener, times(automationComposition.getElements().size())).undeploy(any(), any(), any());
  93         for (var element: automationComposition.getElements().values()) {
  94             assertEquals(DeployState.UNDEPLOYING, element.getDeployState());
  95         }
  96     }
  97
  98     @Test
  99     void handleAutomationCompositionStateChangeLockTest() {
 100         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 101         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
 102                 automationComposition.getInstanceId(), DeployOrder.NONE, LockOrder.LOCK);
 103         var cacheProvider = mock(CacheProvider.class);
 104         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 105                 .thenReturn(automationComposition);
 106         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
 107
 108         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 109         var listener = mock(ThreadHandler.class);
 110         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 111         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
 112         verify(listener, times(automationComposition.getElements().size())).lock(any(), any(), any());
 113         for (var element: automationComposition.getElements().values()) {
 114             assertEquals(LockState.LOCKING, element.getLockState());
 115         }
 116     }
 117
 118     @Test
 119     void handleAutomationCompositionStateChangeUnlockTest() {
 120         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 121         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
 122                 automationComposition.getInstanceId(), DeployOrder.NONE, LockOrder.UNLOCK);
 123         var cacheProvider = mock(CacheProvider.class);
 124         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 125                 .thenReturn(automationComposition);
 126         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
 127
 128         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 129         var listener = mock(ThreadHandler.class);
 130         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 131         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
 132         verify(listener, times(automationComposition.getElements().size())).unlock(any(), any(), any());
 133         for (var element: automationComposition.getElements().values()) {
 134             assertEquals(LockState.UNLOCKING, element.getLockState());
 135         }
 136     }
 137
 138     @Test
 139     void handleAutomationCompositionStateChangeDeleteTest() {
 140         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 141         var automationCompositionStateChange = CommonTestData.getStateChange(CommonTestData.getParticipantId(),
 142                 automationComposition.getInstanceId(), DeployOrder.DELETE, LockOrder.NONE);
 143         var cacheProvider = mock(CacheProvider.class);
 144         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 145                 .thenReturn(automationComposition);
 146         when(cacheProvider.getCommonProperties(any(UUID.class), any(UUID.class))).thenReturn(Map.of());
 147
 148         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 149         var listener = mock(ThreadHandler.class);
 150         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 151         ach.handleAutomationCompositionStateChange(automationCompositionStateChange);
 152         verify(listener, times(automationComposition.getElements().size())).delete(any(), any(), any());
 153         for (var element: automationComposition.getElements().values()) {
 154             assertEquals(DeployState.DELETING, element.getDeployState());
 155         }
 156     }
 157
 158     @Test
 159     void handleAcPropertyUpdateTest() {
 160         var cacheProvider = mock(CacheProvider.class);
 161         var listener = mock(ThreadHandler.class);
 162         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 163         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 164
 165         var updateMsg = new PropertiesUpdate();
 166         assertDoesNotThrow(() -> ach.handleAcPropertyUpdate(updateMsg));
 167
 168         updateMsg.setParticipantId(CommonTestData.getParticipantId());
 169         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 170         var participantDeploy = new ParticipantDeploy();
 171         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 172         updateMsg.getParticipantUpdatesList().add(participantDeploy);
 173
 174         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 175         updateMsg.setAutomationCompositionId(automationComposition.getInstanceId());
 176         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 177                 .thenReturn(automationComposition);
 178         var acElementDeploy = new AcElementDeploy();
 179         acElementDeploy.setProperties(Map.of());
 180         acElementDeploy.setId(automationComposition.getElements().values().iterator().next().getId());
 181         participantDeploy.getAcElementList().add(acElementDeploy);
 182
 183         ach.handleAcPropertyUpdate(updateMsg);
 184         verify(listener).update(any(), any(), any(), any());
 185     }
 186
 187     @Test
 188     void handleAutomationCompositionDeployTest() {
 189         var cacheProvider = mock(CacheProvider.class);
 190         var listener = mock(ThreadHandler.class);
 191         var participantMessagePublisher = mock(ParticipantMessagePublisher.class);
 192         var ach = new AutomationCompositionHandler(cacheProvider, participantMessagePublisher, listener);
 193
 194         var deployMsg = new AutomationCompositionDeploy();
 195         assertDoesNotThrow(() -> ach.handleAutomationCompositionDeploy(deployMsg));
 196
 197         deployMsg.setParticipantId(CommonTestData.getParticipantId());
 198         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 199         var participantDeploy = new ParticipantDeploy();
 200         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 201         deployMsg.getParticipantUpdatesList().add(participantDeploy);
 202
 203         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 204         deployMsg.setAutomationCompositionId(automationComposition.getInstanceId());
 205         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 206                 .thenReturn(automationComposition);
 207         for (var element : automationComposition.getElements().values()) {
 208             var acElementDeploy = new AcElementDeploy();
 209             acElementDeploy.setProperties(Map.of());
 210             acElementDeploy.setId(element.getId());
 211             participantDeploy.getAcElementList().add(acElementDeploy);
 212         }
 213         ach.handleAutomationCompositionDeploy(deployMsg);
 214         verify(listener, times(automationComposition.getElements().size())).deploy(any(), any(), any(), any());
 215     }
 216
 217     @Test
 218     void handleComposiotPrimeTest() {
 219         var listener = mock(ThreadHandler.class);
 220         var ach = new AutomationCompositionHandler(mock(CacheProvider.class), mock(ParticipantMessagePublisher.class),
 221                 listener);
 222         var compositionId = UUID.randomUUID();
 223         var list = List.of(new AutomationCompositionElementDefinition());
 224         var messageId = UUID.randomUUID();
 225         ach.prime(messageId, compositionId, list);
 226         verify(listener).prime(messageId, compositionId, list);
 227     }
 228
 229     @Test
 230     void handleComposiotDeprimeTest() {
 231         var listener = mock(ThreadHandler.class);
 232         var ach = new AutomationCompositionHandler(mock(CacheProvider.class), mock(ParticipantMessagePublisher.class),
 233                 listener);
 234         var compositionId = UUID.randomUUID();
 235         var messageId = UUID.randomUUID();
 236         ach.deprime(messageId, compositionId);
 237         verify(listener).deprime(messageId, compositionId);
 238     }
 239
 240     @Test
 241     void restartedTest() {
 242         var listener = mock(ThreadHandler.class);
 243         var cacheProvider = mock(CacheProvider.class);
 244         var ach = new AutomationCompositionHandler(cacheProvider, mock(ParticipantMessagePublisher.class),
 245                 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 }