public virtual void FAILING_testResume()
{
// given
createCaseInstance();
CaseExecution firstHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_1");
string firstHumanTaskId = firstHumanTask.Id;
assertTrue(firstHumanTask.Enabled);
CaseExecution milestone = queryCaseExecutionByActivityId("PI_Milestone_1");
string milestoneId = milestone.Id;
assertTrue(milestone.Available);
suspend(milestoneId);
// (1) when
manualStart(firstHumanTaskId);
complete(firstHumanTaskId);
// (1) then
firstHumanTask = queryCaseExecutionById(firstHumanTaskId);
assertNull(firstHumanTask);
milestone = queryCaseExecutionById(milestoneId);
assertTrue(((CaseExecutionEntity)milestone).Suspended);
// (2) when
resume(milestoneId);
// (2)
milestone = queryCaseExecutionById(milestoneId);
assertNull(milestone);
}
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.Available);
CaseExecution thirdHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_3");
string thirdHumanTaskId = thirdHumanTask.Id;
assertTrue(thirdHumanTask.Available);
// when
caseService.withCaseExecution(firstHumanTaskId).setVariable("value", 80).complete();
// then
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertTrue(secondHumanTask.Available);
thirdHumanTask = queryCaseExecutionById(thirdHumanTaskId);
assertTrue(thirdHumanTask.Active);
}
public virtual void testSequenceWithIfPartSatisfied()
{
// 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.Available);
// when
caseService.withCaseExecution(firstHumanTaskId).setVariable("value", 100).complete();
// then
firstHumanTask = queryCaseExecutionById(firstHumanTaskId);
assertNull(firstHumanTask);
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertTrue(secondHumanTask.Active);
}
public virtual void testSequenceOccurMilestone()
{
// given
string caseInstanceId = createCaseInstance().Id;
CaseExecution firstHumanTask = queryCaseExecutionByActivityId("PI_HumanTask_1");
string firstHumanTaskId = firstHumanTask.Id;
assertTrue(firstHumanTask.Active);
CaseExecution milestone = queryCaseExecutionByActivityId("PI_Milestone_1");
string milestoneId = milestone.Id;
assertTrue(milestone.Available);
// (1) then
milestone = queryCaseExecutionById(milestoneId);
assertTrue(milestone.Available);
assertNull(caseService.getVariable(caseInstanceId, "occur"));
// (2) when
complete(firstHumanTaskId);
// (2) then
milestone = queryCaseExecutionById(milestoneId);
assertNull(milestone);
object occurVariable = caseService.getVariable(caseInstanceId, "occur");
assertNotNull(occurVariable);
assertTrue((bool?)occurVariable);
}
public virtual void testSequenceAutoStartTask()
{
// 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.Available);
// (1) then
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertTrue(secondHumanTask.Available);
assertNull(caseService.getVariable(caseInstanceId, "enable"));
assertNull(caseService.getVariable(caseInstanceId, "start"));
// (2) when
complete(firstHumanTaskId);
// (2) then
secondHumanTask = queryCaseExecutionById(secondHumanTaskId);
assertTrue(secondHumanTask.Active);
assertNull(caseService.getVariable(caseInstanceId, "enable"));
object startVariable = caseService.getVariable(caseInstanceId, "start");
assertNotNull(startVariable);
assertTrue((bool?)startVariable);
}
/// <summary>
/// CAM-3226
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testSentryShouldNotBeEvaluatedAfterStageComplete()
public virtual void testSentryShouldNotBeEvaluatedAfterStageComplete()
{
// given
string caseInstanceId = createCaseInstance().Id;
// when
CaseExecution stageExecution = caseService.createCaseExecutionQuery().activityId("PI_Stage_1").singleResult();
assertNotNull(stageExecution);
// .. there is a local stage variable
caseService.setVariableLocal(stageExecution.Id, "value", 99);
// .. and the stage is activated (such that the tasks are instantiated)
caseService.manuallyStartCaseExecution(stageExecution.Id);
CaseExecution task1Execution = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").singleResult();
assertNotNull(task1Execution);
// then
// .. completing the stage should be successful; evaluating Sentry_1 should not fail
caseService.completeCaseExecution(task1Execution.Id);
stageExecution = caseService.createCaseExecutionQuery().activityId("PI_Stage_1").singleResult();
assertNull(stageExecution);
// .. and the case plan model should have completed
CaseExecution casePlanModelExecution = caseService.createCaseExecutionQuery().caseExecutionId(caseInstanceId).singleResult();
assertNotNull(casePlanModelExecution);
assertFalse(casePlanModelExecution.Active);
caseService.closeCaseInstance(caseInstanceId);
}
public MyConvention()
{
Classes.NameEndsWith("Weeb");
Methods.Where(m => m.Name.EndsWith("Frob"));
Parameters(FromInputAttributes);
CaseExecution.Skip(@case => @case.Method.HasOrInherits <SkipAttribute>());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testCreateEventListenerByClass()
public virtual void testCreateEventListenerByClass()
{
caseService.withCaseDefinitionByKey("case").create();
CaseExecution taskExecution = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").singleResult();
assertNotNull(taskExecution);
// when i create a variable on the human task
caseService.withCaseExecution(taskExecution.Id).setVariableLocal("aTaskVariable", "aTaskValue").execute();
// then the listener is invoked
assertEquals(1, LogVariableListener.Invocations.Count);
DelegateVariableInstanceSpec.fromCaseExecution(taskExecution).@event([email protected]_Fields.CREATE).name("aTaskVariable").value("aTaskValue").matches(LogVariableListener.Invocations[0]);
LogVariableListener.reset();
// when i update the variable on the human task
caseService.withCaseExecution(taskExecution.Id).setVariable("aTaskVariable", "aNewTaskValue").execute();
// then the listener is not invoked
assertTrue(LogVariableListener.Invocations.Count == 0);
// when i remove the variable from the human task
caseService.withCaseExecution(taskExecution.Id).removeVariable("aTaskVariable").execute();
// then the listener is not invoked
assertTrue(LogVariableListener.Invocations.Count == 0);
}
public virtual void testReenableAnDisabledStage()
{
// given:
// a deployed case definition
string caseDefinitionId = repositoryService.createCaseDefinitionQuery().singleResult().Id;
// an active case instance
caseService.withCaseDefinition(caseDefinitionId).create();
CaseExecutionQuery caseExecutionQuery = caseService.createCaseExecutionQuery();
string caseExecutionId = caseExecutionQuery.activityId("PI_Stage_1").singleResult().Id;
// the human task is disabled
caseService.withCaseExecution(caseExecutionId).disable();
// when
caseService.withCaseExecution(caseExecutionId).reenable();
// then
CaseExecution caseExecution = caseExecutionQuery.singleResult();
// the human task is disabled
assertFalse(caseExecution.Disabled);
assertFalse(caseExecution.Active);
assertTrue(caseExecution.Enabled);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testInvokeBuiltinListenersOnly()
public virtual void testInvokeBuiltinListenersOnly()
{
// disable custom variable listener invocation
processEngineConfiguration.InvokeCustomVariableListeners = false;
// add a builtin variable listener the hard way
CaseDefinition caseDefinition = repositoryService.createCaseDefinitionQuery().singleResult();
processEngineConfiguration.DeploymentCache.getCaseDefinitionById(caseDefinition.Id).findActivity("PI_HumanTask_1").addBuiltInVariableListener([email protected]_Fields.CREATE, new LogVariableListener());
caseService.withCaseDefinitionByKey("case").create();
CaseExecution taskExecution = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").singleResult();
assertNotNull(taskExecution);
// when i set a variable
caseService.withCaseExecution(taskExecution.Id).setVariableLocal("testVariable", "value1").execute();
// then the builtin listener is invoked
assertEquals(1, LogVariableListener.Invocations.Count);
// but the custom listener is not invoked
assertEquals(0, LogExecutionContextListener.CaseExecutionContexts.Count);
LogVariableListener.reset();
LogExecutionContextListener.reset();
// restore configuration
processEngineConfiguration.InvokeCustomVariableListeners = true;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testListenerInvocationFinishesBeforeSubsequentInvocations()
public virtual void testListenerInvocationFinishesBeforeSubsequentInvocations()
{
caseService.withCaseDefinitionByKey("case").create();
CaseExecution taskExecution = caseService.createCaseExecutionQuery().activityId("PI_HumanTask_1").singleResult();
assertNotNull(taskExecution);
// when i set a variable and the listener itself sets another variable
caseService.withCaseExecution(taskExecution.Id).setVariableLocal("variable", "value1").execute();
// then all listeners for the first variable update are invoked first
// and then the listeners for the second update are invoked
IList <DelegateCaseVariableInstance> invocations = LogAndUpdateVariableListener.Invocations;
assertEquals(6, invocations.Count);
// the first invocations should regard the first value
DelegateVariableInstanceSpec.fromCaseExecution(taskExecution).@event([email protected]_Fields.CREATE).name("variable").value("value1").matches(LogAndUpdateVariableListener.Invocations[0]);
DelegateVariableInstanceSpec.fromCaseExecution(taskExecution).@event([email protected]_Fields.CREATE).name("variable").value("value1").matches(LogAndUpdateVariableListener.Invocations[1]);
// the second invocations should regard the updated value
// there are four invocations since both listeners have set "value2" and both were again executed, i.e. 2*2 = 4
for (int i = 2; i < 6; i++)
{
DelegateVariableInstanceSpec.fromCaseExecution(taskExecution).@event([email protected]_Fields.UPDATE).name("variable").value("value2").matches(LogAndUpdateVariableListener.Invocations[i]);
}
LogAndUpdateVariableListener.reset();
}
public virtual void testSequenceEnableStage()
{
// 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.Available);
// (1) then
stage = queryCaseExecutionById(stageId);
assertTrue(stage.Available);
assertNull(caseService.getVariable(caseInstanceId, "enable"));
// (2) when
complete(firstHumanTaskId);
// (2) then
stage = queryCaseExecutionById(stageId);
assertTrue(stage.Enabled);
object enableVariable = caseService.getVariable(caseInstanceId, "enable");
assertNotNull(enableVariable);
assertTrue((bool?)enableVariable);
}
public virtual void testManualStartWithLocalVariables()
{
// given
string superCaseInstanceId = createCaseInstance(DEFINITION_KEY).Id;
string caseTaskId = queryCaseExecutionByActivityId(CASE_TASK_KEY).Id;
CaseInstance subCaseInstance = queryCaseInstanceByKey(DEFINITION_KEY_2);
assertNull(subCaseInstance);
// variables
IDictionary <string, object> variables = new Dictionary <string, object>();
variables["aVariableName"] = "abc";
variables["anotherVariableName"] = 999;
// when
// activate child case execution
caseService.withCaseExecution(caseTaskId).setVariablesLocal(variables).manualStart();
// then
subCaseInstance = queryCaseInstanceByKey(DEFINITION_KEY_2);
assertNotNull(subCaseInstance);
assertTrue(subCaseInstance.Active);
CaseExecution caseTask = queryCaseExecutionByActivityId(CASE_TASK_KEY);
assertTrue(caseTask.Active);
// the case instance has two variables:
// - aVariableName
// - anotherVariableName
IList <VariableInstance> result = runtimeService.createVariableInstanceQuery().list();
assertFalse(result.Count == 0);
assertEquals(2, result.Count);
foreach (VariableInstance variable in result)
{
assertEquals(caseTaskId, variable.CaseExecutionId);
assertEquals(superCaseInstanceId, variable.CaseInstanceId);
if (variable.Name.Equals("aVariableName"))
{
assertEquals("aVariableName", variable.Name);
assertEquals("abc", variable.Value);
}
else if (variable.Name.Equals("anotherVariableName"))
{
assertEquals("anotherVariableName", variable.Name);
assertEquals(999, variable.Value);
}
else
{
fail("Unexpected variable: " + variable.Name);
}
}
}
private void CommitBeforeTestCase(CaseExecution caseexecution, object instance, Action innerbehavior)
{
var session = _container.GetInstance <ISession>();
session.Flush();
session.Clear();
innerbehavior();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testCaseFileItemOnPart()
public virtual void testCaseFileItemOnPart()
{
createCaseInstance().Id;
CaseExecution humanTask = queryCaseExecutionByActivityId("PI_HumanTask_1");
// sentry has been ignored
assertTrue(humanTask.Active);
}
/// <summary>
/// Initializes a new instance of the <see cref="LightInjectConvention"/> class.
/// </summary>
public LightInjectConvention()
{
FixtureExecution.Wrap(WrapFixtureExecution);
CaseExecution.Wrap(WrapCaseExecution);
ClassExecution.Wrap(WrapClassExecution);
ClassExecution.UsingFactory(CreateTestClassInstance);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Deployment public void testIfPartOnCaseInstanceCreateWithSentry()
public virtual void testIfPartOnCaseInstanceCreateWithSentry()
{
// when
createCaseInstanceByKey("case", Variables.putValue("myVar", 101));
// then
CaseExecution caseExecution = queryCaseExecutionByActivityId("PI_HumanTask_1");
assertTrue(caseExecution.Active);
}
public void Execute(CaseExecution caseExecution, object instance)
{
try
{
outer(caseExecution, instance, () => inner.Execute(caseExecution, instance));
}
catch (Exception exception)
{
caseExecution.Fail(exception);
}
}
public void ShouldLogExceptionWhenMethodCannotBeInvoked()
{
var @case = Case("CannotInvoke");
var caseExecution = new CaseExecution(@case);
@case.Execute(this, caseExecution);
invoked.ShouldBeFalse();
ExpectException(caseExecution, "TargetParameterCountException", "Parameter count mismatch.");
}
public void ShouldInvokeMethodsWithParameters()
{
var @case = Case("Parameterized", 123, true, 'a', "s1", "s2", null, this);
var caseExecution = new CaseExecution(@case);
@case.Execute(this, caseExecution);
invoked.ShouldBeTrue();
caseExecution.Exceptions.Count.ShouldEqual(0);
}
public void ShouldInvokeGenericMethodsWithParameters()
{
var @case = Case("Generic", 123, true, "a", "b");
var caseExecution = new CaseExecution(@case);
@case.Execute(this, caseExecution);
invoked.ShouldBeTrue();
caseExecution.Exceptions.Count.ShouldEqual(0);
}
public void ShouldLogOriginalExceptionWhenMethodThrows()
{
var @case = Case("Throws");
var caseExecution = new CaseExecution(@case);
@case.Execute(this, caseExecution);
invoked.ShouldBeTrue();
ExpectException(caseExecution, "FailureException", "'Throws' failed!");
}
public void ShouldInvokeAsyncMethods()
{
var @case = Case("Await");
var caseExecution = new CaseExecution(@case);
@case.Execute(this, caseExecution);
invoked.ShouldBeTrue();
caseExecution.Exceptions.Count.ShouldEqual(0);
}
public void ShouldLogOriginalExceptionWhenAsyncMethodThrowsBeforeAwaitingOnAnyTask()
{
var @case = Case("ThrowBeforeAwait");
var caseExecution = new CaseExecution(@case);
@case.Execute(this, caseExecution);
invoked.ShouldBeTrue();
ExpectException(caseExecution, "FailureException", "'ThrowBeforeAwait' failed!");
}
public void ShouldLogOriginalExceptionWhenAsyncMethodThrowsWithinTheAwaitedTask()
{
var @case = Case("AwaitOnTaskThatThrows");
var caseExecution = new CaseExecution(@case);
@case.Execute(this, caseExecution);
invoked.ShouldBeTrue();
ExpectException(caseExecution, "DivideByZeroException", "Attempted to divide by zero.");
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void manuallyStartCaseExecutionWithAuthenticatedTenant()
public virtual void manuallyStartCaseExecutionWithAuthenticatedTenant()
{
identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE));
caseService.manuallyStartCaseExecution(caseExecutionId);
identityService.clearAuthentication();
CaseExecution caseExecution = CaseExecution;
assertThat(caseExecution.Active, @is(true));
}
public virtual void testTerminateNonFluent()
{
// given
createCaseInstance(DEFINITION_KEY);
CaseExecution caseTaskExecution = queryCaseExecutionByActivityId(CASE_TASK_KEY);
// when
caseService.terminateCaseExecution(caseTaskExecution.Id);
caseTaskExecution = queryCaseExecutionByActivityId(CASE_TASK_KEY);
assertNull(caseTaskExecution);
}
private void createCaseExecutionMock()
{
IList <CaseExecution> caseExecutions = new List <CaseExecution>();
CaseExecution mockCaseExecution = MockProvider.createMockCaseExecution();
caseExecutions.Add(mockCaseExecution);
CaseExecutionQuery mockCaseExecutionQuery = mock(typeof(CaseExecutionQuery));
when(mockCaseExecutionQuery.list()).thenReturn(caseExecutions);
when(mockCaseService.createCaseExecutionQuery()).thenReturn(mockCaseExecutionQuery);
}
public virtual void testManualStartWithLocalVariable()
{
// given
string caseInstanceId = createCaseInstance(DEFINITION_KEY).Id;
string processTaskId = queryCaseExecutionByActivityId(PROCESS_TASK_KEY).Id;
ProcessInstance processInstance = queryProcessInstance();
assertNull(processInstance);
// when
caseService.withCaseExecution(processTaskId).setVariableLocal("aVariableName", "abc").setVariableLocal("anotherVariableName", 999).manualStart();
// then
processInstance = queryProcessInstance();
assertNotNull(processInstance);
assertEquals(caseInstanceId, processInstance.CaseInstanceId);
CaseExecution processTask = queryCaseExecutionByActivityId(PROCESS_TASK_KEY);
assertTrue(processTask.Active);
// the case instance has two variables:
// - aVariableName
// - anotherVariableName
IList <VariableInstance> result = runtimeService.createVariableInstanceQuery().list();
assertFalse(result.Count == 0);
assertEquals(2, result.Count);
foreach (VariableInstance variable in result)
{
assertEquals(processTaskId, variable.CaseExecutionId);
assertEquals(caseInstanceId, variable.CaseInstanceId);
if (variable.Name.Equals("aVariableName"))
{
assertEquals("aVariableName", variable.Name);
assertEquals("abc", variable.Value);
}
else if (variable.Name.Equals("anotherVariableName"))
{
assertEquals("anotherVariableName", variable.Name);
assertEquals(999, variable.Value);
}
else
{
fail("Unexpected variable: " + variable.Name);
}
}
}
public virtual void testTerminate()
{
// given
createCaseInstance(DEFINITION_KEY);
CaseExecution processTask = queryCaseExecutionByActivityId(PROCESS_TASK_KEY);
assertTrue(processTask.Active);
// when
caseService.withCaseExecution(processTask.Id).terminate();
processTask = queryCaseExecutionByActivityId(PROCESS_TASK_KEY);
assertNull(processTask);
}
public void ShouldAlwaysFailWithoutInvokingTheUnderlyingMethod()
{
var @case = UncallableParameterizedCase("Parameterized");
var caseExecution = new CaseExecution(@case);
@case.Execute(this, caseExecution);
invoked.ShouldBeFalse();
var exception = caseExecution.Exceptions.Single();
exception.GetType().Name.ShouldEqual("ArgumentException");
exception.Message.ShouldEqual("This parameterized test could not be executed, because no input values were available.");
}
public void Execute(Type testClass, Convention convention, CaseExecution[] caseExecutions)
{
try
{
var instance = construct(testClass);
var fixture = new Fixture(testClass, instance, convention.CaseExecution.Behavior, caseExecutions);
convention.InstanceExecution.Behavior.Execute(fixture);
Dispose(instance);
}
catch (Exception exception)
{
foreach (var caseExecution in caseExecutions)
caseExecution.Fail(exception);
}
}
public void Execute(Type testClass, Convention convention, CaseExecution[] caseExecutions)
{
try
{
outer(testClass, convention, caseExecutions, () => inner.Execute(testClass, convention, caseExecutions));
}
catch (Exception exception)
{
foreach (var caseExecution in caseExecutions)
caseExecution.Fail(exception);
}
}
public void Execute(CaseExecution caseExecution, object instance)
{
try
{
outer(caseExecution, instance, () => inner.Execute(caseExecution, instance));
}
catch (Exception exception)
{
caseExecution.Fail(exception);
}
}
public void Execute(CaseExecution caseExecution, object instance)
{
caseExecution.Case.Execute(instance, caseExecution);
}
protected static void CaseTearDown(CaseExecution caseExecution, object instance)
{
caseExecution.Case.Class.ShouldEqual(typeof(SampleTestClass));
instance.ShouldBeType<SampleTestClass>();
WhereAmI();
}
public CaseExecutionTests()
{
@case = new Case(typeof(SampleTestClass).GetInstanceMethod("Test"));
execution = new CaseExecution(@case);
}
