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

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