//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCompletionIsNotPossibleOnComplete()
public virtual void testCompletionIsNotPossibleOnComplete()
{
// expect
thrown.expect(typeof(ProcessEngineException));
thrown.expectMessage(containsString("invalid task state"));
//given
createProcessWithListener([email protected]_Fields.EVENTNAME_COMPLETE);
//when
runtimeService.startProcessInstanceByKey(TASK_LISTENER_PROCESS);
Task task = taskService.createTaskQuery().singleResult();
taskService.complete(task.Id);
}
public virtual void testDeleteHistoricProcessInstanceIgnoreDeleteHistory()
{
// given
processEngineConfiguration.DisabledPermissions = Arrays.asList(Permissions.DELETE_HISTORY.name());
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("oneTaskProcess");
runtimeService.deleteProcessInstance(processInstance.Id, "any");
authRule.enableAuthorization(USER_ID);
engineRule.HistoryService.deleteHistoricProcessInstance(processInstance.Id);
authRule.disableAuthorization();
assertNull(engineRule.HistoryService.createHistoricProcessInstanceQuery().singleResult());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testThrownInJavaDelegate()
public virtual void testThrownInJavaDelegate()
{
// expect
thrown.expect(typeof(ProcessEngineException));
thrown.expectMessage(containsString("no error handler"));
// given
BpmnModelInstance instance = Bpmn.createExecutableProcess("process").startEvent().serviceTask().camundaClass(typeof(ThrowBpmnErrorDelegate)).endEvent().done();
testRule.deploy(instance);
// when
runtimeService.startProcessInstanceByKey("process");
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testFailedServiceTaskStandardStrategy()
public virtual void testFailedServiceTaskStandardStrategy()
{
engineRule.ProcessEngineConfiguration.FailedJobRetryTimeCycle = null;
BpmnModelInstance bpmnModelInstance = prepareFailingServiceTask();
testRule.deploy(bpmnModelInstance);
ProcessInstance pi = runtimeService.startProcessInstanceByKey(PROCESS_ID);
assertJobRetries(pi, 2);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void deployTestProcesses() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void deployTestProcesses()
{
org.camunda.bpm.engine.repository.Deployment deployment = engineRule.RepositoryService.createDeployment().addClasspathResource("org/camunda/bpm/engine/test/api/externaltask/oneExternalTaskProcess.bpmn20.xml").addClasspathResource("org/camunda/bpm/engine/test/api/externaltask/externalTaskPriorityExpression.bpmn20.xml").deploy();
engineRule.manageDeployment(deployment);
RuntimeService runtimeService = engineRule.RuntimeService;
processInstanceIds = new List <string>();
for (int i = 0; i < 4; i++)
{
processInstanceIds.Add(runtimeService.startProcessInstanceByKey(PROCESS_DEFINITION_KEY, i + "").Id);
}
processInstanceIds.Add(runtimeService.startProcessInstanceByKey(PROCESS_DEFINITION_KEY_2).Id);
}
public virtual void testLogCreation()
{
// given
ProcessInstance processInstance1 = runtimeService.startProcessInstanceByKey("oneExternalTaskProcess");
ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("twoExternalTaskProcess");
rule.IdentityService.AuthenticatedUserId = "userId";
// when
Batch suspendprocess = runtimeService.updateProcessInstanceSuspensionState().byProcessInstanceIds(Arrays.asList(processInstance1.Id, processInstance2.Id)).suspendAsync();
rule.IdentityService.clearAuthentication();
helper.executeSeedJob(suspendprocess);
helper.executeJobs(suspendprocess);
// then
IList <UserOperationLogEntry> opLogEntries = rule.HistoryService.createUserOperationLogQuery().list();
assertEquals(2, opLogEntries.Count);
IDictionary <string, UserOperationLogEntry> entries = asMap(opLogEntries);
UserOperationLogEntry asyncEntry = entries["async"];
assertNotNull(asyncEntry);
assertEquals("ProcessInstance", asyncEntry.EntityType);
assertEquals("SuspendJob", asyncEntry.OperationType);
assertNull(asyncEntry.ProcessInstanceId);
assertNull(asyncEntry.OrgValue);
assertEquals("true", asyncEntry.NewValue);
assertEquals(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.CATEGORY_OPERATOR, asyncEntry.Category);
UserOperationLogEntry numInstancesEntry = entries["nrOfInstances"];
assertNotNull(numInstancesEntry);
assertEquals("ProcessInstance", numInstancesEntry.EntityType);
assertEquals("SuspendJob", numInstancesEntry.OperationType);
assertNull(numInstancesEntry.ProcessInstanceId);
assertNull(numInstancesEntry.ProcessDefinitionKey);
assertNull(numInstancesEntry.ProcessDefinitionId);
assertNull(numInstancesEntry.OrgValue);
assertEquals("2", numInstancesEntry.NewValue);
assertEquals(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.CATEGORY_OPERATOR, asyncEntry.Category);
assertEquals(asyncEntry.OperationId, numInstancesEntry.OperationId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Transactional public void hello()
public virtual void hello()
{
// here you can do transactional stuff in your domain model
// and it will be combined in the same transaction as
// the startProcessInstanceByKey to the Activiti RuntimeService
runtimeService.startProcessInstanceByKey("helloProcess");
}
//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()));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testStartInstanceAfterDeleteLatestProcessVersion()
public virtual void testStartInstanceAfterDeleteLatestProcessVersion()
{
// given a deployed process
testRule.deploy(SINGLE_MESSAGE_START_EVENT_XML);
// deploy second version of the process
string deploymentId = testRule.deploy(SINGLE_MESSAGE_START_EVENT_XML).Id;
org.camunda.bpm.engine.repository.Deployment deployment = repositoryService.createDeploymentQuery().deploymentId(deploymentId).singleResult();
// delete it
repositoryService.deleteDeployment(deployment.Id, true);
// when
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("singleMessageStartEvent");
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");
}
}
public virtual void testDeletingIdentityLinkByProcDefId()
{
// Pre test
IList <HistoricIdentityLinkLog> historicIdentityLinks = historyService.createHistoricIdentityLinkLogQuery().list();
assertEquals(historicIdentityLinks.Count, 0);
// given
runtimeService.startProcessInstanceByKey("oneTaskProcess");
string taskId = taskService.createTaskQuery().singleResult().Id;
identityService.AuthenticatedUserId = "anAuthUser";
taskService.addCandidateUser(taskId, "aUser");
taskService.deleteCandidateUser(taskId, "aUser");
// assume
historicIdentityLinks = historyService.createHistoricIdentityLinkLogQuery().list();
assertTrue(historicIdentityLinks.Count > 0);
// when
repositoryService.deleteProcessDefinitions().byKey("oneTaskProcess").cascade().delete();
// then
historicIdentityLinks = historyService.createHistoricIdentityLinkLogQuery().list();
assertEquals(0, historicIdentityLinks.Count);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testFailingJobBoundaryTimerWithDelegateVariables() throws InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void testFailingJobBoundaryTimerWithDelegateVariables()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("ImmediatelyFailing");
IList <Job> jobs = managementService.createJobQuery().list();
assertEquals(1, jobs.Count);
assertEquals(3, jobs[0].Retries);
assertEquals(1, runtimeService.createExecutionQuery().processInstanceId(pi.ProcessInstanceId).activityId("usertask1").count());
assertEquals(2, runtimeService.createExecutionQuery().processInstanceId(pi.ProcessInstanceId).count());
assertEquals(1, managementService.createJobQuery().executable().count());
waitForJobExecutorToProcessAllJobs();
assertEquals(0, managementService.createJobQuery().executable().count()); // should be 0, because it has failed 3 times
assertEquals(1, managementService.createJobQuery().withException().count()); // should be 1, because job failed!
assertEquals(1, runtimeService.createExecutionQuery().processInstanceId(pi.ProcessInstanceId).activityId("usertask1").count());
assertEquals(2, runtimeService.createExecutionQuery().processInstanceId(pi.ProcessInstanceId).count());
taskService.complete(taskService.createTaskQuery().processInstanceId(pi.Id).singleResult().Id); // complete task with failed job => complete process
assertEquals(0, runtimeService.createExecutionQuery().processInstanceId(pi.ProcessInstanceId).count());
assertEquals(0, managementService.createJobQuery().count()); // should be 0, because process is finished.
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test @Deployment public void testSubTaskData()
public virtual void testSubTaskData()
{
//given simple process with user task
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("subTaskTest");
Task task = taskService.createTaskQuery().processInstanceId(processInstance.Id).singleResult();
// when set variable to user task
taskService.setVariable(task.Id, "testVariable", "testValue");
// then variable is set in the scope of execution
Assert.assertEquals("testValue", runtimeService.getVariable(task.ExecutionId, "testVariable"));
// when sub task is created create subtask for user task
Task subTask = taskService.newTask("123456789");
subTask.ParentTaskId = task.Id;
subTask.Name = "Test Subtask";
taskService.saveTask(subTask);
// and variable is update
taskService.setVariable(subTask.Id, "testVariable", "newTestValue");
//then variable is also updated in the scope execution
Assert.assertEquals("newTestValue", runtimeService.getVariable(task.ExecutionId, "testVariable"));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testHistoricVariableBinaryForFileValues()
public virtual void testHistoricVariableBinaryForFileValues()
{
// given
BpmnModelInstance instance = createProcess();
testRule.deploy(instance);
FileValue fileValue = createFile();
runtimeService.startProcessInstanceByKey("Process", Variables.createVariables().putValueTyped("fileVar", fileValue));
string byteArrayValueId = ((HistoricVariableInstanceEntity)historyService.createHistoricVariableInstanceQuery().singleResult()).ByteArrayValueId;
// when
ByteArrayEntity byteArrayEntity = configuration.CommandExecutorTxRequired.execute(new GetByteArrayCommand(byteArrayValueId));
checkBinary(byteArrayEntity);
}
public virtual void run()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.RuntimeService runtimeService = processEngine.getRuntimeService();
RuntimeService runtimeService = processEngine.RuntimeService;
runtimeService.startProcessInstanceByKey(processDefinitionKey);
}
public virtual void testSetRetriesLogCreationForOneExternalTaskId()
{
// given
runtimeService.startProcessInstanceByKey(PROCESS_DEFINITION_KEY);
rule.IdentityService.AuthenticatedUserId = "userId";
// when
ExternalTask externalTask = externalTaskService.createExternalTaskQuery().singleResult();
externalTaskService.setRetries(externalTask.Id, 5);
rule.IdentityService.clearAuthentication();
// then
IList <UserOperationLogEntry> opLogEntries = rule.HistoryService.createUserOperationLogQuery().list();
Assert.assertEquals(1, opLogEntries.Count);
IDictionary <string, UserOperationLogEntry> entries = asMap(opLogEntries);
UserOperationLogEntry retriesEntry = entries["retries"];
Assert.assertNotNull(retriesEntry);
Assert.assertEquals(EntityTypes.EXTERNAL_TASK, retriesEntry.EntityType);
Assert.assertEquals("SetExternalTaskRetries", retriesEntry.OperationType);
Assert.assertEquals(externalTask.Id, retriesEntry.ExternalTaskId);
Assert.assertEquals(externalTask.ProcessInstanceId, retriesEntry.ProcessInstanceId);
Assert.assertEquals(externalTask.ProcessDefinitionId, retriesEntry.ProcessDefinitionId);
Assert.assertEquals(externalTask.ProcessDefinitionKey, retriesEntry.ProcessDefinitionKey);
Assert.assertNull(retriesEntry.OrgValue);
Assert.assertEquals("5", retriesEntry.NewValue);
Assert.assertEquals(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.CATEGORY_OPERATOR, retriesEntry.Category);
}
//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 jobId = managementService.createJobQuery().singleResult().Id;
managementService.setJobRetries(jobId, 5);
ClockUtil.CurrentTime = END_DATE;
for (int i = 0; i < 5; i++)
{
try
{
managementService.executeJob(jobId);
}
catch (Exception)
{
}
}
managementService.executeJob(jobId);
string taskId = taskService.createTaskQuery().singleResult().Id;
taskService.complete(taskId);
engineConfiguration.HistoryCleanupBatchSize = 5;
engineConfiguration.initHistoryCleanup();
DateTime removalTime = addDays(END_DATE, 5);
ClockUtil.CurrentTime = removalTime;
// when
runHistoryCleanup();
Job job = historyService.findHistoryCleanupJobs()[0];
// then
assertThat(job.Duedate, @is(removalTime));
}
protected internal virtual void startTestProcesses()
{
RuntimeService runtimeService = engineRule.RuntimeService;
for (int i = 4; i < 1000; i++)
{
processInstanceIds.Add(runtimeService.startProcessInstanceByKey(PROCESS_DEFINITION_KEY, i + "").Id);
}
}
//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));
}
//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());
}
// helper //////////////////////////////////////////////////////////
protected internal virtual string startProcessInstance(string tenantId)
{
if (string.ReferenceEquals(tenantId, null))
{
return(runtimeService.startProcessInstanceByKey(PROCESS_DEFINITION_KEY).Id);
}
else
{
return(runtimeService.createProcessInstanceByKey(PROCESS_DEFINITION_KEY).processDefinitionTenantId(tenantId).execute().Id);
}
}
protected internal virtual void startProcessInstances(string key, int numberOfInstances)
{
for (int i = 0; i < numberOfInstances; i++)
{
IDictionary <string, object> variables = Collections.singletonMap <string, object>("message", "exception" + i);
runtimeService.startProcessInstanceByKey(key, i + "", variables);
}
testHelper.executeAvailableJobs();
}
protected internal virtual IList <string> startProcessInstance(string key, int instances)
{
IList <string> ids = new List <string>();
for (int i = 0; i < instances; i++)
{
ids.Add(runtimeService.startProcessInstanceByKey(key, i.ToString()).Id);
}
((IList <string>)processInstanceIds).AddRange(ids);
return(ids);
}
protected internal virtual IList <string> startTestProcesses(int numberOfProcesses)
{
List <string> ids = new List <string>();
for (int i = 0; i < numberOfProcesses; i++)
{
ids.Add(runtimeService.startProcessInstanceByKey(ONE_TASK_PROCESS).ProcessInstanceId);
}
return(ids);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: @Override public void execute(org.camunda.bpm.engine.delegate.DelegateExecution execution) throws Exception
public virtual void execute(DelegateExecution execution)
{
RuntimeService runtimeService = engine.RuntimeService;
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process");
// then the wait state is reached immediately after instantiation
ActivityInstance activityInstance = runtimeService.getActivityInstance(processInstance.Id);
ActivityInstance[] activityInstances = activityInstance.getActivityInstances("waitState");
Assert.assertEquals(1, activityInstances.Length);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDeleteCascadeProcessDefinitionsByKeyWithAuthenticatedTenant()
public virtual void testDeleteCascadeProcessDefinitionsByKeyWithAuthenticatedTenant()
{
// given
for (int i = 0; i < 3; i++)
{
deployProcessDefinitionWithTenant();
}
runtimeService.startProcessInstanceByKey("process");
identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
// when
repositoryService.deleteProcessDefinitions().byKey("process").withTenantId(TENANT_ONE).cascade().delete();
// then
identityService.clearAuthentication();
assertThat(historyService.createHistoricProcessInstanceQuery().count(), @is(0L));
assertThat(repositoryService.createProcessDefinitionQuery().count(), @is(1L));
assertThat(repositoryService.createProcessDefinitionQuery().tenantIdIn(TENANT_ONE).count(), @is(1L));
}
private IList <string> prepareHistoricProcesses(string businessKey)
{
IList <string> processInstanceIds = new List <string>();
for (int i = 0; i < 5; i++)
{
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(businessKey);
processInstanceIds.Add(processInstance.Id);
}
return(processInstanceIds);
}
public virtual void testQueryByLeafInstancesThreeLayers()
{
/*
* nested structure:
* superProcessWithNestedSubProcess
* +-- nestedSubProcess
* +-- subProcess
*/
ProcessInstance threeLayerProcess = runtimeService.startProcessInstanceByKey("nestedSubProcessQueryTest");
ProcessInstanceQuery simpleSubProcessQuery = runtimeService.createProcessInstanceQuery().processDefinitionKey("simpleSubProcess");
assertThat(runtimeService.createProcessInstanceQuery().count(), @is(3L));
assertThat(runtimeService.createProcessInstanceQuery().processDefinitionKey("nestedSubProcessQueryTest").count(), @is(1L));
assertThat(runtimeService.createProcessInstanceQuery().processDefinitionKey("nestedSimpleSubProcess").count(), @is(1L));
assertThat(simpleSubProcessQuery.count(), @is(1L));
ProcessInstance instance = runtimeService.createProcessInstanceQuery().leafProcessInstances().singleResult();
assertThat(instance.RootProcessInstanceId, @is(threeLayerProcess.Id));
assertThat(instance.Id, @is(simpleSubProcessQuery.singleResult().Id));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldLogIncidentCreation()
public virtual void shouldLogIncidentCreation()
{
// given
testRule.deploy(ProcessModels.TWO_TASKS_PROCESS);
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("Process");
assertEquals(0, historyService.createUserOperationLogQuery().count());
// when
identityService.AuthenticatedUserId = "userId";
Incident incident = runtimeService.createIncident("foo", processInstance.Id, "aa", "bar");
identityService.clearAuthentication();
// then
assertEquals(2, historyService.createUserOperationLogQuery().count());
UserOperationLogEntry entry = historyService.createUserOperationLogQuery().property("incidentType").singleResult();
assertEquals(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_CREATE_INCIDENT, entry.OperationType);
assertEquals(EntityTypes.PROCESS_INSTANCE, entry.EntityType);
assertEquals(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.CATEGORY_OPERATOR, entry.Category);
assertNull(entry.OrgValue);
assertEquals("foo", entry.NewValue);
assertNull(entry.ExecutionId);
assertEquals(processInstance.Id, entry.ProcessInstanceId);
assertEquals(processInstance.ProcessDefinitionId, entry.ProcessDefinitionId);
assertEquals("Process", entry.ProcessDefinitionKey);
entry = historyService.createUserOperationLogQuery().property("configuration").singleResult();
assertEquals(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_CREATE_INCIDENT, entry.OperationType);
assertEquals(EntityTypes.PROCESS_INSTANCE, entry.EntityType);
assertEquals(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.CATEGORY_OPERATOR, entry.Category);
assertNull(entry.OrgValue);
assertEquals(incident.Configuration, entry.NewValue);
assertNull(entry.ExecutionId);
assertEquals(processInstance.Id, entry.ProcessInstanceId);
assertEquals(processInstance.ProcessDefinitionId, entry.ProcessDefinitionId);
assertEquals("Process", entry.ProcessDefinitionKey);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment @Test public void testSingleIntermediateMessageEvent()
public virtual void testSingleIntermediateMessageEvent()
{
ProcessInstance pi = runtimeService.startProcessInstanceByKey("process");
IList <string> activeActivityIds = runtimeService.getActiveActivityIds(pi.Id);
assertNotNull(activeActivityIds);
assertEquals(1, activeActivityIds.Count);
assertTrue(activeActivityIds.Contains("messageCatch"));
string messageName = "newInvoiceMessage";
Execution execution = runtimeService.createExecutionQuery().messageEventSubscriptionName(messageName).singleResult();
assertNotNull(execution);
runtimeService.messageEventReceived(messageName, execution.Id);
Task task = taskService.createTaskQuery().singleResult();
assertNotNull(task);
taskService.complete(task.Id);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDisableQueryOfProcessDefinitionAddModelInstancesToDeploymentCache()
public virtual void testDisableQueryOfProcessDefinitionAddModelInstancesToDeploymentCache()
{
// given
deploy(ProcessModels.ONE_TASK_PROCESS_WITH_DOCUMENTATION);
ProcessInstance pi = runtimeService.startProcessInstanceByKey(ProcessModels.PROCESS_KEY);
// when
repositoryService.createProcessDefinitionQuery().processDefinitionKey(ProcessModels.PROCESS_KEY).singleResult().Id;
// then
DeploymentCache deploymentCache = processEngineConfiguration.DeploymentCache;
BpmnModelInstance modelInstance = deploymentCache.BpmnModelInstanceCache.get(pi.ProcessDefinitionId);
assertNull(modelInstance);
}
