public TestFlowElement AddConditionalLink(TestActivity sourceActivity, TestFlowConditional flowConditional, TestFlowElement trueFlowElement, TestActivity falseActivity)
{
AddConditionalLink(sourceActivity, flowConditional, (TestActivity)null, falseActivity);
flowConditional.TrueAction = trueFlowElement;
AddTestFlowLink(trueFlowElement);
return(flowConditional);
}
public TestFlowElement AddStartLink(TestActivity targetActivity)
{
TestFlowStep flowStep = new TestFlowStep(targetActivity);
SetStartNode(flowStep);
return(AddTestFlowLink(flowStep));
}
internal void GetCancellationTrace(TraceGroup traceGroup)
{
// This handler should only be invoked once (unless the CA is in a loop).
_currentIterationCount++;
if (_currentIterationCount > _hintIterationCount)
{
return;
}
// Attempt to process through the provided compensation activity to pick up the traces
if (_cancellation != null)
{
_cancellation.GetTrace(traceGroup);
}
// Additionally, if there are any hints, trace these as well...
// Scenario1: There are just hints but no compensation activity -- hints control all the work
// Scenario2: There is a compensation activity which does work but there is work remaining afterwards -- hints control the remaining work
foreach (Directive directive in this.CompensationHint)
{
TestActivity target = FindChildActivity(directive.Name);
TestCompensableActivity.ProcessDirective(target, directive, Directive.Compensate, traceGroup);
}
}
public TestFlowElement AddConditionalLink(TestActivity sourceActivity, TestFlowConditional flowConditional, TestActivity trueActivity, TestFlowElement falseFlowElement)
{
AddConditionalLink(sourceActivity, flowConditional, trueActivity, (TestActivity)null);
flowConditional.FalseAction = falseFlowElement;
AddTestFlowLink(falseFlowElement);
return(flowConditional);
}
public TestFlowElement AddLink(TestActivity sourceActivity, TestActivity targetActivity)
{
//Search in the elements collection if the flowstep exists and just needs to be
//connected to next element
TestFlowStep sourceStep = GetFlowStepContainingActionActivity(sourceActivity);
TestFlowStep targetStep = GetFlowStepContainingActionActivity(targetActivity);
if (sourceStep == null)
{
sourceStep = new TestFlowStep(sourceActivity);
SetStartNode(sourceStep);
AddTestFlowLink(sourceStep);
}
if (targetStep == null)
{
targetStep = new TestFlowStep(targetActivity);
}
sourceStep.NextElement = targetStep;
AddTestFlowLink(targetStep);
//We need to return the source step since the IsFaulting has to be set in case
//of fault
return(sourceStep);
}
public TestFlowElement AddSwitchLink <T>(TestActivity sourceActivity, Dictionary <T, TestActivity> cases, List <int> hintsExecutingActivityIndex, Expression <Func <ActivityContext, T> > lambdaExpression, params TestActivity[] defaultActivity)
{
TestFlowSwitch <T> flowSwitch = CreateSwitchElement <T>(sourceActivity, cases, hintsExecutingActivityIndex, defaultActivity, true) as TestFlowSwitch <T>;
flowSwitch.LambdaExpression = lambdaExpression;
return(AddTestFlowLink(flowSwitch));
}
public TestFlowElement AddSwitchLink <T>(TestActivity sourceActivity, Dictionary <T, TestActivity> cases, List <int> hintsExecutingActivityIndex, TestActivity expressionActivity, params TestActivity[] defaultActivity)
{
TestFlowSwitch <T> flowSwitch = CreateSwitchElement <T>(sourceActivity, cases, hintsExecutingActivityIndex, defaultActivity, true) as TestFlowSwitch <T>;
flowSwitch.ExpressionActivity = expressionActivity;
return(AddTestFlowLink(flowSwitch));
}
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);
}
public TestFlowElement AddConditionalLink(TestActivity sourceActivity, TestFlowConditional flowConditional, TestActivity trueActivity, TestActivity falseActivity)
{
if (sourceActivity != null)
{
TestFlowStep flowStep = GetFlowStepContainingActionActivity(sourceActivity);
if (flowStep == null)
{
flowStep = new TestFlowStep(sourceActivity)
{
NextElement = flowConditional
};
AddTestFlowLink(flowStep);
SetStartNode(flowStep);
}
else
{
flowStep.NextElement = flowConditional;
}
}
AddTestFlowLink(flowConditional);
if (trueActivity != null)
{
//For loops we need to check if the element already exists with the target activity
TestFlowStep trueStep = GetFlowStepContainingActionActivity(trueActivity);
if (trueStep != null)
{
flowConditional.TrueAction = trueStep;
}
else
{
flowConditional.TrueAction = new TestFlowStep(trueActivity);
}
AddTestFlowLink(flowConditional.TrueAction);
}
if (falseActivity != null)
{
//For loops we need to check if the element already exists with the target activity
TestFlowStep falseStep = GetFlowStepContainingActionActivity(falseActivity);
if (falseStep != null)
{
flowConditional.FalseAction = falseStep;
}
else
{
flowConditional.FalseAction = new TestFlowStep(falseActivity);
}
AddTestFlowLink(flowConditional.FalseAction);
}
if (_startElement == null)
{
SetStartNode(flowConditional);
AddTestFlowLink(flowConditional);
}
return(flowConditional);
}
public TestWhile(TestActivity condition)
{
if (!(condition.ProductActivity is Activity <bool> prodActivity))
{
throw new ArgumentNullException("ProductActivity");
}
this.body = condition;
this.ProductActivity = new While(prodActivity);
}
private void HandleError(TraceGroup traceGroup)
{
// Use the expected hints to get the compensation traces for each
foreach (Directive directive in this.CompensationHint)
{
TestActivity target = FindChildActivity(directive.Name);
TestCompensableActivity.ProcessDirective(target, directive, Directive.Compensate, traceGroup);
}
}
public TestFlowStep(TestActivity actionActivity)
: this()
{
if (actionActivity == null)
{
return;
}
_actionActivity = actionActivity;
_productFlowStep.Action = actionActivity.ProductActivity;
}
public TestDoWhile(TestActivity condition)
{
if (!(condition.ProductActivity is Activity <bool> prodActivity))
{
throw new Exception("DoWhile can only be constructed with Activity<bool> condition");
}
this.body = condition;
this.ProductActivity = new DoWhile(prodActivity);
}
public TestFlowElement AddSwitchLink <T>(TestActivity sourceActivity, Dictionary <T, TestFlowElement> cases, List <int> hintsExecutingActivityIndex, T expression, params TestActivity[] defaultActivity)
{
TestFlowSwitch <T> flowSwitch = CreateSwitchElement <T>(sourceActivity, null, hintsExecutingActivityIndex, defaultActivity, true) as TestFlowSwitch <T>;
flowSwitch.Expression = expression;
foreach (KeyValuePair <T, TestFlowElement> flowCase in cases)
{
flowSwitch.AddCase(flowCase.Key, flowCase.Value);
AddTestFlowLink(flowCase.Value);
}
return(AddTestFlowLink(flowSwitch));
}
public void AddNullCase(TestActivity activity)
{
TestFlowStep step = null;
FlowNode node = null;
if (activity != null)
{
step = new TestFlowStep(activity);
node = step.GetProductElement();
}
(this.productFlowSwitch as FlowSwitch <T>).Cases.Add(default(T), node);
this.caseElements.Add(step);
}
/// <summary>
/// Modify the FlowStep's Next to point to a different node
/// </summary>
/// <param name="flowStep">FlowStep to be updated</param>
/// <param name="newNextActivity">new activity to be executed next</param>
/// <param name="removeOldNextNode">wehther we want to remove the old Next node from Flowchart</param>
public void ChangeFlowStepNextNode(TestFlowStep flowStep, TestActivity newNextActivity, bool removeOldNextNode = true)
{
TestFlowStep newNextNode = null;
if (newNextActivity != null)
{
newNextNode = this.GetFlowStepContainingActionActivity(newNextActivity);
if (newNextNode == null)
{
newNextNode = new TestFlowStep(newNextActivity);
}
}
this.ChangeFlowStepNextNode(flowStep, newNextNode, removeOldNextNode);
}
public TestFlowElement AddLink(TestActivity sourceActivity, TestFlowElement flowElement)
{
TestFlowStep sourceStep = GetFlowStepContainingActionActivity(sourceActivity);
if (sourceStep == null)
{
sourceStep = new TestFlowStep(sourceActivity);
SetStartNode(sourceStep);
AddTestFlowLink(sourceStep);
}
sourceStep.NextElement = flowElement;
AddTestFlowLink(flowElement);
return(sourceStep);
}
internal static void ProcessDirective(TestActivity target, Directive directive, string defaultAction, TraceGroup traceGroup)
{
// A directive's action of "*" == "don't care" == "use default action"
string action = (directive.Action == Directive.Wildcard) ? defaultAction : directive.Action;
switch (action)
{
case Directive.Compensate:
target.GetCompensationTrace(traceGroup);
break;
case Directive.Confirm:
target.GetConfirmationTrace(traceGroup);
break;
default:
throw new Exception(string.Format("Invalid directive {0}", directive));
}
}
public TestIf(TestActivity condition, params HintThenOrElse[] thenOrElseHint)
{
if (!(condition.ProductActivity is Activity <bool> prodActivity))
{
throw new ArgumentNullException("ProductActivity");
}
this.ProductActivity = new If(prodActivity);
if (thenOrElseHint == null)
{
_thenOrElse = null;
}
else
{
_thenOrElse = new List <HintThenOrElse>(thenOrElseHint);
}
}
//
// 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);
}
}
private bool TryFindChildActivity(string targetDisplayName, out TestActivity found)
{
if (this.DisplayName == targetDisplayName)
{
found = this;
return(true);
}
foreach (TestActivity candidate in this.GetChildren())
{
if (candidate.TryFindChildActivity(targetDisplayName, out found))
{
return(true);
}
}
found = null;
return(false);
}
protected override void GetActivitySpecificTrace(TraceGroup traceGroup)
{
// Use the anchor as the starting point for the child search
if (_anchor != null && !_disableTrace)
{
// If the target was valid, use that one. Otherwise we need the hints to determine what to do
if (_target != null)
{
TestActivity target = _anchor.Activity.FindChildActivity(_target.Name);
target.GetConfirmationTrace(traceGroup);
}
else
{
foreach (Directive directive in _confirmationHint)
{
TestActivity target = _anchor.Activity.FindChildActivity(directive.Name);
target.GetConfirmationTrace(traceGroup);
}
}
}
}
internal Outcome GetTriggerTrace(TraceGroup traceGroup)
{
Outcome outcome = this.ExpectedOutcome;
for (int i = 0; i < HintTriggerIterationCount; i++)
{
TestActivity trigger = this.Trigger;
if (this.Trigger == null)
{
trigger = this.Source.NullTrigger;
}
outcome = trigger.GetTrace(traceGroup);
}
if (HintTriggerScheduled == true)
{
traceGroup.Steps.Add(new ActivityTrace(this.Trigger.DisplayName, ActivityInstanceState.Executing));
}
_triggerIterationNumber++;
return(outcome);
}
private TestFlowStep GetFlowStepContainingActionActivity(TestActivity activity)
{
if (_startElement == null || activity == null)
{
return(null);
}
List <TestFlowConditional> conditionals = new List <TestFlowConditional>();
List <TestFlowSwitchBase> switches = new List <TestFlowSwitchBase>();
TestFlowElement current = _startElement;
while (current != null)
{
if (current is TestFlowConditional && !conditionals.Contains((TestFlowConditional)current))
{
conditionals.Add((TestFlowConditional)current);
}
else if (current is TestFlowSwitchBase && !switches.Contains((TestFlowSwitchBase)current))
{
switches.Add((TestFlowSwitchBase)current);
}
else if (current is TestFlowStep && ((TestFlowStep)current).ActionActivity.DisplayName == activity.DisplayName)
{
//Need to reset the iteration numbers of
//flowconditionals and flowSwitched since they will be increment
//on GetNextElement()
ResetConditionalsIterationCounter(conditionals);
ResetSwitchesIterationCounter(switches);
return(current as TestFlowStep);
}
current = current.GetNextElement();
}
ResetConditionalsIterationCounter(conditionals);
ResetSwitchesIterationCounter(switches);
return(null);
}
public void SetTargetObjectActivity <T>(TestActivity activity)
{
this.ProductInvokeMethod.TargetObject = new InArgument <T>((Activity <T>)activity.ProductActivity);
}
public void SetResultActivity <T>(TestActivity activity)
{
this.ProductInvokeMethod.Result = new OutArgument <T>((Activity <Location <T> >)activity.ProductActivity);
}
/// <summary>
/// Modify FlowSwitch's Case to point to a different activity
/// </summary>
/// <param name="flowSwitch">FlowSwitch to be updated</param>
/// <param name="flowSwitchCase">case whose action to be updated</param>
/// <param name="newCaseActivity">new activity to be executed in the given FlowSwitch Case</param>
/// <param name="removeOldCaseNode">wehther we want to remove the old Case node from Flowchart</param>
public void ChangeFlowSwitchCaseAction <T>(TestFlowSwitch <T> flowSwitch, T caseExpression, int caseIndex, TestActivity oldCaseActivity, TestActivity newCaseActivity, bool removeOldCaseNode = true)
{
TestFlowStep oldCaseNode = null;
TestFlowStep newCaseNode = null;
// remove old Case node from Flowchart
if (removeOldCaseNode)
{
oldCaseNode = this.GetFlowStepContainingActionActivity(oldCaseActivity);
if (oldCaseNode == null)
{
throw new ArgumentException("Failed to find the node corresponding to the given oldCaseActivity.");
}
this.Elements.Remove(oldCaseNode);
}
// add new Case node to Flowchart
if (newCaseActivity != null)
{
newCaseNode = this.GetFlowStepContainingActionActivity(newCaseActivity);
if (newCaseNode == null)
{
newCaseNode = new TestFlowStep(newCaseActivity);
}
this.AddTestFlowLink(newCaseNode);
}
// set new Case action
flowSwitch.UpdateCase(caseExpression, caseIndex, newCaseNode);
}
/// <summary>
/// Modify the FlowSwitch's Expression activity and its corresponding hint.
/// </summary>
public void ChangeFlowSwitchExpression <T>(TestFlowSwitch <T> flowSwitch, TestActivity newExpressionActivity, List <int> newHint)
{
flowSwitch.ExpressionActivity = newExpressionActivity;
flowSwitch.SetHints(newHint);
}
private TestFlowSwitchBase CreateSwitchElement <T>(TestActivity sourceActivity, Dictionary <T, TestActivity> cases, List <int> hintsExecutingActivityIndex, TestActivity[] defaultActivity, bool genericSwitch = false)
{
TestFlowStep flowStep = null;
List <TestFlowStep> newAddedSteps = new List <TestFlowStep>();
TestFlowSwitchBase flowSwitch;
flowSwitch = new TestFlowSwitch <T>();
flowSwitch.SetHints(hintsExecutingActivityIndex);
if (sourceActivity != null)
{
flowStep = GetFlowStepContainingActionActivity(sourceActivity);
if (flowStep == null)
{
flowStep = new TestFlowStep(sourceActivity);
AddTestFlowLink(flowStep);
}
}
if (cases != null)
{
foreach (KeyValuePair <T, TestActivity> flowCase in cases)
{
TestFlowStep targetStep = GetFlowStepContainingActionActivity(flowCase.Value);
if (targetStep == null && flowCase.Value != null)
{
//Need this to find identical FlowSteps in the cases locally as they are not
//added yet to the linked list
if ((targetStep = FindMatchingCase(newAddedSteps, flowCase.Value.DisplayName)) == null)
{
targetStep = new TestFlowStep(flowCase.Value);
newAddedSteps.Add(targetStep);
}
AddTestFlowLink(targetStep);
}
(flowSwitch as TestFlowSwitch <T>).AddCase(flowCase.Key, targetStep);
}
}
if (defaultActivity != null && defaultActivity.Length != 0)
{
TestFlowStep defaultStep = GetFlowStepContainingActionActivity(defaultActivity[0]);
if (defaultStep == null)
{
if ((defaultStep = FindMatchingCase(newAddedSteps, defaultActivity[0].DisplayName)) == null)
{
defaultStep = new TestFlowStep(defaultActivity[0]);
}
}
(flowSwitch as TestFlowSwitch <T>).Default = defaultStep;
AddTestFlowLink(defaultStep);
}
if (flowStep != null)
{
flowStep.NextElement = flowSwitch;
}
else
{
SetStartNode(flowSwitch);
}
return(flowSwitch);
}
/// <summary>
/// Modify the FlowDecision's True or False path to point to a different node
/// </summary>
/// <param name="flowConditional">FlowDecision to be updated</param>
/// <param name="changeTrueAction">true if TrueAction to be changed, false if FalseAction to be changed</param>
/// <param name="newAction">new activity to be executed on the specified FlowDecision's path</param>
/// <param name="removeOldNode">wehther we want to remove the old node from Flowchart</param>
public void ChangeFlowDecisionAction(TestFlowConditional flowConditional, bool changeTrueAction, TestActivity newAction, bool removeOldNode = true)
{
// remove old node from Flowchart
if (removeOldNode)
{
if (changeTrueAction)
{
this.Elements.Remove(flowConditional.TrueAction);
}
else
{
this.Elements.Remove(flowConditional.FalseAction);
}
}
// add new node to Flowchart
TestFlowStep newNode = null;
if (newAction != null)
{
newNode = this.GetFlowStepContainingActionActivity(newAction);
if (newNode == null)
{
newNode = new TestFlowStep(newAction);
}
this.AddTestFlowLink(newNode);
}
// set new Action
if (changeTrueAction)
{
flowConditional.TrueAction = newNode;
}
else
{
flowConditional.FalseAction = newNode;
}
}
