protected internal override void startInstance(ActivityExecution execution, VariableMap variables, string businessKey)
{
CmmnCaseDefinition definition = getCaseDefinitionToCall(execution, CallableElement);
CmmnCaseInstance caseInstance = execution.createSubCaseInstance(definition, businessKey);
caseInstance.create(variables);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSerializeFileVariable()
public virtual void testSerializeFileVariable()
{
BpmnModelInstance modelInstance = Bpmn.createExecutableProcess("process").startEvent().userTask().endEvent().done();
org.camunda.bpm.engine.repository.Deployment deployment = repositoryService.createDeployment().addModelInstance("process.bpmn", modelInstance).deploy();
VariableMap variables = Variables.createVariables();
string filename = "test.txt";
string type = "text/plain";
FileValue fileValue = Variables.fileValue(filename).file("ABC".GetBytes()).encoding("UTF-8").mimeType(type).create();
variables.put("file", fileValue);
runtimeService.startProcessInstanceByKey("process", variables);
Task task = taskService.createTaskQuery().singleResult();
VariableInstance result = runtimeService.createVariableInstanceQuery().processInstanceIdIn(task.ProcessInstanceId).singleResult();
FileValue value = (FileValue)result.TypedValue;
assertThat(value.Filename, @is(filename));
assertThat(value.MimeType, @is(type));
assertThat(value.Encoding, @is("UTF-8"));
assertThat(value.EncodingAsCharset, @is(Charset.forName("UTF-8")));
using (Scanner scanner = new Scanner(value.Value))
{
assertThat(scanner.nextLine(), @is("ABC"));
}
// clean up
repositoryService.deleteDeployment(deployment.Id, true);
}
public virtual void onClear(ExecutionEntity execution)
{
if (variableSnapshot == null)
{
variableSnapshot = getVariables(this.localVariables);
}
}
//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);
}
public virtual void testPojo()
{
VariableMap variables = Variables.createVariables().putValue("pojo", new TestPojo("okay", 13.37));
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testProcess", variables);
assertEquals("okay", getDecisionResult(processInstance));
}
protected internal override void startInstance(ActivityExecution execution, VariableMap variables, string businessKey)
{
ProcessDefinitionImpl definition = getProcessDefinitionToCall(execution, CallableElement);
PvmProcessInstance processInstance = execution.createSubProcessInstance(definition, businessKey);
processInstance.start(variables);
}
public static void initFormPropertiesOnScope(VariableMap variables, PvmExecutionImpl execution)
{
ProcessDefinitionEntity pd = (ProcessDefinitionEntity)execution.ProcessDefinition;
StartFormHandler startFormHandler = pd.StartFormHandler;
startFormHandler.submitFormVariables(variables, execution);
}
public virtual void decisionRefWithCompositeExpression()
{
VariableMap variables = Variables.createVariables().putValue("version", 1);
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("testProcessCompositeExpression", variables);
assertEquals("okay", getDecisionResult(processInstance));
}
public virtual void testCatchErrorThrownBySignalOfDelegateExpression()
{
VariableMap variables = Variables.createVariables().putValue("myDelegate", new ThrowErrorDelegate());
string pi = runtimeService.startProcessInstanceByKey("testProcess", variables).Id;
assertTrue((bool?)runtimeService.getVariable(pi, "executed"));
assertNull(runtimeService.getVariable(pi, "signaled"));
Execution serviceTask = runtimeService.createExecutionQuery().processInstanceId(pi).activityId("serviceTask").singleResult();
assertNotNull(serviceTask);
runtimeService.setVariables(pi, throwError());
runtimeService.signal(serviceTask.Id);
assertTrue((bool?)runtimeService.getVariable(pi, "executed"));
assertTrue((bool?)runtimeService.getVariable(pi, "signaled"));
Task userTask = taskService.createTaskQuery().processInstanceId(pi).singleResult();
assertNotNull(userTask);
assertEquals("userTaskError", userTask.TaskDefinitionKey);
taskService.complete(userTask.Id);
}
public virtual void testPojo()
{
// given
VariableMap variables = Variables.createVariables().putValue("pojo", new TestPojo("okay", 13.37));
CaseInstance caseInstance = createCaseInstanceByKey(CASE_KEY, variables);
assertEquals("okay", getDecisionResult(caseInstance));
}
public ConditionSet(ConditionEvaluationBuilderImpl builder)
{
this.businessKey = builder.BusinessKey;
this.processDefinitionId = builder.ProcessDefinitionId;
this.variables = builder.getVariables();
this.tenantId = builder.TenantId;
this.isTenantIdSet = builder.TenantIdSet;
}
public virtual void submitFormVariables(VariableMap properties, VariableScope variableScope)
{
ProcessEngineConfigurationImpl processEngineConfiguration = Context.ProcessEngineConfiguration;
IdentityService identityService = processEngineConfiguration.IdentityService;
RuntimeService runtimeService = processEngineConfiguration.RuntimeService;
logAuthentication(identityService);
logInstancesCount(runtimeService);
}
public virtual void testExecutionWithScriptTargetScope()
{
VariableMap variables = Variables.createVariables().putValue("orderIds", Arrays.asList(new int[] { 1, 2, 3 }));
ProcessInstance processInstance = engineRule.RuntimeService.startProcessInstanceByKey("Process_MultiInstanceCallAcitivity", variables);
// it runs without any problems
assertThat(processInstance.Ended, @is(true));
assertThat(((ProcessInstanceWithVariablesImpl)processInstance).Variables.containsKey("targetOrderId"), @is(false));
}
public virtual void testWithDelegateVariableMapping()
{
BpmnModelInstance instance = Bpmn.createExecutableProcess("process1").startEvent().subProcess("SubProcess_1").embeddedSubProcess().startEvent().callActivity().calledElement("Process_StuffDoer").camundaVariableMappingClass("org.camunda.bpm.engine.test.api.variables.scope.SetVariableMappingDelegate").serviceTask().camundaClass("org.camunda.bpm.engine.test.api.variables.scope.AssertVariableScopeDelegate").endEvent().subProcessDone().endEvent().done();
instance = modify(instance).activityBuilder("SubProcess_1").multiInstance().parallel().camundaCollection("orderIds").camundaElementVariable("orderId").done();
ProcessDefinition processDefinition = testHelper.deployAndGetDefinition(instance);
VariableMap variables = Variables.createVariables().putValue("orderIds", Arrays.asList(new int[] { 1, 2, 3 }));
engineRule.RuntimeService.startProcessInstanceById(processDefinition.Id, variables);
}
public virtual void testProcessVariableMapLocal()
{
BusinessProcess businessProcess = getBeanInstance(typeof(BusinessProcess));
businessProcess.startProcessByKey("businessProcessBeanTest");
VariableMap variables = (VariableMap)getBeanInstance("processVariableMapLocal");
assertNotNull(variables);
///////////////////////////////////////////////////////////////////
// Put a variable via BusinessProcess and get it via VariableMap //
///////////////////////////////////////////////////////////////////
string aValue = "aValue";
businessProcess.setVariableLocal(VARNAME_1, Variables.stringValue(aValue));
// Legacy API
assertEquals(aValue, variables.get(VARNAME_1));
// Typed variable API
TypedValue aTypedValue = variables.getValueTyped(VARNAME_1);
assertEquals(ValueType.STRING, aTypedValue.Type);
assertEquals(aValue, aTypedValue.Value);
assertEquals(aValue, variables.getValue(VARNAME_1, typeof(string)));
// Type API with wrong type
try
{
variables.getValue(VARNAME_1, typeof(Integer));
fail("ClassCastException expected!");
}
catch (System.InvalidCastException ex)
{
assertEquals("Cannot cast variable named 'aVariable' with value 'aValue' to type 'class java.lang.Integer'.", ex.Message);
}
///////////////////////////////////////////////////////////////////
// Put a variable via VariableMap and get it via BusinessProcess //
///////////////////////////////////////////////////////////////////
string anotherValue = "anotherValue";
variables.put(VARNAME_2, Variables.stringValue(anotherValue));
// Legacy API
assertEquals(anotherValue, businessProcess.getVariableLocal(VARNAME_2));
// Typed variable API
TypedValue anotherTypedValue = businessProcess.getVariableLocalTyped(VARNAME_2);
assertEquals(ValueType.STRING, anotherTypedValue.Type);
assertEquals(anotherValue, anotherTypedValue.Value);
}
public virtual void testExecutionWithoutProperTargetScope()
{
VariableMap variables = Variables.createVariables().putValue("orderIds", Arrays.asList(new int[] { 1, 2, 3 }));
//fails due to inappropriate variable scope target
thrown.expect(typeof(ScriptEvaluationException));
ProcessDefinition processDefinition = engineRule.RepositoryService.createProcessDefinitionQuery().processDefinitionKey("Process_MultiInstanceCallAcitivity").singleResult();
thrown.expectMessage(startsWith("Unable to evaluate script while executing activity 'CallActivity_1' in the process definition with id '" + processDefinition.Id + "': org.camunda.bpm.engine.ProcessEngineException: ENGINE-20011 Scope with specified activity Id NOT_EXISTING and execution"));
engineRule.RuntimeService.startProcessInstanceByKey("Process_MultiInstanceCallAcitivity", variables);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testLimitedRepetitions()
public virtual void testLimitedRepetitions()
{
// given
VariableMap variables = Variables.createVariables().putValue("repetition", 0);
createCaseInstanceByKey("case", variables);
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 activeQuery = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").active();
string activeTaskId = activeQuery.listPage(0, 1).get(0).Id;
// when (1)
complete(activeTaskId);
// then (1)
CaseExecutionQuery query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_2");
assertEquals(2, query.count());
assertEquals(1, query.active().count());
assertEquals(1, query.available().count());
// when (2)
activeTaskId = activeQuery.listPage(0, 1).get(0).Id;
complete(activeTaskId);
// then (2)
query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_2");
assertEquals(3, query.count());
assertEquals(2, query.active().count());
assertEquals(1, query.available().count());
// when (3)
activeTaskId = activeQuery.listPage(0, 1).get(0).Id;
complete(activeTaskId);
// then (3)
query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_2");
assertEquals(3, query.count());
assertEquals(3, query.active().count());
assertEquals(0, query.available().count());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void decisionRefVersionTagBindingExpression()
public virtual void decisionRefVersionTagBindingExpression()
{
// given
testRule.deploy(DECISION_VERSION_TAG_OKAY_DMN);
testRule.deploy(Bpmn.createExecutableProcess("process").startEvent().businessRuleTask().camundaDecisionRef("decision").camundaDecisionRefBinding("versionTag").camundaDecisionRefVersionTag("${versionTagExpr}").camundaMapDecisionResult("singleEntry").camundaResultVariable("result").endEvent().camundaAsyncBefore().done());
// when
VariableMap variables = Variables.createVariables().putValue("versionTagExpr", "0.0.2").putValue("status", "gold");
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("process", variables);
// then
assertEquals("A", getDecisionResult(processInstance));
}
public virtual void testWithDelegateVariableMappingAndChildScope()
{
BpmnModelInstance instance = Bpmn.createExecutableProcess("process1").startEvent().parallelGateway().subProcess("SubProcess_1").embeddedSubProcess().startEvent().callActivity().calledElement("Process_StuffDoer").camundaVariableMappingClass("org.camunda.bpm.engine.test.api.variables.scope.SetVariableToChildMappingDelegate").serviceTask().camundaClass("org.camunda.bpm.engine.test.api.variables.scope.AssertVariableScopeDelegate").endEvent().subProcessDone().moveToLastGateway().subProcess("SubProcess_2").embeddedSubProcess().startEvent().userTask("ut").endEvent().subProcessDone().endEvent().done();
instance = modify(instance).activityBuilder("SubProcess_1").multiInstance().parallel().camundaCollection("orderIds").camundaElementVariable("orderId").done();
ProcessDefinition processDefinition = testHelper.deployAndGetDefinition(instance);
thrown.expect(typeof(ProcessEngineException));
thrown.expectMessage(startsWith("org.camunda.bpm.engine.ProcessEngineException: ENGINE-20011 Scope with specified activity Id SubProcess_2 and execution"));
VariableMap variables = Variables.createVariables().putValue("orderIds", Arrays.asList(new int[] { 1, 2, 3 }));
engineRule.RuntimeService.startProcessInstanceById(processDefinition.Id, variables);
}
// submit /////////////////////////////////
public virtual void validate(object submittedValue, VariableMap submittedValues, FormFieldHandler formFieldHandler, VariableScope variableScope)
{
try
{
FormFieldValidatorContext context = new DefaultFormFieldValidatorContext(variableScope, config, submittedValues, formFieldHandler);
if (!validator.validate(submittedValue, context))
{
throw new FormFieldValidatorException(formFieldHandler.Id, name, config, submittedValue, "Invalid value submitted for form field '" + formFieldHandler.Id + "': validation of " + this + " failed.");
}
}
catch (FormFieldValidationException e)
{
throw new FormFieldValidatorException(formFieldHandler.Id, name, config, submittedValue, "Invalid value submitted for form field '" + formFieldHandler.Id + "': validation of " + this + " failed.", e);
}
}
public virtual void testProcessVariableTypeAnnotation()
{
BusinessProcess businessProcess = getBeanInstance(typeof(BusinessProcess));
VariableMap variables = Variables.createVariables().putValue("injectedValue", "camunda");
businessProcess.startProcessByKey("keyOfTheProcess", variables);
TypedValue value = getBeanInstance(typeof(DeclarativeProcessController)).InjectedValue;
assertNotNull(value);
assertTrue(value is StringValue);
assertEquals(ValueType.STRING, value.Type);
assertEquals("camunda", value.Value);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testHistoricDecisionInstance()
public virtual void testHistoricDecisionInstance()
{
VariableMap variables = Variables.createVariables().putValue("status", "bronze").putValue("sum", 100);
ProcessInstance pi = runtimeService.startProcessInstanceByKey("testProcess", variables);
HistoricDecisionInstance historicDecisionInstance = historyService.createHistoricDecisionInstanceQuery().includeInputs().includeOutputs().singleResult();
assertThat(historicDecisionInstance, @is(notNullValue()));
assertThat(historicDecisionInstance.DecisionDefinitionKey, @is("decision"));
assertThat(historicDecisionInstance.DecisionDefinitionName, @is("Check Order"));
assertThat(historicDecisionInstance.Inputs.Count, @is(2));
assertThat(historicDecisionInstance.Outputs.Count, @is(2));
Task task = taskService.createTaskQuery().processInstanceId(pi.Id).singleResult();
taskService.complete(task.Id);
}
public virtual void testDefaultVariableBasedRepetitionRuleEvaluatesToFalse()
{
// given
VariableMap variables = Variables.createVariables().putValue("repeat", false);
createCaseInstanceByKey("case", variables);
string humanTask1 = queryCaseExecutionByActivityId("PI_HumanTask_1").Id;
// when
complete(humanTask1);
// then
CaseExecutionQuery query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_2");
assertEquals(1, query.count());
assertEquals(1, query.active().count());
}
public virtual void complete(CompleteExternalTaskDto dto)
{
ExternalTaskService externalTaskService = engine.ExternalTaskService;
VariableMap variables = VariableValueDto.toMap(dto.Variables, engine, objectMapper);
VariableMap localVariables = VariableValueDto.toMap(dto.LocalVariables, engine, objectMapper);
try
{
externalTaskService.complete(externalTaskId, dto.WorkerId, variables, localVariables);
}
catch (NotFoundException e)
{
throw new RestException(Status.NOT_FOUND, e, "External task with id " + externalTaskId + " does not exist");
}
catch (BadUserRequestException e)
{
throw new RestException(Status.BAD_REQUEST, e, e.Message);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testLimitedParallelRepetitions()
public virtual void testLimitedParallelRepetitions()
{
// given
VariableMap variables = Variables.createVariables().putValue("repetition", 0);
createCaseInstanceByKey("case", variables);
// when (1)
CaseExecutionQuery query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
// then (1)
assertEquals(3, query.count());
// when (2)
// complete any task
string caseExecutionId = query.listPage(0, 1).get(0).Id;
complete(caseExecutionId);
// then (2)
assertEquals(2, query.count());
}
public virtual void signalExecution(ExecutionTriggerDto triggerDto)
{
RuntimeService runtimeService = engine.RuntimeService;
try
{
VariableMap variables = VariableValueDto.toMap(triggerDto.Variables, engine, objectMapper);
runtimeService.signal(executionId, variables);
}
catch (RestException e)
{
string errorMessage = string.Format("Cannot signal execution {0}: {1}", executionId, e.Message);
throw new InvalidRequestException(e.Status, e, errorMessage);
}
catch (AuthorizationException e)
{
throw e;
}
catch (ProcessEngineException e)
{
throw new RestException(Status.INTERNAL_SERVER_ERROR, e, "Cannot signal execution " + executionId + ": " + e.Message);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testLimitedSequentialRepetitions()
public virtual void testLimitedSequentialRepetitions()
{
// given
VariableMap variables = Variables.createVariables().putValue("repetition", 0);
createCaseInstanceByKey("case", variables);
CaseExecutionQuery activeQuery = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").active();
string enabledCaseExecutionId = activeQuery.singleResult().Id;
// when (1)
complete(enabledCaseExecutionId);
// then (1)
CaseExecutionQuery query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
assertEquals(1, query.count());
assertEquals(1, query.active().count());
// when (2)
enabledCaseExecutionId = activeQuery.singleResult().Id;
complete(enabledCaseExecutionId);
// then (2)
query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
assertEquals(1, query.count());
assertEquals(1, query.active().count());
// when (3)
enabledCaseExecutionId = activeQuery.singleResult().Id;
complete(enabledCaseExecutionId);
// then (3)
query = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1");
assertEquals(0, query.count());
}
public virtual void triggerEvent(ExecutionTriggerDto triggerDto)
{
RuntimeService runtimeService = engine.RuntimeService;
try
{
VariableMap variables = VariableValueDto.toMap(triggerDto.Variables, engine, objectMapper);
runtimeService.messageEventReceived(messageName, executionId, variables);
}
catch (AuthorizationException e)
{
throw e;
}
catch (ProcessEngineException e)
{
throw new RestException(Status.INTERNAL_SERVER_ERROR, e, string.Format("Cannot trigger message {0} for execution {1}: {2}", messageName, executionId, e.Message));
}
catch (RestException e)
{
string errorMessage = string.Format("Cannot trigger message {0} for execution {1}: {2}", messageName, executionId, e.Message);
throw new InvalidRequestException(e.Status, e, errorMessage);
}
}
public virtual void mapInputVariables(DelegateExecution superExecution, VariableMap subVariables)
{
throw new ProcessEngineException("New process engine exception.");
}
public virtual void mapInputVariables(DelegateExecution superExecution, VariableMap subVariables)
{
}
