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

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