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