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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 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.assertj.core.api.Assertions.assertThat;
  24 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
  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.DeployState;
  38 import org.onap.policy.clamp.models.acm.concepts.LockState;
  39 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  40 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeployAck;
  41 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantPrimeAck;
  42 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantStatus;
  43
  44 class AutomationCompositionOutHandlerTest {
  45
  46     @Test
  47     void updateAutomationCompositionElementStateNullTest() {
  48         var cacheProvider = mock(CacheProvider.class);
  49         var acOutHandler = new AutomationCompositionOutHandler(mock(ParticipantMessagePublisher.class), cacheProvider);
  50
  51         assertDoesNotThrow(
  52                 () -> acOutHandler.updateAutomationCompositionElementState(null, null, null, null, null, null));
  53
  54         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(UUID.randomUUID(),
  55                 UUID.randomUUID(), null, null, null, null));
  56
  57         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(UUID.randomUUID(),
  58                 UUID.randomUUID(), DeployState.DEPLOYED, null, null, null));
  59
  60         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  61         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  62                 .thenReturn(automationComposition);
  63         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(
  64                 automationComposition.getInstanceId(), UUID.randomUUID(), DeployState.DEPLOYED, null, null, null));
  65
  66         var elementId = automationComposition.getElements().values().iterator().next().getId();
  67         assertDoesNotThrow(() -> acOutHandler.updateAutomationCompositionElementState(
  68                 automationComposition.getInstanceId(), elementId, null, null, null, null));
  69     }
  70
  71     @Test
  72     void updateAutomationCompositionElementStateDeployedTest() {
  73         var publisher = mock(ParticipantMessagePublisher.class);
  74         var cacheProvider = mock(CacheProvider.class);
  75         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
  76
  77         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  78         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  79                 .thenReturn(automationComposition);
  80         var elementId = automationComposition.getElements().values().iterator().next().getId();
  81         acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), elementId,
  82                 DeployState.DEPLOYED, null, StateChangeResult.NO_ERROR, "Deployed");
  83         verify(publisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
  84     }
  85
  86     @Test
  87     void updateAutomationCompositionElementStateLockTest() {
  88         var publisher = mock(ParticipantMessagePublisher.class);
  89         var cacheProvider = mock(CacheProvider.class);
  90         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
  91
  92         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
  93         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
  94                 .thenReturn(automationComposition);
  95         var elementId = automationComposition.getElements().values().iterator().next().getId();
  96         acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), elementId, null,
  97                 LockState.LOCKED, StateChangeResult.NO_ERROR, "Locked");
  98         verify(publisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
  99     }
 100
 101     @Test
 102     void updateAutomationCompositionElementStateRestartedTest() {
 103         var publisher = mock(ParticipantMessagePublisher.class);
 104         var cacheProvider = mock(CacheProvider.class);
 105         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 106
 107         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 108         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 109                 .thenReturn(automationComposition);
 110         var element = automationComposition.getElements().values().iterator().next();
 111         element.setRestarting(true);
 112         acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), element.getId(),
 113                 DeployState.DEPLOYED, LockState.LOCKED, StateChangeResult.NO_ERROR, "Restarted");
 114         verify(publisher).sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 115         assertThat(element.getRestarting()).isNull();
 116     }
 117
 118     @Test
 119     void updateAutomationCompositionElementStateDeleteTest() {
 120         var publisher = mock(ParticipantMessagePublisher.class);
 121         var cacheProvider = mock(CacheProvider.class);
 122         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 123
 124         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 125         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 126                 .thenReturn(automationComposition);
 127         for (var element : automationComposition.getElements().values()) {
 128             acOutHandler.updateAutomationCompositionElementState(automationComposition.getInstanceId(), element.getId(),
 129                     DeployState.DELETED, null, StateChangeResult.NO_ERROR, "Deleted");
 130         }
 131         verify(publisher, times(automationComposition.getElements().size()))
 132                 .sendAutomationCompositionAck(any(AutomationCompositionDeployAck.class));
 133         verify(cacheProvider).removeAutomationComposition(automationComposition.getInstanceId());
 134     }
 135
 136     @Test
 137     void sendAcElementInfoTestNull() {
 138         var publisher = mock(ParticipantMessagePublisher.class);
 139         var cacheProvider = mock(CacheProvider.class);
 140         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 141
 142         assertDoesNotThrow(() -> acOutHandler.sendAcElementInfo(null, null, null, null, null));
 143         assertDoesNotThrow(() -> acOutHandler.sendAcElementInfo(UUID.randomUUID(), null, null, null, null));
 144         assertDoesNotThrow(
 145                 () -> acOutHandler.sendAcElementInfo(UUID.randomUUID(), UUID.randomUUID(), null, null, null));
 146
 147         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 148         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 149                 .thenReturn(automationComposition);
 150         assertDoesNotThrow(() -> acOutHandler.sendAcElementInfo(automationComposition.getInstanceId(),
 151                 UUID.randomUUID(), null, null, null));
 152     }
 153
 154     @Test
 155     void sendAcElementInfoTest() {
 156         var publisher = mock(ParticipantMessagePublisher.class);
 157         var cacheProvider = mock(CacheProvider.class);
 158         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 159
 160         var automationComposition = CommonTestData.getTestAutomationCompositionMap().values().iterator().next();
 161         when(cacheProvider.getAutomationComposition(automationComposition.getInstanceId()))
 162                 .thenReturn(automationComposition);
 163         var elementId = automationComposition.getElements().values().iterator().next().getId();
 164         acOutHandler.sendAcElementInfo(automationComposition.getInstanceId(), elementId, "", "", Map.of());
 165         verify(publisher).sendParticipantStatus(any(ParticipantStatus.class));
 166     }
 167
 168     @Test
 169     void updateCompositionStatePrimedTest() {
 170         var cacheProvider = mock(CacheProvider.class);
 171         when(cacheProvider.getParticipantId()).thenReturn(UUID.randomUUID());
 172         var publisher = mock(ParticipantMessagePublisher.class);
 173         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 174         var compositionId = UUID.randomUUID();
 175         acOutHandler.updateCompositionState(compositionId, AcTypeState.PRIMED, StateChangeResult.NO_ERROR,
 176                 "Primed");
 177         verify(publisher).sendParticipantPrimeAck(any(ParticipantPrimeAck.class));
 178         verify(cacheProvider, times(0)).removeElementDefinition(compositionId);
 179     }
 180
 181     @Test
 182     void updateCompositionStateDeprimingTest() {
 183         var cacheProvider = mock(CacheProvider.class);
 184         when(cacheProvider.getParticipantId()).thenReturn(UUID.randomUUID());
 185         var publisher = mock(ParticipantMessagePublisher.class);
 186         var acOutHandler = new AutomationCompositionOutHandler(publisher, cacheProvider);
 187         var compositionId = UUID.randomUUID();
 188         acOutHandler.updateCompositionState(compositionId, AcTypeState.COMMISSIONED, StateChangeResult.NO_ERROR,
 189                 "Deprimed");
 190         verify(publisher).sendParticipantPrimeAck(any(ParticipantPrimeAck.class));
 191         verify(cacheProvider).removeElementDefinition(compositionId);
 192     }
 193 }