public virtual void testNotAffectedSentriesInMultipleStageScopes()
{
caseService.createCaseInstanceByKey("Case_1").Id;
string stageExecution1_Id = queryCaseExecutionByActivityId("Stage_1").Id;
caseService.setVariable(stageExecution1_Id, "value", 99);
CaseExecution humanTask1 = queryCaseExecutionByActivityId("HumanTask_1");
// if part is not satisfied
assertFalse(humanTask1.Enabled);
CaseExecution humanTask2 = queryCaseExecutionByActivityId("HumanTask_2");
// if part is not satisfied
assertFalse(humanTask2.Enabled);
// Evaluates the sentry's IfPart alone
caseService.setVariable(stageExecution1_Id, "value", 101);
humanTask1 = queryCaseExecutionByActivityId("HumanTask_1");
assertTrue(humanTask1.Enabled);
humanTask2 = queryCaseExecutionByActivityId("HumanTask_2");
assertTrue(humanTask2.Enabled);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCallCmmnCaseSequentialMultiInstanceRemoveMiBody()
public virtual void testCallCmmnCaseSequentialMultiInstanceRemoveMiBody()
{
// given
ProcessDefinition sourceProcessDefinition = testHelper.deployAndGetDefinition(modify(CallActivityModels.oneCmmnCallActivityProcess("oneTaskCase")).activityBuilder("callActivity").multiInstance().sequential().cardinality("1").done());
ProcessDefinition targetProcessDefinition = testHelper.deployAndGetDefinition(CallActivityModels.oneCmmnCallActivityProcess("oneTaskCase"));
MigrationPlan migrationPlan = rule.RuntimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapActivities("callActivity", "callActivity").build();
// when
ProcessInstance processInstance = testHelper.createProcessInstanceAndMigrate(migrationPlan);
// then
testHelper.assertExecutionTreeAfterMigration().hasProcessDefinitionId(targetProcessDefinition.Id).matches(describeExecutionTree(null).scope().id(testHelper.snapshotBeforeMigration.ProcessInstanceId).child("callActivity").scope().done());
testHelper.assertActivityTreeAfterMigration().hasStructure(describeActivityInstanceTree(targetProcessDefinition.Id).activity("callActivity", testHelper.getSingleActivityInstanceBeforeMigration("callActivity").Id).done());
// then the link between calling and called instance is maintained correctly
testHelper.assertSuperExecutionOfCaseInstance(rule.CaseService.createCaseInstanceQuery().caseDefinitionKey("oneTaskCase").singleResult().Id, testHelper.getSingleExecutionIdForActivityAfterMigration("callActivity"));
// and it is possible to complete the called case instance
CaseExecution caseExecution = rule.CaseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").singleResult();
testHelper.completeTask("PI_HumanTask_1");
// and the calling process instance
testHelper.completeTask("userTask");
testHelper.assertProcessEnded(processInstance.Id);
// and close the called case instance
rule.CaseService.withCaseExecution(caseExecution.CaseInstanceId).close();
testHelper.assertCaseEnded(caseExecution.CaseInstanceId);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testAutoCompleteStageWithoutEntryCriteria()
public virtual void testAutoCompleteStageWithoutEntryCriteria()
{
// given
VariableMap variables = Variables.createVariables().putValue("manualActivation", false);
string caseInstanceId = createCaseInstanceByKey("case", variables).Id;
// then (1)
CaseExecutionQuery query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
assertEquals(1, query.count());
assertEquals(1, query.active().count());
string activeTaskId = query.singleResult().Id;
// when (2)
// completing active task
complete(activeTaskId);
// then (2)
// the stage should be completed
CaseExecution stage = queryCaseExecutionByActivityId("PI_Stage_1");
assertNull(stage);
CaseInstance caseInstance = (CaseInstance)queryCaseExecutionById(caseInstanceId);
assertTrue(caseInstance.Completed);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testAutoCompleteStageRequiredRepeatableTask()
public virtual void testAutoCompleteStageRequiredRepeatableTask()
{
// given
string caseInstanceId = createCaseInstance().Id;
// then (1)
CaseExecutionQuery query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
assertEquals(1, query.count());
assertEquals(1, query.active().count());
string activeTaskId = query.singleResult().Id;
// when (2)
complete(activeTaskId);
// then (2)
query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
assertEquals(1, query.count());
assertEquals(1, query.active().count());
CaseExecution stage = queryCaseExecutionByActivityId("PI_Stage_1");
assertNotNull(stage);
assertTrue(stage.Active);
CaseInstance caseInstance = (CaseInstance)queryCaseExecutionById(caseInstanceId);
assertTrue(caseInstance.Active);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testNonRepeatableTaskDependsOnRepeatableTask()
public virtual void testNonRepeatableTaskDependsOnRepeatableTask()
{
// given
createCaseInstance();
CaseExecutionQuery availableQuery = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").available();
// fire three times entry criteria of repeatable task
// -> three enabled tasks
// -> one available task
fireEntryCriteria(availableQuery.singleResult().Id);
fireEntryCriteria(availableQuery.singleResult().Id);
fireEntryCriteria(availableQuery.singleResult().Id);
// get any enabled task
CaseExecutionQuery enabledQuery = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").active();
string enabledTaskId = enabledQuery.listPage(0, 1).get(0).Id;
CaseExecution secondHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_2");
assertNotNull(secondHumanTask);
assertTrue(secondHumanTask.Available);
// when
complete(enabledTaskId);
// then
// there is only one instance of PI_HumanTask_2
secondHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_2");
assertNotNull(secondHumanTask);
assertTrue(secondHumanTask.Active);
}
public virtual void testShouldnotEvaluateSentryBeforeSentryCreation()
{
caseService.createCaseInstanceByKey("Case_1").Id;
CaseExecution stageExecution = queryCaseExecutionByActivityId("Stage_1");
assertTrue(stageExecution.Enabled);
CaseExecution humanTask = queryCaseExecutionByActivityId("HumanTask_1");
assertNull(humanTask);
// set the variable in the scope of stage - should not trigger sentry inside the stage as the sentry is not yet created.
caseService.setVariableLocal(stageExecution.Id, "variable_1", "aVariable");
manualStart(stageExecution.Id);
humanTask = queryCaseExecutionByActivityId("HumanTask_1");
// variable event occurred before sentry creation
assertTrue(humanTask.Available);
caseService.removeVariable(stageExecution.Id, "variable_1");
// Sentry is active and would enable human task 1
caseService.setVariableLocal(stageExecution.Id, "variable_1", "aVariable");
humanTask = queryCaseExecutionByActivityId("HumanTask_1");
assertTrue(humanTask.Enabled);
}
public virtual void FAILING_testExitOnParentSuspendInsideStage()
{
// given
createCaseInstance();
CaseExecution stage = queryCaseExecutionByActivityId("PI_Stage_1");
string stageId = stage.Id;
manualStart(stageId);
CaseExecution firstHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_1");
string firstHumanTaskId = firstHumanTask.Id;
assertTrue(firstHumanTask.Enabled);
CaseExecution secondHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_2");
string secondHumanTaskId = secondHumanTask.Id;
assertTrue(secondHumanTask.Enabled);
// when
suspend(stageId);
// then
stage = queryCaseExecutionById(stageId);
assertTrue(((CaseExecutionEntity)stage).Suspended);
firstHumanTask = queryCaseExecutionById(firstHumanTaskId);
assertTrue(((CaseExecutionEntity)firstHumanTask).Suspended);
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertNull(secondHumanTask);
}
public virtual void testRepeatTaskWithoutEntryCriteriaWhenTerminating()
{
// given
string caseInstanceId = createCaseInstanceByKey(CASE_ID, Variables.createVariables().putValue("repeating", true)).Id;
CaseExecutionQuery query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
assertEquals(1, query.count());
CaseExecution activeCaseExecution = query.active().singleResult();
assertNotNull(activeCaseExecution);
// when (1)
terminate(activeCaseExecution.Id);
// then (1)
query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
assertEquals(1, query.count());
activeCaseExecution = query.active().singleResult();
assertNotNull(activeCaseExecution);
// when (2)
caseService.setVariable(caseInstanceId, "repeating", false);
terminate(activeCaseExecution.Id);
// then (2)
query = caseService.createCaseExecutionQuery();
assertEquals(1, query.count());
assertEquals(caseInstanceId, query.singleResult().Id);
}
public virtual void testExitTask()
{
// given
string caseInstanceId = createCaseInstance().Id;
CaseExecution firstHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_1");
string firstHumanTaskId = firstHumanTask.Id;
assertTrue(firstHumanTask.Active);
CaseExecution secondHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_2");
string secondHumanTaskId = secondHumanTask.Id;
assertTrue(secondHumanTask.Active);
assertNull(caseService.getVariable(caseInstanceId, "exit"));
// (1) when
complete(firstHumanTaskId);
// (2) then
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertNull(secondHumanTask);
object exitVariable = caseService.getVariable(caseInstanceId, "exit");
assertNotNull(exitVariable);
assertTrue((bool?)exitVariable);
}
public virtual void testNestedScopes()
{
string caseInstanceId = caseService.createCaseInstanceByKey("Case_1").Id;
string stageExecution1_Id = queryCaseExecutionByActivityId("Stage_1").Id;
// set the variable 'value' in the scope of the case model
caseService.setVariable(stageExecution1_Id, "value", 99);
CaseExecution humanTask1 = queryCaseExecutionByActivityId("HumanTask_1");
assertTrue(humanTask1.Available);
CaseExecution humanTask2 = queryCaseExecutionByActivityId("HumanTask_2");
assertTrue(humanTask2.Available);
// update the variable 'value' in the case model scope
caseService.setVariable(caseInstanceId, "value", 102);
// then sentry of HumanTask 1 and HumanTask 2 gets evaluated.
humanTask1 = queryCaseExecutionByActivityId("HumanTask_1");
assertTrue(humanTask1.Enabled);
humanTask2 = queryCaseExecutionByActivityId("HumanTask_2");
assertTrue(humanTask2.Enabled);
}
public virtual void testOrFork()
{
// given
createCaseInstance();
CaseExecution firstHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_1");
string firstHumanTaskId = firstHumanTask.Id;
assertTrue(firstHumanTask.Active);
CaseExecution secondHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_2");
string secondHumanTaskId = secondHumanTask.Id;
assertTrue(secondHumanTask.Active);
CaseExecution thirdHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_3");
string thirdHumanTaskId = thirdHumanTask.Id;
assertTrue(thirdHumanTask.Active);
// when
caseService.withCaseExecution(firstHumanTaskId).setVariable("value", 80).complete();
// then
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertNotNull(secondHumanTask);
assertTrue(secondHumanTask.Active);
thirdHumanTask = queryCaseExecutionById(thirdHumanTaskId);
assertNull(thirdHumanTask);
}
public virtual void testCycle()
{
// given
createCaseInstance();
CaseExecution firstHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_1");
string firstHumanTaskId = firstHumanTask.Id;
assertTrue(firstHumanTask.Active);
CaseExecution secondHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_2");
string secondHumanTaskId = secondHumanTask.Id;
assertTrue(secondHumanTask.Active);
CaseExecution thirdHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_3");
string thirdHumanTaskId = thirdHumanTask.Id;
assertTrue(thirdHumanTask.Active);
// when
complete(firstHumanTaskId);
// then
firstHumanTask = queryCaseExecutionById(firstHumanTaskId);
assertNull(firstHumanTask);
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertNull(secondHumanTask);
thirdHumanTask = queryCaseExecutionById(thirdHumanTaskId);
assertNull(thirdHumanTask);
}
public virtual void testNestedScopesWithNullVariableValue()
{
string caseInstanceId = caseService.createCaseInstanceByKey("Case_1").Id;
string stageExecution1_Id = queryCaseExecutionByActivityId("Stage_1").Id;
// set the variable 'value' in the scope of the case model
caseService.setVariable(caseInstanceId, "value", 99);
// set the variable 'value' in the scope of the stage 1 with null value
caseService.setVariableLocal(stageExecution1_Id, "value", null);
CaseExecution humanTask1 = queryCaseExecutionByActivityId("HumanTask_1");
assertTrue(humanTask1.Available);
CaseExecution humanTask2 = queryCaseExecutionByActivityId("HumanTask_2");
assertTrue(humanTask2.Available);
// update the variable 'value' in the case model scope
caseService.setVariable(caseInstanceId, "value", 102);
// then sentry of HumanTask 1 and HumanTask 2 gets evaluated.
humanTask1 = queryCaseExecutionByActivityId("HumanTask_1");
assertTrue(humanTask1.Enabled);
humanTask2 = queryCaseExecutionByActivityId("HumanTask_2");
// Sentry attached to HumanTask 2 is not evaluated because a variable 'value' exists in stage 2 even if the value is null
assertFalse(humanTask2.Enabled);
}
public virtual void testExitTaskWithMultipleOnPartSatisfied()
{
// given
createCaseInstance();
CaseExecution stageExecution;
CaseExecution humanTask1 = queryCaseExecutionByActivityId("HumanTask_1");
assertTrue(humanTask1.Active);
CaseExecution humanTask2 = queryCaseExecutionByActivityId("HumanTask_2");
assertTrue(humanTask2.Active);
complete(humanTask1.Id);
stageExecution = queryCaseExecutionByActivityId("Stage_1");
// Still if part and variable on part conditions are yet to be satisfied for the exit criteria
assertNotNull(stageExecution);
caseService.setVariable(stageExecution.Id, "value", 99);
stageExecution = queryCaseExecutionByActivityId("Stage_1");
// Still if part is yet to be satisfied for the exit criteria
assertNotNull(stageExecution);
caseService.setVariable(stageExecution.Id, "value", 101);
stageExecution = queryCaseExecutionByActivityId("Stage_1");
// exit criteria satisfied
assertNull(stageExecution);
}
public virtual void testExitTaskWithIfPartNotSatisfied()
{
// given
createCaseInstance();
CaseExecution firstHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_1");
string firstHumanTaskId = firstHumanTask.Id;
assertTrue(firstHumanTask.Active);
CaseExecution secondHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_2");
string secondHumanTaskId = secondHumanTask.Id;
assertTrue(secondHumanTask.Active);
// when
caseService.withCaseExecution(firstHumanTaskId).setVariable("value", 99).complete();
// then
firstHumanTask = queryCaseExecutionById(firstHumanTaskId);
assertNull(firstHumanTask);
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertTrue(secondHumanTask.Active);
}
public virtual void testWithMultipleEntryCriterias()
{
// given
string caseInstanceId = caseService.withCaseDefinitionByKey("case").create().Id;
CaseExecution milestone = caseService.createCaseExecutionQuery().activityId("PI_Milestone_1").singleResult();
string humanTaskId = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_2").singleResult().Id;
assertTrue(milestone.Available);
// then
assertNull(caseService.getVariable(caseInstanceId, "occur"));
milestone = caseService.createCaseExecutionQuery().available().singleResult();
assertTrue(milestone.Available);
// when
caseService.withCaseExecution(humanTaskId).complete();
// then
object occurVariable = caseService.getVariable(caseInstanceId, "occur");
assertNotNull(occurVariable);
assertTrue((bool?)occurVariable);
milestone = caseService.createCaseExecutionQuery().available().singleResult();
assertNull(milestone);
CaseInstance caseInstance = caseService.createCaseInstanceQuery().caseInstanceId(caseInstanceId).singleResult();
assertTrue(caseInstance.Active);
}
public virtual void testStageLocalScope()
{
caseService.createCaseInstanceByKey("Case_1").Id;
string stageExecution1_Id = queryCaseExecutionByActivityId("Stage_1").Id;
string stageExecution2_Id = queryCaseExecutionByActivityId("Stage_2").Id;
// variable set to stage 1 scope, so that sentries in stage 2 and in case model should not be triggered
caseService.setVariableLocal(stageExecution1_Id, "variable_1", "aVariable");
CaseExecution humanTask1 = queryCaseExecutionByActivityId("HumanTask_1");
assertTrue(humanTask1.Enabled);
CaseExecution humanTask2 = queryCaseExecutionByActivityId("HumanTask_2");
assertFalse(humanTask2.Enabled);
CaseExecution humanTask3 = queryCaseExecutionByActivityId("HumanTask_3");
assertFalse(humanTask3.Enabled);
// variable set to stage 2 scope, so that sentries in the scope of case model should not be triggered
caseService.setVariableLocal(stageExecution2_Id, "variable_1", "aVariable");
humanTask2 = queryCaseExecutionByActivityId("HumanTask_2");
assertTrue(humanTask2.Enabled);
humanTask3 = queryCaseExecutionByActivityId("HumanTask_3");
assertFalse(humanTask3.Enabled);
}
public virtual void checkReadCaseInstance(CaseExecution caseExecution)
{
if (caseExecution != null && !TenantManager.isAuthenticatedTenant(caseExecution.TenantId))
{
throw LOG.exceptionCommandWithUnauthorizedTenant("get the case execution '" + caseExecution.Id + "'");
}
}
public virtual void testStageScope()
{
caseService.createCaseInstanceByKey("Case_1");
CaseExecution caseModelHumanTask = queryCaseExecutionByActivityId("CaseModel_HumanTask");
assertFalse(caseModelHumanTask.Enabled);
string stageExecutionId = queryCaseExecutionByActivityId("Stage_1").Id;
// set the variable in the scope of stage such that sentry in the scope of case model does not gets evaluated.
caseService.setVariableLocal(stageExecutionId, "variable_1", "aVariable");
CaseExecution stageHumanTask = queryCaseExecutionByActivityId("Stage_HumanTask");
caseModelHumanTask = queryCaseExecutionByActivityId("CaseModel_HumanTask");
assertFalse(caseModelHumanTask.Enabled);
assertTrue(stageHumanTask.Enabled);
caseService.removeVariable(stageExecutionId, "variable_1");
// set the variable in the scope of case model that would trigger the sentry outside the scope of the stage
caseService.setVariable(stageHumanTask.Id, "variable_1", "aVariable");
stageHumanTask = queryCaseExecutionByActivityId("Stage_HumanTask");
caseModelHumanTask = queryCaseExecutionByActivityId("CaseModel_HumanTask");
assertTrue(caseModelHumanTask.Enabled);
assertTrue(stageHumanTask.Enabled);
}
public virtual void testTriggerStageEntryCriterion()
{
// given
string secondHumanTaskId = rule.caseExecutionQuery().activityId("PI_HumanTask_2").singleResult().Id;
string firstStageId = rule.caseExecutionQuery().activityId("PI_Stage_1").singleResult().Id;
// when
// complete human task
caseService.completeCaseExecution(secondHumanTaskId);
// then
// "PI_Stage_1" should be completed
CaseExecution firstStage = rule.caseExecutionQuery().activityId("PI_Stage_1").singleResult();
assertNull(firstStage);
// "PI_Stage_2" should be enabled
CaseExecution secondStage = rule.caseExecutionQuery().activityId("PI_Stage_2").singleResult();
assertNotNull(secondStage);
assertTrue(secondStage.Enabled);
CaseSentryPartEntity sentryPart = createCaseSentryPartQuery().sourceCaseExecutionId(firstStageId).singleResult();
// the associated sentry part is not satisfied
assertFalse(sentryPart.Satisfied);
// the source is null (since this sentry part
// has been migrated into 7.4)
assertNull(sentryPart.Source);
}
public virtual void testTriggerTaskEntryCriterion()
{
// given
// enabled human task inside a stage instance
string firstHumanTaskId = rule.caseExecutionQuery().activityId("PI_HumanTask_1").singleResult().Id;
// when
// start and complete human task
caseService.manuallyStartCaseExecution(firstHumanTaskId);
caseService.completeCaseExecution(firstHumanTaskId);
// then
// entry criterion of the second human task inside the stage instance
// will be triggered
CaseExecution secondHumanTask = rule.caseExecutionQuery().activityId("PI_HumanTask_2").singleResult();
// ... and the task is enabled
assertTrue(secondHumanTask.Enabled);
CaseSentryPartEntity sentryPart = createCaseSentryPartQuery().sourceCaseExecutionId(firstHumanTaskId).singleResult();
// the associated sentry part is not satisfied
assertFalse(sentryPart.Satisfied);
// the source is null (because this sentry part
// has been migrated into 7.4)
assertNull(sentryPart.Source);
}
protected internal virtual void createCaseInstance(string caseDefinitionKey, string tenantId)
{
caseService.withCaseDefinitionByKey(caseDefinitionKey).caseDefinitionTenantId(tenantId).create();
CaseExecution caseExecution = caseService.createCaseExecutionQuery().activityId(CASE_TASK_ID).tenantIdIn(tenantId).singleResult();
caseService.withCaseExecution(caseExecution.Id).manualStart();
}
public virtual void testExitStage()
{
// given
string caseInstanceId = createCaseInstance().Id;
CaseExecution firstHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_1");
string firstHumanTaskId = firstHumanTask.Id;
assertTrue(firstHumanTask.Active);
CaseExecution stage = queryCaseExecutionByActivityId("PI_Stage_1");
string stageId = stage.Id;
assertTrue(stage.Active);
stage = queryCaseExecutionById(stageId);
assertTrue(stage.Active);
CaseExecution milestone = queryCaseExecutionByActivityId("PI_Milestone_1");
string milestoneId = milestone.Id;
assertTrue(milestone.Available);
CaseExecution secondHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_2");
string secondHumanTaskId = secondHumanTask.Id;
assertTrue(secondHumanTask.Active);
// (2) then
stage = queryCaseExecutionById(stageId);
assertTrue(stage.Active);
assertNull(caseService.getVariable(caseInstanceId, "exit"));
assertNull(caseService.getVariable(caseInstanceId, "parentTerminate"));
// (2) when
complete(firstHumanTaskId);
// (2) then
stage = queryCaseExecutionById(stageId);
assertNull(stage);
milestone = queryCaseExecutionById(milestoneId);
assertNull(milestone);
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertNull(secondHumanTask);
object exitVariable = caseService.getVariable(caseInstanceId, "exit");
assertNotNull(exitVariable);
assertTrue((bool?)exitVariable);
object parentTerminateVariable = caseService.getVariable(caseInstanceId, "parentTerminate");
assertNotNull(parentTerminateVariable);
assertTrue((bool?)parentTerminateVariable);
}
protected internal virtual CaseInstance createCaseInstance(string caseDefinitionKey)
{
CaseInstance caseInstance = caseService.withCaseDefinitionByKey(caseDefinitionKey).create();
CaseExecution caseExecution = caseService.createCaseExecutionQuery().activityId(DECISION_TASK_ID).singleResult();
caseService.withCaseExecution(caseExecution.Id).setVariable("status", "gold").manualStart();
return(caseInstance);
}
public static DelegateVariableInstanceSpec fromCaseExecution(CaseExecution caseExecution)
{
DelegateVariableInstanceSpec spec = new DelegateVariableInstanceSpec();
spec.expectedCaseExecutionId = caseExecution.Id;
spec.expectedCaseInstanceId = caseExecution.CaseInstanceId;
spec.expectedSourceExecution = caseExecution;
return(spec);
}
public virtual void testUnknownVariableCreate()
{
string caseInstanceId = caseService.createCaseInstanceByKey("Case_1").Id;
caseService.setVariable(caseInstanceId, "unknown", "aVariable");
CaseExecution firstHumanTask = queryCaseExecutionByActivityId("HumanTask_1");
assertFalse(firstHumanTask.Enabled);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testDefaultRequiredRuleWithEmptyConditionEvaluatesToTrue()
public virtual void testDefaultRequiredRuleWithEmptyConditionEvaluatesToTrue()
{
caseService.createCaseInstanceByKey("case");
CaseExecution taskExecution = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").singleResult();
assertThat(taskExecution, @is(notNullValue()));
assertThat(taskExecution.Required, @is(true));
}
public virtual void FAILING_testParentResumeInsideStage()
{
// given
createCaseInstance();
CaseExecution stage = queryCaseExecutionByActivityId("PI_Stage_1");
string stageId = stage.Id;
manualStart(stageId);
CaseExecution firstHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_1");
string firstHumanTaskId = firstHumanTask.Id;
assertTrue(firstHumanTask.Enabled);
CaseExecution secondHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_2");
string secondHumanTaskId = secondHumanTask.Id;
assertTrue(secondHumanTask.Enabled);
CaseExecution thirdHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_3");
string thirdHumanTaskId = thirdHumanTask.Id;
assertTrue(thirdHumanTask.Available);
// (1) when
suspend(stageId);
// (1) then
stage = queryCaseExecutionById(stageId);
assertTrue(((CaseExecutionEntity)stage).Suspended);
firstHumanTask = queryCaseExecutionById(firstHumanTaskId);
assertTrue(((CaseExecutionEntity)firstHumanTask).Suspended);
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertTrue(((CaseExecutionEntity)secondHumanTask).Suspended);
thirdHumanTask = queryCaseExecutionById(thirdHumanTaskId);
assertTrue(((CaseExecutionEntity)thirdHumanTask).Suspended);
// (2) when
resume(stageId);
// (2) then
stage = queryCaseExecutionById(stageId);
assertTrue(stage.Active);
firstHumanTask = queryCaseExecutionById(firstHumanTaskId);
assertTrue(firstHumanTask.Enabled);
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertNull(secondHumanTask);
thirdHumanTask = queryCaseExecutionById(thirdHumanTaskId);
assertTrue(thirdHumanTask.Enabled);
}
public virtual void testManualActivationRuleWithoutCondition()
{
createCaseInstanceByKey("case", Variables.createVariables().putValue("manual", false));
CaseExecution taskExecution = queryCaseExecutionByActivityId("PI_HumanTask_1");
assertNotNull(taskExecution);
assertTrue(taskExecution.Enabled);
}
public virtual void testActivationWithoutManualActivationDefined()
{
caseService.createCaseInstanceByKey("case");
CaseExecution taskExecution = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").singleResult();
assertThat(taskExecution, @is(notNullValue()));
assertThat(taskExecution.Enabled, @is(false));
assertThat("Human Task is active, when ManualActivation is omitted", taskExecution.Active, @is(true));
}
