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