//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));
}
