public void should_advance_workflow()
{
//arrange
var definition = new WorkflowDefinition();
var pointer1 = new ExecutionPointer()
{
Active = true, StepId = 0, Status = PointerStatus.Running
};
var pointer2 = new ExecutionPointer();
var outcome = new StepOutcome()
{
NextStep = 1
};
var step = A.Fake <WorkflowStep>();
var workflowResult = new WorkflowExecutorResult();
var instance = GivenWorkflow(pointer1);
var result = ExecutionResult.Next();
A.CallTo(() => step.Outcomes).Returns(new List <StepOutcome>()
{
outcome
});
A.CallTo(() => PointerFactory.BuildNextPointer(definition, pointer1, outcome)).Returns(pointer2);
//act
Subject.ProcessExecutionResult(instance, definition, pointer1, step, result, workflowResult);
//assert
pointer1.Active.Should().BeFalse();
pointer1.Status.Should().Be(PointerStatus.Complete);
pointer1.EndTime.Should().NotBeNull();
A.CallTo(() => PointerFactory.BuildNextPointer(definition, pointer1, outcome)).MustHaveHappened();
instance.ExecutionPointers.Should().Contain(pointer2);
}
public IStepOutcomeBuilder <TData> When(object outcomeValue)
{
StepOutcome result = new StepOutcome();
result.Value = outcomeValue;
Step.Outcomes.Add(result);
var outcomeBuilder = new StepOutcomeBuilder <TData>(_workflowBuilder, result);
return(outcomeBuilder);
}
public IStepOutcomeBuilder <TData> When(object outcomeValue, string label = null)
{
StepOutcome result = new StepOutcome();
result.Value = x => outcomeValue;
result.Label = label;
Step.Outcomes.Add(result);
var outcomeBuilder = new StepOutcomeBuilder <TData>(WorkflowBuilder, result);
return(outcomeBuilder);
}
public void should_select_correct_outcomes()
{
//arrange
var definition = new WorkflowDefinition();
var pointer1 = new ExecutionPointer()
{
Id = "1", Active = true, StepId = 0, Status = PointerStatus.Running
};
var pointer2 = new ExecutionPointer()
{
Id = "2"
};
var pointer3 = new ExecutionPointer()
{
Id = "3"
};
Expression <Func <object, object> > expr1 = data => 10;
Expression <Func <object, object> > expr2 = data => 20;
var outcome1 = new StepOutcome()
{
NextStep = 1, Value = expr1
};
var outcome2 = new StepOutcome()
{
NextStep = 2, Value = expr2
};
var step = A.Fake <WorkflowStep>();
var workflowResult = new WorkflowExecutorResult();
var instance = GivenWorkflow(pointer1);
var result = ExecutionResult.Outcome(20);
A.CallTo(() => step.Outcomes).Returns(new List <StepOutcome>()
{
outcome1, outcome2
});
A.CallTo(() => PointerFactory.BuildNextPointer(definition, pointer1, outcome1)).Returns(pointer2);
A.CallTo(() => PointerFactory.BuildNextPointer(definition, pointer1, outcome2)).Returns(pointer3);
//act
Subject.ProcessExecutionResult(instance, definition, pointer1, step, result, workflowResult);
//assert
pointer1.Active.Should().BeFalse();
pointer1.Status.Should().Be(PointerStatus.Complete);
pointer1.EndTime.Should().NotBeNull();
A.CallTo(() => PointerFactory.BuildNextPointer(definition, pointer1, outcome1)).MustNotHaveHappened();
A.CallTo(() => PointerFactory.BuildNextPointer(definition, pointer1, outcome2)).MustHaveHappened();
instance.ExecutionPointers.Should().NotContain(pointer2);
instance.ExecutionPointers.Should().Contain(pointer3);
}
public IStepOutcomeBuilder <TData> When(object outcomeValue, string label = null)
{
Expression <Func <object, object> > expr = x => outcomeValue;
StepOutcome result = new StepOutcome
{
Value = expr,
Label = label
};
Step.Outcomes.Add(result);
var outcomeBuilder = new StepOutcomeBuilder <TData>(WorkflowBuilder, result);
return(outcomeBuilder);
}
internal BuildStepDomainEntity Stop(StepOutcome outcome)
{
if (Status != BuildStepStatus.Running)
{
throw new Exception($"Step was not expecting to be stopped: it was not running.");
}
switch (outcome)
{
case StepOutcome.Fail:
Status = BuildStepStatus.Error;
break;
case StepOutcome.Success:
case StepOutcome.Unknown:
Status = BuildStepStatus.Done;
break;
}
return(this);
}
private StepOutcome[] ConvertOutDataDefault(IOrchestrationComponent component)
{
List <StepOutcome> outcomes = new List <StepOutcome>();
if (typeof(AbstractMultiPathProcessComponent).IsAssignableFrom(component.GetType()))
{
string[] paths = ((AbstractMultiPathProcessComponent)component).GetConnectionPaths();
foreach (string path in paths)
{
LogicBase.Core.Data.DataDefinition[] dataParts = null;
if (component is IMultiPathDataAdded)
{
dataParts = ((IMultiPathDataAdded)component).GetAddedData(path);
}
StepOutcome outcomeToAdd = new StepOutcome()
{
PathName = path
};
List <LogicBaseProjectConversionUtility.ProjectConversionService.DataDefinition> outcomeDefs
= new List <LogicBaseProjectConversionUtility.ProjectConversionService.DataDefinition>();
if (dataParts != null)
{
foreach (LogicBase.Core.Data.DataDefinition oldDef in dataParts)
{
outcomeDefs.Add(new LogicBaseProjectConversionUtility.ProjectConversionService.DataDefinition()
{
FullTypeName = oldDef.DataType.FullName,
IsList = oldDef.IsArray,
Name = oldDef.Name
});
}
}
outcomeToAdd.OutcomeData = outcomeDefs.ToArray();
outcomes.Add(outcomeToAdd);
}
}
return(outcomes.ToArray());
}
public override StepOutcome[] GetOutcomes(IOrchestrationComponent component)
{
// Linked model outputs will need to be recreated to work well
// so no need to worry about the outcomes from the old engine here.
List <StepOutcome> results = new List <StepOutcome>();
StepOutcome result = new StepOutcome();
result.PathName = "End";
List <DataDefinition> data = new List <DataDefinition>();
foreach (LogicBase.Core.Data.DataDefinition x in component.Model.OutputData)
{
data.Add(new DataDefinition()
{
Name = x.Name,
IsList = x.IsArray,
FullTypeName = x.DataType.FullName
});
}
result.OutcomeData = data.ToArray();
return(results.ToArray());
}
public ExecutionPointer BuildNextPointer(WorkflowDefinition def, ExecutionPointer pointer, StepOutcome outcomeTarget)
{
var nextId = GenerateId();
return(new ExecutionPointer()
{
Id = nextId,
PredecessorId = pointer.Id,
StepId = outcomeTarget.NextStep,
Active = true,
ContextItem = pointer.ContextItem,
Status = PointerStatus.Pending,
StepName = def.Steps.FindById(outcomeTarget.NextStep).Name,
Scope = new List <string>(pointer.Scope)
});
}
public StepOutcomeBuilder(IWorkflowBuilder <TData> workflowBuilder, StepOutcome outcome)
{
WorkflowBuilder = workflowBuilder;
Outcome = outcome;
}
private static void CreateOutcomeEntry(Dictionary<string, StepOutcome> dictionary, List<string> header, List<string> result)
{
string key = header.First().Trim().TrimEnd(':');
var resultLineOne = result.First().Trim();
var doneMatch = Regex.Match(resultLineOne, "done: (?<method>.*)\\((?<args>.*)\\) \\((?<seconds>.*)s\\)");
var errorMatch = Regex.Match(resultLineOne, "(?<result>.*): (?<message>.*)");
if (doneMatch.Success)
{
var args = header.Count > 1 ? string.Join("\n", header.Skip(2).Select(x => x.Trim())) : doneMatch.Groups["args"].Value;
dictionary[key] = new StepOutcome
{
Method = doneMatch.Groups["method"].Value,
Result = Status.Passed,
Args = args,
Seconds = double.Parse(doneMatch.Groups["seconds"].Value)
};
}
else if (errorMatch.Success)
{
dictionary[key] = new StepOutcome
{
Result = Status.Failed,
ErrorMessage = errorMatch.Groups["message"].Value + string.Concat(result.Skip(1).Select(x => "\n" + x)),
};
}
else if (resultLineOne.StartsWith("-> No matching step definition found for the step"))
{
dictionary[key] = new StepOutcome
{
Result = Status.Pending,
ErrorMessage = "(Step missing)",
FullErrorMessage = "No matching step definition found for the step, implement it with:\n" + string.Concat(result.Skip(1).Select(x => "\n" + x))
};
}
else if (resultLineOne.StartsWith("-> skipped because of previous errors"))
{
dictionary[key] = new StepOutcome
{
Result = Status.Unknown,
ErrorMessage = "(Skipped)",
FullErrorMessage = "Step was skipped because of previous errors"
};
}
else
{
dictionary[key] = new StepOutcome
{
Result = Status.Inconclusive,
FullErrorMessage = "SpecShow failed to parse: " + resultLineOne
};
}
}
public ProcessingResult(StepOutcome outcome, TResult result, IResultDetails details)
{
Result = result;
Outcome = outcome;
Details = details;
}
public EndStepCommand(string buildID, int stepIndex, StepOutcome outcome)
{
BuildID = buildID;
StepIndex = stepIndex;
Outcome = outcome;
}
