public void CancelExecutingChildActivities() { TestFlowchart parent = new TestFlowchart("Parent"); TestBlockingActivity blocking = new TestBlockingActivity("BlockingActivity", "B1"); TestWriteLine writeLine1 = new TestWriteLine("w1", "w1"); TestWriteLine writeLine2 = new TestWriteLine("w2", "w2"); parent.AddLink(writeLine1, blocking); TestFlowElement element = parent.AddLink(blocking, writeLine2); element.IsCancelling = true; blocking.ExpectedOutcome = Outcome.Canceled; parent.ExpectedOutcome = Outcome.Canceled; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(parent)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange("BlockingActivity", TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); System.Threading.Thread.Sleep(2000); testWorkflowRuntime.WaitForCanceled(); } }
public void CancelElseDuringExecution() { TestIf testIf = new TestIf("MyIf", HintThenOrElse.Else) { Condition = false, ThenActivity = new TestWriteLine("Then Branch", "The message would not be displayed"), ElseActivity = new TestSequence("Else Branch") { Activities = { new TestCustomActivity <BlockingActivity>("BlockingActivity", null) { ExpectedOutcome = Outcome.Canceled }, new TestWriteLine("Test WriteLine", "The message would not be displayed"), }, }, }; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(testIf)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange("BlockingActivity", TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); testWorkflowRuntime.WaitForCanceled(); } }
public void DoWhileCancelled() { TestDoWhile doWhile = new TestDoWhile("Do while") { Condition = true, Body = new TestSequence("Do While Body") { Activities = { new TestBlockingActivity("BlockingActivity", "Bookmark") { ExpectedOutcome = Outcome.Canceled }, new TestWriteLine("Writeline") { Message = "Hello" } } }, HintIterationCount = 1, }; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(doWhile)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange("BlockingActivity", TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); // This test is not run on desktop and I don't think it would pass there if it did run. //testWorkflowRuntime.WaitForCompletion(); testWorkflowRuntime.WaitForCanceled(); } }
public void WhileCancelled() { Variable <int> count = new Variable <int> { Name = "Counter", Default = 0 }; TestBlockingActivity blocking = new TestBlockingActivity("Bookmark") { ExpectedOutcome = Outcome.Canceled }; TestWhile whileAct = new TestWhile { Variables = { count }, Body = blocking, ConditionExpression = (e => count.Get(e) < 5), HintIterationCount = 1, ExpectedOutcome = Outcome.Canceled }; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(whileAct)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange(blocking.DisplayName, TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); testWorkflowRuntime.WaitForCanceled(); } }
public void CancelParallelForEach() { TestParallelForEach <string> parallelForEach = new TestParallelForEach <string>() { HintValues = new List <string>() { "Hi", "There" }, ValuesExpression = (context => new List <string>() { "Hi", "There" }), Body = new TestBlockingActivityUnique("Blocking activity") { ExpectedOutcome = Outcome.Canceled } }; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(parallelForEach)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange("Blocking activity", TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); testWorkflowRuntime.WaitForCanceled(); } }
public void CancelFlowchartWhileEvaluatingFlowSwitchExpression() { TestFlowchart flowchart = new TestFlowchart(); TestWriteLine writeHello = new TestWriteLine("Hello", "Hello"); TestWriteLine writeStart = new TestWriteLine("Start", "Start"); TestExpressionEvaluatorWithBody <object> expressionActivity = new TestExpressionEvaluatorWithBody <object> { ExpressionResultExpression = context => "One", Body = new TestBlockingActivity("B1", "Blocking") { ExpectedOutcome = Outcome.Canceled }, WillBodyExecute = true }; Dictionary <object, TestActivity> cases = new Dictionary <object, TestActivity>(); cases.Add("One", writeHello); List <int> hints = new List <int>() { -1 }; flowchart.AddStartLink(writeStart); flowchart.AddSwitchLink(writeStart, cases, hints, expressionActivity); flowchart.ExpectedOutcome = Outcome.Canceled; expressionActivity.ExpectedOutcome = Outcome.Canceled; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(flowchart)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange("B1", TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); testWorkflowRuntime.WaitForCanceled(true); } }
public void CancelOnAction() { TestPick pick = new TestPick { DisplayName = "PickActivity", ExpectedOutcome = Outcome.Canceled, Branches = { new TestPickBranch { DisplayName = "Branch1", Trigger = new TestDelay() { Duration = new TimeSpan(0, 0, 3), }, Action = new TestBlockingActivity("Block1") { ExpectedOutcome = Outcome.Canceled, } }, new TestPickBranch { DisplayName = "Branch2", Trigger = new TestBlockingActivity("Block2") { ExpectedOutcome = Outcome.Canceled, }, Action = new TestWriteLine("Action2") { Message = "Action2", } } } }; using (TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(pick)) { runtime.ExecuteWorkflow(); runtime.WaitForActivityStatusChange("Block1", TestActivityInstanceState.Executing); System.Threading.Thread.Sleep(1000); runtime.CancelWorkflow(); ExpectedTrace trace = pick.GetExpectedTrace(); runtime.WaitForCanceled(trace); } }
public void CancelInTryBlock() { TestBlockingActivity blocking = new TestBlockingActivity("Bookmark") { ExpectedOutcome = Outcome.Canceled }; TestTryCatch tryCatch = new TestTryCatch("TryCatchTest") { Try = new TestSequence("TrySeq") { Activities = { blocking, new TestThrow <ArgumentException>("TryException") { ExpectedOutcome = Outcome.None }, }, }, Catches = { new TestCatch <ArgumentException>() { Body = new TestWriteLine("Caught", "Caught"), ExpectedOutcome = Outcome.None } } }; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(tryCatch)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange(blocking.DisplayName, TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); testWorkflowRuntime.WaitForCanceled(); } }
public void CancelFlowchart() { TestFlowchart flowchart = new TestFlowchart(); TestBlockingActivity blocking1 = new TestBlockingActivity("B1", "B1"); blocking1.ExpectedOutcome = Outcome.Canceled; flowchart.AddStartLink(blocking1); flowchart.ExpectedOutcome = Outcome.Canceled; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(flowchart)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange(blocking1.DisplayName, TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); testWorkflowRuntime.WaitForCanceled(true); } }
public void WhileCancelledDuringConditionExecution() { TestWhile whileActivity = new TestWhile("While") { HintIterationCount = 0, ExpectedOutcome = Outcome.Canceled, ConditionActivity = new TestBlockingActivity <bool>("Blocking") { ExpectedOutcome = Outcome.Canceled, }, Body = new TestWriteLine("WriteLine", "WriteLine - Body"), }; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(whileActivity)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange("Blocking", TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); testWorkflowRuntime.WaitForCanceled(); } }
public void CancelFlowchartWhileEvaluatingFlowConditionalCondition() { TestFlowchart flowchart = new TestFlowchart(); TestBlockingActivity blocking = new TestBlockingActivity("Block", "Blocked") { ExpectedOutcome = Outcome.Canceled }; TestExpressionEvaluatorWithBody <bool> expression = new TestExpressionEvaluatorWithBody <bool>(true) { Body = blocking, WillBodyExecute = true }; TestFlowConditional conditional = new TestFlowConditional { ConditionValueExpression = expression }; flowchart.AddConditionalLink(new TestWriteLine("Start", "Flowchart started"), conditional, new TestWriteLine("True", "True Action"), new TestWriteLine("False", "False Action")); expression.ExpectedOutcome = Outcome.Canceled; flowchart.ExpectedOutcome = Outcome.Canceled; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(flowchart)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange(blocking.DisplayName, TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); testWorkflowRuntime.WaitForCanceled(true); } }
public void CancelSequenceInTheMiddle() { TestSequence seq = new TestSequence { Activities = { new TestWriteLine("W1", "I should be printed"), new TestBlockingActivity("BookMark1") { ExpectedOutcome = Outcome.Canceled }, new TestWriteLine("W2", "I should not be printed") { ExpectedOutcome = Outcome.Canceled }, new TestWriteLine("W3", "I should not be printed") { ExpectedOutcome = Outcome.Canceled }, } }; JsonFileInstanceStore.FileInstanceStore jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~"); using (TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(seq, null, jsonStore, PersistableIdleAction.None)) { runtime.ExecuteWorkflow(); runtime.WaitForIdle(); runtime.PersistWorkflow(); runtime.CancelWorkflow(); runtime.WaitForCanceled(); } }
private static void TestInstanceOperationFromResumeBookmarkCallback(int operationsId, bool isSync) { string shouldNotExecuteMsg = "Should not see this message"; Variable <int> value = VariableHelper.Create <int>("value"); TestWriteLine writeLineNotRun = new TestWriteLine("NotExecuted", shouldNotExecuteMsg) { }; TestSequence testSequence = new TestSequence() { Variables = { value }, Activities = { new TestWriteLine() { Message = "Workflow Started" }, new TestWaitReadLine <int>("Read", "Read") { BookmarkValue = value }, } }; //Get Expected Trace without TestWriteLine() if (operationsId == 2) { testSequence.ExpectedOutcome = Outcome.Canceled; } ExpectedTrace expectedTrace = testSequence.GetExpectedTrace(); if (operationsId == 4) { expectedTrace.Trace.Steps.RemoveAt(expectedTrace.Trace.Steps.Count - 1); } else if (operationsId == 3) { expectedTrace.Trace.Steps.RemoveAt(expectedTrace.Trace.Steps.Count - 1); expectedTrace.Trace.Steps.Add(new ActivityTrace(testSequence.DisplayName, ActivityInstanceState.Faulted)); } //Now Add TestWriteLine to workflow testSequence.Activities.Add(writeLineNotRun); TestWorkflowRuntimeAsyncResult asyncResultResume = null; TestWorkflowRuntimeAsyncResult asyncResultOperation = null; string message = ""; //Execute Workflow JsonFileInstanceStore.FileInstanceStore jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~"); // using PersistableIdleAction.None here because the idle unload was racing with the resume bookmark after the wait for the BeforeWait trace. TestWorkflowRuntime workflowRuntime = TestRuntime.CreateTestWorkflowRuntime(testSequence, null, jsonStore, PersistableIdleAction.None); workflowRuntime.ExecuteWorkflow(); workflowRuntime.WaitForActivityStatusChange("Read", TestActivityInstanceState.Executing); if (isSync) { //Log.Info("Resuming Bookmark"); if (isSync) { workflowRuntime.ResumeBookMark("Read", 9999); } else { asyncResultResume = workflowRuntime.BeginResumeBookMark("Read", 9999, null, null); } workflowRuntime.WaitForTrace(new UserTrace(WaitReadLine <int> .BeforeWait)); switch (operationsId) { case 2: //Cancel Workflow during OnResumeBookmark is executing //Log.Info("CancelWorkflow during OnResumeBookmark executing"); if (isSync) { workflowRuntime.CancelWorkflow(); } else { asyncResultOperation = workflowRuntime.BeginCancelWorkflow(null, null); workflowRuntime.EndResumeBookMark(asyncResultResume); workflowRuntime.EndCancelWorkflow(asyncResultOperation); } //Trace.WriteLine should not execute break; case 3: //Terminate Workflow during OnResumeBookmark is executing //Log.Info("TerminateWorkflow during OnResumeBookmark executing"); if (isSync) { workflowRuntime.TerminateWorkflow("Terminate Exception"); } else { asyncResultOperation = workflowRuntime.BeginTerminateWorkflow("Terminate Exception", null, null); workflowRuntime.EndResumeBookMark(asyncResultResume); workflowRuntime.EndTerminateWorkflow(asyncResultOperation); } //Trace.WriteLine should not execute. break; case 4: //Unload Workflow during OnResumeBookmark is executing //This should wait till ResumeMark finishes the work //Log.Info("UnloadWorkflow during OnResumeBookmark executing"); if (isSync) { workflowRuntime.UnloadWorkflow(); } else { asyncResultOperation = workflowRuntime.BeginUnloadWorkflow(null, null); workflowRuntime.EndResumeBookMark(asyncResultResume); workflowRuntime.EndUnloadWorkflow(asyncResultOperation); } //message = String.Format(ExceptionStrings.WorkflowInstanceUnloaded, workflowRuntime.CurrentWorkflowInstanceId); ExceptionHelpers.CheckForException(typeof(WorkflowApplicationUnloadedException), message, new ExceptionHelpers.MethodDelegate( delegate { workflowRuntime.ResumeWorkflow(); })); break; } } if (isSync) { switch (operationsId) { case 2: { workflowRuntime.WaitForCanceled(expectedTrace); break; } case 3: { Exception terminationException; workflowRuntime.WaitForTerminated(1, out terminationException, expectedTrace); break; } case 4: { // We tried to do a ResumeWorkflow without loading it after an unload, so we expected // to get a WorkflowApplicationUnloadedException. The workflow will never complete, // so don't wait for it to complete. break; } } } else { //Give some time for Workflow to execute Thread.CurrentThread.Join((int)TimeSpan.FromSeconds(1).TotalMilliseconds); } if (isSync) { expectedTrace.AddIgnoreTypes(typeof(WorkflowInstanceTrace)); workflowRuntime.ActualTrace.Validate(expectedTrace); } else { //The traces are vary in the async situations, thus we can not do a full trace valdation //validate the writeline after read activity is not executed is sufficient if (workflowRuntime.ActualTrace.ToString().Contains(shouldNotExecuteMsg)) { throw new Exception("The NotExecuted WriteLine activity has been executed, the expectation is it does not"); } } }
private // Abort with Cancel failing in desktop too. so disabling test //[InlineData(true)] void AbortParallel(bool isTestCancel) { const int noBranches = 10; Variable <int> value = VariableHelper.Create <int>("value"); TestParallel parallel = new TestParallel() { Variables = { value }, ExpectedOutcome = Outcome.Faulted }; for (int i = 0; i < noBranches; i++) { string branchName = "Branch" + i.ToString(); TestSequence branchSequence = new TestSequence("Seq" + branchName) { Activities = { new TestWriteLine() { Message = branchName + " Started" }, new TestReadLine <int>(branchName, branchName) { BookmarkValue = value, ExpectedOutcome = Outcome.Faulted }, new TestWriteLine() { Message = branchName + " Completed", ExpectedOutcome = Outcome.Faulted }, }, ExpectedOutcome = Outcome.Faulted }; if (isTestCancel) { if (i == 0) { branchSequence.Activities[1].ExpectedOutcome = Outcome.Canceled; } } parallel.Branches.Add(branchSequence); } TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(parallel); runtime.ExecuteWorkflow(); runtime.WaitForIdle(); //Cancel Workflow if (isTestCancel) { //Log.Info("Cancelling Workflow"); runtime.CancelWorkflow(); runtime.WaitForCanceled(); } //Abort Workflow runtime.AbortWorkflow("Aborting for Test"); ExpectedTrace expectedTrace = parallel.GetExpectedTrace(); //Only verify User trace since activity traces will not be available once abort is called expectedTrace.AddVerifyTypes(typeof(UserTrace)); Exception excepion; runtime.WaitForAborted(out excepion, expectedTrace); }
public void CancelChildOfParallelForEach() { DelegateInArgument <string> _currentVariable = new DelegateInArgument <string>() { Name = "_currentVariable" }; TestParallelForEach <string> parallelForEach = new TestParallelForEach <string>("Parallel For Each Activity") { HintValues = new List <string>() { "Hi", "There" }, ValuesExpression = (context => new List <string>() { "Hi", "There" }), CurrentVariable = _currentVariable, Body = new TestSequence("Body of parallel for each") { Activities = { new TestWriteLine("Writeline in parallel for each") { MessageExpression = (env) => (string)_currentVariable.Get(env), HintMessageList = { "There", "Hi" } }, new TestIf("Test If", HintThenOrElse.Else, HintThenOrElse.Then) { ConditionExpression = (env) => (bool)(_currentVariable.Get(env).Equals("Hi")), ThenActivity = new TestBlockingActivityUnique("BlockingActivity", "Bookmark") { ExpectedOutcome = Outcome.Canceled }, ElseActivity = new TestWriteLine("Writeline in Else") { MessageExpression = (env) => (string)_currentVariable.Get(env), HintMessage = "There" } }, new TestWriteLine() { Message = "Hello" } } }, HintIterationCount = 2 }; using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(parallelForEach)) { testWorkflowRuntime.ExecuteWorkflow(); testWorkflowRuntime.WaitForActivityStatusChange("BlockingActivity", TestActivityInstanceState.Executing); testWorkflowRuntime.CancelWorkflow(); testWorkflowRuntime.WaitForCanceled(); } }