//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldScheduleToNow()
public virtual void shouldScheduleToNow()
{
// given
testRule.deploy(PROCESS);
runtimeService.startProcessInstanceByKey(PROCESS_KEY);
string processInstanceId = runtimeService.createProcessInstanceQuery().activityIdIn("userTask").singleResult().Id;
ClockUtil.CurrentTime = END_DATE;
for (int i = 0; i < 5; i++)
{
taskService.createAttachment(null, null, processInstanceId, null, null, "http://camunda.com");
}
string taskId = taskService.createTaskQuery().singleResult().Id;
taskService.complete(taskId);
engineConfiguration.HistoryCleanupBatchSize = 5;
engineConfiguration.initHistoryCleanup();
DateTime removalTime = addDays(END_DATE, 5);
ClockUtil.CurrentTime = addDays(END_DATE, 5);
// when
runHistoryCleanup();
Job job = historyService.findHistoryCleanupJobs()[0];
// then
assertThat(job.Duedate, @is(removalTime));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDeleteProcessDefinitionCascade()
public virtual void testDeleteProcessDefinitionCascade()
{
// given process definition and a process instance
BpmnModelInstance bpmnModel = Bpmn.createExecutableProcess(PROCESS_DEFINITION_KEY).startEvent().userTask().endEvent().done();
testHelper.deploy(bpmnModel);
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionKey(PROCESS_DEFINITION_KEY).singleResult();
runtimeService.createProcessInstanceByKey(PROCESS_DEFINITION_KEY).executeWithVariablesInReturn();
authRule.init(scenario).withUser("userId").start();
//when the corresponding process definition is cascading deleted from the deployment
repositoryService.deleteProcessDefinition(processDefinition.Id, true);
//then exist no process instance and no definition
if (authRule.assertScenario(scenario))
{
assertEquals(0, runtimeService.createProcessInstanceQuery().count());
assertEquals(0, repositoryService.createProcessDefinitionQuery().count());
if (processEngineConfiguration.HistoryLevel.Id >= org.camunda.bpm.engine.impl.history.HistoryLevel_Fields.HISTORY_LEVEL_ACTIVITY.Id)
{
assertEquals(0, engineRule.HistoryService.createHistoricActivityInstanceQuery().count());
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @After public void cleanUp()
public virtual void cleanUp()
{
if (runtimeService.createProcessInstanceQuery().count() > 0)
{
runtimeService.deleteProcessInstance(runtimeService.createProcessInstanceQuery().singleResult().Id,null,true);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testApplicationFailure() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void testApplicationFailure()
{
/* if we start a transaction here and then successfully start
* a process instance, if our transaction is rolled back,
* the process instnace is not persisted.
*/
try
{
utx.begin();
string id = runtimeService.startProcessInstanceByKey("testApplicationFailure").Id;
// assert that the transaction is in good shape:
Assert.assertEquals(Status.STATUS_ACTIVE, utx.Status);
// now rollback the transaction (simmulating an application failure after the process engine is done).
utx.rollback();
utx.begin();
// the process instance does not exist:
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(id).singleResult();
Assert.assertNull(processInstance);
utx.commit();
}
catch (Exception e)
{
utx.rollback();
throw e;
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testStartInstanceAfterDeleteLatestProcessVersionByIds()
public virtual void testStartInstanceAfterDeleteLatestProcessVersionByIds()
{
// given a deployed process
testRule.deploy(SINGLE_MESSAGE_START_EVENT_XML);
// deploy second version of the process
DeploymentWithDefinitions deployment = testRule.deploy(SINGLE_MESSAGE_START_EVENT_XML);
ProcessDefinition processDefinition = deployment.DeployedProcessDefinitions[0];
// delete it
repositoryService.deleteProcessDefinitions().byIds(processDefinition.Id).delete();
// when
ProcessInstance processInstance = runtimeService.startProcessInstanceByMessage("newInvoiceMessage");
// then
assertFalse(processInstance.Ended);
Task task = taskService.createTaskQuery().singleResult();
assertNotNull(task);
taskService.complete(task.Id);
ProcessInstance completedInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstance.Id).singleResult();
if (completedInstance != null)
{
throw new AssertionFailedError("Expected finished process instance '" + completedInstance + "' but it was still in the db");
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testExclusiveJobs()
public virtual void testExclusiveJobs()
{
testRule.deploy(Bpmn.createExecutableProcess("testProcess").startEvent().serviceTask("task1").camundaExpression("${true}").camundaAsyncBefore().serviceTask("task2").camundaExpression("${true}").camundaAsyncBefore().endEvent().done());
JobDefinition jobDefinition = managementService.createJobDefinitionQuery().activityIdIn("task2").singleResult();
// given that the second task is suspended
managementService.suspendJobDefinitionById(jobDefinition.Id);
// if I start a process instance
runtimeService.startProcessInstanceByKey("testProcess");
testRule.waitForJobExecutorToProcessAllJobs(10000);
// then the second task is not executed
assertEquals(1, runtimeService.createProcessInstanceQuery().count());
// there is a suspended job instance
Job job = managementService.createJobQuery().singleResult();
assertEquals(job.JobDefinitionId, jobDefinition.Id);
assertTrue(job.Suspended);
// if I unsuspend the job definition, the job is executed:
managementService.activateJobDefinitionById(jobDefinition.Id, true);
testRule.waitForJobExecutorToProcessAllJobs(10000);
assertEquals(0, runtimeService.createProcessInstanceQuery().count());
}
public virtual void testSignalBusinessKeyPayload()
{
// given
string businessKey = "aBusinessKey";
// when
runtimeService.startProcessInstanceByKey("throwBusinessKeyPayloadSignal", businessKey);
// then
ProcessInstance catchingPI = runtimeService.createProcessInstanceQuery().singleResult();
assertEquals(businessKey, catchingPI.BusinessKey);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldPointToRoot()
public virtual void shouldPointToRoot()
{
// given
testRule.deploy(CALLED_PROCESS);
testRule.deploy(CALLED_AND_CALLING_PROCESS);
testRule.deploy(CALLING_PROCESS);
// when
runtimeService.startProcessInstanceByKey(CALLING_PROCESS_KEY);
ProcessInstance calledProcessInstance = runtimeService.createProcessInstanceQuery().processDefinitionKey(CALLED_PROCESS_KEY).singleResult();
ProcessInstance calledAndCallingProcessInstance = runtimeService.createProcessInstanceQuery().processDefinitionKey(CALLED_AND_CALLING_PROCESS_KEY).singleResult();
ProcessInstance callingProcessInstance = runtimeService.createProcessInstanceQuery().processDefinitionKey(CALLING_PROCESS_KEY).singleResult();
// assume
assertThat(runtimeService.createProcessInstanceQuery().count(), @is(3L));
assertThat(callingProcessInstance.RootProcessInstanceId, notNullValue());
// then
assertThat(callingProcessInstance.RootProcessInstanceId, @is(callingProcessInstance.ProcessInstanceId));
assertThat(calledProcessInstance.RootProcessInstanceId, @is(callingProcessInstance.ProcessInstanceId));
assertThat(calledAndCallingProcessInstance.RootProcessInstanceId, @is(callingProcessInstance.ProcessInstanceId));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void startProcessInstanceWithTenantId()
public virtual void startProcessInstanceWithTenantId()
{
testRule.deployForTenant(TENANT_ONE, PROCESS);
Job job = managementService.createJobQuery().singleResult();
assertThat(job.TenantId, @is(TENANT_ONE));
managementService.executeJob(job.Id);
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().singleResult();
assertThat(processInstance, @is(notNullValue()));
assertThat(processInstance.TenantId, @is(TENANT_ONE));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test @Deployment public void testStartInstanceWithTrueConditionalStartEvent()
public virtual void testStartInstanceWithTrueConditionalStartEvent()
{
// given a deployed process
// when
IList <ProcessInstance> conditionInstances = runtimeService.createConditionEvaluation().evaluateStartConditions();
// then
assertEquals(1, conditionInstances.Count);
IList <ProcessInstance> processInstances = runtimeService.createProcessInstanceQuery().processDefinitionKey(TRUE_CONDITION_PROCESS).list();
assertEquals(1, processInstances.Count);
assertEquals(processInstances[0].Id, conditionInstances[0].Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void evaluateDecisionWithDecisionService()
public virtual void evaluateDecisionWithDecisionService()
{
runtimeService.startProcessInstanceByKey("testProcess", Variables.createVariables().putValue("input1", null).putValue("myBean", new DecisionServiceDelegate()));
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().singleResult();
ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(processInstance.ProcessDefinitionId).singleResult();
string decisionDefinitionId = repositoryService.createDecisionDefinitionQuery().decisionDefinitionKey(DECISION_DEFINITION_KEY).singleResult().Id;
HistoricDecisionInstance historicDecisionInstance = historyService.createHistoricDecisionInstanceQuery().singleResult();
assertThat(historicDecisionInstance, @is(notNullValue()));
assertThat(historicDecisionInstance.DecisionDefinitionId, @is(decisionDefinitionId));
assertThat(historicDecisionInstance.DecisionDefinitionKey, @is(DECISION_DEFINITION_KEY));
assertThat(historicDecisionInstance.DecisionDefinitionName, @is("sample decision"));
// references to process instance should be set since the decision is evaluated while executing a process instance
assertThat(historicDecisionInstance.ProcessDefinitionKey, @is(processDefinition.Key));
assertThat(historicDecisionInstance.ProcessDefinitionId, @is(processDefinition.Id));
assertThat(historicDecisionInstance.ProcessInstanceId, @is(processInstance.Id));
assertThat(historicDecisionInstance.CaseDefinitionKey, @is(nullValue()));
assertThat(historicDecisionInstance.CaseDefinitionId, @is(nullValue()));
assertThat(historicDecisionInstance.CaseInstanceId, @is(nullValue()));
assertThat(historicDecisionInstance.ActivityId, @is(activityId));
assertThat(historicDecisionInstance.EvaluationTime, @is(notNullValue()));
}
public virtual void testMigrateHistoryUserTaskInstance()
{
//given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(ProcessModels.ONE_TASK_PROCESS).changeElementId("Process", "Process2").changeElementId("userTask", "userTask2"));
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask", "userTask2").build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
HistoricTaskInstanceQuery sourceHistoryTaskInstanceQuery = historyService.createHistoricTaskInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
HistoricTaskInstanceQuery targetHistoryTaskInstanceQuery = historyService.createHistoricTaskInstanceQuery().processDefinitionId(targetProcessDefinition.Id);
ActivityInstance activityInstance = runtimeService.getActivityInstance(processInstance.Id);
//when
assertEquals(1, sourceHistoryTaskInstanceQuery.count());
assertEquals(0, targetHistoryTaskInstanceQuery.count());
ProcessInstanceQuery sourceProcessInstanceQuery = runtimeService.createProcessInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
runtimeService.newMigration(migrationPlan).processInstanceQuery(sourceProcessInstanceQuery).execute();
//then
assertEquals(0, sourceHistoryTaskInstanceQuery.count());
assertEquals(1, targetHistoryTaskInstanceQuery.count());
HistoricTaskInstance instance = targetHistoryTaskInstanceQuery.singleResult();
assertEquals(targetProcessDefinition.Key, instance.ProcessDefinitionKey);
assertEquals(targetProcessDefinition.Id, instance.ProcessDefinitionId);
assertEquals("userTask2", instance.TaskDefinitionKey);
assertEquals(activityInstance.getActivityInstances("userTask")[0].Id, instance.ActivityInstanceId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @After public void cleanUp()
public virtual void cleanUp()
{
foreach (ProcessInstance processInstance in runtimeService.createProcessInstanceQuery().list())
{
runtimeService.deleteProcessInstance(processInstance.Id, "test ended", true);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testBatchCreationWithOverlappingProcessInstanceIdsAndQuery()
public virtual void testBatchCreationWithOverlappingProcessInstanceIdsAndQuery()
{
RuntimeService runtimeService = engineRule.RuntimeService;
int processInstanceCount = 15;
ProcessDefinition sourceProcessDefinition = migrationRule.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetProcessDefinition = migrationRule.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
IList <string> processInstanceIds = new List <string>();
for (int i = 0; i < processInstanceCount; i++)
{
processInstanceIds.Add(runtimeService.startProcessInstanceById(sourceProcessDefinition.Id).Id);
}
MigrationPlan migrationPlan = engineRule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapEqualActivities().build();
ProcessInstanceQuery sourceProcessInstanceQuery = runtimeService.createProcessInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
assertEquals(processInstanceCount, sourceProcessInstanceQuery.count());
// when
Batch batch = runtimeService.newMigration(migrationPlan).processInstanceIds(processInstanceIds).processInstanceQuery(sourceProcessInstanceQuery).executeAsync();
// then a batch is created
assertBatchCreated(batch, processInstanceCount);
}
public string getProperty(Execution obj)
{
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(obj.ProcessInstanceId).singleResult();
ProcessDefinition processDefinition = repositoryService.getProcessDefinition(processInstance.ProcessDefinitionId);
return(processDefinition.Key);
}
public virtual void testMigrateHistoryActivityInstance()
{
//given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(modify(ProcessModels.ONE_TASK_PROCESS).changeElementId("Process", "Process2").changeElementId("userTask", "userTask2").changeElementName("userTask", "new activity name"));
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("userTask", "userTask2").build();
ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id);
HistoricActivityInstanceQuery sourceHistoryActivityInstanceQuery = historyService.createHistoricActivityInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
HistoricActivityInstanceQuery targetHistoryActivityInstanceQuery = historyService.createHistoricActivityInstanceQuery().processDefinitionId(targetProcessDefinition.Id);
//when
assertEquals(2, sourceHistoryActivityInstanceQuery.count());
assertEquals(0, targetHistoryActivityInstanceQuery.count());
ProcessInstanceQuery sourceProcessInstanceQuery = runtimeService.createProcessInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
runtimeService.newMigration(migrationPlan).processInstanceQuery(sourceProcessInstanceQuery).execute();
// then one instance of the start event still belongs to the source process
// and one active user task instances is now migrated to the target process
assertEquals(1, sourceHistoryActivityInstanceQuery.count());
assertEquals(1, targetHistoryActivityInstanceQuery.count());
HistoricActivityInstance instance = targetHistoryActivityInstanceQuery.singleResult();
assertMigratedTo(instance, targetProcessDefinition, "userTask2");
assertEquals("new activity name", instance.ActivityName);
assertEquals(processInstance.Id, instance.ParentActivityInstanceId);
assertEquals("userTask", instance.ActivityType);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: protected void assertProcessEnded(final String processInstanceId)
protected internal virtual void assertProcessEnded(string processInstanceId)
{
ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
if (processInstance != null)
{
throw new AssertionFailedError("Expected finished process instance '" + processInstanceId + "' but it was still in the db");
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldScheduleToNow()
public virtual void shouldScheduleToNow()
{
// given
engineConfiguration.BatchOperationHistoryTimeToLive = "P5D";
engineConfiguration.HistoryCleanupBatchSize = 5;
engineConfiguration.initHistoryCleanup();
testRule.deploy(PROCESS);
testRule.deploy(CALLING_PROCESS);
runtimeService.startProcessInstanceByKey(CALLING_PROCESS_KEY).Id;
for (int i = 0; i < 5; i++)
{
string processInstanceId = runtimeService.createProcessInstanceQuery().processDefinitionKey(PROCESS_KEY).list().get(0).Id;
runtimeService.deleteProcessInstancesAsync(Collections.singletonList(processInstanceId), "aDeleteReason");
ClockUtil.CurrentTime = END_DATE;
string jobId = managementService.createJobQuery().singleResult().Id;
managementService.executeJob(jobId);
jobIds.Add(jobId);
IList <Job> jobs = managementService.createJobQuery().list();
foreach (Job job in jobs)
{
managementService.executeJob(job.Id);
jobIds.Add(job.Id);
}
}
DateTime removalTime = addDays(END_DATE, 5);
ClockUtil.CurrentTime = removalTime;
// when
runHistoryCleanup();
Job job = historyService.findHistoryCleanupJobs()[0];
// then
assertThat(job.Duedate, @is(removalTime));
}
private void createProcessInstanceMock()
{
ProcessInstance mockInstance = MockProvider.createMockInstance();
ProcessInstanceQuery mockInstanceQuery = mock(typeof(ProcessInstanceQuery));
when(mockInstanceQuery.processInstanceId(eq(MockProvider.EXAMPLE_PROCESS_INSTANCE_ID))).thenReturn(mockInstanceQuery);
when(mockInstanceQuery.singleResult()).thenReturn(mockInstance);
when(mockRuntimeService.createProcessInstanceQuery()).thenReturn(mockInstanceQuery);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test @Deployment public void simpleProcessTest()
public virtual void simpleProcessTest()
{
runtimeService.startProcessInstanceByKey("simpleProcess");
Task task = taskService.createTaskQuery().singleResult();
assertEquals("My Task", task.Name);
taskService.complete(task.Id);
assertEquals(0, runtimeService.createProcessInstanceQuery().count());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testMigrateWithIdVarargsArray()
public virtual void testMigrateWithIdVarargsArray()
{
ProcessDefinition sourceDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
ProcessDefinition targetDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
MigrationPlan migrationPlan = runtimeService.createMigrationPlan(sourceDefinition.Id, targetDefinition.Id).mapEqualActivities().build();
ProcessInstance processInstance1 = runtimeService.startProcessInstanceById(sourceDefinition.Id);
ProcessInstance processInstance2 = runtimeService.startProcessInstanceById(sourceDefinition.Id);
// when
runtimeService.newMigration(migrationPlan).processInstanceIds(processInstance1.Id, processInstance2.Id).execute();
// then
Assert.assertEquals(2, runtimeService.createProcessInstanceQuery().processDefinitionId(targetDefinition.Id).count());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldUpdateRetriesByProcessInstanceQuery()
public virtual void shouldUpdateRetriesByProcessInstanceQuery()
{
// given
ProcessInstanceQuery processInstanceQuery = runtimeService.createProcessInstanceQuery();
// when
Batch batch = externalTaskService.updateRetries().processInstanceQuery(processInstanceQuery).setAsync(5);
executeSeedAndBatchJobs(batch);
// then
IList <ExternalTask> tasks = externalTaskService.createExternalTaskQuery().list();
assertEquals(6, tasks.Count);
foreach (ExternalTask task in tasks)
{
assertEquals(5, (int)task.Retries);
}
}
public virtual void migrateProcessInstance(MigrationPlan migrationPlan, ProcessInstance processInstance)
{
snapshotBeforeMigration = takeFullProcessInstanceSnapshot(processInstance);
RuntimeService runtimeService = processEngine.RuntimeService;
runtimeService.newMigration(migrationPlan).processInstanceIds(Collections.singletonList(snapshotBeforeMigration.ProcessInstanceId)).execute();
// fetch updated process instance
processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstance.Id).singleResult();
snapshotAfterMigration = takeFullProcessInstanceSnapshot(processInstance);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test @Deployment public void ruleUsageExample()
public virtual void ruleUsageExample()
{
RuntimeService runtimeService = engineRule.RuntimeService;
runtimeService.startProcessInstanceByKey("ruleUsage");
TaskService taskService = engineRule.TaskService;
Task task = taskService.createTaskQuery().singleResult();
assertEquals("My Task", task.Name);
taskService.complete(task.Id);
assertEquals(0, runtimeService.createProcessInstanceQuery().count());
}
public virtual void testQueryByCauseIncidentId()
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("callFailingProcess");
testHelper.executeAvailableJobs();
ProcessInstance subProcessInstance = runtimeService.createProcessInstanceQuery().superProcessInstanceId(processInstance.Id).singleResult();
assertNotNull(subProcessInstance);
Incident causeIncident = runtimeService.createIncidentQuery().processInstanceId(subProcessInstance.Id).singleResult();
assertNotNull(causeIncident);
IncidentQuery query = runtimeService.createIncidentQuery().causeIncidentId(causeIncident.Id);
assertEquals(2, query.count());
IList <Incident> incidents = query.list();
assertFalse(incidents.Count == 0);
assertEquals(2, incidents.Count);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void executeModificationWithValidProcessInstanceQuerySync()
public virtual void executeModificationWithValidProcessInstanceQuerySync()
{
when(runtimeServiceMock.createProcessInstanceQuery()).thenReturn(new ProcessInstanceQueryImpl());
IDictionary <string, object> json = new Dictionary <string, object>();
IList <IDictionary <string, object> > instructions = new List <IDictionary <string, object> >();
instructions.Add(ModificationInstructionBuilder.startAfter().activityId("activityId").Json);
json["processDefinitionId"] = "processDefinitionId";
ProcessInstanceQueryDto processInstanceQueryDto = new ProcessInstanceQueryDto();
processInstanceQueryDto.BusinessKey = "foo";
json["processInstanceQuery"] = processInstanceQueryDto;
json["instructions"] = instructions;
given().contentType(ContentType.JSON).body(json).then().expect().statusCode(Status.NO_CONTENT.StatusCode).when().post(EXECUTE_MODIFICATION_SYNC_URL);
verify(runtimeServiceMock, times(1)).createProcessInstanceQuery();
verify(modificationBuilderMock).startAfterActivity("activityId");
verify(modificationBuilderMock).processInstanceQuery(processInstanceQueryDto.toQuery(processEngine));
verify(modificationBuilderMock).execute();
}
public virtual void testQueryByProcessDefinitionId()
{
startProcessInstance(PROCESS_DEFINITION_KEY);
ProcessInstance pi = runtimeService.createProcessInstanceQuery().singleResult();
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().processDefinitionId(pi.ProcessDefinitionId);
assertEquals(1, query.list().size());
assertEquals(1, query.count());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @After public void checkIfProcessCanBeFinished()
public virtual void checkIfProcessCanBeFinished()
{
//given tasks after variable was set
assertNotNull(tasksAfterVariableIsSet);
//when tasks are completed
foreach (Task task in tasksAfterVariableIsSet)
{
taskService.complete(task.Id);
}
//then
assertEquals(0, conditionEventSubscriptionQuery.list().Count);
assertNull(taskService.createTaskQuery().singleResult());
assertNull(runtimeService.createProcessInstanceQuery().singleResult());
tasksAfterVariableIsSet = null;
}
public virtual void testMigrateHistoryProcessInstance()
{
//given
HistoricProcessInstanceQuery sourceHistoryProcessInstanceQuery = historyService.createHistoricProcessInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
HistoricProcessInstanceQuery targetHistoryProcessInstanceQuery = historyService.createHistoricProcessInstanceQuery().processDefinitionId(targetProcessDefinition.Id);
//when
assertEquals(1, sourceHistoryProcessInstanceQuery.count());
assertEquals(0, targetHistoryProcessInstanceQuery.count());
ProcessInstanceQuery sourceProcessInstanceQuery = runtimeService.createProcessInstanceQuery().processDefinitionId(sourceProcessDefinition.Id);
runtimeService.newMigration(migrationPlan).processInstanceQuery(sourceProcessInstanceQuery).execute();
//then
assertEquals(0, sourceHistoryProcessInstanceQuery.count());
assertEquals(1, targetHistoryProcessInstanceQuery.count());
HistoricProcessInstance instance = targetHistoryProcessInstanceQuery.singleResult();
assertEquals(instance.ProcessDefinitionKey, targetProcessDefinition.Key);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @After public void cleanUp()
public virtual void cleanUp()
{
IList <ProcessInstance> processInstances = runtimeService.createProcessInstanceQuery().list();
foreach (ProcessInstance processInstance in processInstances)
{
runtimeService.deleteProcessInstance(processInstance.Id, null, true, true);
}
IList <Task> tasks = taskService.createTaskQuery().list();
foreach (Task task in tasks)
{
taskService.deleteTask(task.Id, true);
}
IList <HistoricProcessInstance> historicProcessInstances = historyService.createHistoricProcessInstanceQuery().list();
foreach (HistoricProcessInstance historicProcessInstance in historicProcessInstances)
{
historyService.deleteHistoricProcessInstance(historicProcessInstance.Id);
}
}
