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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2023-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.Map;
  32 import java.util.UUID;
  33 import org.junit.jupiter.api.Test;
  34 import org.onap.policy.clamp.acm.participant.intermediary.comm.ParticipantMessagePublisher;
  35 import org.onap.policy.clamp.acm.participant.intermediary.main.parameters.CommonTestData;
  36 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  37 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
  38 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  39 import org.onap.policy.clamp.models.acm.concepts.LockState;
  40 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  41 import org.onap.policy.clamp.models.acm.concepts.SubState;
  42 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionDeployAck;
  43 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantPrimeAck;
  44 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantStatus;
  45 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  46
  47 class AutomationCompositionOutHandlerTest {
  48
  49     @Test
  50     void updateAutomationCompositionElementStateNullTest() {
  51         var cacheProvider = mock(CacheProvider.class);
  52         var publisher = mock(ParticipantMessagePublisher.class);
  53         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
  54
  55         assertDoesNotThrow(
  56                 () -> acOutHandler.updateAutomationCompositionElementState(null, null, null, null, null, null));
  57
  58         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(null,
  59                 UUID.randomUUID(), null, null, null, null));
  60
  61         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(UUID.randomUUID(),
  62                 null, null, null, null, null));
  63
  64         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(UUID.randomUUID(),
  65                 UUID.randomUUID(), null, null, null, null));
  66
  67         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(UUID.randomUUID(),
  68                 UUID.randomUUID(), DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, null));
  69
  70         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(UUID.randomUUID(),
  71                 UUID.randomUUID(), DeployState.DEPLOYED, null, null, null));
  72
  73         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  74         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  75                 .thenReturn(automationComposition);
  76         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(
  77                 automationComposition.getInstanceId(), UUID.randomUUID(), DeployState.DEPLOYED,
  78             null, StateChangeResult.NO_ERROR, null));
  79
  80         var elementId = automationComposition.getElements().values().iterator().next().getId();
  81         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(
  82                 automationComposition.getInstanceId(), elementId, null, null,
  83                 StateChangeResult.NO_ERROR, null));
  84
  85         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementStage(
  86                 elementId, null, StateChangeResult.NO_ERROR, 0, null));
  87         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementStage(
  88                 null, elementId, StateChangeResult.NO_ERROR, 0, null));
  89         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementStage(
  90                 UUID.randomUUID(), elementId, StateChangeResult.NO_ERROR, 0, null));
  91         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementStage(
  92                 automationComposition.getInstanceId(), UUID.randomUUID(),
  93                 StateChangeResult.NO_ERROR, 0, null));
  94         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(
  95                 automationComposition.getInstanceId(), elementId, DeployState.DEPLOYED, LockState.LOCKED,
  96                 StateChangeResult.NO_ERROR, null));
  97         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(
  98                 automationComposition.getInstanceId(), elementId, DeployState.DEPLOYING, null,
  99                 StateChangeResult.NO_ERROR, ""));
 100         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(
 101                 automationComposition.getInstanceId(), elementId, DeployState.DEPLOYED, null,
 102                 StateChangeResult.TIMEOUT, ""));
 103
 104         verify(publisher, times(0)).sendAutomationCompositionAck(any());
 105     }
 106
 107     @Test
 108     void updateAutomationCompositionElementStageTest() {
 109         var publisher = mock(ParticipantMessagePublisher.class);
 110         var cacheProvider = mock(CacheProvider.class);
 111         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 112         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 113         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 114                 .thenReturn(automationComposition);
 115         var elementId = automationComposition.getElements().values().iterator().next().getId();
 116         acOutHandler.updateAutomationCompositionElementStage(
 117                 automationComposition.getInstanceId(), elementId, StateChangeResult.NO_ERROR, 0, "OK");
 118         verify(publisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 119     }
 120
 121     @Test
 122     void updateAutomationCompositionElementStateDeployedTest() {
 123         var publisher = mock(ParticipantMessagePublisher.class);
 124         var cacheProvider = mock(CacheProvider.class);
 125         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 126
 127         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 128         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 129                 .thenReturn(automationComposition);
 130         var elementId = automationComposition.getElements().values().iterator().next().getId();
 131         acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), elementId,
 132                 DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, "Deployed");
 133         verify(publisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 134     }
 135
 136     @Test
 137     void updateAutomationCompositionElementStatePrepareTest() {
 138         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 139         automationComposition.setSubState(SubState.PREPARING);
 140         var cacheProvider = mock(CacheProvider.class);
 141         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 142                 .thenReturn(automationComposition);
 143         var element = automationComposition.getElements().values().iterator().next();
 144         element.setSubState(SubState.PREPARING);
 145         var elementId = element.getId();
 146         var publisher = mock(ParticipantMessagePublisher.class);
 147         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 148         acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), elementId,
 149                 DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, "Prepare completed");
 150         verify(publisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 151     }
 152
 153     @Test
 154     void updateAutomationCompositionElementStateLockTest() {
 155         var publisher = mock(ParticipantMessagePublisher.class);
 156         var cacheProvider = mock(CacheProvider.class);
 157         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 158
 159         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 160         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 161                 .thenReturn(automationComposition);
 162         var elementId = automationComposition.getElements().values().iterator().next().getId();
 163         acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), elementId, null,
 164                 LockState.LOCKED, StateChangeResult.NO_ERROR, "Locked");
 165         verify(publisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 166     }
 167
 168     @Test
 169     void updateAutomationCompositionElementStateDeleteTest() {
 170         var publisher = mock(ParticipantMessagePublisher.class);
 171         var cacheProvider = mock(CacheProvider.class);
 172         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 173
 174         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 175         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 176                 .thenReturn(automationComposition);
 177         for (var element : automationComposition.getElements().values()) {
 178             acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), element.getId(),
 179                     DeployState.DELETED, null, StateChangeResult.NO_ERROR, "Deleted");
 180         }
 181         verify(publisher, times(automationComposition.getElements().size()))
 182                 .sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 183         verify(cacheProvider).removeAutomationComposition(automationComposition.getInstanceId());
 184     }
 185
 186     @Test
 187     void sendAcElementInfoTestNull() {
 188         var publisher = mock(ParticipantMessagePublisher.class);
 189         var cacheProvider = mock(CacheProvider.class);
 190         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 191
 192         assertDoesNotThrow(() -> acOutHandler.sendAcElementInfo(null, null, null, null, null));
 193         assertDoesNotThrow(() -> acOutHandler.sendAcElementInfo(UUID.randomUUID(), null, null, null, null));
 194         assertDoesNotThrow(
 195                 () -> acOutHandler.sendAcElementInfo(UUID.randomUUID(), UUID.randomUUID(), null, null, null));
 196
 197         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 198         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 199                 .thenReturn(automationComposition);
 200         assertDoesNotThrow(() -> acOutHandler.sendAcElementInfo(automationComposition.getInstanceId(),
 201                 UUID.randomUUID(), null, null, null));
 202     }
 203
 204     @Test
 205     void sendAcElementInfoTest() {
 206         var publisher = mock(ParticipantMessagePublisher.class);
 207         var cacheProvider = mock(CacheProvider.class);
 208         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 209
 210         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 211         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 212                 .thenReturn(automationComposition);
 213         var elementId = automationComposition.getElements().values().iterator().next().getId();
 214         acOutHandler.sendAcElementInfo(automationComposition.getInstanceId(), elementId, "", "", Map.of());
 215         verify(publisher).sendParticipantStatus(any(ParticipantStatus.class));
 216     }
 217
 218     @Test
 219     void updateCompositionStateNullTest() {
 220         var publisher = mock(ParticipantMessagePublisher.class);
 221         var cacheProvider = mock(CacheProvider.class);
 222         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 223
 224         assertDoesNotThrow(
 225                 () -> acOutHandler.updateCompositionState(null, null, null, null));
 226         assertDoesNotThrow(() -> acOutHandler.updateCompositionState(UUID.randomUUID(), null,
 227                                 StateChangeResult.NO_ERROR, null));
 228         assertDoesNotThrow(
 229                 () -> acOutHandler.updateCompositionState(UUID.randomUUID(), AcTypeState.PRIMED, null, null));
 230         assertDoesNotThrow(() -> acOutHandler.updateCompositionState(UUID.randomUUID(), AcTypeState.PRIMING,
 231                 StateChangeResult.NO_ERROR, null));
 232         assertDoesNotThrow(() -> acOutHandler.updateCompositionState(UUID.randomUUID(), AcTypeState.DEPRIMING,
 233                 StateChangeResult.NO_ERROR, null));
 234         assertDoesNotThrow(() -> acOutHandler.updateCompositionState(UUID.randomUUID(), AcTypeState.PRIMED,
 235                 StateChangeResult.TIMEOUT, null));
 236
 237         verify(publisher, times(0)).sendParticipantPrimeAck(any());
 238     }
 239
 240     @Test
 241     void updateCompositionStatePrimedTest() {
 242         var cacheProvider = mock(CacheProvider.class);
 243         when(cacheProvider.getParticipantId()).thenReturn(UUID.randomUUID());
 244         var publisher = mock(ParticipantMessagePublisher.class);
 245         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 246         var compositionId = UUID.randomUUID();
 247         acOutHandler.updateCompositionState(compositionId, AcTypeState.PRIMED, StateChangeResult.NO_ERROR, "Primed");
 248         verify(publisher).sendParticipantPrimeAck(any(ParticipantPrimeAck.class));
 249         verify(cacheProvider, times(0)).removeElementDefinition(compositionId);
 250     }
 251
 252     @Test
 253     void updateCompositionStateDeprimingTest() {
 254         var cacheProvider = mock(CacheProvider.class);
 255         when(cacheProvider.getParticipantId()).thenReturn(UUID.randomUUID());
 256         var publisher = mock(ParticipantMessagePublisher.class);
 257         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 258         var compositionId = UUID.randomUUID();
 259         acOutHandler.updateCompositionState(compositionId, AcTypeState.COMMISSIONED, StateChangeResult.NO_ERROR,
 260                 "Deprimed");
 261         verify(publisher).sendParticipantPrimeAck(any(ParticipantPrimeAck.class));
 262         verify(cacheProvider).removeElementDefinition(compositionId);
 263     }
 264
 265     @Test
 266     void sendAcDefinitionInfoTest() {
 267         var cacheProvider = mock(CacheProvider.class);
 268         when(cacheProvider.getParticipantId()).thenReturn(UUID.randomUUID());
 269         var compositionId = UUID.randomUUID();
 270         var elementId = new ToscaConceptIdentifier("code", "1.0.0");
 271         var mapAcElementsDefinitions =
 272                 Map.of(compositionId, Map.of(elementId, new AutomationCompositionElementDefinition()));
 273         when(cacheProvider.getAcElementsDefinitions()).thenReturn(mapAcElementsDefinitions);
 274         var publisher = mock(ParticipantMessagePublisher.class);
 275         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 276
 277         acOutHandler.sendAcDefinitionInfo(null, null, Map.of());
 278         verify(publisher, times(0)).sendParticipantStatus(any(ParticipantStatus.class));
 279
 280         acOutHandler.sendAcDefinitionInfo(UUID.randomUUID(), null, Map.of());
 281         verify(publisher, times(0)).sendParticipantStatus(any(ParticipantStatus.class));
 282
 283         acOutHandler.sendAcDefinitionInfo(compositionId, new ToscaConceptIdentifier("wrong", "1.0.0"), Map.of());
 284         verify(publisher, times(0)).sendParticipantStatus(any(ParticipantStatus.class));
 285
 286         acOutHandler.sendAcDefinitionInfo(compositionId, elementId, Map.of());
 287         verify(publisher).sendParticipantStatus(any(ParticipantStatus.class));
 288     }
 289
 290     @Test
 291     void updateMigrationStatusTest() {
 292         var cacheProvider = mock(CacheProvider.class);
 293         when(cacheProvider.getParticipantId()).thenReturn(UUID.randomUUID());
 294         var publisher = mock(ParticipantMessagePublisher.class);
 295         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 296
 297         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 298         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 299                 .thenReturn(automationComposition);
 300
 301         var compositionTarget = UUID.randomUUID();
 302         automationComposition.setCompositionTargetId(compositionTarget);
 303         automationComposition.setDeployState(DeployState.DEPLOYED);
 304         when(cacheProvider.getAcElementsDefinitions()).thenReturn(Map.of(compositionTarget, Map.of()));
 305
 306         for (var element : automationComposition.getElements().values()) {
 307             acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), element.getId(),
 308                     DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, "");
 309         }
 310         verify(publisher, times(automationComposition.getElements().size()))
 311                 .sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 312         assertEquals(compositionTarget, automationComposition.getCompositionId());
 313     }
 314 }