public void TraceData(object data)
{
//tracking data is now directly pushed by the tracking participant to the test trace manager.
if (data is WorkflowInstanceTrace)
{
WorkflowInstanceTrace instanceTrace = (WorkflowInstanceTrace)data;
this.testTraceManager.AddTrace(instanceTrace.InstanceName, instanceTrace);
//Log.TraceInternal("[TestTraceListener] {0}", instanceTrace.ToString());
}
else if (data is WorkflowExceptionTrace)
{
WorkflowExceptionTrace exceptionTrace = (WorkflowExceptionTrace)data;
this.testTraceManager.AddTrace(exceptionTrace.InstanceName, exceptionTrace);
//Log.TraceInternal("[TestTraceListener] {0}", exceptionTrace.ToString());
}
else if (data is UserTrace)
{
UserTrace userTrace = (UserTrace)data;
this.testTraceManager.AddTrace(userTrace.InstanceId, userTrace);
//Log.TraceInternal("[TestTraceListener] {0}", userTrace.ToString());
}
else if (data is SynchronizeTrace)
{
SynchronizeTrace synchronizeTrace = (SynchronizeTrace)data;
this.testTraceManager.AddTrace(synchronizeTrace.userTrace.InstanceId, synchronizeTrace);
//Log.TraceInternal("[TestTraceListener] {0}", synchronizeTrace.ToString());
}
else if (data is WorkflowAbortedTrace)
{
WorkflowAbortedTrace synchronizeTrace = (WorkflowAbortedTrace)data;
this.testTraceManager.AddTrace(synchronizeTrace.InstanceId, synchronizeTrace);
//Log.TraceInternal("[TestTraceListener] {0}", synchronizeTrace.ToString());
}
}
protected override void Execute(CodeActivityContext context)
{
TestTraceManager.Instance.AddTrace(context.WorkflowInstanceId, new SynchronizeTrace(EnterExecute));
SynchronizeTrace.Trace(context.WorkflowInstanceId, EnterExecute);
if (this.TraceToWait.Get(context).Length != 0)
{
TestTraceManager.Instance.WaitForTrace(context.WorkflowInstanceId, new SynchronizeTrace(this.TraceToWait.Get(context)), 1);
}
Thread.CurrentThread.Join((int)this.DelayDuration.Get(context).TotalMilliseconds);
}
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 void TestOperationsResumeBookmarkCallback(int operationId)
{
var value = VariableHelper.Create <int>("value");
const string WaitMessage = "WaitActivity will wait for this trace";
var testSequence = new TestSequence()
{
Variables = { value },
Activities =
{
new TestWriteLine()
{
Message = "Workflow Started"
},
new TestWaitForTrace()
{
DisplayName = "WaitActivity",
TraceToWait = WaitMessage
},
new TestWaitReadLine <int>("Read", "Read")
{
BookmarkValue = value
},
new TestReadLine <int>("Read1", "Read1")
{
BookmarkValue = value
},
new TestWriteLine()
{
Message = "Workflow Completed"
}
}
};
var jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~");
var workflowRuntime = TestRuntime.CreateTestWorkflowRuntime(testSequence, null, jsonStore, PersistableIdleAction.Unload);
workflowRuntime.ExecuteWorkflow();
workflowRuntime.WaitForActivityStatusChange("WaitActivity", TestActivityInstanceState.Executing);
var asyncResult = workflowRuntime.BeginResumeBookMark("Read", 10, new AsyncCallback(ResumeBookmarkCallback), operationId);
//Continue the WaitActivity
TestTraceManager.Instance.AddTrace(workflowRuntime.CurrentWorkflowInstanceId, new SynchronizeTrace(WaitMessage));
SynchronizeTrace.Trace(workflowRuntime.CurrentWorkflowInstanceId, WaitMessage);
workflowRuntime.EndResumeBookMark(asyncResult);
workflowRuntime.WaitForTrace(new UserTrace("After ResumeBookmarkCallback"));
if (operationId == 2)
{
//Do nothing
}
else if (operationId == 3)
{
workflowRuntime.UnloadWorkflow();
workflowRuntime.LoadWorkflow();
workflowRuntime.ExecuteWorkflow();
workflowRuntime.ResumeBookMark("Read1", 99);
}
else if (operationId == 4)
{
workflowRuntime.LoadWorkflow();
workflowRuntime.ExecuteWorkflow();
workflowRuntime.ResumeBookMark("Read1", 99);
}
var expectedTrace = testSequence.GetExpectedTrace();
expectedTrace.AddIgnoreTypes(typeof(UserTrace));
workflowRuntime.WaitForCompletion(expectedTrace);
}
public static void TestPersistDuringResumeBookmark()
{
var isSync = true;
var value = VariableHelper.Create <int>("value");
var persist = VariableHelper.Create <string>("persist");
const string WaitMessage = "Continue the WaitActivity";
var testSequence = new TestSequence()
{
Variables = { value, persist },
Activities =
{
new TestWriteLine()
{
Message = "Workflow Started"
},
new TestWaitForTrace()
{
DisplayName = "WaitActivity",
TraceToWait = WaitMessage,
DelayDuration = TimeSpan.FromMilliseconds(10)
},
new TestWaitReadLine <int>("Read", "Read")
{
BookmarkValue = value,
WaitTime = TimeSpan.FromSeconds(1)
},
new TestReadLine <string>("PersistBookmark", "PersistBookmark")
{
BookmarkValue = persist
},
new TestWriteLine()
{
MessageExpression = ((env) => value.Get(env).ToString()),
HintMessage = "9999"
}
}
};
var jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~");
var workflowRuntime = TestRuntime.CreateTestWorkflowRuntime(testSequence, null, jsonStore, PersistableIdleAction.Unload);
workflowRuntime.ExecuteWorkflow();
workflowRuntime.WaitForActivityStatusChange("WaitActivity", TestActivityInstanceState.Executing);
TestTraceManager.Instance.AddTrace(workflowRuntime.CurrentWorkflowInstanceId, new SynchronizeTrace(WaitMessage));
SynchronizeTrace.Trace(workflowRuntime.CurrentWorkflowInstanceId, WaitMessage);
if (isSync)
{
workflowRuntime.ResumeBookMark("Read", 9999);
workflowRuntime.PersistWorkflow();
}
else
{
var asyncResultResume = workflowRuntime.BeginResumeBookMark("Read", 9999, null, null);
var asyncResultPersist = workflowRuntime.BeginPersistWorkflow(null, null);
workflowRuntime.EndResumeBookMark(asyncResultResume);
workflowRuntime.EndPersistWorkflow(asyncResultPersist);
}
workflowRuntime.WaitForActivityStatusChange("PersistBookmark", TestActivityInstanceState.Executing);
workflowRuntime.WaitForUnloaded(1);
workflowRuntime.LoadWorkflow();
workflowRuntime.ResumeBookMark("PersistBookmark", "Yes");
workflowRuntime.WaitForCompletion(false);
}
private void OnWorkflowInstanceAborted(WorkflowApplicationAbortedEventArgs e)
{
TestTraceManager.Instance.AddTrace(e.InstanceId, new SynchronizeTrace(WorkflowInstanceAbortTests.AbortedHandlerCalled));
SynchronizeTrace.Trace(e.InstanceId, WorkflowInstanceAbortTests.AbortedHandlerCalled);
}
/// <summary>
/// All operations should be blocked by throwing an InvalidOperationException.
/// </summary>
////[Fact]
////public void TestOperationsFromAbortedCallback()
////{
//// TestSequence sequence = new TestSequence()
//// {
//// Activities =
//// {
//// new TestWriteLine()
//// {
//// Message = "Write a line"
//// },
//// new TestReadLine<string>("Read", "Read")
//// {
//// }
//// }
//// };
////
//// TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(sequence);
//// runtime.OnWorkflowAborted += new EventHandler<TestWorkflowAbortedEventArgs>(OnWorkflowInstanceAborted_TestOperations);
//// runtime.PersistenceProviderFactoryType = null;
//// runtime.ExecuteWorkflow();
//// runtime.WaitForIdle();
//// runtime.AbortWorkflow(AbortReasonMessage);
////
//// runtime.WaitForTrace(new SynchronizeTrace(WorkflowInstanceHelper.TraceMessage_TriedAllOperations));
//// //Wait for the completion trace
////
//// runtime.WaitForAborted();
//// TestTraceManager.Instance.WaitForTrace(runtime.CurrentWorkflowInstanceId, new SynchronizeTrace(RemoteWorkflowRuntime.CompletedOrAbortedHandlerCalled), 1);
////}
private static void OnWorkflowInstanceAborted_ThrowException(object sender, TestWorkflowAbortedEventArgs e)
{
TestTraceManager.Instance.AddTrace(e.EventArgs.InstanceId, new SynchronizeTrace(TraceMessage_ThrowExceptionFromAborted));
SynchronizeTrace.Trace(e.EventArgs.InstanceId, TraceMessage_ThrowExceptionFromAborted);
throw new Exception("Throw an exception in OnAborted call back");
}
