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