public override ExpectedTrace GetExpectedTrace()
{
this.ResetForValidation();
OrderedTraces orderedTrace = new OrderedTraces();
Outcome outcome = _activity.GetTrace(orderedTrace);
ExpectedTrace baseTrace = new ExpectedTrace(orderedTrace);
baseTrace.AddIgnoreTypes(typeof(WorkflowExceptionTrace));
baseTrace.AddIgnoreTypes(typeof(WorkflowAbortedTrace));
baseTrace.AddIgnoreTypes(typeof(SynchronizeTrace));
baseTrace.AddIgnoreTypes(typeof(BookmarkResumptionTrace));
bool compensate = outcome.DefaultPropogationState != OutcomeState.Completed;
foreach (Directive directive in this.CompensationHint)
{
TestActivity target = _activity.FindChildActivity(directive.Name);
if (compensate)
{
target.GetCompensationTrace(baseTrace.Trace);
}
else
{
target.GetConfirmationTrace(baseTrace.Trace);
}
}
return(baseTrace);
}
private void AddIgnoreTypes(ExpectedTrace expected)
{
// always ignore WorkflowInstanceTraces
expected.AddIgnoreTypes(typeof(WorkflowExceptionTrace));
expected.AddIgnoreTypes(typeof(WorkflowAbortedTrace));
expected.AddIgnoreTypes(typeof(SynchronizeTrace));
expected.AddIgnoreTypes(typeof(BookmarkResumptionTrace));
}
public void WhileWithExceptionFromCondition()
{
// Test case description:
// Throw exception in while and in while condition
TestSequence outerSequence = new TestSequence("sequence1");
TestSequence innerSequence = new TestSequence("Seq");
TestAssign <int> increment = new TestAssign <int>("Increment Counter");
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 0);
TestWhile whileAct = new TestWhile("while act")
{
Body = innerSequence,
HintIterationCount = 10,
};
ExceptionThrowingActivitiy <bool> throwFromCondition = new ExceptionThrowingActivitiy <bool>();
((Microsoft.CoreWf.Statements.While)whileAct.ProductActivity).Condition = throwFromCondition;
increment.ToVariable = counter;
increment.ValueExpression = ((env) => (((int)counter.Get(env))) + 1);
innerSequence.Activities.Add(increment);
outerSequence.Variables.Add(counter);
outerSequence.Activities.Add(whileAct);
OrderedTraces trace = new OrderedTraces();
trace.Steps.Add(new ActivityTrace(outerSequence.DisplayName, ActivityInstanceState.Executing));
trace.Steps.Add(new ActivityTrace(whileAct.DisplayName, ActivityInstanceState.Executing));
OrderedTraces ordered = new OrderedTraces();
UnorderedTraces unordered = new UnorderedTraces();
unordered.Steps.Add(ordered);
unordered.Steps.Add(new ActivityTrace(throwFromCondition.DisplayName, ActivityInstanceState.Executing));
unordered.Steps.Add(new ActivityTrace(throwFromCondition.DisplayName, ActivityInstanceState.Faulted));
trace.Steps.Add(unordered);
ExpectedTrace expected = new ExpectedTrace(trace);
expected.AddIgnoreTypes(typeof(WorkflowAbortedTrace));
expected.AddIgnoreTypes(typeof(SynchronizeTrace));
Exception exc;
TestWorkflowRuntime tr = TestRuntime.CreateTestWorkflowRuntime(outerSequence);
tr.CreateWorkflow();
tr.ResumeWorkflow();
tr.WaitForAborted(out exc, expected);
Assert.True((exc.GetType() == typeof(DataMisalignedException)) && exc.Message == "I am Miss.Aligned!");
}
internal void ValidateTrackingAndTracing(ExpectedTrace expectedTrace)
{
expectedTrace.AddIgnoreTypes(false, typeof(WorkflowInstanceTrace));
//The expected trace may get modified in the validateTraces method. Hence make a copy to be userd for tracking validation.
ExpectedTrace copyOfExpectedTrace = new ExpectedTrace(expectedTrace);
ValidateTracking(copyOfExpectedTrace);
//Log.TraceInternal("[TestTracingWatcher]Validate Tracing...");
ValidateTraces(expectedTrace, GetActualTrace());
}
public void CheckWorkflowProperties()
{
TestActivity workflow = new TestWriteLine("Write1", "Write a line");
TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(workflow);
runtime.CreateWorkflow();
runtime.Extensions.Add(new CheckWorkflowPropertiesExtension(runtime.CurrentWorkflowInstanceId, workflow.ProductActivity));
runtime.ResumeWorkflow();
ExpectedTrace expectedTrace = workflow.GetExpectedTrace();
expectedTrace.AddIgnoreTypes(typeof(UserTrace));
runtime.WaitForCompletion(expectedTrace);
}
public void ThrowFromInterfaceMethods()
{
TestActivity workflow = new TestWriteLine("Write1", "Write a line");
TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(workflow);
runtime.PersistenceProviderFactoryType = null;
runtime.CreateWorkflow();
ThrowFromAdditionalExtensions throwFromAdditionalExtensions = new ThrowFromAdditionalExtensions();
CheckExceptionPropagated(throwFromAdditionalExtensions, "Throw from AdditionalExtensionsAdded", runtime);
ThrowFromSetInstance throwFromSetInstance = new ThrowFromSetInstance();
CheckExceptionPropagated(throwFromSetInstance, "Throw from SetInstance", runtime);
runtime.ResumeWorkflow();
ExpectedTrace expectedTrace = workflow.GetExpectedTrace();
expectedTrace.AddIgnoreTypes(typeof(UserTrace));
runtime.WaitForCompletion(expectedTrace);
}
public void VerifyAdditionalExtensionsAdded()
{
TestActivity workflow = new TestReadLine <int>("Read1", "Read1");
TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(workflow);
runtime.OnWorkflowUnloaded += WorkflowInstanceHelper.wfRuntime_OnUnload;
runtime.CreateWorkflow();
runtime.Extensions.Add(new AdditionalExtensionsAdded(new Collection <object>()
{
new OperationOrderTracePersistExtension(runtime.CurrentWorkflowInstanceId)
}));
runtime.ResumeWorkflow();
runtime.WaitForIdle();
runtime.ResumeBookMark("Read1", 1);
ExpectedTrace expectedTrace = workflow.GetExpectedTrace();
expectedTrace.AddIgnoreTypes(typeof(UserTrace));
runtime.WaitForCompletion(expectedTrace);
runtime.WaitForTrace(new UserTrace(WorkflowInstanceHelper.UnloadMessage));
runtime.WaitForTrace(new UserTrace(OperationOrderTracePersistExtension.TraceSave));
}
public static void TestOperationsResumeBookmarkCallback(int operationId)
{
Variable <int> value = VariableHelper.Create <int>("value");
const string WaitMessage = "WaitActivity will wait for this trace";
TestSequence 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"
}
}
};
JsonFileInstanceStore.FileInstanceStore jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~");
TestWorkflowRuntime workflowRuntime = TestRuntime.CreateTestWorkflowRuntime(testSequence, null, jsonStore, PersistableIdleAction.Unload);
workflowRuntime.ExecuteWorkflow();
workflowRuntime.WaitForActivityStatusChange("WaitActivity", TestActivityInstanceState.Executing);
TestWorkflowRuntimeAsyncResult 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);
}
ExpectedTrace expectedTrace = testSequence.GetExpectedTrace();
expectedTrace.AddIgnoreTypes(typeof(UserTrace));
workflowRuntime.WaitForCompletion(expectedTrace);
}
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");
}
}
}
public void SetDelegateArgument()
{
// for using delegate argument
TheStruct valueType = new TheStruct();
int indiceValue = 2;
DelegateInArgument <int> indice = new DelegateInArgument <int>();
Variable <TheStruct> var = VariableHelper.CreateInitialized <TheStruct>("var", valueType);
TestValueTypeIndexerReference <TheStruct, int> valueTypeIndexerReference = new TestValueTypeIndexerReference <TheStruct, int>()
{
OperandLocationVariable = var,
};
valueTypeIndexerReference.Indices.Add(new TestArgument <int>(Direction.In, null, (env) => indice.Get(env)));
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypeIndexerReference, Value = value
};
TestSequence seq = new TestSequence()
{
Activities =
{
testAssign,
new TestWriteLine {
MessageExpression = ((ctx) => var.Get(ctx)[indiceValue].ToString())
}
}
};
CoreWf.Statements.Sequence outerSeq = new CoreWf.Statements.Sequence()
{
Variables =
{
var
},
Activities =
{
new InvokeAction <int>()
{
Argument = indiceValue,
Action = new ActivityAction <int>()
{
Argument = indice,
Handler = seq.ProductActivity
}
}
}
};
TestCustomActivity testActivity = TestCustomActivity <CoreWf.Statements.Sequence> .CreateFromProduct(outerSeq);
UnorderedTraces traces = new UnorderedTraces()
{
Steps =
{
new UserTrace(value.ToString())
}
};
testActivity.ActivitySpecificTraces.Add(traces);
ExpectedTrace expectedTrace = testActivity.GetExpectedTrace();
expectedTrace.AddIgnoreTypes(typeof(ActivityTrace));
TestRuntime.RunAndValidateWorkflow(testActivity, expectedTrace);
}
public void ParallelForEachWithAChildThatOverridesCancelAndCompletionConditionIsTrue()
{
Variable <bool> cancelIt = new Variable <bool> {
Name = "cancelIt", Default = false
};
DelegateInArgument <bool> arg = new DelegateInArgument <bool>("arg");
TestParallelForEach <bool> pfeAct = new TestParallelForEach <bool>
{
DisplayName = "ParallelForEach1",
HintIterationCount = 2,
HintValues = new bool[] { true, false },
ValuesExpression = (e => new bool[] { true, false }),
CurrentVariable = arg,
CompletionConditionVariable = cancelIt,
Body = new TestIf(HintThenOrElse.Then, HintThenOrElse.Else)
{
DisplayName = "If1",
ConditionExpression = e => arg.Get(e),
ThenActivity = new TestBlockingActivityWithWriteLineInCancel("writeLineInCancel", OutcomeState.Completed)
{
ExpectedOutcome = new Outcome(OutcomeState.Completed, OutcomeState.Canceled),
},
ElseActivity = new TestSequence
{
DisplayName = "Sequence2",
Activities =
{
new TestDelay("d1", new TimeSpan(1)),
new TestAssign <bool> {
DisplayName = "Assign1",Value = true, ToVariable = cancelIt
}
}
}
},
};
TestSequence root = new TestSequence
{
DisplayName = "Sequence1",
Activities = { pfeAct },
Variables = { cancelIt },
};
OrderedTraces ordered = new OrderedTraces()
{
Steps =
{
new ActivityTrace("Sequence1", ActivityInstanceState.Executing),
new ActivityTrace("ParallelForEach1", ActivityInstanceState.Executing),
new UnorderedTraces
{
Steps =
{
new OrderedTraces()
{
Steps =
{
new ActivityTrace("If1", ActivityInstanceState.Executing),
new ActivityTrace("writeLineInCancel", ActivityInstanceState.Executing),
new ActivityTrace("w1", ActivityInstanceState.Executing),
new ActivityTrace("w1", ActivityInstanceState.Closed),
new ActivityTrace("writeLineInCancel", ActivityInstanceState.Closed),
new ActivityTrace("If1", ActivityInstanceState.Closed),
}
},
new OrderedTraces()
{
Steps =
{
new ActivityTrace("If1", ActivityInstanceState.Executing),
new ActivityTrace("Sequence2", ActivityInstanceState.Executing),
new ActivityTrace("d1", ActivityInstanceState.Executing),
new ActivityTrace("d1", ActivityInstanceState.Closed),
new ActivityTrace("Assign1", ActivityInstanceState.Executing),
new ActivityTrace("Assign1", ActivityInstanceState.Closed),
new ActivityTrace("Sequence2", ActivityInstanceState.Closed),
new ActivityTrace("If1", ActivityInstanceState.Closed),
new ActivityTrace("VariableValue<Boolean>", ActivityInstanceState.Executing),
new ActivityTrace("VariableValue<Boolean>", ActivityInstanceState.Closed),
}
}
}
},
new ActivityTrace("ParallelForEach1", ActivityInstanceState.Closed),
new ActivityTrace("Sequence1", ActivityInstanceState.Closed),
}
};
ExpectedTrace trace = new ExpectedTrace(ordered);
trace.AddIgnoreTypes(typeof(SynchronizeTrace));
trace.AddIgnoreTypes(typeof(BookmarkResumptionTrace));
TestRuntime.RunAndValidateWorkflow(root, trace);
}