/*-
* ============LICENSE_START=======================================================
* Copyright (C) 2019 Bell Canada. All rights reserved.
+ * Modifications Copyright (C) 2020 Nordix Foundation.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
import static org.mockito.Mockito.when;
import com.google.common.collect.ImmutableMap;
+import com.google.protobuf.Struct;
+
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
+
import org.junit.Before;
-import org.junit.Rule;
import org.junit.Test;
-import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.onap.ccsdk.cds.controllerblueprints.common.api.Status;
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput;
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput;
+import org.onap.policy.cds.CdsResponse;
import org.onap.policy.cds.client.CdsProcessorGrpcClient;
import org.onap.policy.cds.properties.CdsServerProperties;
import org.onap.policy.controlloop.ControlLoopOperation;
private static final String CDS_BLUEPRINT_VERSION = "1.0.0";
private static final UUID REQUEST_ID = UUID.randomUUID();
private static final String SUBREQUEST_ID = "123456";
+ private static final String CDS_RECIPE = "test-cds-recipe";
- @Rule
- public ExpectedException exceptionRule = ExpectedException.none();
@Mock
private CdsProcessorGrpcClient cdsClient;
private CdsActorServiceProvider cdsActor;
// Setup policy
policy = new Policy();
Map<String, String> payloadMap = new HashMap<String, String>() {
+ private static final long serialVersionUID = 1L;
+
{
put(CdsActorConstants.KEY_CBA_NAME, CDS_BLUEPRINT_NAME);
put(CdsActorConstants.KEY_CBA_VERSION, CDS_BLUEPRINT_VERSION);
}
};
policy.setPayload(payloadMap);
- policy.setRecipe("CDS");
+ policy.setRecipe(CDS_RECIPE);
// Setup the CDS properties
cdsProps = new CdsServerProperties();
@Test
public void testActor() {
- assertEquals(cdsActor.actor(), CdsActorConstants.CDS_ACTOR);
+ assertEquals(CdsActorConstants.CDS_ACTOR, cdsActor.actor());
}
@Test
- public void testConstructRequest() {
+ public void testConstructRequestWhenMissingCdsParamsInPolicyPayload() {
policy.setPayload(new HashMap<>());
- Optional<ExecutionServiceInput> cdsRequestOpt = cdsActor
- .constructRequest(onset, operation, policy, aaiParams);
+ Optional<ExecutionServiceInput> cdsRequestOpt = cdsActor.constructRequest(onset, operation, policy, aaiParams);
assertFalse(cdsRequestOpt.isPresent());
}
@Test
- public void testConstructRequestWhenMissingCdsParamsInPolicyPayload() {
- Optional<ExecutionServiceInput> cdsRequestOpt = cdsActor
- .constructRequest(onset, operation, policy, aaiParams);
+ public void testConstructRequest() {
+ Optional<ExecutionServiceInput> cdsRequestOpt = cdsActor.constructRequest(onset, operation, policy, aaiParams);
assertTrue(cdsRequestOpt.isPresent());
final ExecutionServiceInput cdsRequest = cdsRequestOpt.get();
assertTrue(cdsRequest.hasCommonHeader());
CommonHeader commonHeader = cdsRequest.getCommonHeader();
assertEquals(commonHeader.getRequestId(), REQUEST_ID.toString());
- assertEquals(commonHeader.getSubRequestId(), SUBREQUEST_ID);
+ assertEquals(SUBREQUEST_ID, commonHeader.getSubRequestId());
assertTrue(cdsRequest.hasPayload());
+ Struct cdsPayload = cdsRequest.getPayload();
+ assertTrue(cdsPayload.containsFields(CDS_RECIPE + "-request"));
assertTrue(cdsRequest.hasActionIdentifiers());
ActionIdentifiers actionIdentifiers = cdsRequest.getActionIdentifiers();
- assertEquals(actionIdentifiers.getActionName(), CdsActorConstants.CDS_ACTOR);
- assertEquals(actionIdentifiers.getBlueprintName(), CDS_BLUEPRINT_NAME);
- assertEquals(actionIdentifiers.getBlueprintVersion(), CDS_BLUEPRINT_VERSION);
+ assertEquals(CDS_RECIPE, actionIdentifiers.getActionName());
+ assertEquals(CDS_BLUEPRINT_NAME, actionIdentifiers.getBlueprintName());
+ assertEquals(CDS_BLUEPRINT_VERSION, actionIdentifiers.getBlueprintVersion());
}
@Test
public void testRecipePayloads() {
- assertEquals(cdsActor.recipePayloads("").size(), 0);
+ assertEquals(0, cdsActor.recipePayloads("").size());
}
@Test
public void testRecipes() {
- assertEquals(cdsActor.recipes().size(), 0);
+ assertEquals(0, cdsActor.recipes().size());
}
@Test
public void testRecipeTargets() {
- assertEquals(cdsActor.recipeTargets("").size(), 0);
+ assertEquals(0, cdsActor.recipeTargets("").size());
}
@Test
public void testSendRequestToCdsLatchInterrupted() throws InterruptedException {
// Reset cdsClient
CountDownLatch countDownLatch = mock(CountDownLatch.class);
- doThrow(new InterruptedException("Test latch interrupted failure")).when(countDownLatch)
- .await(anyLong(), any(TimeUnit.class));
+ doThrow(new InterruptedException("Test latch interrupted failure")).when(countDownLatch).await(anyLong(),
+ any(TimeUnit.class));
when(cdsClient.sendRequest(any(ExecutionServiceInput.class))).thenReturn(countDownLatch);
CdsActorServiceProvider.CdsActorServiceManager cdsActorSvcMgr = cdsActor.new CdsActorServiceManager();
- String response = cdsActorSvcMgr
- .sendRequestToCds(cdsClient, cdsProps, ExecutionServiceInput.newBuilder().build());
+ CdsResponse response =
+ cdsActorSvcMgr.sendRequestToCds(cdsClient, cdsProps, ExecutionServiceInput.newBuilder().build());
assertTrue(Thread.interrupted());
- assertEquals(response, CdsActorConstants.INTERRUPTED);
+ assertNotNull(response);
+ assertEquals(CdsActorConstants.INTERRUPTED, response.getStatus());
}
@Test
public void testSendRequestToCdsLatchTimedOut() {
CdsActorServiceProvider.CdsActorServiceManager cdsActorSvcMgr = cdsActor.new CdsActorServiceManager();
- String response = cdsActorSvcMgr
- .sendRequestToCds(cdsClient, cdsProps, ExecutionServiceInput.newBuilder().build());
- assertEquals(response, CdsActorConstants.TIMED_OUT);
+ CdsResponse response =
+ cdsActorSvcMgr.sendRequestToCds(cdsClient, cdsProps, ExecutionServiceInput.newBuilder().build());
+ assertNotNull(response);
+ assertEquals(CdsActorConstants.TIMED_OUT, response.getStatus());
}
@Test
// #1: Failure test
cdsActorSvcMgr.onMessage(message);
- assertEquals(cdsActorSvcMgr.getCdsResponse(), CdsActorConstants.FAILED);
+ assertEquals(CdsActorConstants.FAILED, cdsActorSvcMgr.getCdsStatus());
// #2: Success test
cdsActorSvcMgr = sendRequestToCds();
message = ExecutionServiceOutput.newBuilder()
.setStatus(Status.newBuilder().setEventType(EventType.EVENT_COMPONENT_EXECUTED).build()).build();
cdsActorSvcMgr.onMessage(message);
- assertEquals(cdsActorSvcMgr.getCdsResponse(), CdsActorConstants.SUCCESS);
+ assertEquals(CdsActorConstants.SUCCESS, cdsActorSvcMgr.getCdsStatus());
// #3: Processing test
cdsActorSvcMgr = sendRequestToCds();
message = ExecutionServiceOutput.newBuilder()
.setStatus(Status.newBuilder().setEventType(EventType.EVENT_COMPONENT_PROCESSING).build()).build();
cdsActorSvcMgr.onMessage(message);
- assertEquals(cdsActorSvcMgr.getCdsResponse(), CdsActorConstants.PROCESSING);
+ assertEquals(CdsActorConstants.PROCESSING, cdsActorSvcMgr.getCdsStatus());
}
private CdsActorServiceManager sendRequestToCds() {
Code Review / policy / models.git / blobdiff