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.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 acOutHandler = new AutomationCompositionOutHandler(mock(ParticipantMessagePublisher.class), cacheProvider);
  53
  54         assertDoesNotThrow(
  55                 () -> acOutHandler.updateAutomationCompositionElementState(null, null, null, null, null, null));
  56
  57         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(UUID.randomUUID(),
  58                 UUID.randomUUID(), null, null, null, null));
  59
  60         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(UUID.randomUUID(),
  61                 UUID.randomUUID(), DeployState.DEPLOYED, null, null, null));
  62
  63         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  64         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  65                 .thenReturn(automationComposition);
  66         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(
  67                 automationComposition.getInstanceId(), UUID.randomUUID(), DeployState.DEPLOYED, null, null, null));
  68
  69         var elementId = automationComposition.getElements().values().iterator().next().getId();
  70         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(
  71                 automationComposition.getInstanceId(), elementId, null, null, null, null));
  72     }
  73
  74     @Test
  75     void updateAutomationCompositionElementStateDeployedTest() {
  76         var publisher = mock(ParticipantMessagePublisher.class);
  77         var cacheProvider = mock(CacheProvider.class);
  78         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
  79
  80         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  81         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  82                 .thenReturn(automationComposition);
  83         var elementId = automationComposition.getElements().values().iterator().next().getId();
  84         acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), elementId,
  85                 DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, "Deployed");
  86         verify(publisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
  87     }
  88
  89     @Test
  90     void updateAutomationCompositionElementStateLockTest() {
  91         var publisher = mock(ParticipantMessagePublisher.class);
  92         var cacheProvider = mock(CacheProvider.class);
  93         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
  94
  95         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  96         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  97                 .thenReturn(automationComposition);
  98         var elementId = automationComposition.getElements().values().iterator().next().getId();
  99         acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), elementId, null,
 100                 LockState.LOCKED, StateChangeResult.NO_ERROR, "Locked");
 101         verify(publisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 102     }
 103
 104     @Test
 105     void updateAutomationCompositionElementStateRestartedTest() {
 106         var publisher = mock(ParticipantMessagePublisher.class);
 107         var cacheProvider = mock(CacheProvider.class);
 108         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 109
 110         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 111         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 112                 .thenReturn(automationComposition);
 113         var element = automationComposition.getElements().values().iterator().next();
 114         element.setRestarting(true);
 115         acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), element.getId(),
 116                 DeployState.DEPLOYED, LockState.LOCKED, StateChangeResult.NO_ERROR, "Restarted");
 117         verify(publisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 118         assertThat(element.getRestarting()).isNull();
 119     }
 120
 121     @Test
 122     void updateAutomationCompositionElementStateDeleteTest() {
 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         for (var element : automationComposition.getElements().values()) {
 131             acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), element.getId(),
 132                     DeployState.DELETED, null, StateChangeResult.NO_ERROR, "Deleted");
 133         }
 134         verify(publisher, times(automationComposition.getElements().size()))
 135                 .sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 136         verify(cacheProvider).removeAutomationComposition(automationComposition.getInstanceId());
 137     }
 138
 139     @Test
 140     void sendAcElementInfoTestNull() {
 141         var publisher = mock(ParticipantMessagePublisher.class);
 142         var cacheProvider = mock(CacheProvider.class);
 143         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 144
 145         assertDoesNotThrow(() -> acOutHandler.sendAcElementInfo(null, null, null, null, null));
 146         assertDoesNotThrow(() -> acOutHandler.sendAcElementInfo(UUID.randomUUID(), null, null, null, null));
 147         assertDoesNotThrow(
 148                 () -> acOutHandler.sendAcElementInfo(UUID.randomUUID(), UUID.randomUUID(), null, null, null));
 149
 150         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 151         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 152                 .thenReturn(automationComposition);
 153         assertDoesNotThrow(() -> acOutHandler.sendAcElementInfo(automationComposition.getInstanceId(),
 154                 UUID.randomUUID(), null, null, null));
 155     }
 156
 157     @Test
 158     void sendAcElementInfoTest() {
 159         var publisher = mock(ParticipantMessagePublisher.class);
 160         var cacheProvider = mock(CacheProvider.class);
 161         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 162
 163         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 164         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 165                 .thenReturn(automationComposition);
 166         var elementId = automationComposition.getElements().values().iterator().next().getId();
 167         acOutHandler.sendAcElementInfo(automationComposition.getInstanceId(), elementId, "", "", Map.of());
 168         verify(publisher).sendParticipantStatus(any(ParticipantStatus.class));
 169     }
 170
 171     @Test
 172     void updateCompositionStatePrimedTest() {
 173         var cacheProvider = mock(CacheProvider.class);
 174         when(cacheProvider.getParticipantId()).thenReturn(UUID.randomUUID());
 175         var publisher = mock(ParticipantMessagePublisher.class);
 176         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 177         var compositionId = UUID.randomUUID();
 178         acOutHandler.updateCompositionState(compositionId, AcTypeState.PRIMED, StateChangeResult.NO_ERROR, "Primed");
 179         verify(publisher).sendParticipantPrimeAck(any(ParticipantPrimeAck.class));
 180         verify(cacheProvider, times(0)).removeElementDefinition(compositionId);
 181     }
 182
 183     @Test
 184     void updateCompositionStateDeprimingTest() {
 185         var cacheProvider = mock(CacheProvider.class);
 186         when(cacheProvider.getParticipantId()).thenReturn(UUID.randomUUID());
 187         var publisher = mock(ParticipantMessagePublisher.class);
 188         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 189         var compositionId = UUID.randomUUID();
 190         acOutHandler.updateCompositionState(compositionId, AcTypeState.COMMISSIONED, StateChangeResult.NO_ERROR,
 191                 "Deprimed");
 192         verify(publisher).sendParticipantPrimeAck(any(ParticipantPrimeAck.class));
 193         verify(cacheProvider).removeElementDefinition(compositionId);
 194     }
 195
 196     @Test
 197     void sendAcDefinitionInfoTest() {
 198         var cacheProvider = mock(CacheProvider.class);
 199         when(cacheProvider.getParticipantId()).thenReturn(UUID.randomUUID());
 200         var compositionId = UUID.randomUUID();
 201         var elementId = new ToscaConceptIdentifier("code", "1.0.0");
 202         var mapAcElementsDefinitions =
 203                 Map.of(compositionId, Map.of(elementId, new AutomationCompositionElementDefinition()));
 204         when(cacheProvider.getAcElementsDefinitions()).thenReturn(mapAcElementsDefinitions);
 205         var publisher = mock(ParticipantMessagePublisher.class);
 206         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 207
 208         acOutHandler.sendAcDefinitionInfo(null, null, Map.of());
 209         verify(publisher, times(0)).sendHeartbeat(any(ParticipantStatus.class));
 210
 211         acOutHandler.sendAcDefinitionInfo(UUID.randomUUID(), null, Map.of());
 212         verify(publisher, times(0)).sendHeartbeat(any(ParticipantStatus.class));
 213
 214         acOutHandler.sendAcDefinitionInfo(compositionId, new ToscaConceptIdentifier("wrong", "1.0.0"), Map.of());
 215         verify(publisher, times(0)).sendHeartbeat(any(ParticipantStatus.class));
 216
 217         acOutHandler.sendAcDefinitionInfo(compositionId, elementId, Map.of());
 218         verify(publisher).sendHeartbeat(any(ParticipantStatus.class));
 219     }
 220
 221     @Test
 222     void updateMigrationStatusTest() {
 223         var cacheProvider = mock(CacheProvider.class);
 224         when(cacheProvider.getParticipantId()).thenReturn(UUID.randomUUID());
 225         var publisher = mock(ParticipantMessagePublisher.class);
 226         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 227
 228         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 229         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 230                 .thenReturn(automationComposition);
 231
 232         var compositionTarget = UUID.randomUUID();
 233         automationComposition.setCompositionTargetId(compositionTarget);
 234         automationComposition.setDeployState(DeployState.DEPLOYED);
 235         when(cacheProvider.getAcElementsDefinitions()).thenReturn(Map.of(compositionTarget, Map.of()));
 236
 237         for (var element : automationComposition.getElements().values()) {
 238             acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), element.getId(),
 239                     DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, "");
 240         }
 241         verify(publisher, times(automationComposition.getElements().size()))
 242                 .sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 243         assertEquals(compositionTarget, automationComposition.getCompositionId());
 244     }
 245 }