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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2024-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.mockito.ArgumentMatchers.any;
  24 import static org.mockito.ArgumentMatchers.anyList;
  25 import static org.mockito.Mockito.mock;
  26 import static org.mockito.Mockito.verify;
  27 import static org.mockito.Mockito.when;
  28
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.UUID;
  32 import org.junit.jupiter.api.Test;
  33 import org.onap.policy.clamp.acm.participant.intermediary.api.CompositionDto;
  34 import org.onap.policy.clamp.acm.participant.intermediary.comm.ParticipantMessagePublisher;
  35 import org.onap.policy.clamp.acm.participant.intermediary.handler.cache.AcDefinition;
  36 import org.onap.policy.clamp.acm.participant.intermediary.handler.cache.CacheProvider;
  37 import org.onap.policy.clamp.acm.participant.intermediary.main.parameters.CommonTestData;
  38 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  39 import org.onap.policy.clamp.models.acm.concepts.ParticipantDefinition;
  40 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  41 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantPrime;
  42 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantPrimeAck;
  43 import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantSync;
  44 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  45
  46 class AcDefinitionHandlerTest {
  47
  48     @Test
  49     void handleCompositionPrimeTest() {
  50         var cacheProvider = mock(CacheProvider.class);
  51         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
  52         var participantPrimeMsg = new ParticipantPrime();
  53         participantPrimeMsg.setCompositionId(UUID.randomUUID());
  54         participantPrimeMsg.setRevisionIdComposition(UUID.randomUUID());
  55         participantPrimeMsg.setParticipantDefinitionUpdates(List.of(createParticipantDefinition()));
  56         var listener = mock(ThreadHandler.class);
  57         var ach = new AcDefinitionHandler(cacheProvider, mock(ParticipantMessagePublisher.class), listener);
  58         ach.handlePrime(participantPrimeMsg);
  59         verify(cacheProvider).addElementDefinition(any(UUID.class), anyList(), any(UUID.class));
  60         verify(listener).prime(any(UUID.class), any(CompositionDto.class));
  61     }
  62
  63     private ParticipantDefinition createParticipantDefinition() {
  64         var def = new ParticipantDefinition();
  65         def.setParticipantId(CommonTestData.getParticipantId());
  66         def.setAutomationCompositionElementDefinitionList(
  67                 List.of(CommonTestData.createAutomationCompositionElementDefinition(
  68                         new ToscaConceptIdentifier("key", "1.0.0"))));
  69         return def;
  70     }
  71
  72     @Test
  73     void handleCompositionDeprimeTest() {
  74         var acElementDefinition = CommonTestData.createAutomationCompositionElementDefinition(
  75                 new ToscaConceptIdentifier("key", "1.0.0"));
  76         var acDefinition = new AcDefinition();
  77         var compositionId = UUID.randomUUID();
  78         acDefinition.setCompositionId(compositionId);
  79         acDefinition.getElements().put(acElementDefinition.getAcElementDefinitionId(), acElementDefinition);
  80
  81         var listener = mock(ThreadHandler.class);
  82         var cacheProvider = mock(CacheProvider.class);
  83         var ach = new AcDefinitionHandler(cacheProvider, mock(ParticipantMessagePublisher.class), listener);
  84         when(cacheProvider.getAcElementsDefinitions()).thenReturn(Map.of(compositionId, acDefinition));
  85         var participantPrimeMsg = new ParticipantPrime();
  86         participantPrimeMsg.setCompositionId(compositionId);
  87         ach.handlePrime(participantPrimeMsg);
  88         verify(listener).deprime(any(UUID.class), any(CompositionDto.class));
  89     }
  90
  91     @Test
  92     void handleCompositionAlreadyDeprimedTest() {
  93         var compositionId = UUID.randomUUID();
  94         var participantMessagePublisher =  mock(ParticipantMessagePublisher.class);
  95         var ach = new AcDefinitionHandler(mock(CacheProvider.class), participantMessagePublisher,
  96                 mock(ThreadHandler.class));
  97         var participantPrimeMsg = new ParticipantPrime();
  98         participantPrimeMsg.setCompositionId(compositionId);
  99         ach.handlePrime(participantPrimeMsg);
 100         verify(participantMessagePublisher).sendParticipantPrimeAck(any(ParticipantPrimeAck.class));
 101     }
 102
 103     @Test
 104     void syncTest() {
 105         var participantSyncMsg = new ParticipantSync();
 106         participantSyncMsg.setState(AcTypeState.PRIMED);
 107         participantSyncMsg.setCompositionId(UUID.randomUUID());
 108         participantSyncMsg.getParticipantDefinitionUpdates().add(createParticipantDefinition());
 109         participantSyncMsg.setAutomationcompositionList(List.of(CommonTestData.createParticipantRestartAc()));
 110         participantSyncMsg.setRevisionIdComposition(UUID.randomUUID());
 111         participantSyncMsg.setRevisionIdInstance(UUID.randomUUID());
 112
 113         var cacheProvider = mock(CacheProvider.class);
 114         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 115         var listener = mock(ThreadHandler.class);
 116         var ach = new AcDefinitionHandler(cacheProvider, mock(ParticipantMessagePublisher.class), listener);
 117         ach.handleParticipantSync(participantSyncMsg);
 118         verify(cacheProvider).initializeAutomationComposition(any(UUID.class), any());
 119         verify(cacheProvider).addElementDefinition(any(UUID.class), any(), any(UUID.class));
 120     }
 121
 122     @Test
 123     void syncCompositionDefinitionTimeout() {
 124         var participantSyncMsg = new ParticipantSync();
 125         participantSyncMsg.setState(AcTypeState.PRIMED);
 126         participantSyncMsg.setStateChangeResult(StateChangeResult.TIMEOUT);
 127         participantSyncMsg.setCompositionId(UUID.randomUUID());
 128         participantSyncMsg.getParticipantDefinitionUpdates().add(createParticipantDefinition());
 129         participantSyncMsg.setRevisionIdComposition(UUID.randomUUID());
 130         participantSyncMsg.setRevisionIdInstance(UUID.randomUUID());
 131         var participantRestartAc = CommonTestData.createParticipantRestartAc();
 132         participantRestartAc.setStateChangeResult(StateChangeResult.TIMEOUT);
 133         participantSyncMsg.setAutomationcompositionList(List.of(participantRestartAc));
 134
 135         var cacheProvider = mock(CacheProvider.class);
 136         when(cacheProvider.getParticipantId()).thenReturn(CommonTestData.getParticipantId());
 137         var listener = mock(ThreadHandler.class);
 138         var ach = new AcDefinitionHandler(cacheProvider, mock(ParticipantMessagePublisher.class), listener);
 139         ach.handleParticipantSync(participantSyncMsg);
 140         verify(cacheProvider).initializeAutomationComposition(any(UUID.class), any());
 141         verify(cacheProvider).addElementDefinition(any(UUID.class), any(), any(UUID.class));
 142         verify(listener).cleanExecution(participantSyncMsg.getCompositionId(), participantSyncMsg.getMessageId());
 143         var elementId = participantRestartAc.getAcElementList().get(0).getId();
 144         verify(listener).cleanExecution(elementId, participantSyncMsg.getMessageId());
 145     }
 146
 147     @Test
 148     void syncDeleteTest() {
 149         var participantSyncMsg = new ParticipantSync();
 150         participantSyncMsg.setState(AcTypeState.COMMISSIONED);
 151         participantSyncMsg.setDelete(true);
 152         participantSyncMsg.setCompositionId(UUID.randomUUID());
 153         participantSyncMsg.getParticipantDefinitionUpdates().add(createParticipantDefinition());
 154         var restartAc = CommonTestData.createParticipantRestartAc();
 155         participantSyncMsg.setAutomationcompositionList(List.of(restartAc));
 156
 157         var cacheProvider = mock(CacheProvider.class);
 158         var listener = mock(ThreadHandler.class);
 159         var ach = new AcDefinitionHandler(cacheProvider, mock(ParticipantMessagePublisher.class), listener);
 160         ach.handleParticipantSync(participantSyncMsg);
 161         verify(cacheProvider).removeElementDefinition(participantSyncMsg.getCompositionId());
 162         verify(cacheProvider).removeAutomationComposition(restartAc.getAutomationCompositionId());
 163     }
 164 }