//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void setUpRuntimeData() public virtual void setUpRuntimeData() { when(processEngine.ExternalTaskService).thenReturn(externalTaskService); lockedExternalTaskMock = MockProvider.createMockLockedExternalTask(); when(externalTaskService.fetchAndLock(anyInt(), any(typeof(string)), any(typeof(Boolean)))).thenReturn(fetchTopicBuilder); when(fetchTopicBuilder.topic(any(typeof(string)), anyLong())).thenReturn(fetchTopicBuilder); when(fetchTopicBuilder.variables(anyListOf(typeof(string)))).thenReturn(fetchTopicBuilder); when(fetchTopicBuilder.enableCustomObjectDeserialization()).thenReturn(fetchTopicBuilder); // for authentication when(processEngine.IdentityService).thenReturn(identityServiceMock); IList <Group> groupMocks = MockProvider.createMockGroups(); groupIds = setupGroupQueryMock(groupMocks); IList <Tenant> tenantMocks = Collections.singletonList(MockProvider.createMockTenant()); tenantIds = setupTenantQueryMock(tenantMocks); (new FetchAndLockContextListener()).contextInitialized(mock(typeof(ServletContextEvent), RETURNS_DEEP_STUBS)); }
public void failedOperation(DbOperation operation) { if (operation is DbEntityOperation) { DbEntityOperation dbEntityOperation = (DbEntityOperation)operation; DbEntity dbEntity = dbEntityOperation.Entity; bool failedOperationEntityInList = false; IEnumerator <LockedExternalTask> it = tasks.GetEnumerator(); while (it.MoveNext()) { LockedExternalTask resultTask = it.Current; if (resultTask.Id.Equals(dbEntity.Id)) { //JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only: it.remove(); failedOperationEntityInList = true; break; } } if (!failedOperationEntityInList) { throw LOG.concurrentUpdateDbEntityException(operation); } } }
public virtual void testFetchAndLockIgnoreRead() { // given IList <string> permissions = new List <string>(); permissions.Add(READ.name()); permissions.Add(READ_INSTANCE.name()); processEngineConfiguration.DisabledPermissions = permissions; ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneExternalTaskProcess"); authRule.createGrantAuthorization(PROCESS_INSTANCE, "*", USER_ID, UPDATE); authRule.enableAuthorization(USER_ID); // when IList <LockedExternalTask> externalTasks = engineRule.ExternalTaskService.fetchAndLock(1, "aWorkerId").topic("externalTaskTopic", 10000L).execute(); // then assertEquals(1, externalTasks.Count); LockedExternalTask task = externalTasks[0]; assertNotNull(task.Id); assertEquals(processInstance.Id, task.ProcessInstanceId); assertEquals(processInstance.ProcessDefinitionId, task.ProcessDefinitionId); assertEquals("externalTask", task.ActivityId); assertEquals("oneExternalTaskProcess", task.ProcessDefinitionKey); }
public async Task ProcessLockedTasks(string workerId, LockedExternalTask lockedExternalTask) { var executor = GetExecutor(lockedExternalTask.TopicName); var executorAttribute = GetExecutorAttributeData(executor); var externalTask = lockedExternalTask.ToExternalTask(); try { var resultVariables = await ExecuteExternalTask(executor, externalTask); var completeExternalTask = new CompleteExternalTask { WorkerId = workerId, Variables = resultVariables.ToVariableDictionary() }; await _engineClient.Client().ExternalTasks[externalTask.Id].Complete(completeExternalTask); } catch (ExternalTaskException ex) { HandleExternalTaskException(workerId, externalTask, ex); } catch (Exception ex) { HandleException(workerId, executorAttribute, externalTask, ex); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldScheduleToLater() public virtual void shouldScheduleToLater() { // given testRule.deploy(Bpmn.createExecutableProcess("process").camundaHistoryTimeToLive(5).startEvent().serviceTask().camundaExternalTask("anExternalTaskTopic").multiInstance().cardinality("5").multiInstanceDone().endEvent().done()); ClockUtil.CurrentTime = END_DATE; runtimeService.startProcessInstanceByKey("process"); for (int i = 0; i < 5; i++) { LockedExternalTask externalTask = externalTaskService.fetchAndLock(1, "aWorkerId").topic("anExternalTaskTopic", 2000).execute()[0]; externalTaskService.complete(externalTask.Id, "aWorkerId"); } engineConfiguration.HistoryCleanupBatchSize = 6; engineConfiguration.initHistoryCleanup(); DateTime removalTime = addDays(END_DATE, 5); ClockUtil.CurrentTime = removalTime; // when runHistoryCleanup(); Job job = historyService.findHistoryCleanupJobs()[0]; // then assertThat(job.Duedate, @is(addSeconds(removalTime, START_DELAY))); }
public void Execute(LockedExternalTask externalTask, ref Dictionary <string, VariableValue> resultVariables) { Thread.Sleep(8000); var amountLeft = ((double)externalTask.Variables["amount"].Value) - 1000; resultVariables.Add("amountLeft", VariableValue.FromObject(amountLeft)); Console.WriteLine("Charging credit..."); }
private static void CompleteTask(CamundaClient camunda, LockedExternalTask task, string response) { var completion = new CompleteExternalTask(); completion.WorkerId = task.WorkerId; completion.SetVariable("AsyncPostResponse", response); camunda.ExternalTasks[task.Id].Complete(completion); Console.WriteLine($"Finsihed Processing {task.Id} for {task.WorkerId}"); }
// handle failure test cases //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testHandleFailureWithAuthenticatedTenant() public virtual void testHandleFailureWithAuthenticatedTenant() { LockedExternalTask task = externalTaskService.fetchAndLock(1, WORKER_ID).topic(TOPIC_NAME, LOCK_TIME).execute()[0]; identityService.setAuthentication("aUserId", null, Arrays.asList(TENANT_ONE)); externalTaskService.handleFailure(task.Id, WORKER_ID, ERROR_MESSAGE, 1, 0); // then assertEquals(ERROR_MESSAGE, externalTaskService.fetchAndLock(1, WORKER_ID).topic(TOPIC_NAME, LOCK_TIME).execute()[0].ErrorMessage); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testHandleFailureWithNoAuthenticatedTenant() public virtual void testHandleFailureWithNoAuthenticatedTenant() { LockedExternalTask task = externalTaskService.fetchAndLock(1, WORKER_ID).topic(TOPIC_NAME, LOCK_TIME).execute()[0]; identityService.setAuthentication("aUserId", null); // then thrown.expect(typeof(ProcessEngineException)); thrown.expectMessage("Cannot update the process instance '" + processInstanceId + "' because it belongs to no authenticated tenant."); externalTaskService.handleFailure(task.Id, WORKER_ID, ERROR_MESSAGE, 1, 0); }
public void Execute(LockedExternalTask lockedExternalTask) { var resultVariables = new Dictionary <string, VariableValue>(); Console.WriteLine($"Executing External Task {lockedExternalTask.Id} from topic {topicManagerInfo.TopicName}"); try { topicManagerInfo.TaskAdapter.Execute(lockedExternalTask, ref resultVariables); var completeExternalTask = new CompleteExternalTask() { WorkerId = workerId, Variables = resultVariables }; policyManager.completePolicy().Execute(() => { externalTaskService[lockedExternalTask.Id].Complete(completeExternalTask).Wait(); Console.WriteLine($"Finished External Task {lockedExternalTask.Id} from topic {topicManagerInfo.TopicName}..."); }); } catch (UnrecoverableBusinessErrorException ex) { Console.WriteLine($"Failed with business error code {ex.BusinessErrorCode} for External Task {lockedExternalTask.Id} in topic {topicManagerInfo.TopicName}..."); var externalTaskBpmnError = new ExternalTaskBpmnError { WorkerId = workerId, ErrorCode = ex.BusinessErrorCode, ErrorMessage = ex.Message }; policyManager.handleBpmnErrorPolicy().Execute(() => externalTaskService[lockedExternalTask.Id].HandleBpmnError(externalTaskBpmnError).Wait()); } catch (UnlockTaskException ex) { Console.WriteLine($"Unlock requested for External Task {lockedExternalTask.Id} in topic {topicManagerInfo.TopicName}..."); policyManager.unlockPolicy().Execute(() => externalTaskService[lockedExternalTask.Id].Unlock().Wait()); } catch (Exception ex) { Console.WriteLine($"Failed External Task {lockedExternalTask.Id} in topic {topicManagerInfo.TopicName}..."); var retriesLeft = topicManagerInfo.Retries; // start with default if (lockedExternalTask.Retries.HasValue) // or decrement if retries are already set { retriesLeft = lockedExternalTask.Retries.Value - 1; } var externalTaskFailure = new ExternalTaskFailure() { WorkerId = workerId, Retries = retriesLeft, ErrorMessage = ex.Message, ErrorDetails = ex.StackTrace }; policyManager.handleFailurePolicy().Execute(() => externalTaskService[lockedExternalTask.Id].HandleFailure(externalTaskFailure).Wait()); } }
private void Execute(LockedExternalTask lockedExternalTask, Type type) { ExternalTask externalTask = lockedExternalTask.ToExternalTask(); var resultVariables = new Dictionary <string, object>(); try { LogEventToConsole($"{externalTask.ProcessDefinitionId} {externalTask.TopicName} Started", "INFO"); CreateAdapterInstanceAndExecute(externalTask, ref resultVariables, type); LogEventToConsole($"{externalTask.ProcessDefinitionId} {externalTask.TopicName} Finished", "INFO"); CompleteExternalTask completeExternalTask = new CompleteExternalTask() { WorkerId = _workerId, Variables = resultVariables.ToVariableDictionary() }; _camundaClient.ExternalTasks[externalTask.Id].Complete(completeExternalTask); } catch (ExternalTaskException ex) { LogEventToConsole($"{externalTask.ProcessDefinitionId} {externalTask.TopicName} {ex.Message}", "ERROR"); ExternalTaskBpmnError externalTaskBpmnError = new ExternalTaskBpmnError() { WorkerId = _workerId, ErrorCode = ex.BusinessErrorCode }; _camundaClient.ExternalTasks[externalTask.Id].HandleBpmnError(externalTaskBpmnError); } catch (Exception ex) { LogEventToConsole($"{externalTask.ProcessDefinitionId} {externalTask.TopicName} {ex.Message}", "ERROR"); var retriesLeft = _externalTaskWorkerInfo.Retries; // start with default if (externalTask.Retries.HasValue) // or decrement if retries are already set { retriesLeft = externalTask.Retries.Value - 1; } ExternalTaskFailure externalTaskFailure = new ExternalTaskFailure() { WorkerId = _workerId, ErrorMessage = ex.Message, ErrorDetails = ex.StackTrace, RetryTimeout = _externalTaskWorkerInfo.RetryTimeout, Retries = retriesLeft }; _camundaClient.ExternalTasks[externalTask.Id].HandleFailure(externalTaskFailure); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void initMocks() public virtual void initMocks() { when(processEngine.IdentityService).thenReturn(identityService); when(processEngine.ExternalTaskService).thenReturn(externalTaskService); when(processEngine.Name).thenReturn("default"); when(externalTaskService.fetchAndLock(anyInt(), any(typeof(string)), any(typeof(Boolean)))).thenReturn(fetchTopicBuilder); when(fetchTopicBuilder.topic(any(typeof(string)), anyLong())).thenReturn(fetchTopicBuilder); when(fetchTopicBuilder.variables(anyListOf(typeof(string)))).thenReturn(fetchTopicBuilder); when(fetchTopicBuilder.enableCustomObjectDeserialization()).thenReturn(fetchTopicBuilder); doNothing().when(handler).suspend(anyLong()); doReturn(processEngine).when(handler).getProcessEngine(any(typeof(FetchAndLockRequest))); lockedExternalTaskMock = MockProvider.createMockLockedExternalTask(); }
public void Execute(LockedExternalTask externalTask, ref Dictionary <string, VariableValue> resultVariables) { Random _random = new Random(); var randomNumber = _random.Next(0, 10); Console.WriteLine("Charging started"); var remaining = (double)externalTask.Variables["remaining"].Value; if (randomNumber >= 5) { resultVariables.Add("credit", VariableValue.FromObject(remaining)); } else { throw new UnrecoverableBusinessErrorException("ChargingFailure", "Charging failed"); } }
public virtual void testCompleteExternalTask() { // given ProcessInstance processInstance = engineRule.RuntimeService.startProcessInstanceByKey("oneExternalTaskProcess"); IList <LockedExternalTask> tasks = engineRule.ExternalTaskService.fetchAndLock(5, "workerId").topic("externalTaskTopic", 5000L).execute(); LockedExternalTask task = tasks[0]; // when authRule.init(scenario).withUser("userId").bindResource("processInstanceId", processInstance.Id).bindResource("processDefinitionKey", "oneExternalTaskProcess").start(); testExternalTaskApi(task); // then if (authRule.assertScenario(scenario)) { assertExternalTaskResults(); } }
public void Execute(LockedExternalTask externalTask, ref Dictionary <string, VariableValue> resultVariables) { bool creditBooleans; var amount = (double)externalTask.Variables["amount"].Value; var credit = (double)externalTask.Variables["credit"].Value; var remaining = credit - amount; if (remaining > 0) { creditBooleans = true; } else { creditBooleans = false; } resultVariables.Add("remaining", VariableValue.FromObject(remaining)); resultVariables.Add("creditSufficient", VariableValue.FromObject(creditBooleans)); }
public virtual void testSetJobPriority() { // given ProcessInstance processInstance = engineRule.RuntimeService.startProcessInstanceByKey("oneExternalTaskProcess"); IList <LockedExternalTask> tasks = engineRule.ExternalTaskService.fetchAndLock(5, "workerId").topic("externalTaskTopic", 5000L).execute(); LockedExternalTask task = tasks[0]; // when authRule.init(scenario).withUser("userId").bindResource("processInstanceId", processInstance.Id).bindResource("processDefinitionKey", "oneExternalTaskProcess").start(); engineRule.ExternalTaskService.unlock(task.Id); // then if (authRule.assertScenario(scenario)) { ExternalTask externalTask = engineRule.ExternalTaskService.createExternalTaskQuery().singleResult(); Assert.assertNull(externalTask.LockExpirationTime); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testLockedTaskContinueProcess() public virtual void testLockedTaskContinueProcess() { // given ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS); ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS).changeElementId(ProcessModels.PROCESS_KEY, "new" + ProcessModels.PROCESS_KEY).changeElementId("externalTask", "newExternalTask")); MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("externalTask", "newExternalTask").build(); ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id); LockedExternalTask externalTask = fetchAndLockSingleTask(ExternalTaskModels.TOPIC); // when testHelper.migrateProcessInstance(migrationPlan, processInstance); // then it is possible to complete the task and the process rule.ExternalTaskService.complete(externalTask.Id, WORKER_ID); testHelper.assertProcessEnded(processInstance.Id); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testChangeTaskType() public virtual void testChangeTaskType() { // given ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS); ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.newModel().startEvent().businessRuleTask("externalBusinessRuleTask").camundaType(ExternalTaskModels.EXTERNAL_TASK_TYPE).camundaTopic(ExternalTaskModels.TOPIC).camundaTaskPriority(ExternalTaskModels.PRIORITY.ToString()).endEvent().done()); MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("externalTask", "externalBusinessRuleTask").build(); ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id); // when testHelper.migrateProcessInstance(migrationPlan, processInstance); // then the task and process can be completed LockedExternalTask task = fetchAndLockSingleTask(ExternalTaskModels.TOPIC); rule.ExternalTaskService.complete(task.Id, WORKER_ID); testHelper.assertProcessEnded(processInstance.Id); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testRemoveParentScope() public virtual void testRemoveParentScope() { // given ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ExternalTaskModels.SUBPROCESS_PROCESS); ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS); MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("externalTask", "externalTask").build(); ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id); // when testHelper.migrateProcessInstance(migrationPlan, processInstance); // then it is possible to complete the task LockedExternalTask task = fetchAndLockSingleTask(ExternalTaskModels.TOPIC); rule.ExternalTaskService.complete(task.Id, WORKER_ID); testHelper.assertProcessEnded(processInstance.Id); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testIncident() public virtual void testIncident() { // given ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS); ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(ExternalTaskModels.ONE_EXTERNAL_TASK_PROCESS).changeElementId("externalTask", "newExternalTask")); MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("externalTask", "newExternalTask").build(); ProcessInstance processInstance = rule.RuntimeService.startProcessInstanceById(sourceProcessDefinition.Id); ExternalTask externalTask = rule.ExternalTaskService.createExternalTaskQuery().singleResult(); rule.ExternalTaskService.setRetries(externalTask.Id, 0); Incident incidentBeforeMigration = rule.RuntimeService.createIncidentQuery().singleResult(); // when testHelper.migrateProcessInstance(migrationPlan, processInstance); // then the incident has migrated Incident incidentAfterMigration = rule.RuntimeService.createIncidentQuery().singleResult(); assertNotNull(incidentAfterMigration); assertEquals(incidentBeforeMigration.Id, incidentAfterMigration.Id); assertEquals(org.camunda.bpm.engine.runtime.Incident_Fields.EXTERNAL_TASK_HANDLER_TYPE, incidentAfterMigration.IncidentType); assertEquals(externalTask.Id, incidentAfterMigration.Configuration); assertEquals("newExternalTask", incidentAfterMigration.ActivityId); assertEquals(targetProcessDefinition.Id, incidentAfterMigration.ProcessDefinitionId); assertEquals(externalTask.ExecutionId, incidentAfterMigration.ExecutionId); // and it is possible to complete the process rule.ExternalTaskService.setRetries(externalTask.Id, 1); LockedExternalTask task = fetchAndLockSingleTask(ExternalTaskModels.TOPIC); rule.ExternalTaskService.complete(task.Id, WORKER_ID); testHelper.assertProcessEnded(processInstance.Id); }
public static ExternalTask ToExternalTask(this LockedExternalTask lockedExternalTask) { if (lockedExternalTask == null) { return(null); } return(new ExternalTask { Id = lockedExternalTask.Id, WorkerId = lockedExternalTask.WorkerId, TopicName = lockedExternalTask.TopicName, ActivityId = lockedExternalTask.ActivityId, ActivityInstanceId = lockedExternalTask.ActivityInstanceId, ProcessInstanceId = lockedExternalTask.ProcessInstanceId, ProcessDefinitionId = lockedExternalTask.ProcessDefinitionId, Retries = lockedExternalTask.Retries, Priority = lockedExternalTask.Priority, Variables = lockedExternalTask.Variables.ToObjectDictionary() }); }
public virtual LockedExternalTask buildLockedExternalTask() { LockedExternalTask task = mock(typeof(LockedExternalTask)); when(task.ActivityId).thenReturn(activityId_Renamed); when(task.ActivityInstanceId).thenReturn(activityInstanceId_Renamed); when(task.ErrorMessage).thenReturn(errorMessage_Renamed); when(task.ExecutionId).thenReturn(executionId_Renamed); when(task.Id).thenReturn(id_Renamed); when(task.LockExpirationTime).thenReturn(lockExpirationTime_Renamed); when(task.ProcessDefinitionId).thenReturn(processDefinitionId_Renamed); when(task.ProcessDefinitionKey).thenReturn(processDefinitionKey_Renamed); when(task.ProcessInstanceId).thenReturn(processInstanceId_Renamed); when(task.Retries).thenReturn(retries_Renamed); when(task.TopicName).thenReturn(topicName_Renamed); when(task.WorkerId).thenReturn(workerId_Renamed); when(task.TenantId).thenReturn(tenantId_Renamed); when(task.Variables).thenReturn(variables); when(task.Priority).thenReturn(priority_Renamed); return(task); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testHistoricExternalTaskJobLogStacktraceBinary() public virtual void testHistoricExternalTaskJobLogStacktraceBinary() { // given testRule.deploy("org/camunda/bpm/engine/test/api/externaltask/oneExternalTaskProcess.bpmn20.xml"); runtimeService.startProcessInstanceByKey("oneExternalTaskProcess"); IList <LockedExternalTask> tasks = externalTaskService.fetchAndLock(5, WORKER_ID).topic(TOPIC_NAME, LOCK_TIME).execute(); LockedExternalTask task = tasks[0]; // submitting a failure (after a simulated processing time of three seconds) ClockUtil.CurrentTime = nowPlus(3000L); string errorMessage; string exceptionStackTrace; try { throw new RuntimeSqlException("test cause"); } catch (Exception e) { exceptionStackTrace = ExceptionUtils.getStackTrace(e); errorMessage = e.Message; } assertNotNull(exceptionStackTrace); externalTaskService.handleFailure(task.Id, WORKER_ID, errorMessage, exceptionStackTrace, 5, 3000L); HistoricExternalTaskLogEntity entity = (HistoricExternalTaskLogEntity)historyService.createHistoricExternalTaskLogQuery().errorMessage(errorMessage).singleResult(); assertNotNull(entity); ByteArrayEntity byteArrayEntity = configuration.CommandExecutorTxRequired.execute(new GetByteArrayCommand(entity.ErrorDetailsByteArrayId)); // then checkBinary(byteArrayEntity); }
public virtual void testCompleteExternalTask() { // given ProcessInstance processInstance = engineRule.RuntimeService.startProcessInstanceByKey("oneExternalTaskProcess"); IList <LockedExternalTask> tasks = engineRule.ExternalTaskService.fetchAndLock(5, "workerId").topic("externalTaskTopic", 5000L).execute(); LockedExternalTask task = tasks[0]; //preconditions method engineRule.ExternalTaskService.handleFailure(task.Id, task.WorkerId, "anError", ERROR_DETAILS, 1, 1000L); // when authRule.init(scenario).withUser("userId").bindResource("processInstanceId", processInstance.Id).bindResource("processDefinitionKey", "oneExternalTaskProcess").start(); //execution method currentDetails = engineRule.ExternalTaskService.getExternalTaskErrorDetails(task.Id); // then if (authRule.assertScenario(scenario)) { //assertion method assertThat(currentDetails, @is(ERROR_DETAILS)); } }
public static LockedExternalTaskDto fromLockedExternalTask(LockedExternalTask task) { LockedExternalTaskDto dto = new LockedExternalTaskDto(); dto.activityId = task.ActivityId; dto.activityInstanceId = task.ActivityInstanceId; dto.errorMessage = task.ErrorMessage; dto.errorDetails = task.ErrorDetails; dto.executionId = task.ExecutionId; dto.id = task.Id; dto.lockExpirationTime = task.LockExpirationTime; dto.processDefinitionId = task.ProcessDefinitionId; dto.processDefinitionKey = task.ProcessDefinitionKey; dto.processInstanceId = task.ProcessInstanceId; dto.retries = task.Retries; dto.topicName = task.TopicName; dto.workerId = task.WorkerId; dto.tenantId = task.TenantId; dto.variables = VariableValueDto.fromMap(task.Variables); dto.priority = task.Priority; dto.businessKey = task.BusinessKey; return(dto); }
public void Execute(LockedExternalTask externalTask, ref Dictionary <string, VariableValue> resultVariables) { Console.WriteLine("Refunding customer credit..."); }
/// <summary> /// Tests or either executes the external task api. /// The given locked external task is used to test there api. /// </summary> /// <param name="task"> the external task which should be tested </param> public abstract void testExternalTaskApi(LockedExternalTask task);
public void Execute(LockedExternalTask externalTask, ref Dictionary <string, VariableValue> resultVariables) { var credit = (double)externalTask.Variables["credit"].Value; resultVariables.Add("remaining", VariableValue.FromObject(credit)); }