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