public static void ModifyAndValidateException(TestActivity testActivity, Type exceptionType, string errorString) { string originalXaml = XamlTestDriver.Serialize(testActivity.ProductActivity); string modifiedXaml = testActivity.ModifyXamlDelegate(originalXaml); ExceptionHelpers.CheckForException(exceptionType, errorString, () => Deserialize(modifiedXaml)); }
private void CheckExceptionPropagated(ThrowFromInterfaceMethodsBase throwExceptionExtension, string exceptionMessage, TestWorkflowRuntime runtime) { throwExceptionExtension.ExceptionMessage = exceptionMessage; throwExceptionExtension.IsThrow = true; runtime.Extensions.Add(throwExceptionExtension); ExceptionHelpers.CheckForException(typeof(Exception), throwExceptionExtension.ExceptionMessage, delegate { runtime.ResumeWorkflow(); }); throwExceptionExtension.IsThrow = false; }
public static void ValidateInstantiationException(TestActivity testActivity, Type exceptionType, string errorString) { Dictionary <string, string> exception = new Dictionary <string, string>(); exception.Add("Message", errorString); ExceptionHelpers.CheckForException( exceptionType, exception, delegate { WorkflowApplication instance = new WorkflowApplication(testActivity.ProductActivity); instance.Extensions.Add(TestRuntime.TraceListenerExtension); instance.Run(); }, true); }
private void GetBookMarksOnAbortedWorkflow(bool isDefaultTimeout) { const string traceToWaitMsg = "Continue WaitForTrace1"; Sequence sequence = new Sequence() { Activities = { new WaitForTrace() { DisplayName = "WaitForTrace1", TraceToWait = new InArgument <string>(traceToWaitMsg) }, new ReadLine <string>(bookMarkName_InvalidOperationsOnAbortedWorkflow) { } } }; WorkflowApplication instance = new WorkflowApplication(sequence) { Aborted = OnWorkflowInstanceAborted }; instance.Run(); TestTraceManager.Instance.WaitForTrace(instance.Id, new SynchronizeTrace(WaitForTrace.EnterExecute), 1); instance.Abort(); //Continue WaitForTrace. The instance should get aborted after WaitForTrace1 activity is done TestTraceManager.Instance.AddTrace(instance.Id, new SynchronizeTrace(traceToWaitMsg)); SynchronizeTrace.Trace(instance.Id, traceToWaitMsg); TestTraceManager.Instance.WaitForTrace(instance.Id, new SynchronizeTrace(WorkflowInstanceAbortTests.AbortedHandlerCalled), 1); string message = String.Format(ExceptionStrings.WorkflowApplicationAborted, instance.Id); ExceptionHelpers.CheckForException(typeof(WorkflowApplicationAbortedException), message, delegate { if (isDefaultTimeout) { instance.GetBookmarks(); } else { instance.GetBookmarks(TimeSpan.FromMilliseconds(1)); } }); }
public static Activity <Location <TResult> > ConvertReference <TResult>(Expression <Func <ActivityContext, TResult> > expression, Exception expectedException) { Activity <Location <TResult> > result = null; if (expectedException != null) { ExceptionHelpers.CheckForException( expectedException.GetType(), expectedException.Message, () => { result = ExpressionServices.ConvertReference <TResult>(expression); }, true); } else { result = ExpressionServices.ConvertReference <TResult>(expression); } return(result); }
private static readonly string s_path = string.Empty; //DirectoryAssistance.GetTestBinsDirectory("TempFile.txt"); public static void ValidateExpressionXaml <T>(TestExpression te) { Activity expectedActivity = null, actualActivity = null; Expression <Func <ActivityContext, T> > lambdaExpression = null; lambdaExpression = (Expression <Func <ActivityContext, T> >)te.CreateLambdaExpresson <T>(); //Log.TraceInternal("Expression: {0}", lambdaExpression.ToString()); expectedActivity = te.CreateExpectedActivity() as Activity; if (te.ExpectedConversionException != null) { ExceptionHelpers.CheckForException( te.ExpectedConversionException.GetType(), te.ExpectedConversionException.Message, () => { actualActivity = ExpressionServices.Convert(lambdaExpression); }, true); } else { actualActivity = ExpressionServices.Convert(lambdaExpression); ValidateActivity(expectedActivity, actualActivity); } }
private static void TestInstanceOperationFromResumeBookmarkCallback(int operationsId, bool isSync) { var shouldNotExecuteMsg = "Should not see this message"; var value = VariableHelper.Create <int>("value"); var writeLineNotRun = new TestWriteLine("NotExecuted", shouldNotExecuteMsg) { }; var 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; } var 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; var message = ""; //Execute Workflow var 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. var 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: { workflowRuntime.WaitForTerminated(1, out var 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"); } } }