public virtual void testDecisionInstanceProperties()
{
startProcessInstanceAndEvaluateDecision();
IProcessInstance processInstance = runtimeService.CreateProcessInstanceQuery().First();
IProcessDefinition processDefinition = repositoryService.CreateProcessDefinitionQuery(c => c.Id == processInstance.ProcessDefinitionId).First();
string decisionDefinitionId = repositoryService.CreateDecisionDefinitionQuery(c => c.Key == DECISION_DEFINITION_KEY).First().Id;
string activityInstanceId = historyService.CreateHistoricActivityInstanceQuery(c => c.ActivityId == "task").First().Id;
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery().First();
Assert.That(historicDecisionInstance, Is.Not.Null);
Assert.That(historicDecisionInstance.DecisionDefinitionId, Is.EqualTo(decisionDefinitionId));
Assert.That(historicDecisionInstance.DecisionDefinitionKey, Is.EqualTo(DECISION_DEFINITION_KEY));
Assert.That(historicDecisionInstance.DecisionDefinitionName, Is.EqualTo("sample decision"));
Assert.That(historicDecisionInstance.ProcessDefinitionKey, Is.EqualTo(processDefinition.Key));
Assert.That(historicDecisionInstance.ProcessDefinitionId, Is.EqualTo(processDefinition.Id));
Assert.That(historicDecisionInstance.ProcessInstanceId, Is.EqualTo(processInstance.Id));
Assert.That(historicDecisionInstance.CaseDefinitionKey, Is.EqualTo(null));
Assert.That(historicDecisionInstance.CaseDefinitionId, Is.EqualTo(null));
Assert.That(historicDecisionInstance.CaseInstanceId, Is.EqualTo(null));
Assert.That(historicDecisionInstance.ActivityId, Is.EqualTo("task"));
Assert.That(historicDecisionInstance.ActivityInstanceId, Is.EqualTo(activityInstanceId));
Assert.That(historicDecisionInstance.RootDecisionInstanceId, Is.EqualTo(null));
Assert.That(historicDecisionInstance.DecisionRequirementsDefinitionId, Is.EqualTo(null));
Assert.That(historicDecisionInstance.DecisionRequirementsDefinitionKey, Is.EqualTo(null));
Assert.That(historicDecisionInstance.EvaluationTime, Is.Not.Null);
}
public virtual void testDecisionInstancePropertiesOfDecisionLiteralExpression()
{
IDecisionDefinition decisionDefinition = repositoryService.CreateDecisionDefinitionQuery().First();
decisionService.EvaluateDecisionByKey("decision").Variables(ESS.FW.Bpm.Engine.Variable.Variables.CreateVariables().PutValue("sum", 2205)).Evaluate();
IQueryable <IHistoricDecisionInstance> query = historyService.CreateHistoricDecisionInstanceQuery() /*/*.IncludeInputs()*//*.IncludeOutputs()*/;
Assert.That(query.Count(), Is.EqualTo(1L));
IHistoricDecisionInstance historicDecisionInstance = query.First();
Assert.That(historicDecisionInstance.DecisionDefinitionId, Is.EqualTo(decisionDefinition.Id));
Assert.That(historicDecisionInstance.DecisionDefinitionKey, Is.EqualTo("decision"));
Assert.That(historicDecisionInstance.DecisionDefinitionName, Is.EqualTo("Decision with Literal Expression"));
Assert.That(historicDecisionInstance.EvaluationTime, Is.Not.Null);
Assert.That(historicDecisionInstance.Inputs.Count, Is.EqualTo(0));
IList <IHistoricDecisionOutputInstance> outputs = historicDecisionInstance.Outputs;
Assert.That(outputs.Count, Is.EqualTo(1));
IHistoricDecisionOutputInstance output = outputs[0];
Assert.That(output.VariableName, Is.EqualTo("result"));
Assert.That(output.TypeName, Is.EqualTo("string"));
Assert.That((string)output.Value, Is.EqualTo("ok"));
Assert.That(output.ClauseId, Is.EqualTo(null));
Assert.That(output.ClauseName, Is.EqualTo(null));
Assert.That(output.RuleId, Is.EqualTo(null));
Assert.That(output.RuleOrder, Is.EqualTo(null));
}
public virtual void testCompoundDecisionOutputInstances()
{
startProcessInstanceAndEvaluateDecision();
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery() /*.IncludeOutputs()*/.First();
IList <IHistoricDecisionOutputInstance> outputs = historicDecisionInstance.Outputs;
Assert.That(outputs.Count, Is.EqualTo(2));
IHistoricDecisionOutputInstance firstOutput = outputs[0];
Assert.That(firstOutput.ClauseId, Is.EqualTo("out1"));
Assert.That(firstOutput.RuleId, Is.EqualTo("rule1"));
Assert.That(firstOutput.RuleOrder, Is.EqualTo(1));
Assert.That(firstOutput.VariableName, Is.EqualTo("result1"));
Assert.That(firstOutput.Value, Is.EqualTo((object)"okay"));
IHistoricDecisionOutputInstance secondOutput = outputs[1];
Assert.That(secondOutput.ClauseId, Is.EqualTo("out2"));
Assert.That(secondOutput.RuleId, Is.EqualTo("rule1"));
Assert.That(secondOutput.RuleOrder, Is.EqualTo(1));
Assert.That(secondOutput.VariableName, Is.EqualTo("result2"));
Assert.That(secondOutput.Value, Is.EqualTo((object)"not okay"));
}
public virtual void testCaseDecisionEvaluatedWithDecisionServiceInsideDelegate()
{
ICaseInstance caseInstance = createCaseInstanceAndEvaluateDecision();
//ICaseDefinition caseDefinition = repositoryService.CreateCaseDefinitionQuery(c=>c.CaseDefinitionId== caseInstance.CaseDefinitionId).First();
//string decisionDefinitionId = repositoryService.CreateDecisionDefinitionQuery(c=>c.Key== DECISION_DEFINITION_KEY).First().Id;
string activityInstanceId = historyService.CreateHistoricCaseActivityInstanceQuery(c => c.CaseActivityId == "PI_HumanTask_1").First().Id;
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery().First();
//Assert.That(historicDecisionInstance, Is.Not.Null);
//Assert.That(historicDecisionInstance.DecisionDefinitionId, Is.EqualTo(decisionDefinitionId));
//Assert.That(historicDecisionInstance.DecisionDefinitionKey, Is.EqualTo(DECISION_DEFINITION_KEY));
//Assert.That(historicDecisionInstance.DecisionDefinitionName, Is.EqualTo("sample decision"));
//// references to case instance should be set since the decision is evaluated while executing a case instance
//Assert.That(historicDecisionInstance.ProcessDefinitionKey, Is.EqualTo(null));
//Assert.That(historicDecisionInstance.ProcessDefinitionId, Is.EqualTo(null));
//Assert.That(historicDecisionInstance.ProcessInstanceId, Is.EqualTo(null));
//Assert.That(historicDecisionInstance.CaseDefinitionKey, Is.EqualTo(caseDefinition.Key));
//Assert.That(historicDecisionInstance.CaseDefinitionId, Is.EqualTo(caseDefinition.Id));
//Assert.That(historicDecisionInstance.CaseInstanceId, Is.EqualTo(caseInstance.Id));
//Assert.That(historicDecisionInstance.ActivityId, Is.EqualTo("PI_HumanTask_1"));
//Assert.That(historicDecisionInstance.ActivityInstanceId, Is.EqualTo(activityInstanceId));
//Assert.That(historicDecisionInstance.EvaluationTime, Is.Not.Null);
}
public virtual void testManualActivationRuleEvaluatesDecision()
{
ICaseInstance caseInstance = caseService.WithCaseDefinitionByKey("case").SetVariable("input1", null).SetVariable("myBean", new DecisionServiceDelegate()).Create();
//ICaseDefinition caseDefinition = repositoryService.CreateCaseDefinitionQuery(c=>c.CaseDefinitionId== caseInstance.CaseDefinitionId).First();
string decisionDefinitionId = repositoryService.CreateDecisionDefinitionQuery(c => c.DecisionRequirementsDefinitionKey == DECISION_DEFINITION_KEY).First().Id;
string activityInstanceId = historyService.CreateHistoricCaseActivityInstanceQuery(c => c.CaseActivityId == "PI_HumanTask_1").First().Id;
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery().First();
Assert.That(historicDecisionInstance, Is.Not.Null);
Assert.That(historicDecisionInstance.DecisionDefinitionId, Is.EqualTo(decisionDefinitionId));
Assert.That(historicDecisionInstance.DecisionDefinitionKey, Is.EqualTo(DECISION_DEFINITION_KEY));
Assert.That(historicDecisionInstance.DecisionDefinitionName, Is.EqualTo("sample decision"));
// references to case instance should be set since the decision is evaluated while executing a case instance
Assert.That(historicDecisionInstance.ProcessDefinitionKey, Is.EqualTo(null));
Assert.That(historicDecisionInstance.ProcessDefinitionId, Is.EqualTo(null));
Assert.That(historicDecisionInstance.ProcessInstanceId, Is.EqualTo(null));
//Assert.That(historicDecisionInstance.CaseDefinitionKey, Is.EqualTo(caseDefinition.Key));
//Assert.That(historicDecisionInstance.CaseDefinitionId, Is.EqualTo(caseDefinition.Id));
Assert.That(historicDecisionInstance.CaseInstanceId, Is.EqualTo(caseInstance.Id));
Assert.That(historicDecisionInstance.ActivityId, Is.EqualTo("PI_HumanTask_1"));
Assert.That(historicDecisionInstance.ActivityInstanceId, Is.EqualTo(activityInstanceId));
Assert.That(historicDecisionInstance.EvaluationTime, Is.Not.Null);
}
public virtual void CheckDeleteHistoricDecisionInstance(IHistoricDecisionInstance decisionInstance)
{
if (decisionInstance != null && !TenantManager.IsAuthenticatedTenant(decisionInstance.TenantId))
{
throw Log.ExceptionCommandWithUnauthorizedTenant("delete the historic decision instance '" + decisionInstance.Id + "'");
}
}
public virtual void testDecisionEvaluatedWithDecisionService()
{
IDictionary <string, object> variables = new Dictionary <string, object>();
variables["input1"] = "test";
decisionService.EvaluateDecisionTableByKey(DECISION_DEFINITION_KEY, variables);
string decisionDefinitionId = repositoryService.CreateDecisionDefinitionQuery(c => c.Key == DECISION_DEFINITION_KEY).First().Id;
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery().First();
Assert.That(historicDecisionInstance, Is.Not.Null);
Assert.That(historicDecisionInstance.DecisionDefinitionId, Is.EqualTo(decisionDefinitionId));
Assert.That(historicDecisionInstance.DecisionDefinitionKey, Is.EqualTo(DECISION_DEFINITION_KEY));
Assert.That(historicDecisionInstance.DecisionDefinitionName, Is.EqualTo("sample decision"));
Assert.That(historicDecisionInstance.EvaluationTime, Is.Not.Null);
// references to process instance should be null since the decision is not evaluated while executing a process instance
Assert.That(historicDecisionInstance.ProcessDefinitionKey, Is.EqualTo(null));
Assert.That(historicDecisionInstance.ProcessDefinitionId, Is.EqualTo(null));
Assert.That(historicDecisionInstance.ProcessInstanceId, Is.EqualTo(null));
Assert.That(historicDecisionInstance.ActivityId, Is.EqualTo(null));
Assert.That(historicDecisionInstance.ActivityInstanceId, Is.EqualTo(null));
// the IUser should be null since no IUser was authenticated during evaluation
Assert.That(historicDecisionInstance.UserId, Is.EqualTo(null));
}
public virtual void evaluateDecisionWithDecisionService()
{
runtimeService.StartProcessInstanceByKey("testProcess", ESS.FW.Bpm.Engine.Variable.Variables.CreateVariables().PutValue("input1", null).PutValue("myBean", new DecisionServiceDelegate()));
IProcessInstance processInstance = runtimeService.CreateProcessInstanceQuery().First();
IProcessDefinition processDefinition = repositoryService.CreateProcessDefinitionQuery(c => c.Id == processInstance.ProcessDefinitionId).First();
string decisionDefinitionId = repositoryService.CreateDecisionDefinitionQuery(c => c.Key == DECISION_DEFINITION_KEY).First().Id;
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery().First();
Assert.That(historicDecisionInstance, Is.Not.Null);
Assert.That(historicDecisionInstance.DecisionDefinitionId, Is.EqualTo(decisionDefinitionId));
Assert.That(historicDecisionInstance.DecisionDefinitionKey, Is.EqualTo(DECISION_DEFINITION_KEY));
Assert.That(historicDecisionInstance.DecisionDefinitionName, Is.EqualTo("sample decision"));
// references to process instance should be set since the decision is evaluated while executing a process instance
Assert.That(historicDecisionInstance.ProcessDefinitionKey, Is.EqualTo(processDefinition.Key));
Assert.That(historicDecisionInstance.ProcessDefinitionId, Is.EqualTo(processDefinition.Id));
Assert.That(historicDecisionInstance.ProcessInstanceId, Is.EqualTo(processInstance.Id));
Assert.That(historicDecisionInstance.CaseDefinitionKey, Is.EqualTo(null));
Assert.That(historicDecisionInstance.CaseDefinitionId, Is.EqualTo(null));
Assert.That(historicDecisionInstance.CaseInstanceId, Is.EqualTo(null));
Assert.That(historicDecisionInstance.ActivityId, Is.EqualTo(activityId));
Assert.That(historicDecisionInstance.EvaluationTime, Is.Not.Null);
}
public virtual void testCollectResultValue()
{
startProcessInstanceAndEvaluateDecision();
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery().First();
Assert.That(historicDecisionInstance.CollectResultValue, Is.Not.Null);
Assert.That(historicDecisionInstance.CollectResultValue, Is.EqualTo(3.0));
}
public virtual void testDecisionEvaluatedWithAuthenticatedUserFromCase()
{
identityService.AuthenticatedUserId = "demo";
createCaseInstanceAndEvaluateDecision();
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery().First();
Assert.That(historicDecisionInstance, Is.Not.Null);
// the IUser should be null since decision was evaluated by the case
Assert.That(historicDecisionInstance.UserId, Is.EqualTo(null));
}
public virtual void testDecisionEvaluatedWithAuthenticatedUser()
{
identityService.AuthenticatedUserId = "demo";
IVariableMap variables = Variables.PutValue("input1", "test");
decisionService.EvaluateDecisionTableByKey(DECISION_DEFINITION_KEY, variables);
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery().First();
Assert.That(historicDecisionInstance, Is.Not.Null);
// the IUser should be set since the decision was evaluated with the decision service
Assert.That(historicDecisionInstance.UserId, Is.EqualTo("demo"));
}
public virtual void decisionOutputInstanceValue()
{
startProcessInstanceAndEvaluateDecision(inputValue);
IHistoricDecisionInstance historicDecisionInstance = engineRule.HistoryService.CreateHistoricDecisionInstanceQuery() /*.IncludeOutputs()*/.First();
IList <IHistoricDecisionOutputInstance> outputInstances = historicDecisionInstance.Outputs;
Assert.That(outputInstances.Count, Is.EqualTo(1));
IHistoricDecisionOutputInstance outputInstance = outputInstances[0];
Assert.That(outputInstance.TypeName, Is.EqualTo(valueType));
Assert.That(outputInstance.Value, Is.EqualTo(inputValue));
}
public virtual void testDisableDecisionInputInstanceByteValue()
{
byte[] bytes = "object".GetBytes();
startProcessInstanceAndEvaluateDecision(bytes);
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery() /*/*.IncludeInputs()*//*.DisableBinaryFetching()*/.First();
IList <IHistoricDecisionInputInstance> inputs = historicDecisionInstance.Inputs;
Assert.That(inputs.Count, Is.EqualTo(1));
IHistoricDecisionInputInstance input = inputs[0];
Assert.That(input.TypeName, Is.EqualTo("bytes"));
Assert.That(input.Value, Is.EqualTo(null));
}
public virtual void testDeleteHistoricDecisionInstanceByInstanceId()
{
// given
startProcessInstanceAndEvaluateDecision();
IQueryable <IHistoricDecisionInstance> query = historyService.CreateHistoricDecisionInstanceQuery(c => c.DecisionDefinitionKey == DECISION_DEFINITION_KEY);
Assert.That(query.Count(), Is.EqualTo(1L));
IHistoricDecisionInstance historicDecisionInstance = query /*/*.IncludeInputs()*//*.IncludeOutputs()*/.First();
// when
historyService.DeleteHistoricDecisionInstanceByInstanceId(historicDecisionInstance.Id);
// then
Assert.That(query.Count(), Is.EqualTo(0L));
}
public virtual void testDeleteHistoricDecisionInstanceByInstanceIdWithDeleteHistoryPermissionOnDecisionDefinition()
{
// given
createGrantAuthorization(Resources.DecisionDefinition, DECISION_DEFINITION_KEY, userId, Permissions.DeleteHistory, Permissions.ReadHistory);
startProcessInstanceAndEvaluateDecision();
IQueryable <IHistoricDecisionInstance> query = historyService.CreateHistoricDecisionInstanceQuery();
////verifyQueryResults(query, 1);
IHistoricDecisionInstance historicDecisionInstance = query /*/*.IncludeInputs()*//*.IncludeOutputs()*/.First();
// when
historyService.DeleteHistoricDecisionInstanceByInstanceId(historicDecisionInstance.Id);
// then
////verifyQueryResults(query, 0);
}
public virtual void testDecisionInputInstanceProperties()
{
startProcessInstanceAndEvaluateDecision();
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery() /*/*.IncludeInputs()*/.First();
IList <IHistoricDecisionInputInstance> inputs = historicDecisionInstance.Inputs;
//Assert.That(inputs, Is.Not.Null);
Assert.That(inputs.Count, Is.EqualTo(1));
IHistoricDecisionInputInstance input = inputs[0];
Assert.That(input.DecisionInstanceId, Is.EqualTo(historicDecisionInstance.Id));
Assert.That(input.ClauseId, Is.EqualTo("in"));
Assert.That(input.ClauseName, Is.EqualTo("input"));
}
public virtual void testMultipleDecisionInputInstances()
{
IDictionary <string, object> variables = new Dictionary <string, object>();
variables["input1"] = "a";
variables["input2"] = 1;
runtimeService.StartProcessInstanceByKey("testProcess", variables);
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery() /*/*.IncludeInputs()*/.First();
IList <IHistoricDecisionInputInstance> inputs = historicDecisionInstance.Inputs;
Assert.That(inputs.Count, Is.EqualTo(2));
Assert.That(inputs[0].Value, Is.EqualTo((object)"a"));
Assert.That(inputs[1].Value, Is.EqualTo((object)1));
}
public virtual void failToDeleteHistoricDecisionInstanceByInstanceIdNoAuthenticatedTenants()
{
// given
testRule.DeployForTenant(TENANT_ONE, DMN);
evaluateDecisionTable(null);
IQueryable <IHistoricDecisionInstance> query = historyService.CreateHistoricDecisionInstanceQuery();
IHistoricDecisionInstance historicDecisionInstance = query /*/*.IncludeInputs()*/ //*/*.IncludeOutputs()*/
.First();
// when
identityService.SetAuthentication("user", null, null);
// then
//thrown.Expect(typeof(ProcessEngineException));
//thrown.ExpectMessage("Cannot Delete the historic decision instance");
historyService.DeleteHistoricDecisionInstanceByInstanceId(historicDecisionInstance.Id);
}
public virtual void deleteHistoricDecisionInstanceByInstanceIdWithAuthenticatedTenant()
{
// given
testRule.DeployForTenant(TENANT_ONE, DMN);
evaluateDecisionTable(null);
IQueryable <IHistoricDecisionInstance> query = historyService.CreateHistoricDecisionInstanceQuery();
IHistoricDecisionInstance historicDecisionInstance = query /*/*.IncludeInputs()*//*.IncludeOutputs()*/.First();
// when
identityService.SetAuthentication("user", null, new List <string>()
{
TENANT_ONE
});
historyService.DeleteHistoricDecisionInstanceByInstanceId(historicDecisionInstance.Id);
// then
identityService.ClearAuthentication();
Assert.That(query.Count(), Is.EqualTo(0L));
}
public virtual void testDeleteHistoricDecisionInstanceByInstanceIdWithoutAuthorization()
{
// given
createGrantAuthorization(Resources.DecisionDefinition, DECISION_DEFINITION_KEY, userId, Permissions.ReadHistory);
startProcessInstanceAndEvaluateDecision();
IQueryable <IHistoricDecisionInstance> query = historyService.CreateHistoricDecisionInstanceQuery();
IHistoricDecisionInstance historicDecisionInstance = query /*/*.IncludeInputs()*//*.IncludeOutputs()*/.First();
try
{
// when
historyService.DeleteHistoricDecisionInstanceByInstanceId(historicDecisionInstance.Id);
Assert.Fail("expect authorization exception");
}
catch (AuthorizationException e)
{
// then
Assert.That(e.Message, Is.EqualTo("The user with id 'test' does not have 'Permissions.DeleteHistory' permission on resource 'testDecision' of type 'DecisionDefinition'."));
}
}
public virtual void testDecisionOutputInstanceProperties()
{
startProcessInstanceAndEvaluateDecision();
IHistoricDecisionInstance historicDecisionInstance = historyService.CreateHistoricDecisionInstanceQuery() /*.IncludeOutputs()*/.First();
IList <IHistoricDecisionOutputInstance> outputs = historicDecisionInstance.Outputs;
Assert.That(outputs, Is.Not.Null);
Assert.That(outputs.Count, Is.EqualTo(1));
IHistoricDecisionOutputInstance output = outputs[0];
Assert.That(output.DecisionInstanceId, Is.EqualTo(historicDecisionInstance.Id));
Assert.That(output.ClauseId, Is.EqualTo("out"));
Assert.That(output.ClauseName, Is.EqualTo("output"));
Assert.That(output.RuleId, Is.EqualTo("rule"));
Assert.That(output.RuleOrder, Is.EqualTo(1));
Assert.That(output.VariableName, Is.EqualTo("result"));
}
public virtual void CheckDeleteHistoricDecisionInstance(IHistoricDecisionInstance decisionInstance)
{
AuthorizationManager.CheckAuthorization(Permissions.DeleteHistory, Resources.DecisionDefinition,
decisionInstance.DecisionDefinitionKey);
}
