appc-dispatcher/appc-request-handler/appc-request-handler-core/src/test/java/org/onap/appc/requesthandler/impl/RequestValidatorImplTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP : APPC
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Copyright (C) 2017 Amdocs
   8  * ================================================================================
   9  * Copyright (C) 2018-2019 Ericsson. All rights reserved.
  10  * ================================================================================
  11  * Licensed under the Apache License, Version 2.0 (the "License");
  12  * you may not use this file except in compliance with the License.
  13  * You may obtain a copy of the License at
  14  *
  15  *      http://www.apache.org/licenses/LICENSE-2.0
  16  *
  17  * Unless required by applicable law or agreed to in writing, software
  18  * distributed under the License is distributed on an "AS IS" BASIS,
  19  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  20  * See the License for the specific language governing permissions and
  21  * limitations under the License.
  22  *
  23  * ============LICENSE_END=========================================================
  24  */
  25
  26 package org.onap.appc.requesthandler.impl;
  27
  28 import static org.junit.Assert.assertTrue;
  29 import static org.mockito.Matchers.anyBoolean;
  30 import static org.mockito.Matchers.anyObject;
  31 import static org.mockito.Matchers.anyString;
  32 import static org.mockito.Mockito.mock;
  33
  34 import com.att.eelf.configuration.EELFLogger;
  35 import com.att.eelf.configuration.EELFLogger.Level;
  36 import com.att.eelf.configuration.EELFManager;
  37
  38 import java.io.ByteArrayInputStream;
  39 import java.io.InputStream;
  40 import java.net.MalformedURLException;
  41 import java.time.Instant;
  42 import java.time.temporal.ChronoUnit;
  43 import java.util.ArrayList;
  44 import java.util.List;
  45 import java.util.Properties;
  46
  47 import org.apache.commons.lang.StringUtils;
  48 import org.apache.http.HttpResponse;
  49 import org.apache.http.ProtocolVersion;
  50 import org.apache.http.entity.BasicHttpEntity;
  51 import org.apache.http.message.BasicHttpResponse;
  52 import org.junit.Before;
  53 import org.junit.Ignore;
  54 import org.junit.Rule;
  55 import org.junit.Test;
  56 import org.junit.rules.ExpectedException;
  57 import org.junit.runner.RunWith;
  58 import org.mockito.Mockito;
  59 import org.mockito.internal.util.reflection.Whitebox;
  60 import org.mockito.invocation.InvocationOnMock;
  61 import org.mockito.stubbing.Answer;
  62 import org.onap.appc.configuration.Configuration;
  63 import org.onap.appc.configuration.ConfigurationFactory;
  64 import org.onap.appc.domainmodel.lcm.ActionIdentifiers;
  65 import org.onap.appc.domainmodel.lcm.CommonHeader;
  66 import org.onap.appc.domainmodel.lcm.Flags;
  67 import org.onap.appc.domainmodel.lcm.Flags.Mode;
  68 import org.onap.appc.domainmodel.lcm.RequestContext;
  69 import org.onap.appc.domainmodel.lcm.RequestStatus;
  70 import org.onap.appc.domainmodel.lcm.ResponseContext;
  71 import org.onap.appc.domainmodel.lcm.RuntimeContext;
  72 import org.onap.appc.domainmodel.lcm.TransactionRecord;
  73 import org.onap.appc.domainmodel.lcm.VNFOperation;
  74 import org.onap.appc.exceptions.APPCException;
  75 import org.onap.appc.lockmanager.api.LockException;
  76 import org.onap.appc.lockmanager.api.LockManager;
  77 import org.onap.appc.requesthandler.LCMStateManager;
  78 import org.onap.appc.requesthandler.exceptions.DGWorkflowNotFoundException;
  79 import org.onap.appc.requesthandler.exceptions.LCMOperationsDisabledException;
  80 import org.onap.appc.requesthandler.exceptions.RequestValidationException;
  81 import org.onap.appc.requesthandler.exceptions.WorkflowNotFoundException;
  82 import org.onap.appc.rest.client.RestClientInvoker;
  83 import org.onap.appc.transactionrecorder.TransactionRecorder;
  84 import org.onap.appc.validationpolicy.RequestValidationPolicy;
  85 import org.onap.appc.validationpolicy.executors.RuleExecutor;
  86 import org.onap.appc.validationpolicy.objects.RuleResult;
  87 import org.onap.appc.workflow.WorkFlowManager;
  88 import org.onap.appc.workflow.impl.WorkFlowManagerImpl;
  89 import org.onap.appc.workflow.objects.WorkflowExistsOutput;
  90 import org.onap.appc.workflow.objects.WorkflowRequest;
  91 import org.onap.ccsdk.sli.adaptors.aai.AAIService;
  92 import org.onap.ccsdk.sli.core.sli.SvcLogicContext;
  93 import org.onap.ccsdk.sli.core.sli.SvcLogicResource;
  94 import org.osgi.framework.Bundle;
  95 import org.osgi.framework.BundleContext;
  96 import org.osgi.framework.FrameworkUtil;
  97 import org.osgi.framework.ServiceReference;
  98 import org.powermock.api.mockito.PowerMockito;
  99 import org.powermock.core.classloader.annotations.PrepareForTest;
 100 import org.powermock.modules.junit4.PowerMockRunner;
 101
 102 @RunWith(PowerMockRunner.class)
 103 @PrepareForTest({FrameworkUtil.class})
 104 public class RequestValidatorImplTest implements LocalRequestHanlderTestHelper {
 105     private Configuration mockConfig = ConfigurationFactory.getConfiguration();
 106     private RequestValidatorImpl impl;
 107     private final BundleContext bundleContext = Mockito.mock(BundleContext.class);
 108     private final Bundle bundleService = Mockito.mock(Bundle.class);
 109     private final ServiceReference sref = Mockito.mock(ServiceReference.class);
 110     private EELFLogger logger;
 111     private TransactionRecorder transactionRecorder;
 112     private LockManager lockManager;
 113     private LCMStateManager lcmStateManager;
 114
 115     @Rule
 116     public ExpectedException expectedEx = ExpectedException.none();
 117
 118     @Before
 119     public void setUp() throws Exception {
 120         impl = PowerMockito.spy(new RequestValidatorImpl());
 121         Whitebox.setInternalState(impl, "configuration", mockConfig);
 122         logger = Mockito.spy(EELFManager.getInstance().getLogger(RequestHandlerImpl.class));
 123         logger.setLevel(Level.TRACE);
 124         Whitebox.setInternalState(impl, "logger", logger);
 125         lcmStateManager = new LCMStateManagerImpl();
 126         impl.setLcmStateManager(lcmStateManager);
 127         AAIService aaiService = Mockito.mock(AAIService.class);
 128         PowerMockito.when(aaiService.query(
 129                 anyString(), anyBoolean(), anyString(), anyString(), anyString(), anyString(), anyObject()))
 130         .thenAnswer(new Answer<SvcLogicResource.QueryStatus>() {
 131             @Override
 132             public SvcLogicResource.QueryStatus answer(InvocationOnMock invocation) throws Exception {
 133                 Object[] args = invocation.getArguments();
 134                 SvcLogicContext ctx = (SvcLogicContext) args[6];
 135                 String prefix = (String) args[4];
 136                 String key = (String) args[3];
 137                 if (key.contains("'28'")) {
 138                     return SvcLogicResource.QueryStatus.FAILURE;
 139                 } else if (key.contains("'8'")) {
 140                     return SvcLogicResource.QueryStatus.NOT_FOUND;
 141                 } else {
 142                     ctx.setAttribute(prefix + ".vnf-type", "FIREWALL");
 143                     ctx.setAttribute(prefix + ".orchestration-status", "Instantiated");
 144                 }
 145                 return SvcLogicResource.QueryStatus.SUCCESS;
 146             }
 147         });
 148         PowerMockito.mockStatic(FrameworkUtil.class);
 149         PowerMockito.when(FrameworkUtil.getBundle(AAIService.class)).thenReturn(bundleService);
 150         PowerMockito.when(bundleService.getBundleContext()).thenReturn(bundleContext);
 151         PowerMockito.when(bundleContext.getServiceReference(AAIService.class.getName())).thenReturn(sref);
 152         PowerMockito.when(bundleContext.getService(sref)).thenReturn(aaiService);
 153         lockManager = mock(LockManager.class);
 154         impl.setLockManager(lockManager);
 155     }
 156
 157     // TODO: remove Ignore when initialize method actually throws APPCException
 158     @Ignore
 159     @Test(expected = APPCException.class)
 160     public void testInitializeWithNullConfigProps() throws Exception {
 161         Mockito.doReturn(null).when(mockConfig).getProperties();
 162         impl.initialize();
 163     }
 164
 165     // TODO: remove Ignore when initialize method actually throws APPCException
 166     @Ignore
 167     @Test(expected = APPCException.class)
 168     public void testInitializeWithoutEndpointProp() throws Exception {
 169         Properties mockProp = mock(Properties.class);
 170         Mockito.doReturn(null).when(mockProp).getProperty(RequestValidatorImpl.SCOPE_OVERLAP_ENDPOINT);
 171         Mockito.doReturn(mockProp).when(mockConfig).getProperties();
 172         impl.initialize();
 173     }
 174
 175     // TODO: remove Ignore when initialize method actually throws APPCException
 176     @Ignore
 177     @Test(expected = APPCException.class)
 178     public void testInitializeWithMalFormatEndpoint() throws Exception {
 179         Properties mockProp = mock(Properties.class);
 180         Mockito.doReturn("a/b/c").when(mockProp).getProperty(RequestValidatorImpl.SCOPE_OVERLAP_ENDPOINT);
 181         Mockito.doReturn(mockProp).when(mockConfig).getProperties();
 182         impl.initialize();
 183     }
 184
 185     @Test(expected = LCMOperationsDisabledException.class)
 186     public void testValidateRequestLCMException() throws Exception {
 187         RuntimeContext runtimeContext = createRequestValidatorInput();
 188         logger = Mockito.spy(EELFManager.getInstance().getLogger(LCMStateManager.class));
 189         logger.setLevel(Level.TRACE);
 190         Whitebox.setInternalState(lcmStateManager, "logger", logger);
 191         lcmStateManager.disableLCMOperations();
 192         impl.validateRequest(runtimeContext);
 193     }
 194
 195
 196     @Test (expected = RequestValidationException.class)
 197     public void testValidateRequest() throws Exception {
 198         RuntimeContext runtimeContext = createRequestValidatorInput();
 199         logger = Mockito.spy(EELFManager.getInstance().getLogger(LCMStateManager.class));
 200         logger.setLevel(Level.TRACE);
 201         Whitebox.setInternalState(lcmStateManager, "logger", logger);
 202         lcmStateManager.enableLCMOperations();
 203         transactionRecorder = Mockito.mock(TransactionRecorder.class);
 204         Mockito.when(transactionRecorder.isTransactionDuplicate(anyObject())).thenReturn(false);
 205         List<TransactionRecord> transactionRecordList = new ArrayList<TransactionRecord>(1);
 206         TransactionRecord transactionRecord = new TransactionRecord();
 207         transactionRecord.setMode(Mode.EXCLUSIVE);
 208         transactionRecord.setStartTime(Instant.now().minus(5, ChronoUnit.HOURS));
 209         transactionRecord.setRequestState(RequestStatus.ACCEPTED);
 210         runtimeContext.setTransactionRecord(transactionRecord);
 211         transactionRecordList.add(transactionRecord);
 212         Mockito.when(transactionRecorder.getInProgressRequests(Mockito.any(TransactionRecord.class),Mockito.any(int.class)))
 213         .thenReturn(transactionRecordList);
 214         impl.setTransactionRecorder(transactionRecorder);
 215         WorkflowExistsOutput workflowExistsOutput = new WorkflowExistsOutput(true, true);
 216         WorkFlowManager workflowManager = Mockito.mock(WorkFlowManagerImpl.class);
 217         Mockito.when(workflowManager.workflowExists(Mockito.any(WorkflowRequest.class))).thenReturn(workflowExistsOutput);
 218         impl.setWorkflowManager(workflowManager);
 219         ResponseContext responseContext = runtimeContext.getResponseContext();
 220         returnResponseContextCommonHeader(responseContext);
 221         RestClientInvoker client = mock(RestClientInvoker.class);
 222         HttpResponse httpResponse = new BasicHttpResponse(new ProtocolVersion("HTTP",1,0), 200, "ACCEPTED");
 223         httpResponse.setEntity(getHttpEntity());
 224         Mockito.when(client.doPost(Mockito.anyString(), Mockito.anyString())).thenReturn(httpResponse);
 225         impl.setClient(client);
 226         RequestValidationPolicy requestValidationPolicy = Mockito.mock(RequestValidationPolicy.class);
 227         RuleExecutor ruleExecutor = Mockito.mock(RuleExecutor.class);
 228         RuleResult ruleResult = RuleResult.REJECT;
 229         Mockito.when(requestValidationPolicy.getInProgressRuleExecutor()).thenReturn(ruleExecutor);
 230         Mockito.when(ruleExecutor.executeRule(Mockito.anyString(), Mockito.anyListOf(VNFOperation.class))).thenReturn(ruleResult);
 231         impl.setRequestValidationPolicy(requestValidationPolicy);
 232         impl.validateRequest(runtimeContext);
 233     }
 234
 235     @Test
 236     public void testInitializeMalformed() throws Exception {
 237         Properties properties = new Properties();
 238         properties.setProperty("appc.LCM.scopeOverlap.endpoint", "/not/a/URL");
 239         mockConfig.setProperties(properties);
 240         Whitebox.setInternalState(impl, "configuration", mockConfig);
 241         impl.initialize();
 242         Mockito.verify(logger).error(Mockito.anyString(), Mockito.any(MalformedURLException.class));
 243     }
 244
 245     @Test
 246     public void testInitialize() throws Exception {
 247         Configuration mockConfigForInitTest = ConfigurationFactory.getConfiguration(new Properties());
 248         Whitebox.setInternalState(impl, "configuration", mockConfigForInitTest);
 249         impl.initialize();
 250         Mockito.verify(logger).error("End point is not defined for scope over lap service in appc.properties.");
 251     }
 252
 253     @Test(expected = RequestValidationException.class)
 254     public void testValidateRequestExclusiveRequestCount() throws Exception {
 255         RuntimeContext runtimeContext = createRequestValidatorInput();
 256         lcmStateManager.enableLCMOperations();
 257         transactionRecorder = Mockito.mock(TransactionRecorder.class);
 258         Mockito.when(transactionRecorder.isTransactionDuplicate(anyObject())).thenReturn(false);
 259         List<TransactionRecord> transactionRecordList = new ArrayList<TransactionRecord>(1);
 260         TransactionRecord inProgressTransaction = new TransactionRecord();
 261         inProgressTransaction.setMode(Mode.EXCLUSIVE);
 262         inProgressTransaction.setStartTime(Instant.now().minus(5, ChronoUnit.HOURS));
 263         inProgressTransaction.setRequestState(RequestStatus.ACCEPTED);
 264         transactionRecordList.add(inProgressTransaction);
 265         Mockito.when(transactionRecorder.getInProgressRequests(Mockito.any(TransactionRecord.class),Mockito.any(int.class)))
 266             .thenReturn(transactionRecordList);
 267         runtimeContext.setTransactionRecord(inProgressTransaction);
 268         impl.setTransactionRecorder(transactionRecorder);
 269         WorkflowExistsOutput workflowExistsOutput = new WorkflowExistsOutput(true, true);
 270         WorkFlowManager workflowManager = Mockito.mock(WorkFlowManagerImpl.class);
 271         Mockito.when(workflowManager.workflowExists(Mockito.any(WorkflowRequest.class)))
 272             .thenReturn(workflowExistsOutput);
 273         impl.setWorkflowManager(workflowManager);
 274         ResponseContext responseContext = runtimeContext.getResponseContext();
 275         returnResponseContextCommonHeader(responseContext);
 276         impl.validateRequest(runtimeContext);
 277     }
 278
 279     @Test(expected = LockException.class)
 280     public void testValidateLockException() throws Exception {
 281         RuntimeContext runtimeContext = createRequestValidatorInput();
 282         lcmStateManager.enableLCMOperations();
 283         Mockito.when(lockManager.getLockOwner(Mockito.anyString())).thenReturn("TEST_LOCK_OWNER");
 284         transactionRecorder = Mockito.mock(TransactionRecorder.class);
 285         Mockito.when(transactionRecorder.isTransactionDuplicate(anyObject())).thenReturn(false);
 286         impl.setTransactionRecorder(transactionRecorder);
 287         TransactionRecord inProgressTransaction = new TransactionRecord();
 288         runtimeContext.setTransactionRecord(inProgressTransaction);
 289         impl.validateRequest(runtimeContext);
 290     }
 291
 292     @Test
 293     public void testValidateRequestInProgressTransactionLoop() throws Exception {
 294         RuntimeContext runtimeContext = createRequestValidatorInput();
 295         lcmStateManager.enableLCMOperations();
 296         transactionRecorder = Mockito.mock(TransactionRecorder.class);
 297
 298         List<TransactionRecord> transactionRecordList = new ArrayList<TransactionRecord>(1);
 299         TransactionRecord inProgressTransaction = new TransactionRecord();
 300         inProgressTransaction.setMode(Mode.NORMAL);
 301         inProgressTransaction.setOperation(VNFOperation.ActionStatus);
 302         inProgressTransaction.setRequestState(RequestStatus.ACCEPTED);
 303         inProgressTransaction.setStartTime(Instant.now().minus(48, ChronoUnit.HOURS));
 304         transactionRecordList.add(inProgressTransaction);
 305         Mockito.when(transactionRecorder.getInProgressRequests(Mockito.any(TransactionRecord.class),Mockito.any(int.class)))
 306         .thenReturn(transactionRecordList);
 307         Mockito.when(transactionRecorder.isTransactionDuplicate(anyObject())).thenReturn(false);
 308         impl.setTransactionRecorder(transactionRecorder);
 309         runtimeContext.setTransactionRecord(inProgressTransaction);
 310         WorkFlowManager workflowManager = Mockito.mock(WorkFlowManagerImpl.class);
 311         WorkflowExistsOutput workflowExistsOutput = Mockito.spy(new WorkflowExistsOutput(true, true));
 312         Mockito.when(workflowManager.workflowExists(Mockito.any(WorkflowRequest.class)))
 313             .thenReturn(workflowExistsOutput);
 314         impl.setWorkflowManager(workflowManager);
 315         ResponseContext responseContext = runtimeContext.getResponseContext();
 316         returnResponseContextCommonHeader(responseContext);
 317         RestClientInvoker client = mock(RestClientInvoker.class);
 318         HttpResponse httpResponse = new BasicHttpResponse(new ProtocolVersion("HTTP",1,0), 200, "ACCEPTED");
 319         httpResponse.setEntity(getHttpEntity());
 320         Mockito.when(client.doPost(Mockito.anyString(), Mockito.anyString())).thenReturn(httpResponse);
 321         impl.setClient(client);
 322         RequestValidationPolicy requestValidationPolicy = Mockito.mock(RequestValidationPolicy.class);
 323         RuleExecutor ruleExecutor = Mockito.mock(RuleExecutor.class);
 324         RuleResult ruleResult = RuleResult.ACCEPT;
 325         Mockito.when(requestValidationPolicy.getInProgressRuleExecutor()).thenReturn(ruleExecutor);
 326         Mockito.when(ruleExecutor.executeRule(Mockito.anyString(), Mockito.anyListOf(VNFOperation.class)))
 327             .thenReturn(ruleResult);
 328         impl.setRequestValidationPolicy(requestValidationPolicy);
 329         RequestContext requestContext = new RequestContext();
 330         ActionIdentifiers actionIdentifiers = new ActionIdentifiers();
 331         actionIdentifiers.setServiceInstanceId("TEST_SERVICE_INSTANCE_ID");
 332         actionIdentifiers.setVfModuleId("TEST_VNF_MODULE_ID");
 333         actionIdentifiers.setVnfcName("TEST_VNFC_NAME");
 334         actionIdentifiers.setVnfId("TEST_VNF_ID");
 335         actionIdentifiers.setvServerId("TEST_SERVER_ID");
 336         requestContext.setActionIdentifiers(actionIdentifiers);
 337         impl.validateRequest(runtimeContext);
 338         Mockito.verify(logger).debug("Policy validation result ACCEPT");
 339     }
 340
 341     @Test(expected = WorkflowNotFoundException.class)
 342     public void testValidateRequestWorkflowNotFoundException() throws Exception {
 343         RuntimeContext runtimeContext = createRequestValidatorInput();
 344         lcmStateManager.enableLCMOperations();
 345         transactionRecorder = Mockito.mock(TransactionRecorder.class);
 346         Mockito.when(transactionRecorder.isTransactionDuplicate(anyObject())).thenReturn(false);
 347         TransactionRecord transactionRecord = new TransactionRecord();
 348         transactionRecord.setMode(Mode.EXCLUSIVE);
 349         runtimeContext.setTransactionRecord(transactionRecord);
 350         impl.setTransactionRecorder(transactionRecorder);
 351         WorkflowExistsOutput workflowExistsOutput = Mockito.spy(new WorkflowExistsOutput(true, true));
 352         WorkFlowManager workflowManager = Mockito.mock(WorkFlowManagerImpl.class);
 353         Mockito.when(workflowManager.workflowExists(Mockito.any(WorkflowRequest.class)))
 354             .thenReturn(workflowExistsOutput);
 355         Mockito.when(workflowExistsOutput.isMappingExist()).thenReturn(false);
 356         impl.setWorkflowManager(workflowManager);
 357         ResponseContext responseContext = runtimeContext.getResponseContext();
 358         returnResponseContextCommonHeader(responseContext);
 359         RestClientInvoker client = mock(RestClientInvoker.class);
 360         HttpResponse httpResponse = new BasicHttpResponse(new ProtocolVersion("HTTP",1,0), 200, "ACCEPTED");;
 361         httpResponse.setEntity(getHttpEntity());
 362         Mockito.when(client.doPost(Mockito.anyString(), Mockito.anyString())).thenReturn(httpResponse);
 363         impl.setClient(client);
 364         RequestValidationPolicy requestValidationPolicy = Mockito.mock(RequestValidationPolicy.class);
 365         RuleExecutor ruleExecutor = Mockito.mock(RuleExecutor.class);
 366         RuleResult ruleResult = RuleResult.REJECT;
 367         Mockito.when(requestValidationPolicy.getInProgressRuleExecutor()).thenReturn(ruleExecutor);
 368         Mockito.when(ruleExecutor.executeRule(Mockito.anyString(), Mockito.anyListOf(VNFOperation.class)))
 369             .thenReturn(ruleResult);
 370         impl.setRequestValidationPolicy(requestValidationPolicy);
 371         impl.validateRequest(runtimeContext);
 372     }
 373
 374     @Test(expected = DGWorkflowNotFoundException.class)
 375     public void testValidateRequestDGWorkflowNotFoundException() throws Exception {
 376         RuntimeContext runtimeContext = createRequestValidatorInput();
 377         lcmStateManager.enableLCMOperations();
 378         transactionRecorder = Mockito.mock(TransactionRecorder.class);
 379         Mockito.when(transactionRecorder.isTransactionDuplicate(anyObject())).thenReturn(false);
 380         TransactionRecord transactionRecord = new TransactionRecord();
 381         transactionRecord.setMode(Mode.EXCLUSIVE);
 382         runtimeContext.setTransactionRecord(transactionRecord);
 383         impl.setTransactionRecorder(transactionRecorder);
 384         WorkflowExistsOutput workflowExistsOutput = Mockito.spy(new WorkflowExistsOutput(true, true));
 385         WorkFlowManager workflowManager = Mockito.mock(WorkFlowManagerImpl.class);
 386         Mockito.when(workflowManager.workflowExists(Mockito.any(WorkflowRequest.class)))
 387             .thenReturn(workflowExistsOutput);
 388         Mockito.when(workflowExistsOutput.isDgExist()).thenReturn(false);
 389         impl.setWorkflowManager(workflowManager);
 390         ResponseContext responseContext = runtimeContext.getResponseContext();
 391         returnResponseContextCommonHeader(responseContext);
 392         RestClientInvoker client = mock(RestClientInvoker.class);
 393         HttpResponse httpResponse = new BasicHttpResponse(new ProtocolVersion("HTTP",1,0), 200, "ACCEPTED");
 394         httpResponse.setEntity(getHttpEntity());
 395         Mockito.when(client.doPost(Mockito.anyString(), Mockito.anyString())).thenReturn(httpResponse);
 396         impl.setClient(client);
 397         RequestValidationPolicy requestValidationPolicy = Mockito.mock(RequestValidationPolicy.class);
 398         RuleExecutor ruleExecutor = Mockito.mock(RuleExecutor.class);
 399         RuleResult ruleResult = RuleResult.REJECT;
 400         Mockito.when(requestValidationPolicy.getInProgressRuleExecutor()).thenReturn(ruleExecutor);
 401         Mockito.when(ruleExecutor.executeRule(Mockito.anyString(), Mockito.anyListOf(VNFOperation.class)))
 402             .thenReturn(ruleResult);
 403         impl.setRequestValidationPolicy(requestValidationPolicy);
 404         impl.validateRequest(runtimeContext);
 405     }
 406
 407     @Test
 408     public void testLogInProgressTransactions() {
 409         ArrayList<TransactionRecord> trArray = new ArrayList<>();
 410         TransactionRecord tr = new TransactionRecord();
 411         tr.setRequestState(RequestStatus.ACCEPTED);
 412         tr.setStartTime(Instant.now().minus(48, ChronoUnit.HOURS));
 413         tr.setTargetId("Vnf001");
 414         trArray.add(tr);
 415         String loggedMessage = impl.logInProgressTransactions(trArray, 1, 1);
 416         String partMessage = "In Progress transaction for Target ID - Vnf001 in state ACCEPTED";
 417         assertTrue(StringUtils.contains(loggedMessage, partMessage));
 418     }
 419
 420     @Test
 421     public void testWithTransactionWindowNumberFormatException() throws APPCException {
 422         Properties properties = new Properties();
 423         properties.put(RequestValidatorImpl.TRANSACTION_WINDOW_HOURS, "TEST");
 424         properties.put(RequestValidatorImpl.SCOPE_OVERLAP_ENDPOINT, "TEST");
 425         Configuration config = Mockito.mock(Configuration.class);
 426         Mockito.when(config.getProperties()).thenReturn(properties);
 427         Whitebox.setInternalState(impl, "configuration", config);
 428         expectedEx.expect(APPCException.class);
 429         expectedEx.expectMessage("RequestValidatorImpl:::Error parsing transaction window interval!");
 430         impl.initialize();
 431     }
 432
 433     @Test
 434     public void testWithTransactionWindow() throws APPCException {
 435         Properties properties = new Properties();
 436         properties.put(RequestValidatorImpl.TRANSACTION_WINDOW_HOURS, "1");
 437         properties.put(RequestValidatorImpl.SCOPE_OVERLAP_ENDPOINT, "http://server:80");
 438         Configuration config = Mockito.mock(Configuration.class);
 439         Mockito.when(config.getProperties()).thenReturn(properties);
 440         Whitebox.setInternalState(impl, "configuration", config);
 441         impl.initialize();
 442         assertTrue(Whitebox.getInternalState(impl, "client") instanceof RestClientInvoker);
 443     }
 444
 445     private RuntimeContext createRequestValidatorInput() {
 446         return createRequestHandlerRuntimeContext("VSCP", "{\"request-id\":\"request-id\"}");
 447     }
 448
 449     private CommonHeader returnResponseContextCommonHeader(ResponseContext responseContext) {
 450         CommonHeader commonHeader = responseContext.getCommonHeader();
 451         Flags flags = new Flags();
 452         flags.setForce(false);
 453         commonHeader.setFlags(flags);
 454         commonHeader.setRequestId("TEST_REQUEST_ID");
 455         return commonHeader;
 456     }
 457
 458     private BasicHttpEntity getHttpEntity() {
 459         BasicHttpEntity httpEntity = new BasicHttpEntity();
 460         InputStream inputStream = new ByteArrayInputStream(
 461                 "{\"output\": {\"status\": {\"message\": \"test_messge\",\"code\": \"400\",\"status\":\"test_status\"},\"response-info\": { \"block\": \"true\"}}}".getBytes());
 462         httpEntity.setContent(inputStream);
 463         return httpEntity;
 464     }
 465 }