bpmn/MSOCommonBPMN/src/test/java/org/openecomp/mso/bpmn/common/SDNCAdapterV1Test.java

   1 /*- \r
   2  * ============LICENSE_START======================================================= \r
   3  * ONAP - SO \r
   4  * ================================================================================ \r
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. \r
   6  * ================================================================================ \r
   7  * Licensed under the Apache License, Version 2.0 (the "License"); \r
   8  * you may not use this file except in compliance with the License. \r
   9  * You may obtain a copy of the License at \r
  10  * \r
  11  *      http://www.apache.org/licenses/LICENSE-2.0 \r
  12  * \r
  13  * Unless required by applicable law or agreed to in writing, software \r
  14  * distributed under the License is distributed on an "AS IS" BASIS, \r
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. \r
  16  * See the License for the specific language governing permissions and \r
  17  * limitations under the License. \r
  18  * ============LICENSE_END========================================================= \r
  19  */ \r
  20 \r
  21 package org.openecomp.mso.bpmn.common;\r
  22 \r
  23 import static org.junit.Assert.assertEquals;\r
  24 import static org.junit.Assert.assertFalse;\r
  25 import static org.junit.Assert.assertNotNull;\r
  26 import static org.junit.Assert.assertTrue;\r
  27 import static org.openecomp.mso.bpmn.mock.StubResponseDatabase.mockUpdateRequestDB;\r
  28 import static org.openecomp.mso.bpmn.mock.StubResponseSDNCAdapter.mockSDNCAdapter;\r
  29 \r
  30 import java.io.IOException;\r
  31 import java.util.HashMap;\r
  32 import java.util.Map;\r
  33 \r
  34 import javax.ws.rs.core.Response;\r
  35 \r
  36 import org.camunda.bpm.engine.impl.cfg.ProcessEngineConfigurationImpl;\r
  37 import org.camunda.bpm.engine.runtime.Job;\r
  38 import org.camunda.bpm.engine.test.Deployment;\r
  39 import org.camunda.bpm.engine.variable.impl.VariableMapImpl;\r
  40 import org.junit.Assert;\r
  41 import org.junit.Ignore;\r
  42 import org.junit.Test;\r
  43 import org.openecomp.mso.bpmn.common.adapter.sdnc.CallbackHeader;\r
  44 import org.openecomp.mso.bpmn.common.adapter.sdnc.SDNCAdapterCallbackRequest;\r
  45 import org.openecomp.mso.bpmn.common.adapter.sdnc.SDNCAdapterResponse;\r
  46 import org.openecomp.mso.bpmn.common.workflow.service.SDNCAdapterCallbackServiceImpl;\r
  47 import org.openecomp.mso.bpmn.common.workflow.service.SDNCAdapterCallbackServiceImpl.SDNCAdapterErrorResponse;\r
  48 import org.openecomp.mso.bpmn.common.workflow.service.WorkflowResource;\r
  49 import org.openecomp.mso.bpmn.common.workflow.service.WorkflowResponse;\r
  50 import org.openecomp.mso.bpmn.core.PropertyConfigurationSetup;\r
  51 import org.openecomp.mso.bpmn.core.xml.XmlTool;\r
  52 import org.openecomp.mso.bpmn.mock.FileUtil;\r
  53 \r
  54 /**\r
  55  * Unit test cases for SDNCAdapterV1.bpmn\r
  56  */\r
  57 public class SDNCAdapterV1Test extends WorkflowTest {\r
  58 \r
  59         private String sdncAdapterWorkflowRequest;\r
  60         private String sdncAdapterWorkflowRequestAct;\r
  61         private String sdncAdapterCallbackRequestData;\r
  62         private String sdncAdapterCallbackRequestDataNonfinal;\r
  63 \r
  64         public SDNCAdapterV1Test() throws IOException {\r
  65                 sdncAdapterWorkflowRequest = FileUtil.readResourceFile("sdncadapterworkflowrequest.xml");\r
  66                 sdncAdapterWorkflowRequestAct = FileUtil.readResourceFile("sdncadapterworkflowrequest-act.xml");\r
  67                 sdncAdapterCallbackRequestData = FileUtil.readResourceFile("sdncadaptercallbackrequestdata.text");\r
  68                 sdncAdapterCallbackRequestDataNonfinal = FileUtil.readResourceFile("sdncadaptercallbackrequestdata-nonfinal.text");\r
  69         }\r
  70 \r
  71         /**\r
  72          * End-to-End flow - Unit test for SDNCAdapterV1.bpmn\r
  73          *  - String input & String response\r
  74          */\r
  75 \r
  76         private WorkflowResponse invokeFlow(String workflowRequest) {\r
  77 \r
  78                 Map<String, Object>valueMap = new HashMap<String, Object>();\r
  79                 valueMap.put("value", workflowRequest);\r
  80                 Map<String, Object> variables = new HashMap<String, Object>();\r
  81                 variables.put("sdncAdapterWorkflowRequest", valueMap);\r
  82 \r
  83                 Map<String, Object> valueMap2 = new HashMap<String, Object>();\r
  84                 valueMap2.put("value", "true");\r
  85                 variables.put("isDebugLogEnabled", valueMap2);\r
  86 \r
  87                 VariableMapImpl varMap = new VariableMapImpl();\r
  88                 varMap.put("variables", variables);\r
  89 \r
  90                 //System.out.println("Invoking the flow");\r
  91 \r
  92                 WorkflowResource workflowResource = new WorkflowResource();\r
  93                 workflowResource.setProcessEngineServices4junit(processEngineRule);\r
  94 \r
  95                 Response response = workflowResource.startProcessInstanceByKey("sdncAdapter", varMap);\r
  96                 WorkflowResponse workflowResponse = (WorkflowResponse) response.getEntity();\r
  97 \r
  98                 //String pid = workflowResponse.getProcessInstanceID();\r
  99                 //System.out.println("Back from executing process instance with pid=" + pid);\r
 100                 return workflowResponse;\r
 101         }\r
 102 \r
 103         @Test\r
 104         @Deployment(resources = {"subprocess/SDNCAdapterV1.bpmn",\r
 105                         "subprocess/GenericNotificationService.bpmn"\r
 106                         })\r
 107         public void sunnyDay() throws InterruptedException {\r
 108 \r
 109                 mockSDNCAdapter(200);\r
 110 \r
 111                 //System.out.println("SDNCAdapter sunny day flow Started!");\r
 112 \r
 113                 ProcessExecutionThread thread = new ProcessExecutionThread(sdncAdapterWorkflowRequest);\r
 114                 thread.start();\r
 115                 waitForExecutionToStart("sdncAdapter", 3);\r
 116                 String pid = getPid();\r
 117 \r
 118                 assertProcessInstanceNotFinished(pid);\r
 119 \r
 120                 System.out.println("Injecting SDNC Adapter asynchronous callback message to continue processing");\r
 121                 String generatedRequestId = (String) processEngineRule.getRuntimeService().getVariable(pid, "SDNCA_requestId");\r
 122                 CallbackHeader callbackHeader = new CallbackHeader();\r
 123                 callbackHeader.setRequestId(generatedRequestId);\r
 124                 callbackHeader.setResponseCode("200");\r
 125                 callbackHeader.setResponseMessage("OK");\r
 126                 SDNCAdapterCallbackRequest sdncAdapterCallbackRequest = new SDNCAdapterCallbackRequest();\r
 127                 sdncAdapterCallbackRequest.setCallbackHeader(callbackHeader);\r
 128                 sdncAdapterCallbackRequest.setRequestData(sdncAdapterCallbackRequestData);\r
 129                 SDNCAdapterCallbackServiceImpl callbackService = new SDNCAdapterCallbackServiceImpl();\r
 130                 callbackService.setProcessEngineServices4junit(processEngineRule);\r
 131                 SDNCAdapterResponse sdncAdapterResponse = callbackService.sdncAdapterCallback(sdncAdapterCallbackRequest);\r
 132                 //System.out.println("Back from executing process again");\r
 133 \r
 134                 assertFalse(sdncAdapterResponse instanceof SDNCAdapterErrorResponse);\r
 135                 assertProcessInstanceFinished(pid);\r
 136 \r
 137                 //System.out.println("SDNCAdapter sunny day flow Completed!");\r
 138         }\r
 139 \r
 140         @Test\r
 141         @Deployment(resources = {"subprocess/SDNCAdapterV1.bpmn",\r
 142                         "subprocess/GenericNotificationService.bpmn"\r
 143                         })\r
 144         public void nonFinalWithTimeout() throws InterruptedException {\r
 145 \r
 146                 mockSDNCAdapter(200);\r
 147                 mockUpdateRequestDB(200, "Database/DBAdapter.xml");\r
 148 \r
 149                 //System.out.println("SDNCAdapter interim status processing flow Started!");\r
 150 \r
 151                 ProcessExecutionThread thread = new ProcessExecutionThread(sdncAdapterWorkflowRequestAct);\r
 152                 thread.start();\r
 153                 waitForExecutionToStart("sdncAdapter", 3);\r
 154                 String pid = getPid();\r
 155 \r
 156                 assertProcessInstanceNotFinished(pid);\r
 157 \r
 158                 //System.out.println("Injecting SDNC Adapter asynchronous callback message to continue processing");\r
 159                 String generatedRequestId = (String) processEngineRule.getRuntimeService().getVariable(pid, "SDNCA_requestId");\r
 160                 CallbackHeader callbackHeader = new CallbackHeader();\r
 161                 callbackHeader.setRequestId(generatedRequestId);\r
 162                 callbackHeader.setResponseCode("200");\r
 163                 callbackHeader.setResponseMessage("OK");\r
 164                 SDNCAdapterCallbackRequest sdncAdapterCallbackRequest = new SDNCAdapterCallbackRequest();\r
 165                 sdncAdapterCallbackRequest.setCallbackHeader(callbackHeader);\r
 166                 sdncAdapterCallbackRequest.setRequestData(sdncAdapterCallbackRequestDataNonfinal);\r
 167                 SDNCAdapterCallbackServiceImpl callbackService = new SDNCAdapterCallbackServiceImpl();\r
 168                 callbackService.setProcessEngineServices4junit(processEngineRule);\r
 169                 SDNCAdapterResponse sdncAdapterResponse = callbackService.sdncAdapterCallback(sdncAdapterCallbackRequest);\r
 170                 //System.out.println("Back from executing process again");\r
 171 \r
 172                 assertFalse(sdncAdapterResponse instanceof SDNCAdapterErrorResponse);\r
 173                 assertProcessInstanceNotFinished(pid);\r
 174 \r
 175                 checkForTimeout(pid);\r
 176 \r
 177                 assertEquals(true, (Boolean) (getVariable(pid, "continueListening")));\r
 178                 assertEquals(false, (Boolean) (getVariable(pid, "SDNCA_InterimNotify")));\r
 179 \r
 180 \r
 181                 //System.out.println("SDNCAdapter interim status processing flow Completed!");\r
 182         }\r
 183 \r
 184         @Test\r
 185         @Deployment(resources = {"subprocess/SDNCAdapterV1.bpmn",\r
 186                         "subprocess/GenericNotificationService.bpmn"\r
 187                         })\r
 188         public void nonFinalThenFinal() throws InterruptedException {\r
 189 \r
 190                 mockSDNCAdapter(200);\r
 191                 mockUpdateRequestDB(200, "Database/DBAdapter.xml");\r
 192 \r
 193                 //System.out.println("SDNCAdapter non-final then final processing flow Started!");\r
 194 \r
 195                 // Start the flow\r
 196                 ProcessExecutionThread thread = new ProcessExecutionThread(sdncAdapterWorkflowRequestAct);\r
 197                 thread.start();\r
 198                 waitForExecutionToStart("sdncAdapter", 3);\r
 199                 String pid = getPid();\r
 200 \r
 201                 assertProcessInstanceNotFinished(pid);\r
 202 \r
 203                 // Inject a "non-final" SDNC Adapter asynchronous callback message\r
 204                 //System.out.println("Injecting SDNC Adapter asynchronous callback message to continue processing");\r
 205                 String generatedRequestId = (String) processEngineRule.getRuntimeService().getVariable(pid, "SDNCA_requestId");\r
 206                 CallbackHeader callbackHeader = new CallbackHeader();\r
 207                 callbackHeader.setRequestId(generatedRequestId);\r
 208                 callbackHeader.setResponseCode("200");\r
 209                 callbackHeader.setResponseMessage("OK");\r
 210                 SDNCAdapterCallbackRequest sdncAdapterCallbackRequest = new SDNCAdapterCallbackRequest();\r
 211                 sdncAdapterCallbackRequest.setCallbackHeader(callbackHeader);\r
 212                 sdncAdapterCallbackRequest.setRequestData(sdncAdapterCallbackRequestDataNonfinal);\r
 213                 SDNCAdapterCallbackServiceImpl callbackService = new SDNCAdapterCallbackServiceImpl();\r
 214                 callbackService.setProcessEngineServices4junit(processEngineRule);\r
 215                 SDNCAdapterResponse sdncAdapterResponse = callbackService.sdncAdapterCallback(sdncAdapterCallbackRequest);\r
 216                 //System.out.println("Back from executing process again");\r
 217 \r
 218                 assertFalse(sdncAdapterResponse instanceof SDNCAdapterErrorResponse);\r
 219                 assertProcessInstanceNotFinished(pid);\r
 220                 assertEquals(true, (Boolean) (getVariable(pid, "continueListening")));\r
 221                 assertEquals(false, (Boolean) (getVariable(pid, "SDNCA_InterimNotify")));\r
 222 \r
 223                 // Inject a "final" SDNC Adapter asynchronous callback message\r
 224                 sdncAdapterCallbackRequest.setRequestData(sdncAdapterCallbackRequestData);\r
 225                 sdncAdapterResponse = callbackService.sdncAdapterCallback(sdncAdapterCallbackRequest);\r
 226                 //System.out.println("Back from executing process again");\r
 227 \r
 228                 assertFalse(sdncAdapterResponse instanceof SDNCAdapterErrorResponse);\r
 229                 assertProcessInstanceFinished(pid);\r
 230                 assertEquals(false, (Boolean) (getVariable(pid, "continueListening")));\r
 231                 assertEquals(false, (Boolean) (getVariable(pid, "SDNCA_InterimNotify")));\r
 232 \r
 233                 //System.out.println("SDNCAdapter non-final then final processing flow Completed!");\r
 234         }\r
 235 \r
 236 \r
 237         @Test\r
 238         @Deployment(resources = {"subprocess/SDNCAdapterV1.bpmn",\r
 239                         "subprocess/GenericNotificationService.bpmn"\r
 240                         })\r
 241         public void nonFinalThenFinalWithNotify() throws InterruptedException {\r
 242 \r
 243                 mockSDNCAdapter(200);\r
 244                 mockUpdateRequestDB(200, "Database/DBAdapter.xml");\r
 245 \r
 246                 //System.out.println("SDNCAdapter non-final then final processing flow Started!");\r
 247 \r
 248                 String modSdncAdapterWorkflowRequestAct = sdncAdapterWorkflowRequestAct;\r
 249                 try {\r
 250                         // only service-type "uCPE-VMS" is applicable to notification, so modify the test request\r
 251                         modSdncAdapterWorkflowRequestAct = XmlTool.modifyElement(sdncAdapterWorkflowRequestAct, "tag0:service-type", "uCPE-VMS").get();\r
 252                         System.out.println("modified request: " + modSdncAdapterWorkflowRequestAct);\r
 253                 } catch (Exception e) {\r
 254                         System.out.println("request modification failed");\r
 255                         //e.printStackTrace();\r
 256                 }\r
 257 \r
 258                 // Start the flow\r
 259                 ProcessExecutionThread thread = new ProcessExecutionThread(modSdncAdapterWorkflowRequestAct);\r
 260                 thread.start();\r
 261                 waitForExecutionToStart("sdncAdapter", 3);\r
 262                 String pid = getPid();\r
 263 \r
 264                 assertProcessInstanceNotFinished(pid);\r
 265 \r
 266                 // Inject a "non-final" SDNC Adapter asynchronous callback message\r
 267                 //System.out.println("Injecting SDNC Adapter asynchronous callback message to continue processing");\r
 268                 String generatedRequestId = (String) processEngineRule.getRuntimeService().getVariable(pid, "SDNCA_requestId");\r
 269                 CallbackHeader callbackHeader = new CallbackHeader();\r
 270                 callbackHeader.setRequestId(generatedRequestId);\r
 271                 callbackHeader.setResponseCode("200");\r
 272                 callbackHeader.setResponseMessage("OK");\r
 273                 SDNCAdapterCallbackRequest sdncAdapterCallbackRequest = new SDNCAdapterCallbackRequest();\r
 274                 sdncAdapterCallbackRequest.setCallbackHeader(callbackHeader);\r
 275                 sdncAdapterCallbackRequest.setRequestData(sdncAdapterCallbackRequestDataNonfinal);\r
 276                 SDNCAdapterCallbackServiceImpl callbackService = new SDNCAdapterCallbackServiceImpl();\r
 277                 callbackService.setProcessEngineServices4junit(processEngineRule);\r
 278                 SDNCAdapterResponse sdncAdapterResponse = callbackService.sdncAdapterCallback(sdncAdapterCallbackRequest);\r
 279                 //System.out.println("Back from executing process again");\r
 280 \r
 281                 assertFalse(sdncAdapterResponse instanceof SDNCAdapterErrorResponse);\r
 282                 assertProcessInstanceNotFinished(pid);\r
 283                 assertEquals(true, (Boolean) (getVariable(pid, "continueListening")));\r
 284                 assertEquals(true, (Boolean) (getVariable(pid, "SDNCA_InterimNotify")));\r
 285 \r
 286                 // Inject a "final" SDNC Adapter asynchronous callback message\r
 287                 sdncAdapterCallbackRequest.setRequestData(sdncAdapterCallbackRequestData);\r
 288                 sdncAdapterResponse = callbackService.sdncAdapterCallback(sdncAdapterCallbackRequest);\r
 289                 //System.out.println("Back from executing process again");\r
 290 \r
 291                 assertFalse(sdncAdapterResponse instanceof SDNCAdapterErrorResponse);\r
 292                 assertProcessInstanceFinished(pid);\r
 293                 assertEquals(false, (Boolean) (getVariable(pid, "continueListening")));\r
 294                 assertEquals(false, (Boolean) (getVariable(pid, "SDNCA_InterimNotify")));\r
 295 \r
 296                 //System.out.println("SDNCAdapter non-final then final processing flow Completed!");\r
 297         }\r
 298 \r
 299 \r
 300         private void waitForExecutionToStart(String processDefintion, int count) throws InterruptedException {\r
 301                 //System.out.println(processEngineRule.getRuntimeService().createExecutionQuery().processDefinitionKey(processDefintion).count());\r
 302                 while (processEngineRule.getRuntimeService().createExecutionQuery().processDefinitionKey(processDefintion).count() != count) {\r
 303                         Thread.sleep(200);\r
 304                 }\r
 305         }\r
 306 \r
 307         @Test\r
 308         @Ignore // Ignored because PropertyConfigurationSetup is timing out\r
 309         @Deployment(resources = {"subprocess/SDNCAdapterV1.bpmn",\r
 310                         "subprocess/GenericNotificationService.bpmn"\r
 311                         })\r
 312         public void badCorrelationIdTest() throws InterruptedException, IOException {\r
 313 \r
 314                 mockSDNCAdapter(200);\r
 315 \r
 316                 Map<String, String> urnProperties = PropertyConfigurationSetup.createBpmnUrnProperties();\r
 317                 urnProperties.put("mso.correlation.timeout", "5");\r
 318                 PropertyConfigurationSetup.addProperties(urnProperties, 10000);\r
 319 \r
 320                 //System.out.println("SDNCAdapter bad RequestId test Started!");\r
 321 \r
 322                 ProcessExecutionThread thread = new ProcessExecutionThread(sdncAdapterWorkflowRequest);\r
 323                 thread.start();\r
 324                 waitForExecutionToStart("sdncAdapter", 3);\r
 325                 String pid = getPid();\r
 326                 assertProcessInstanceNotFinished(pid);\r
 327 \r
 328                 //System.out.println("Injecting SDNC Adapter asynchronous callback message to continue processing");\r
 329                 String badRequestId = "This is not the RequestId that was used";\r
 330                 CallbackHeader callbackHeader = new CallbackHeader();\r
 331                 callbackHeader.setRequestId(badRequestId);\r
 332                 callbackHeader.setResponseCode("200");\r
 333                 callbackHeader.setResponseMessage("OK");\r
 334                 SDNCAdapterCallbackRequest sdncAdapterCallbackRequest = new SDNCAdapterCallbackRequest();\r
 335                 sdncAdapterCallbackRequest.setCallbackHeader(callbackHeader);\r
 336                 sdncAdapterCallbackRequest.setRequestData(sdncAdapterCallbackRequestData);\r
 337                 SDNCAdapterCallbackServiceImpl callbackService = new SDNCAdapterCallbackServiceImpl();\r
 338                 callbackService.setProcessEngineServices4junit(processEngineRule);\r
 339                 SDNCAdapterResponse sdncAdapterResponse = callbackService.sdncAdapterCallback(sdncAdapterCallbackRequest);\r
 340                 //System.out.println("Back from executing process again");\r
 341 \r
 342                 assertTrue(sdncAdapterResponse instanceof SDNCAdapterErrorResponse);\r
 343                 assertTrue(((SDNCAdapterErrorResponse) sdncAdapterResponse).getError().contains("No process is waiting for sdncAdapterCallbackRequest"));\r
 344                 assertProcessInstanceNotFinished(pid);\r
 345 \r
 346                 //System.out.println("SDNCAdapter bad RequestId test Completed!");\r
 347         }\r
 348 \r
 349         @Test\r
 350         @Deployment(resources = {"subprocess/SDNCAdapterV1.bpmn",\r
 351                         "subprocess/GenericNotificationService.bpmn"\r
 352                         })\r
 353         public void badSynchronousResponse() throws IOException, InterruptedException {\r
 354 \r
 355                 mockSDNCAdapter(404);\r
 356 \r
 357                 //System.out.println("SDNCAdapter bad synchronous response flow Started!");\r
 358 \r
 359                 ProcessExecutionThread thread = new ProcessExecutionThread(sdncAdapterWorkflowRequest);\r
 360                 thread.start();\r
 361                 while (thread.isAlive()) {\r
 362                         Thread.sleep(200);\r
 363                 }\r
 364                 WorkflowResponse response = thread.workflowResponse;\r
 365                 Assert.assertNotNull(response);\r
 366                 Assert.assertEquals("404 error", response.getMessageCode(),7000);\r
 367 //              assertProcessInstanceFinished(response.getProcessInstanceID());\r
 368                 //System.out.println("SDNCAdapter bad synchronous response flow Completed!");\r
 369         }\r
 370 \r
 371         @Test\r
 372         @Deployment(resources = {"subprocess/SDNCAdapterV1.bpmn",\r
 373                         "subprocess/GenericNotificationService.bpmn"\r
 374                         })\r
 375         public void sdncNotFound() throws IOException, InterruptedException {\r
 376                 mockSDNCAdapter(200);\r
 377                 mockSDNCAdapter("/sdncAdapterMock/404", 400, "sdncCallbackErrorResponse.xml");\r
 378 \r
 379                 ProcessExecutionThread thread = new ProcessExecutionThread(sdncAdapterWorkflowRequest);\r
 380                 thread.start();\r
 381                 waitForExecutionToStart("sdncAdapter", 3);\r
 382                 String pid = getPid();\r
 383 \r
 384                 //System.out.println("Injecting SDNC Adapter asynchronous callback message to continue processing");\r
 385                 String generatedRequestId = (String) processEngineRule.getRuntimeService().getVariable(pid, "SDNCA_requestId");\r
 386                 CallbackHeader callbackHeader = new CallbackHeader();\r
 387                 callbackHeader.setRequestId(generatedRequestId);\r
 388                 callbackHeader.setResponseCode("404");\r
 389                 callbackHeader.setResponseMessage("Error processing request to SDNC. Not Found. https://sdncodl.it.us.aic.cip.com:8443/restconf/config/L3SDN-API:services/layer3-service-list/AS%2FVLXM%2F000199%2F%2FSB_INTERNET. SDNC Returned-[error-type:application, error-tag:data-missing, error-message:Request could not be completed because the relevant data model content does not exist.]");\r
 390                 SDNCAdapterCallbackRequest sdncAdapterCallbackRequest = new SDNCAdapterCallbackRequest();\r
 391                 sdncAdapterCallbackRequest.setCallbackHeader(callbackHeader);\r
 392                 SDNCAdapterCallbackServiceImpl callbackService = new SDNCAdapterCallbackServiceImpl();\r
 393                 callbackService.setProcessEngineServices4junit(processEngineRule);\r
 394                 SDNCAdapterResponse sdncAdapterResponse = callbackService.sdncAdapterCallback(sdncAdapterCallbackRequest);\r
 395                 //System.out.println("Back from executing process again");\r
 396 \r
 397                 assertProcessInstanceFinished(pid);\r
 398                 assertNotNull(sdncAdapterResponse);\r
 399                 //TODO query history to see SDNCA_ResponseCode, SDNCA_ErrorResponse\r
 400                 //System.out.println("SDNCAdapter SDNC Notfound test Completed!");\r
 401         }\r
 402 \r
 403         @Test\r
 404         @Deployment(resources = {"subprocess/SDNCAdapterV1.bpmn",\r
 405                         "subprocess/GenericNotificationService.bpmn"\r
 406                         })\r
 407         public void asynchronousMessageTimeout() throws IOException, InterruptedException {\r
 408                 mockSDNCAdapter(200);\r
 409                 //System.out.println("SDNCAdapter asynchronous message timeout flow Started!");\r
 410                 ProcessExecutionThread thread = new ProcessExecutionThread(sdncAdapterWorkflowRequest);\r
 411                 thread.start();\r
 412                 waitForExecutionToStart("sdncAdapter", 3);\r
 413                 checkForTimeout(getPid());\r
 414         }\r
 415 \r
 416         private void checkForTimeout(String pid) throws InterruptedException {\r
 417 \r
 418                 assertProcessInstanceNotFinished(pid);\r
 419 \r
 420                 ProcessEngineConfigurationImpl processEngineConfiguration =\r
 421                         (ProcessEngineConfigurationImpl) processEngineRule.getProcessEngine().getProcessEngineConfiguration();\r
 422                 assertTrue(processEngineConfiguration.getJobExecutor().isActive());\r
 423 \r
 424             Job timerJob = processEngineRule.getManagementService().createJobQuery().processInstanceId(pid).singleResult();\r
 425             assertNotNull(timerJob);\r
 426 \r
 427             processEngineRule.getManagementService().executeJob(timerJob.getId());\r
 428 \r
 429             assertProcessInstanceFinished(pid);\r
 430 \r
 431                 //System.out.println("SDNCAdapter asynchronous message timeout flow Completed!");\r
 432         }\r
 433 \r
 434         class ProcessExecutionThread extends Thread {\r
 435 \r
 436                 private String workflowRequest;\r
 437                 private WorkflowResponse workflowResponse;\r
 438 \r
 439                 public ProcessExecutionThread(String workflowRequest) {\r
 440                         this.workflowRequest = workflowRequest;\r
 441                 }\r
 442 \r
 443                 public void run() {\r
 444                         workflowResponse = invokeFlow(workflowRequest);\r
 445                         workflowResponse.getProcessInstanceID();\r
 446                 }\r
 447         }\r
 448 \r
 449         private String getPid() {\r
 450                 return processEngineRule.getHistoryService().createHistoricProcessInstanceQuery().list().get(0).getId();\r
 451         }\r
 452 \r
 453         private Object getVariable(String pid, String variableName) {\r
 454                 try {\r
 455                         return\r
 456                                 processEngineRule\r
 457                                         .getHistoryService()\r
 458                                         .createHistoricVariableInstanceQuery()\r
 459                                         .processInstanceId(pid).variableName(variableName)\r
 460                                         .singleResult()\r
 461                                         .getValue();\r
 462                 } catch(Exception ex) {\r
 463                         return null;\r
 464                 }\r
 465         }\r
 466 \r
 467         private void assertProcessInstanceFinished(String pid) {\r
 468             assertEquals(1, processEngineRule.getHistoryService().createHistoricProcessInstanceQuery().processInstanceId(pid).finished().count());\r
 469         }\r
 470 \r
 471         private void assertProcessInstanceNotFinished(String pid) {\r
 472             assertEquals(0, processEngineRule.getHistoryService().createHistoricProcessInstanceQuery().processInstanceId(pid).finished().count());\r
 473         }\r
 474 \r
 475 }\r