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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-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.assertFalse;
  25 import static org.junit.jupiter.api.Assertions.assertTrue;
  26 import static org.mockito.ArgumentMatchers.any;
  27 import static org.mockito.Mockito.clearInvocations;
  28 import static org.mockito.Mockito.mock;
  29 import static org.mockito.Mockito.times;
  30 import static org.mockito.Mockito.verify;
  31 import static org.mockito.Mockito.when;
  32
  33 import java.util.List;
  34 import java.util.UUID;
  35 import org.junit.jupiter.api.Test;
  36 import org.onap.policy.clamp.acm.participant.intermediary.comm.ParticipantMessagePublisher;
  37 import org.onap.policy.clamp.acm.participant.intermediary.handler.cache.CacheProvider;
  38 import org.onap.policy.clamp.acm.participant.intermediary.main.parameters.CommonTestData;
  39 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  40 import org.onap.policy.clamp.models.acm.concepts.ParticipantSupportedElementType;
  41 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionDeploy;
  42 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionMigration;
  43 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionPrepare;
  44 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionStateChange;
  45 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantAckMessage;
  46 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantDeregister;
  47 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantDeregisterAck;
  48 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantMessage;
  49 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantMessageType;
  50 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantPrime;
  51 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantRegister;
  52 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantRegisterAck;
  53 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantStatus;
  54 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantStatusReq;
  55 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantSync;
  56 import org.onap.policy.clamp.models.acm.messages.kafka.participant.PropertiesUpdate;
  57 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  58 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
  59
  60 class ParticipantHandlerTest {
  61
  62     @Test
  63     void handleParticipantStatusReqTest() {
  64         var publisher = mock(ParticipantMessagePublisher.class);
  65         when(publisher.isActive()).thenReturn(true);
  66         var cacheProvider = mock(CacheProvider.class);
  67         var msgExecutor = mock(MsgExecutor.class);
  68         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
  69             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class),
  70             publisher, cacheProvider, msgExecutor);
  71         participantHandler.handleParticipantStatusReq(new ParticipantStatusReq());
  72         verify(publisher).sendParticipantRegister(any(ParticipantRegister.class));
  73
  74         when(cacheProvider.isRegistered()).thenReturn(true);
  75         clearInvocations(publisher);
  76         participantHandler.handleParticipantStatusReq(new ParticipantStatusReq());
  77         verify(publisher).sendParticipantStatus(any(ParticipantStatus.class));
  78     }
  79
  80     @Test
  81     void handleAutomationCompositionDeployTest() {
  82         var cacheProvider = mock(CacheProvider.class);
  83         var automationCompositionDeploy = new AutomationCompositionDeploy();
  84         automationCompositionDeploy.setAutomationCompositionId(UUID.randomUUID());
  85         automationCompositionDeploy.setRevisionIdInstance(UUID.randomUUID());
  86         when(cacheProvider.isInstanceUpdated(automationCompositionDeploy.getAutomationCompositionId(),
  87                 automationCompositionDeploy.getRevisionIdInstance())).thenReturn(true);
  88         var acHandler = mock(AutomationCompositionHandler.class);
  89         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
  90         var participantHandler = new ParticipantHandler(acHandler, mock(AcLockHandler.class),
  91                 mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
  92                 cacheProvider, msgExecutor);
  93         participantHandler.handleAutomationCompositionDeploy(automationCompositionDeploy);
  94         verify(acHandler).handleAutomationCompositionDeploy(automationCompositionDeploy);
  95     }
  96
  97     @Test
  98     void handleAutomationCompositionStateChangeTest() {
  99         var acStateChange = new AutomationCompositionStateChange();
 100         acStateChange.setCompositionId(UUID.randomUUID());
 101         acStateChange.setRevisionIdComposition(UUID.randomUUID());
 102         var cacheProvider = mock(CacheProvider.class);
 103         when(cacheProvider.isCompositionDefinitionUpdated(acStateChange.getCompositionId(),
 104                 acStateChange.getRevisionIdComposition())).thenReturn(true);
 105
 106         acStateChange.setDeployOrderedState(DeployOrder.DEPLOY);
 107         acStateChange.setLockOrderedState(LockOrder.NONE);
 108         var acHandler = mock(AutomationCompositionHandler.class);
 109         var acLockHandler = mock(AcLockHandler.class);
 110         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
 111         var participantHandler = new ParticipantHandler(acHandler, acLockHandler, mock(AcSubStateHandler.class),
 112                 mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class), cacheProvider, msgExecutor);
 113         participantHandler.handleAutomationCompositionStateChange(acStateChange);
 114         verify(acHandler).handleAutomationCompositionStateChange(acStateChange);
 115
 116         acStateChange.setDeployOrderedState(DeployOrder.NONE);
 117         acStateChange.setLockOrderedState(LockOrder.LOCK);
 118         participantHandler.handleAutomationCompositionStateChange(acStateChange);
 119         verify(acLockHandler).handleAutomationCompositionStateChange(acStateChange);
 120     }
 121
 122     @Test
 123     void handleAutomationCompositionMigrationTest() {
 124         var cacheProvider = mock(CacheProvider.class);
 125         var migrationMsg = new AutomationCompositionMigration();
 126         migrationMsg.setCompositionId(UUID.randomUUID());
 127         migrationMsg.setRevisionIdComposition(UUID.randomUUID());
 128         when(cacheProvider.isCompositionDefinitionUpdated(migrationMsg.getCompositionId(),
 129                 migrationMsg.getRevisionIdComposition())).thenReturn(true);
 130
 131         migrationMsg.setAutomationCompositionId(UUID.randomUUID());
 132         migrationMsg.setRevisionIdInstance(UUID.randomUUID());
 133         when(cacheProvider.isInstanceUpdated(migrationMsg.getAutomationCompositionId(),
 134                 migrationMsg.getRevisionIdInstance())).thenReturn(true);
 135
 136         migrationMsg.setCompositionTargetId(UUID.randomUUID());
 137         migrationMsg.setRevisionIdCompositionTarget(UUID.randomUUID());
 138         when(cacheProvider.isCompositionDefinitionUpdated(migrationMsg.getCompositionTargetId(),
 139                 migrationMsg.getRevisionIdCompositionTarget())).thenReturn(true);
 140
 141         var acHandler = mock(AutomationCompositionHandler.class);
 142         var acSubStateHandler = mock(AcSubStateHandler.class);
 143         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
 144         var participantHandler = new ParticipantHandler(acHandler, mock(AcLockHandler.class),
 145                 acSubStateHandler, mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
 146                 cacheProvider, msgExecutor);
 147         participantHandler.handleAutomationCompositionMigration(migrationMsg);
 148         verify(acHandler).handleAutomationCompositionMigration(migrationMsg);
 149
 150         migrationMsg.setPrecheck(true);
 151         participantHandler.handleAutomationCompositionMigration(migrationMsg);
 152         verify(acSubStateHandler).handleAcMigrationPrecheck(migrationMsg);
 153     }
 154
 155     @Test
 156     void handleAcPropertyUpdateTest() {
 157         var propertyUpdateMsg = new PropertiesUpdate();
 158         propertyUpdateMsg.setCompositionId(UUID.randomUUID());
 159         propertyUpdateMsg.setRevisionIdComposition(UUID.randomUUID());
 160         var cacheProvider = mock(CacheProvider.class);
 161         when(cacheProvider.isCompositionDefinitionUpdated(propertyUpdateMsg.getCompositionId(),
 162                 propertyUpdateMsg.getRevisionIdComposition())).thenReturn(true);
 163
 164         propertyUpdateMsg.setAutomationCompositionId(UUID.randomUUID());
 165         propertyUpdateMsg.setRevisionIdInstance(UUID.randomUUID());
 166         when(cacheProvider.isInstanceUpdated(propertyUpdateMsg.getAutomationCompositionId(),
 167                 propertyUpdateMsg.getRevisionIdInstance())).thenReturn(true);
 168
 169         var acHandler = mock(AutomationCompositionHandler.class);
 170         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
 171         var participantHandler = new ParticipantHandler(acHandler, mock(AcLockHandler.class),
 172                 mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
 173                 cacheProvider, msgExecutor);
 174         participantHandler.handleAcPropertyUpdate(propertyUpdateMsg);
 175         verify(acHandler).handleAcPropertyUpdate(propertyUpdateMsg);
 176     }
 177
 178     @Test
 179     void sendHandleAutomationCompositionPrepare() {
 180         var acPrepareMsg = new AutomationCompositionPrepare();
 181         acPrepareMsg.setParticipantId(UUID.randomUUID());
 182         acPrepareMsg.setRevisionIdComposition(UUID.randomUUID());
 183         acPrepareMsg.setPreDeploy(false);
 184
 185         var cacheProvider = mock(CacheProvider.class);
 186         var acSubStateHandler = mock(AcSubStateHandler.class);
 187         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
 188         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 189                 mock(AcLockHandler.class), acSubStateHandler, mock(AcDefinitionHandler.class),
 190                 mock(ParticipantMessagePublisher.class), cacheProvider, msgExecutor);
 191
 192         participantHandler.handleAutomationCompositionPrepare(acPrepareMsg);
 193         verify(acSubStateHandler).handleAcPrepare(acPrepareMsg);
 194     }
 195
 196     @Test
 197     void appliesToTest() {
 198         var cacheProvider = mock(CacheProvider.class);
 199         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 200         when(cacheProvider.getReplicaId()).thenReturn(CommonTestData.getReplicaId());
 201         var msgExecutor = mock(MsgExecutor.class);
 202         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 203             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class),
 204             mock(ParticipantMessagePublisher.class), cacheProvider, msgExecutor);
 205
 206         var participantAckMsg = new ParticipantAckMessage(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY);
 207         assertTrue(participantHandler.appliesTo(participantAckMsg));
 208
 209         var participantMsg = new ParticipantMessage(ParticipantMessageType.PARTICIPANT_STATUS);
 210         assertTrue(participantHandler.appliesTo(participantMsg));
 211
 212         participantMsg.setParticipantId(UUID.randomUUID());
 213         assertFalse(participantHandler.appliesTo(participantMsg));
 214     }
 215
 216     @Test
 217     void sendParticipantRegister() {
 218         var publisher = mock(ParticipantMessagePublisher.class);
 219         var cacheProvider = mock(CacheProvider.class);
 220         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 221         when(cacheProvider.getSupportedAcElementTypes()).thenReturn(List.of(new ParticipantSupportedElementType()));
 222         var msgExecutor = mock(MsgExecutor.class);
 223         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 224             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), publisher,
 225             cacheProvider, msgExecutor);
 226
 227         participantHandler.sendParticipantRegister();
 228         verify(publisher).sendParticipantRegister(any(ParticipantRegister.class));
 229     }
 230
 231     @Test
 232     void handleParticipantRegisterAckTest() {
 233         var publisher = mock(ParticipantMessagePublisher.class);
 234         var cacheProvider = mock(CacheProvider.class);
 235         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 236         var msgExecutor = mock(MsgExecutor.class);
 237         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 238             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), publisher,
 239             cacheProvider, msgExecutor);
 240
 241         participantHandler.handleParticipantRegisterAck(new ParticipantRegisterAck());
 242         verify(publisher).sendParticipantStatus(any(ParticipantStatus.class));
 243     }
 244
 245     @Test
 246     void sendParticipantDeregisterTest() {
 247         var publisher = mock(ParticipantMessagePublisher.class);
 248         var cacheProvider = mock(CacheProvider.class);
 249         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 250         var msgExecutor = mock(MsgExecutor.class);
 251         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 252             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), publisher,
 253             cacheProvider, msgExecutor);
 254
 255         participantHandler.sendParticipantDeregister();
 256         verify(publisher).sendParticipantDeregister(any(ParticipantDeregister.class));
 257     }
 258
 259     @Test
 260     void handleParticipantDeregisterAckTest() {
 261         var msgExecutor = mock(MsgExecutor.class);
 262         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 263             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class),
 264             mock(ParticipantMessagePublisher.class), mock(CacheProvider.class), msgExecutor);
 265         var participantDeregisterAck = new ParticipantDeregisterAck();
 266         assertDoesNotThrow(() -> participantHandler.handleParticipantDeregisterAck(participantDeregisterAck));
 267     }
 268
 269     @Test
 270     void handleParticipantPrimeTest() {
 271         var participantPrime = new ParticipantPrime();
 272         participantPrime.setCompositionId(UUID.randomUUID());
 273         participantPrime.setMessageId(UUID.randomUUID());
 274
 275         var acHandler = mock(AcDefinitionHandler.class);
 276         var msgExecutor = mock(MsgExecutor.class);
 277         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 278             mock(AcLockHandler.class), mock(AcSubStateHandler.class), acHandler,
 279             mock(ParticipantMessagePublisher.class), mock(CacheProvider.class), msgExecutor);
 280
 281         participantHandler.handleParticipantPrime(participantPrime);
 282         verify(acHandler).handlePrime(participantPrime);
 283     }
 284
 285     @Test
 286     void handleParticipantRestartTest() {
 287         var participantSyncMsg = new ParticipantSync();
 288         participantSyncMsg.setState(AcTypeState.PRIMED);
 289         participantSyncMsg.setCompositionId(UUID.randomUUID());
 290         participantSyncMsg.setReplicaId(CommonTestData.getReplicaId());
 291
 292         var cacheProvider = mock(CacheProvider.class);
 293         when(cacheProvider.getReplicaId()).thenReturn(CommonTestData.getReplicaId());
 294         var publisher = mock(ParticipantMessagePublisher.class);
 295         var acHandler = mock(AcDefinitionHandler.class);
 296         var msgExecutor = mock(MsgExecutor.class);
 297         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 298             mock(AcLockHandler.class), mock(AcSubStateHandler.class), acHandler, publisher, cacheProvider,
 299             msgExecutor);
 300
 301         participantSyncMsg.getExcludeReplicas().add(cacheProvider.getReplicaId());
 302         participantHandler.handleParticipantSync(participantSyncMsg);
 303         verify(acHandler, times(0)).handleParticipantSync(participantSyncMsg);
 304
 305         participantSyncMsg.getExcludeReplicas().clear();
 306         participantHandler.handleParticipantSync(participantSyncMsg);
 307         verify(acHandler).handleParticipantSync(participantSyncMsg);
 308     }
 309
 310     @Test
 311     void sendHeartbeatTest() {
 312         var cacheProvider = mock(CacheProvider.class);
 313         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 314         when(cacheProvider.isRegistered()).thenReturn(false);
 315         when(cacheProvider.getAutomationCompositions()).thenReturn(CommonTestData.getTestAutomationCompositionMap());
 316         var publisher = mock(ParticipantMessagePublisher.class);
 317         when(publisher.isActive()).thenReturn(true);
 318         var acHandler = mock(AcDefinitionHandler.class);
 319         var msgExecutor = mock(MsgExecutor.class);
 320         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 321             mock(AcLockHandler.class), mock(AcSubStateHandler.class), acHandler, publisher, cacheProvider,
 322             msgExecutor);
 323         participantHandler.sendHeartbeat();
 324         verify(publisher).sendParticipantRegister(any(ParticipantRegister.class));
 325
 326         when(cacheProvider.isRegistered()).thenReturn(true);
 327         clearInvocations(publisher);
 328         participantHandler.sendHeartbeat();
 329         verify(publisher).sendParticipantStatus(any(ParticipantStatus.class));
 330     }
 331 }