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 RunTestWithWorkflowRuntime(TestActivity activity)
{
using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(activity))
{
testWorkflowRuntime.OnWorkflowCompleted += new EventHandler <TestWorkflowCompletedEventArgs>(workflowInstance_Completed);
testWorkflowRuntime.ExecuteWorkflow();
WorkflowTrackingWatcher watcher = testWorkflowRuntime.GetWatcher();
OrderedTraces orderedExpectedTrace = new OrderedTraces
{
Steps =
{
new WorkflowInstanceTrace(testWorkflowRuntime.CurrentWorkflowInstanceId, WorkflowInstanceState.Started),
new WorkflowInstanceTrace(testWorkflowRuntime.CurrentWorkflowInstanceId, WorkflowInstanceState.Terminated),
new WorkflowInstanceTrace(testWorkflowRuntime.CurrentWorkflowInstanceId, WorkflowInstanceState.Deleted)
{
Optional = true
}
}
};
ExpectedTrace expectedWorkflowInstacneTrace = new ExpectedTrace(orderedExpectedTrace);
Exception exp = new Exception();
testWorkflowRuntime.WaitForTerminated(1, out exp, watcher.ExpectedTraces, expectedWorkflowInstacneTrace);
}
}
protected override void GetActivitySpecificTrace(TraceGroup traceGroup)
{
if (_textExpressionType == ExpressionType.Activity)
{
OrderedTraces orderedTraceGroup = new OrderedTraces();
CurrentOutcome = _testExpressionActivity.GetTrace(orderedTraceGroup);
traceGroup.Steps.Add(orderedTraceGroup);
}
}
public virtual ExpectedTrace GetExpectedTrace()
{
this.ResetForValidation();
OrderedTraces orderedTrace = new OrderedTraces();
GetTrace(orderedTrace);
ExpectedTrace expected = new ExpectedTrace(orderedTrace);
AddIgnoreTypes(expected);
return(expected);
}
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!");
}
//
// Example hint list describing 3 branches and the order of processing for CA's on each Branch
// { Branch, CA2, CA1, Branch, CA3, Branch, CA6, CA5, CA4 }
//
private void ProcessCompensationHints(IList <Directive> hints, string defaultAction, TraceGroup traceGroup)
{
// A splited flowchart Confirmation/Compensation are collections of unordered branch traces
// (similar to Parallel)
UnorderedTraces unordered = new UnorderedTraces();
OrderedTraces ordered = null;
foreach (Directive directive in hints)
{
// If we encounter a Branch directive that means we need to start a new OrderedTraces group
if (directive.Name == "Branch")
{
if (ordered != null) // Already had one, so add it to our collection before we create a new one
{
if (ordered.Steps.Count > 0) // There's a chance we didn't produce any output
{
unordered.Steps.Add(ordered);
}
}
ordered = new OrderedTraces();
}
else
{
TestActivity target = FindChildActivity(directive.Name);
TestCompensableActivity.ProcessDirective(target, directive, defaultAction, traceGroup);
}
}
// Was there one left over? (From the last branch directive)
if (ordered != null)
{
if (ordered.Steps.Count > 0) // There's a chance we didn't produce any output
{
unordered.Steps.Add(ordered);
}
}
if (unordered.Steps.Count > 0)
{
traceGroup.Steps.Add(unordered);
}
}
protected override void GetActivitySpecificTrace(Test.Common.TestObjects.Utilities.Validation.TraceGroup traceGroup)
{
UnorderedTraces parallelTraceGroup = null;
Outcome outcome = Outcome.Completed;
parallelTraceGroup = new UnorderedTraces();
foreach (TestPickBranch branch in this.Branches)
{
// Each Branch is Ordered with respect to itself (like normal)
OrderedTraces branchTraceGroup = new OrderedTraces();
Outcome bOutcome = branch.GetTriggerTrace(branchTraceGroup);
if (bOutcome.GetType() != typeof(Outcome))
{
outcome = bOutcome;
}
parallelTraceGroup.Steps.Add(branchTraceGroup);
}
traceGroup.Steps.Add(parallelTraceGroup);
parallelTraceGroup = new UnorderedTraces();
foreach (TestPickBranch branch in this.Branches)
{
// Each Branch is Ordered with respect to itself (like normal)
OrderedTraces branchTraceGroup = new OrderedTraces();
Outcome bOutcome = branch.GetActionTrace(branchTraceGroup);
if (bOutcome != null && bOutcome.GetType() != typeof(Outcome))
{
outcome = bOutcome;
}
parallelTraceGroup.Steps.Add(branchTraceGroup);
}
traceGroup.Steps.Add(parallelTraceGroup);
this.CurrentOutcome = outcome;
}
public static OrderedTraces GetTraces(Outcome expectedOutcome, String name)
{
OrderedTraces ot = new OrderedTraces()
{
Optional = true
};
ot.Steps.Add(new ActivityTrace(name, ActivityInstanceState.Executing)
{
Optional = true
});
switch (expectedOutcome.DefaultPropogationState)
{
case OutcomeState.Completed:
ot.Steps.Add(new ActivityTrace(name, ActivityInstanceState.Closed)
{
Optional = true
});
break;
case OutcomeState.Canceled:
ot.Steps.Add(new ActivityTrace(name, ActivityInstanceState.Canceled)
{
Optional = true
});
break;
case OutcomeState.Faulted:
ot.Steps.Add(new ActivityTrace(name, ActivityInstanceState.Faulted)
{
Optional = true
});
break;
default:
break;
}
return(ot);
}
private void WaitForTerminationHelper(TestWorkflowRuntime testWorkflowRuntime)
{
WorkflowTrackingWatcher watcher = testWorkflowRuntime.GetWatcher();
OrderedTraces orderedExpectedTrace = new OrderedTraces
{
Steps =
{
new WorkflowInstanceTrace(testWorkflowRuntime.CurrentWorkflowInstanceId, WorkflowInstanceState.Started),
new WorkflowInstanceTrace(testWorkflowRuntime.CurrentWorkflowInstanceId, WorkflowInstanceState.Terminated),
new WorkflowInstanceTrace(testWorkflowRuntime.CurrentWorkflowInstanceId, WorkflowInstanceState.Deleted)
{
Optional = true
}
}
};
ExpectedTrace expectedWorkflowInstacneTrace = new ExpectedTrace(orderedExpectedTrace);
Exception exp = new Exception();
testWorkflowRuntime.WaitForTerminated(1, out exp, watcher.ExpectedTraces, expectedWorkflowInstacneTrace);
}
protected override void GetActivitySpecificTrace(TraceGroup traceGroup)
{
UnorderedTraces parallelTraceGroup = new UnorderedTraces();
if (this.HintIterationCount < 0 && _values == null)
{
return;
}
if (this.HintIterationCount < 0 && _values != null)
{
this.HintIterationCount = _values.Count <T>();
}
if (_valuesActivity != null)
{
Outcome conditionOutcome = _valuesActivity.GetTrace(traceGroup);
if (conditionOutcome.DefaultPropogationState != OutcomeState.Completed)
{
// propogate the unknown outcome upwards
this.CurrentOutcome = conditionOutcome;
}
}
if (this.Body != null)
{
Outcome outc;
for (int i = 1; i < _values.Count <T>() + 1; i++)
{
OrderedTraces orderedTraceGroup = new OrderedTraces();
if (HintIterationCount < i)
{
TestDummyTraceActivity tdt = new TestDummyTraceActivity(Body.DisplayName)
{
ExpectedOutcome = Outcome.Canceled
};
tdt.GetTrace(orderedTraceGroup);
}
else
{
outc = this.Body.GetTrace(orderedTraceGroup);
if (this.ProductParallelForEach.CompletionCondition != null && outc.DefaultPropogationState != OutcomeState.Canceled)
{
TestDummyTraceActivity condition = new TestDummyTraceActivity(this.ProductParallelForEach.CompletionCondition, ConditionOutcome);
CurrentOutcome = condition.GetTrace(orderedTraceGroup);
}
if (outc.DefaultPropogationState != OutcomeState.Completed)
{
CurrentOutcome = outc;
}
}
parallelTraceGroup.Steps.Add(orderedTraceGroup);
}
traceGroup.Steps.Add(parallelTraceGroup);
}
}
protected override void GetActivitySpecificTrace(TraceGroup traceGroup)
{
// Parallel is a collection of unordered branches
UnorderedTraces parallelTraceGroup = new UnorderedTraces();
bool oneCompleted = false;
int index = 0;
foreach (TestActivity branch in _branches)
{
// Each Branch is Ordered with respect to itself (like normal)
OrderedTraces branchTraceGroup = new OrderedTraces();
if (_numberOfBranchesExecution == index)
{
// so if we have gone past the hint
if (branch.ExpectedOutcome.DefaultPropogationState == OutcomeState.Completed)
{
TestDummyTraceActivity tdt = new TestDummyTraceActivity(branch.DisplayName)
{
ExpectedOutcome = Outcome.Canceled
};
tdt.GetTrace(branchTraceGroup);
}
}
else
{
index++;
Outcome bOutcome = branch.GetTrace(branchTraceGroup);
if (bOutcome.DefaultPropogationState == OutcomeState.Completed)
{
oneCompleted = true;
if (this.ProductParallel.CompletionCondition != null)
{
if (_expressionActivity != null)
{
CurrentOutcome = _expressionActivity.GetTrace(branchTraceGroup);
}
else
{
TestDummyTraceActivity tdt = new TestDummyTraceActivity(this.ProductParallel.CompletionCondition, Outcome.Completed);
CurrentOutcome = tdt.GetTrace(branchTraceGroup);
}
}
}
else if (CurrentOutcome.IsOverrideable)
{
CurrentOutcome = bOutcome;
}
}
parallelTraceGroup.Steps.Add(branchTraceGroup);
}
// If there's at least one good branch and the CompletionCondition is true, we probably succeeded
if (oneCompleted && _completionCondition)
{
this.CurrentOutcome = Outcome.Completed;
}
traceGroup.Steps.Add(parallelTraceGroup);
}
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);
}
protected override void GetActivitySpecificTrace(TraceGroup traceGroup)
{
// To support PartialTrust, StateMachineEventManagerFactory activity is used in Variable<StateMachineEventManager>.Default
// The code below generates the expected trace for StateMachineEventManagerFactory activity
new TestDummyTraceActivity("StateMachineEventManagerFactory").GetTrace(traceGroup);
Stack <TestStateMachineState> stack = new Stack <TestStateMachineState>();
// get trace for initial state
TestTransition fakeInitialTransition = new TestTransition("fakeinitial")
{
To = this.InitialState
};
Outcome outcome = this.ExpectedOutcome;
TraceGroup ordered = new OrderedTraces();
traceGroup.Steps.Add(ordered);
TestStateMachineState currentState = null;
TestTransition t = fakeInitialTransition;
while (t != null && t.To != null && t.To.IsFinal != true)
{
TestTransition nextTransition = null;
currentState = t.To;
OrderedTraces stateTrace = new OrderedTraces();
ordered.Steps.Add(stateTrace);
// keep HintTransition in nextTransition, because TestStateMachineState.GetTrace increases TestStateMachineState.iterationNumber
nextTransition = currentState.HintTransition;
outcome = currentState.GetTrace(stateTrace, t);
if (CurrentOutcome.IsOverrideable)
{
CurrentOutcome = outcome.Propogate();
}
if (CurrentOutcome.DefaultPropogationState != OutcomeState.Completed)
{
break;
}
t = nextTransition;
}
if (t == null || t.To == null)
{
throw new InvalidOperationException("Invalid HintTransition: null");
}
else if (CurrentOutcome.DefaultPropogationState == OutcomeState.Completed)
{
if (t.To.IsFinal == true)
{
outcome = t.To.GetTrace(traceGroup, null);
if (CurrentOutcome.IsOverrideable)
{
CurrentOutcome = outcome.Propogate();
}
}
else
{
throw new InvalidOperationException(string.Format("Invalid HintTransition: {0}", t.To.DisplayName));
}
}
// faulting and cancellation will be handled by TestActivity
}
