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