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.mockito.Mockito.clearInvocations;
  24 import static org.mockito.Mockito.doThrow;
  25 import static org.mockito.Mockito.mock;
  26 import static org.mockito.Mockito.timeout;
  27 import static org.mockito.Mockito.verify;
  28
  29 import java.io.IOException;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.UUID;
  33 import javax.ws.rs.core.Response.Status;
  34 import org.junit.jupiter.api.Test;
  35 import org.onap.policy.clamp.acm.participant.intermediary.api.AutomationCompositionElementListener;
  36 import org.onap.policy.clamp.acm.participant.intermediary.api.ParticipantIntermediaryApi;
  37 import org.onap.policy.clamp.models.acm.concepts.AcElementDeploy;
  38 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  39 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
  40 import org.onap.policy.clamp.models.acm.concepts.DeployState;
  41 import org.onap.policy.clamp.models.acm.concepts.LockState;
  42 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  43 import org.onap.policy.models.base.PfModelException;
  44
  45 class ThreadHandlerTest {
  46
  47     private static final int TIMEOUT = 400;
  48
  49     @Test
  50     void test() throws PfModelException, IOException {
  51         var listener = mock(AutomationCompositionElementListener.class);
  52         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
  53         try (var threadHandler = new ThreadHandler(listener, intermediaryApi, mock(CacheProvider.class))) {
  54
  55             var compositionId = UUID.randomUUID();
  56             var list = List.of(new AutomationCompositionElementDefinition());
  57             var messageId = UUID.randomUUID();
  58             threadHandler.prime(messageId, compositionId, list);
  59             verify(listener, timeout(TIMEOUT)).prime(compositionId, list);
  60
  61             clearInvocations(listener);
  62             var element = new AcElementDeploy();
  63             var elementId = UUID.randomUUID();
  64             element.setId(elementId);
  65             Map<String, Object> properties = Map.of("key", "value");
  66             var instanceId = UUID.randomUUID();
  67             threadHandler.deploy(messageId, instanceId, element, properties);
  68             verify(listener, timeout(TIMEOUT)).deploy(instanceId, element, properties);
  69
  70             clearInvocations(listener);
  71             threadHandler.update(messageId, instanceId, element, properties);
  72             verify(listener, timeout(TIMEOUT)).update(instanceId, element, properties);
  73
  74             clearInvocations(listener);
  75             threadHandler.lock(messageId, instanceId, elementId);
  76             verify(listener, timeout(TIMEOUT)).lock(instanceId, elementId);
  77
  78             clearInvocations(listener);
  79             threadHandler.unlock(messageId, instanceId, elementId);
  80             verify(listener, timeout(TIMEOUT)).unlock(instanceId, elementId);
  81
  82             clearInvocations(listener);
  83             threadHandler.undeploy(messageId, instanceId, elementId);
  84             verify(listener, timeout(TIMEOUT)).undeploy(instanceId, elementId);
  85
  86             clearInvocations(listener);
  87             threadHandler.delete(messageId, instanceId, elementId);
  88             verify(listener, timeout(TIMEOUT)).delete(instanceId, elementId);
  89
  90             clearInvocations(listener);
  91             threadHandler.deprime(messageId, compositionId);
  92             verify(listener, timeout(TIMEOUT)).deprime(compositionId);
  93         }
  94     }
  95
  96     @Test
  97     void testException() throws PfModelException, IOException {
  98         var listener = mock(AutomationCompositionElementListener.class);
  99         var intermediaryApi = mock(ParticipantIntermediaryApi.class);
 100         try (var threadHandler = new ThreadHandler(listener, intermediaryApi, mock(CacheProvider.class))) {
 101
 102             var compositionId = UUID.randomUUID();
 103             var list = List.of(new AutomationCompositionElementDefinition());
 104             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener).prime(compositionId,
 105                     list);
 106             var messageId = UUID.randomUUID();
 107             threadHandler.prime(messageId, compositionId, list);
 108             verify(intermediaryApi, timeout(TIMEOUT)).updateCompositionState(compositionId, AcTypeState.COMMISSIONED,
 109                     StateChangeResult.FAILED, "Composition Defintion prime failed");
 110
 111             clearInvocations(intermediaryApi);
 112             var element = new AcElementDeploy();
 113             var elementId = UUID.randomUUID();
 114             element.setId(elementId);
 115             Map<String, Object> properties = Map.of("key", "value");
 116             var instanceId = UUID.randomUUID();
 117             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener).deploy(instanceId,
 118                     element, properties);
 119             threadHandler.deploy(messageId, instanceId, element, properties);
 120             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
 121                     DeployState.UNDEPLOYED, null, StateChangeResult.FAILED,
 122                     "Automation composition element deploy failed");
 123
 124             clearInvocations(listener);
 125             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener).update(instanceId,
 126                     element, properties);
 127             threadHandler.update(messageId, instanceId, element, properties);
 128             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
 129                     DeployState.DEPLOYED, null, StateChangeResult.FAILED,
 130                     "Automation composition element update failed");
 131
 132             clearInvocations(listener);
 133             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener).lock(instanceId,
 134                     elementId);
 135             threadHandler.lock(messageId, instanceId, elementId);
 136             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
 137                     null, LockState.UNLOCKED, StateChangeResult.FAILED, "Automation composition element lock failed");
 138
 139             clearInvocations(listener);
 140             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener).unlock(instanceId,
 141                     elementId);
 142             threadHandler.unlock(messageId, instanceId, elementId);
 143             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
 144                     null, LockState.LOCKED, StateChangeResult.FAILED, "Automation composition element unlock failed");
 145
 146             clearInvocations(listener);
 147             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener).undeploy(instanceId,
 148                     elementId);
 149             threadHandler.undeploy(messageId, instanceId, elementId);
 150             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
 151                     DeployState.DEPLOYED, null, StateChangeResult.FAILED,
 152                     "Automation composition element undeploy failed");
 153
 154             clearInvocations(listener);
 155             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener).delete(instanceId,
 156                     elementId);
 157             threadHandler.delete(messageId, instanceId, elementId);
 158             verify(intermediaryApi, timeout(TIMEOUT)).updateAutomationCompositionElementState(instanceId, elementId,
 159                     DeployState.UNDEPLOYED, null, StateChangeResult.FAILED,
 160                     "Automation composition element delete failed");
 161
 162             clearInvocations(listener);
 163             doThrow(new PfModelException(Status.INTERNAL_SERVER_ERROR, "Error")).when(listener).deprime(compositionId);
 164             threadHandler.deprime(messageId, compositionId);
 165             verify(intermediaryApi, timeout(TIMEOUT)).updateCompositionState(compositionId, AcTypeState.PRIMED,
 166                     StateChangeResult.FAILED, "Composition Defintion deprime failed");
 167         }
 168     }
 169 }