models-interactions/model-actors/actor.cds/src/test/java/org/onap/policy/controlloop/actor/cds/CdsActorServiceProviderTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * Copyright (C) 2019 Bell Canada. 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  * ============LICENSE_END=========================================================
  17  */
  18
  19 package org.onap.policy.controlloop.actor.cds;
  20
  21 import static org.junit.Assert.assertEquals;
  22 import static org.junit.Assert.assertFalse;
  23 import static org.junit.Assert.assertTrue;
  24 import static org.mockito.Matchers.any;
  25 import static org.mockito.Matchers.anyLong;
  26 import static org.mockito.Mockito.doThrow;
  27 import static org.mockito.Mockito.mock;
  28 import static org.mockito.Mockito.verify;
  29 import static org.mockito.Mockito.when;
  30
  31 import com.google.common.collect.ImmutableMap;
  32 import com.google.protobuf.Struct;
  33 import java.util.HashMap;
  34 import java.util.Map;
  35 import java.util.Optional;
  36 import java.util.UUID;
  37 import java.util.concurrent.CountDownLatch;
  38 import java.util.concurrent.TimeUnit;
  39 import org.junit.Before;
  40 import org.junit.Rule;
  41 import org.junit.Test;
  42 import org.junit.rules.ExpectedException;
  43 import org.junit.runner.RunWith;
  44 import org.mockito.Mock;
  45 import org.mockito.runners.MockitoJUnitRunner;
  46 import org.onap.ccsdk.cds.controllerblueprints.common.api.ActionIdentifiers;
  47 import org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader;
  48 import org.onap.ccsdk.cds.controllerblueprints.common.api.EventType;
  49 import org.onap.ccsdk.cds.controllerblueprints.common.api.Status;
  50 import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput;
  51 import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput;
  52 import org.onap.policy.cds.client.CdsProcessorGrpcClient;
  53 import org.onap.policy.cds.properties.CdsServerProperties;
  54 import org.onap.policy.controlloop.ControlLoopOperation;
  55 import org.onap.policy.controlloop.VirtualControlLoopEvent;
  56 import org.onap.policy.controlloop.actor.cds.CdsActorServiceProvider.CdsActorServiceManager;
  57 import org.onap.policy.controlloop.actor.cds.constants.CdsActorConstants;
  58 import org.onap.policy.controlloop.policy.Policy;
  59
  60 @RunWith(MockitoJUnitRunner.class)
  61 public class CdsActorServiceProviderTest {
  62
  63     private static final String CDS_BLUEPRINT_NAME = "vfw-cds";
  64     private static final String CDS_BLUEPRINT_VERSION = "1.0.0";
  65     private static final UUID REQUEST_ID = UUID.randomUUID();
  66     private static final String SUBREQUEST_ID = "123456";
  67     private static final String CDS_RECIPE = "test-cds-recipe";
  68
  69     @Rule
  70     public ExpectedException exceptionRule = ExpectedException.none();
  71     @Mock
  72     private CdsProcessorGrpcClient cdsClient;
  73     private CdsActorServiceProvider cdsActor;
  74     private Policy policy;
  75     private CdsServerProperties cdsProps;
  76     private Map<String, String> aaiParams;
  77     private VirtualControlLoopEvent onset;
  78     private ControlLoopOperation operation;
  79
  80     /**
  81      * Test setup.
  82      */
  83     @Before
  84     public void setup() {
  85         // Setup policy
  86         policy = new Policy();
  87         Map<String, String> payloadMap = new HashMap<String, String>() {
  88             {
  89                 put(CdsActorConstants.KEY_CBA_NAME, CDS_BLUEPRINT_NAME);
  90                 put(CdsActorConstants.KEY_CBA_VERSION, CDS_BLUEPRINT_VERSION);
  91                 put("data", "{\"mapInfo\":{\"key\":\"val\"},\"arrayInfo\":[\"one\",\"two\"],\"paramInfo\":\"val\"}");
  92             }
  93         };
  94         policy.setPayload(payloadMap);
  95         policy.setRecipe(CDS_RECIPE);
  96
  97         // Setup the CDS properties
  98         cdsProps = new CdsServerProperties();
  99         cdsProps.setHost("10.10.10.10");
 100         cdsProps.setPort(2000);
 101         cdsProps.setUsername("testUser");
 102         cdsProps.setPassword("testPassword");
 103         cdsProps.setTimeout(1);
 104
 105         // Setup aaiParams
 106         aaiParams = ImmutableMap.of("service-instance-id", "1234", "generic-vnf-id", "5678");
 107
 108         // Setup cdsClient
 109         when(cdsClient.sendRequest(any(ExecutionServiceInput.class))).thenReturn(mock(CountDownLatch.class));
 110
 111         // Setup the cdsActor
 112         cdsActor = new CdsActorServiceProvider();
 113
 114         // Setup onset event
 115         onset = new VirtualControlLoopEvent();
 116         onset.setRequestId(REQUEST_ID);
 117
 118         // Setup controlloop operation object
 119         operation = new ControlLoopOperation();
 120         operation.setSubRequestId(SUBREQUEST_ID);
 121     }
 122
 123     @Test
 124     public void testActor() {
 125         assertEquals(cdsActor.actor(), CdsActorConstants.CDS_ACTOR);
 126     }
 127
 128     @Test
 129     public void testConstructRequestWhenMissingCdsParamsInPolicyPayload() {
 130         policy.setPayload(new HashMap<>());
 131         Optional<ExecutionServiceInput> cdsRequestOpt = cdsActor
 132             .constructRequest(onset, operation, policy, aaiParams);
 133
 134         assertFalse(cdsRequestOpt.isPresent());
 135     }
 136
 137     @Test
 138     public void testConstructRequest() {
 139         Optional<ExecutionServiceInput> cdsRequestOpt = cdsActor
 140             .constructRequest(onset, operation, policy, aaiParams);
 141
 142         assertTrue(cdsRequestOpt.isPresent());
 143         final ExecutionServiceInput cdsRequest = cdsRequestOpt.get();
 144
 145         assertTrue(cdsRequest.hasCommonHeader());
 146         CommonHeader commonHeader = cdsRequest.getCommonHeader();
 147         assertEquals(commonHeader.getRequestId(), REQUEST_ID.toString());
 148         assertEquals(commonHeader.getSubRequestId(), SUBREQUEST_ID);
 149
 150         assertTrue(cdsRequest.hasPayload());
 151         Struct cdsPayload = cdsRequest.getPayload();
 152         assertTrue(cdsPayload.containsFields(CDS_RECIPE + "-request"));
 153
 154         assertTrue(cdsRequest.hasActionIdentifiers());
 155         ActionIdentifiers actionIdentifiers = cdsRequest.getActionIdentifiers();
 156         assertEquals(actionIdentifiers.getActionName(), CDS_RECIPE);
 157         assertEquals(actionIdentifiers.getBlueprintName(), CDS_BLUEPRINT_NAME);
 158         assertEquals(actionIdentifiers.getBlueprintVersion(), CDS_BLUEPRINT_VERSION);
 159     }
 160
 161     @Test
 162     public void testRecipePayloads() {
 163         assertEquals(cdsActor.recipePayloads("").size(), 0);
 164     }
 165
 166     @Test
 167     public void testRecipes() {
 168         assertEquals(cdsActor.recipes().size(), 0);
 169     }
 170
 171     @Test
 172     public void testRecipeTargets() {
 173         assertEquals(cdsActor.recipeTargets("").size(), 0);
 174     }
 175
 176     @Test
 177     public void testSendRequestToCdsSuccess() {
 178         sendRequestToCds();
 179         verify(cdsClient).sendRequest(any(ExecutionServiceInput.class));
 180     }
 181
 182     @Test
 183     public void testSendRequestToCdsLatchInterrupted() throws InterruptedException {
 184         // Reset cdsClient
 185         CountDownLatch countDownLatch = mock(CountDownLatch.class);
 186         doThrow(new InterruptedException("Test latch interrupted failure")).when(countDownLatch)
 187             .await(anyLong(), any(TimeUnit.class));
 188         when(cdsClient.sendRequest(any(ExecutionServiceInput.class))).thenReturn(countDownLatch);
 189
 190         CdsActorServiceProvider.CdsActorServiceManager cdsActorSvcMgr = cdsActor.new CdsActorServiceManager();
 191         String response = cdsActorSvcMgr
 192             .sendRequestToCds(cdsClient, cdsProps, ExecutionServiceInput.newBuilder().build());
 193         assertTrue(Thread.interrupted());
 194         assertEquals(response, CdsActorConstants.INTERRUPTED);
 195     }
 196
 197     @Test
 198     public void testSendRequestToCdsLatchTimedOut() {
 199         CdsActorServiceProvider.CdsActorServiceManager cdsActorSvcMgr = cdsActor.new CdsActorServiceManager();
 200         String response = cdsActorSvcMgr
 201             .sendRequestToCds(cdsClient, cdsProps, ExecutionServiceInput.newBuilder().build());
 202         assertEquals(response, CdsActorConstants.TIMED_OUT);
 203     }
 204
 205     @Test
 206     public void testOnMessage() throws InterruptedException {
 207         ExecutionServiceOutput message = ExecutionServiceOutput.newBuilder()
 208             .setStatus(Status.newBuilder().setEventType(EventType.EVENT_COMPONENT_FAILURE).build()).build();
 209
 210         // Test "no timeout" scenarios
 211         CountDownLatch latch = mock(CountDownLatch.class);
 212         when(latch.await(anyLong(), any(TimeUnit.class))).thenReturn(true);
 213         when(cdsClient.sendRequest(any(ExecutionServiceInput.class))).thenReturn(latch);
 214
 215         CdsActorServiceManager cdsActorSvcMgr = sendRequestToCds();
 216
 217         // #1: Failure test
 218         cdsActorSvcMgr.onMessage(message);
 219         assertEquals(cdsActorSvcMgr.getCdsResponse(), CdsActorConstants.FAILED);
 220
 221         // #2: Success test
 222         cdsActorSvcMgr = sendRequestToCds();
 223         message = ExecutionServiceOutput.newBuilder()
 224             .setStatus(Status.newBuilder().setEventType(EventType.EVENT_COMPONENT_EXECUTED).build()).build();
 225         cdsActorSvcMgr.onMessage(message);
 226         assertEquals(cdsActorSvcMgr.getCdsResponse(), CdsActorConstants.SUCCESS);
 227
 228         // #3: Processing test
 229         cdsActorSvcMgr = sendRequestToCds();
 230         message = ExecutionServiceOutput.newBuilder()
 231             .setStatus(Status.newBuilder().setEventType(EventType.EVENT_COMPONENT_PROCESSING).build()).build();
 232         cdsActorSvcMgr.onMessage(message);
 233         assertEquals(cdsActorSvcMgr.getCdsResponse(), CdsActorConstants.PROCESSING);
 234     }
 235
 236     private CdsActorServiceManager sendRequestToCds() {
 237         CdsActorServiceManager cdsActorSvcMgr = cdsActor.new CdsActorServiceManager();
 238         cdsActorSvcMgr.sendRequestToCds(cdsClient, cdsProps, ExecutionServiceInput.newBuilder().build());
 239         return cdsActorSvcMgr;
 240     }
 241 }