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.AcElementDeploy;
  40 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  41 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  42 import org.onap.policy.clamp.models.acm.concepts.MigrationState;
  43 import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
  44 import org.onap.policy.clamp.models.acm.concepts.ParticipantSupportedElementType;
  45 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionDeploy;
  46 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionMigration;
  47 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionPrepare;
  48 import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionStateChange;
  49 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantAckMessage;
  50 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantDeregister;
  51 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantDeregisterAck;
  52 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantMessage;
  53 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantMessageType;
  54 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantPrime;
  55 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantRegister;
  56 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantRegisterAck;
  57 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantStatus;
  58 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantStatusReq;
  59 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantSync;
  60 import org.onap.policy.clamp.models.acm.messages.kafka.participant.PropertiesUpdate;
  61 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
  62 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.LockOrder;
  63
  64 class ParticipantHandlerTest {
  65
  66     @Test
  67     void handleParticipantStatusReqTest() {
  68         var publisher = mock(ParticipantMessagePublisher.class);
  69         when(publisher.isActive()).thenReturn(true);
  70         var cacheProvider = mock(CacheProvider.class);
  71         var msgExecutor = mock(MsgExecutor.class);
  72         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
  73             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class),
  74             publisher, cacheProvider, msgExecutor);
  75         participantHandler.handleParticipantStatusReq(new ParticipantStatusReq());
  76         verify(publisher).sendParticipantRegister(any(ParticipantRegister.class));
  77
  78         when(cacheProvider.isRegistered()).thenReturn(true);
  79         clearInvocations(publisher);
  80         participantHandler.handleParticipantStatusReq(new ParticipantStatusReq());
  81         verify(publisher).sendParticipantStatus(any(ParticipantStatus.class));
  82     }
  83
  84     @Test
  85     void handleAutomationCompositionDeployTest() {
  86         var cacheProvider = mock(CacheProvider.class);
  87         var automationCompositionDeploy = new AutomationCompositionDeploy();
  88         automationCompositionDeploy.setAutomationCompositionId(UUID.randomUUID());
  89         automationCompositionDeploy.setRevisionIdInstance(UUID.randomUUID());
  90         when(cacheProvider.isInstanceUpdated(automationCompositionDeploy.getAutomationCompositionId(),
  91                 automationCompositionDeploy.getRevisionIdInstance())).thenReturn(true);
  92         var acHandler = mock(AutomationCompositionHandler.class);
  93         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
  94         var participantHandler = new ParticipantHandler(acHandler, mock(AcLockHandler.class),
  95                 mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
  96                 cacheProvider, msgExecutor);
  97         participantHandler.handleAutomationCompositionDeploy(automationCompositionDeploy);
  98         verify(acHandler).handleAutomationCompositionDeploy(automationCompositionDeploy);
  99     }
 100
 101     @Test
 102     void handleAutomationCompositionStateChangeTest() {
 103         var acStateChange = new AutomationCompositionStateChange();
 104         acStateChange.setCompositionId(UUID.randomUUID());
 105         acStateChange.setRevisionIdComposition(UUID.randomUUID());
 106         var cacheProvider = mock(CacheProvider.class);
 107         when(cacheProvider.isCompositionDefinitionUpdated(acStateChange.getCompositionId(),
 108                 acStateChange.getRevisionIdComposition())).thenReturn(true);
 109
 110         acStateChange.setDeployOrderedState(DeployOrder.DEPLOY);
 111         acStateChange.setLockOrderedState(LockOrder.NONE);
 112         var acHandler = mock(AutomationCompositionHandler.class);
 113         var acLockHandler = mock(AcLockHandler.class);
 114         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
 115         var participantHandler = new ParticipantHandler(acHandler, acLockHandler, mock(AcSubStateHandler.class),
 116                 mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class), cacheProvider, msgExecutor);
 117         participantHandler.handleAutomationCompositionStateChange(acStateChange);
 118         verify(acHandler).handleAutomationCompositionStateChange(acStateChange);
 119
 120         acStateChange.setDeployOrderedState(DeployOrder.NONE);
 121         acStateChange.setLockOrderedState(LockOrder.LOCK);
 122         participantHandler.handleAutomationCompositionStateChange(acStateChange);
 123         verify(acLockHandler).handleAutomationCompositionStateChange(acStateChange);
 124     }
 125
 126     @Test
 127     void handleMigrationAddTest() {
 128         var migrationMsg = new AutomationCompositionMigration();
 129         migrationMsg.setCompositionId(UUID.randomUUID());
 130         migrationMsg.setRevisionIdComposition(UUID.randomUUID());
 131         migrationMsg.setAutomationCompositionId(UUID.randomUUID());
 132         migrationMsg.setRevisionIdInstance(UUID.randomUUID());
 133
 134         migrationMsg.setCompositionTargetId(UUID.randomUUID());
 135         migrationMsg.setRevisionIdCompositionTarget(UUID.randomUUID());
 136         var cacheProvider = mock(CacheProvider.class);
 137         when(cacheProvider.isCompositionDefinitionUpdated(migrationMsg.getCompositionTargetId(),
 138                 migrationMsg.getRevisionIdCompositionTarget())).thenReturn(true);
 139
 140         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 141         var participantDeploy = new ParticipantDeploy();
 142         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 143         var acElementDeploy = new AcElementDeploy();
 144         acElementDeploy.setMigrationState(MigrationState.NEW);
 145         participantDeploy.setAcElementList(List.of(acElementDeploy));
 146         migrationMsg.setParticipantUpdatesList(List.of(participantDeploy));
 147
 148         var acHandler = mock(AutomationCompositionHandler.class);
 149         var acSubStateHandler = mock(AcSubStateHandler.class);
 150         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
 151         var participantHandler = new ParticipantHandler(acHandler, mock(AcLockHandler.class),
 152                 acSubStateHandler, mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
 153                 cacheProvider, msgExecutor);
 154         participantHandler.handleAutomationCompositionMigration(migrationMsg);
 155         verify(acHandler).handleAutomationCompositionMigration(migrationMsg);
 156         verify(cacheProvider).initializeAutomationComposition(any(), any());
 157
 158         clearInvocations(acHandler, cacheProvider);
 159         migrationMsg.setRollback(true);
 160         var automationComposition = new AutomationComposition();
 161         automationComposition.setInstanceId(migrationMsg.getAutomationCompositionId());
 162         when(cacheProvider.getAutomationComposition(migrationMsg.getAutomationCompositionId()))
 163                 .thenReturn(automationComposition);
 164         participantHandler.handleAutomationCompositionMigration(migrationMsg);
 165         verify(acHandler).handleAutomationCompositionMigration(migrationMsg);
 166         verify(cacheProvider).initializeAutomationComposition(any(), any());
 167
 168         clearInvocations(acHandler, cacheProvider);
 169         automationComposition.setRevisionId(migrationMsg.getRevisionIdInstance());
 170         when(cacheProvider.getAutomationComposition(migrationMsg.getAutomationCompositionId()))
 171                 .thenReturn(automationComposition);
 172         participantHandler.handleAutomationCompositionMigration(migrationMsg);
 173         verify(acHandler).handleAutomationCompositionMigration(migrationMsg);
 174         verify(cacheProvider, times(0)).initializeAutomationComposition(any(), any());
 175     }
 176
 177     @Test
 178     void handleMigrationRemovedTest() {
 179         var migrationMsg = new AutomationCompositionMigration();
 180         migrationMsg.setCompositionId(UUID.randomUUID());
 181         migrationMsg.setRevisionIdComposition(UUID.randomUUID());
 182         var cacheProvider = mock(CacheProvider.class);
 183         when(cacheProvider.isCompositionDefinitionUpdated(migrationMsg.getCompositionId(),
 184                 migrationMsg.getRevisionIdComposition())).thenReturn(true);
 185
 186         migrationMsg.setAutomationCompositionId(UUID.randomUUID());
 187         migrationMsg.setRevisionIdInstance(UUID.randomUUID());
 188         when(cacheProvider.isInstanceUpdated(migrationMsg.getAutomationCompositionId(),
 189                 migrationMsg.getRevisionIdInstance())).thenReturn(true);
 190
 191         migrationMsg.setCompositionTargetId(UUID.randomUUID());
 192         migrationMsg.setRevisionIdCompositionTarget(UUID.randomUUID());
 193
 194         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 195         var participantDeploy = new ParticipantDeploy();
 196         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 197         var acElementDeploy = new AcElementDeploy();
 198         acElementDeploy.setMigrationState(MigrationState.REMOVED);
 199         participantDeploy.setAcElementList(List.of(acElementDeploy));
 200         migrationMsg.setParticipantUpdatesList(List.of(participantDeploy));
 201
 202         var acHandler = mock(AutomationCompositionHandler.class);
 203         var acSubStateHandler = mock(AcSubStateHandler.class);
 204         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
 205         var participantHandler = new ParticipantHandler(acHandler, mock(AcLockHandler.class),
 206                 acSubStateHandler, mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
 207                 cacheProvider, msgExecutor);
 208         participantHandler.handleAutomationCompositionMigration(migrationMsg);
 209         verify(acHandler).handleAutomationCompositionMigration(migrationMsg);
 210     }
 211
 212     @Test
 213     void handleAutomationCompositionMigrationTest() {
 214         var cacheProvider = mock(CacheProvider.class);
 215         var migrationMsg = new AutomationCompositionMigration();
 216         migrationMsg.setCompositionId(UUID.randomUUID());
 217         migrationMsg.setRevisionIdComposition(UUID.randomUUID());
 218         when(cacheProvider.isCompositionDefinitionUpdated(migrationMsg.getCompositionId(),
 219                 migrationMsg.getRevisionIdComposition())).thenReturn(true);
 220
 221         migrationMsg.setAutomationCompositionId(UUID.randomUUID());
 222         migrationMsg.setRevisionIdInstance(UUID.randomUUID());
 223         when(cacheProvider.isInstanceUpdated(migrationMsg.getAutomationCompositionId(),
 224                 migrationMsg.getRevisionIdInstance())).thenReturn(true);
 225
 226         migrationMsg.setCompositionTargetId(UUID.randomUUID());
 227         migrationMsg.setRevisionIdCompositionTarget(UUID.randomUUID());
 228         when(cacheProvider.isCompositionDefinitionUpdated(migrationMsg.getCompositionTargetId(),
 229                 migrationMsg.getRevisionIdCompositionTarget())).thenReturn(true);
 230
 231         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 232         var participantDeploy = new ParticipantDeploy();
 233         participantDeploy.setParticipantId(CommonTestData.getParticipantId());
 234         var acElementDeploy = new AcElementDeploy();
 235         acElementDeploy.setMigrationState(MigrationState.DEFAULT);
 236         participantDeploy.setAcElementList(List.of(acElementDeploy));
 237         var participantDeploy2 = new ParticipantDeploy();
 238         participantDeploy2.setParticipantId(UUID.randomUUID());
 239         migrationMsg.setParticipantUpdatesList(List.of(participantDeploy, participantDeploy2));
 240
 241         var acHandler = mock(AutomationCompositionHandler.class);
 242         var acSubStateHandler = mock(AcSubStateHandler.class);
 243         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
 244         var participantHandler = new ParticipantHandler(acHandler, mock(AcLockHandler.class),
 245                 acSubStateHandler, mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
 246                 cacheProvider, msgExecutor);
 247         participantHandler.handleAutomationCompositionMigration(migrationMsg);
 248         verify(acHandler).handleAutomationCompositionMigration(migrationMsg);
 249
 250         migrationMsg.setPrecheck(true);
 251         participantHandler.handleAutomationCompositionMigration(migrationMsg);
 252         verify(acSubStateHandler).handleAcMigrationPrecheck(migrationMsg);
 253     }
 254
 255     @Test
 256     void handleAcPropertyUpdateTest() {
 257         var propertyUpdateMsg = new PropertiesUpdate();
 258         propertyUpdateMsg.setCompositionId(UUID.randomUUID());
 259         propertyUpdateMsg.setRevisionIdComposition(UUID.randomUUID());
 260         var cacheProvider = mock(CacheProvider.class);
 261         when(cacheProvider.isCompositionDefinitionUpdated(propertyUpdateMsg.getCompositionId(),
 262                 propertyUpdateMsg.getRevisionIdComposition())).thenReturn(true);
 263
 264         propertyUpdateMsg.setAutomationCompositionId(UUID.randomUUID());
 265         propertyUpdateMsg.setRevisionIdInstance(UUID.randomUUID());
 266         when(cacheProvider.isInstanceUpdated(propertyUpdateMsg.getAutomationCompositionId(),
 267                 propertyUpdateMsg.getRevisionIdInstance())).thenReturn(true);
 268
 269         var acHandler = mock(AutomationCompositionHandler.class);
 270         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
 271         var participantHandler = new ParticipantHandler(acHandler, mock(AcLockHandler.class),
 272                 mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), mock(ParticipantMessagePublisher.class),
 273                 cacheProvider, msgExecutor);
 274         participantHandler.handleAcPropertyUpdate(propertyUpdateMsg);
 275         verify(acHandler).handleAcPropertyUpdate(propertyUpdateMsg);
 276     }
 277
 278     @Test
 279     void sendHandleAutomationCompositionPrepare() {
 280         var acPrepareMsg = new AutomationCompositionPrepare();
 281         acPrepareMsg.setParticipantId(UUID.randomUUID());
 282         acPrepareMsg.setRevisionIdComposition(UUID.randomUUID());
 283         acPrepareMsg.setPreDeploy(false);
 284
 285         var cacheProvider = mock(CacheProvider.class);
 286         var acSubStateHandler = mock(AcSubStateHandler.class);
 287         var msgExecutor = new MsgExecutor(cacheProvider, mock(ParticipantMessagePublisher.class));
 288         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 289                 mock(AcLockHandler.class), acSubStateHandler, mock(AcDefinitionHandler.class),
 290                 mock(ParticipantMessagePublisher.class), cacheProvider, msgExecutor);
 291
 292         participantHandler.handleAutomationCompositionPrepare(acPrepareMsg);
 293         verify(acSubStateHandler).handleAcPrepare(acPrepareMsg);
 294     }
 295
 296     @Test
 297     void appliesToTest() {
 298         var cacheProvider = mock(CacheProvider.class);
 299         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 300         when(cacheProvider.getReplicaId()).thenReturn(CommonTestData.getReplicaId());
 301         var msgExecutor = mock(MsgExecutor.class);
 302         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 303             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class),
 304             mock(ParticipantMessagePublisher.class), cacheProvider, msgExecutor);
 305
 306         var participantAckMsg = new ParticipantAckMessage(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY);
 307         assertTrue(participantHandler.appliesTo(participantAckMsg));
 308
 309         var participantMsg = new ParticipantMessage(ParticipantMessageType.PARTICIPANT_STATUS);
 310         assertTrue(participantHandler.appliesTo(participantMsg));
 311
 312         participantMsg.setParticipantId(UUID.randomUUID());
 313         assertFalse(participantHandler.appliesTo(participantMsg));
 314     }
 315
 316     @Test
 317     void sendParticipantRegister() {
 318         var publisher = mock(ParticipantMessagePublisher.class);
 319         var cacheProvider = mock(CacheProvider.class);
 320         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 321         when(cacheProvider.getSupportedAcElementTypes()).thenReturn(List.of(new ParticipantSupportedElementType()));
 322         var msgExecutor = mock(MsgExecutor.class);
 323         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 324             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), publisher,
 325             cacheProvider, msgExecutor);
 326
 327         participantHandler.sendParticipantRegister();
 328         verify(publisher).sendParticipantRegister(any(ParticipantRegister.class));
 329     }
 330
 331     @Test
 332     void handleParticipantRegisterAckTest() {
 333         var publisher = mock(ParticipantMessagePublisher.class);
 334         var cacheProvider = mock(CacheProvider.class);
 335         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 336         var msgExecutor = mock(MsgExecutor.class);
 337         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 338             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), publisher,
 339             cacheProvider, msgExecutor);
 340
 341         participantHandler.handleParticipantRegisterAck(new ParticipantRegisterAck());
 342         verify(publisher).sendParticipantStatus(any(ParticipantStatus.class));
 343     }
 344
 345     @Test
 346     void sendParticipantDeregisterTest() {
 347         var publisher = mock(ParticipantMessagePublisher.class);
 348         var cacheProvider = mock(CacheProvider.class);
 349         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 350         var msgExecutor = mock(MsgExecutor.class);
 351         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 352             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class), publisher,
 353             cacheProvider, msgExecutor);
 354
 355         participantHandler.sendParticipantDeregister();
 356         verify(publisher).sendParticipantDeregister(any(ParticipantDeregister.class));
 357     }
 358
 359     @Test
 360     void handleParticipantDeregisterAckTest() {
 361         var msgExecutor = mock(MsgExecutor.class);
 362         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 363             mock(AcLockHandler.class), mock(AcSubStateHandler.class), mock(AcDefinitionHandler.class),
 364             mock(ParticipantMessagePublisher.class), mock(CacheProvider.class), msgExecutor);
 365         var participantDeregisterAck = new ParticipantDeregisterAck();
 366         assertDoesNotThrow(() -> participantHandler.handleParticipantDeregisterAck(participantDeregisterAck));
 367     }
 368
 369     @Test
 370     void handleParticipantPrimeTest() {
 371         var participantPrime = new ParticipantPrime();
 372         participantPrime.setCompositionId(UUID.randomUUID());
 373         participantPrime.setMessageId(UUID.randomUUID());
 374
 375         var acHandler = mock(AcDefinitionHandler.class);
 376         var msgExecutor = mock(MsgExecutor.class);
 377         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 378             mock(AcLockHandler.class), mock(AcSubStateHandler.class), acHandler,
 379             mock(ParticipantMessagePublisher.class), mock(CacheProvider.class), msgExecutor);
 380
 381         participantHandler.handleParticipantPrime(participantPrime);
 382         verify(acHandler).handlePrime(participantPrime);
 383     }
 384
 385     @Test
 386     void handleParticipantRestartTest() {
 387         var participantSyncMsg = new ParticipantSync();
 388         participantSyncMsg.setState(AcTypeState.PRIMED);
 389         participantSyncMsg.setCompositionId(UUID.randomUUID());
 390         participantSyncMsg.setReplicaId(CommonTestData.getReplicaId());
 391
 392         var cacheProvider = mock(CacheProvider.class);
 393         when(cacheProvider.getReplicaId()).thenReturn(CommonTestData.getReplicaId());
 394         var publisher = mock(ParticipantMessagePublisher.class);
 395         var acHandler = mock(AcDefinitionHandler.class);
 396         var msgExecutor = mock(MsgExecutor.class);
 397         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 398             mock(AcLockHandler.class), mock(AcSubStateHandler.class), acHandler, publisher, cacheProvider,
 399             msgExecutor);
 400
 401         participantSyncMsg.getExcludeReplicas().add(cacheProvider.getReplicaId());
 402         participantHandler.handleParticipantSync(participantSyncMsg);
 403         verify(acHandler, times(0)).handleParticipantSync(participantSyncMsg);
 404
 405         participantSyncMsg.getExcludeReplicas().clear();
 406         participantHandler.handleParticipantSync(participantSyncMsg);
 407         verify(acHandler).handleParticipantSync(participantSyncMsg);
 408     }
 409
 410     @Test
 411     void sendHeartbeatTest() {
 412         var cacheProvider = mock(CacheProvider.class);
 413         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 414         when(cacheProvider.isRegistered()).thenReturn(false);
 415         when(cacheProvider.getAutomationCompositions()).thenReturn(CommonTestData.getTestAutomationCompositionMap());
 416         var publisher = mock(ParticipantMessagePublisher.class);
 417         when(publisher.isActive()).thenReturn(true);
 418         var acHandler = mock(AcDefinitionHandler.class);
 419         var msgExecutor = mock(MsgExecutor.class);
 420         var participantHandler = new ParticipantHandler(mock(AutomationCompositionHandler.class),
 421             mock(AcLockHandler.class), mock(AcSubStateHandler.class), acHandler, publisher, cacheProvider,
 422             msgExecutor);
 423         participantHandler.sendHeartbeat();
 424         verify(publisher).sendParticipantRegister(any(ParticipantRegister.class));
 425
 426         when(cacheProvider.isRegistered()).thenReturn(true);
 427         clearInvocations(publisher);
 428         participantHandler.sendHeartbeat();
 429         verify(publisher).sendParticipantStatus(any(ParticipantStatus.class));
 430     }
 431 }