FeatureResult ExecuteFeature(Feature feature, Type[] types, RunnerOptions options)
{
var featureResult = new FeatureResult(feature);
var matcher = new StepMatcher();
var finder = new ActionStepFinder();
var steps = GetUniqueSteps(feature);
var actionStepsClasses = finder.Find(types);
var matches = MatchStepsToActionMethods(steps, actionStepsClasses, matcher);
var executionObjects = GetExecutionObjects(matches);
var filter = options.Filter;
try
{
BeforeFeature(feature, executionObjects);
foreach (var scenario in feature.Scenarios.SelectMany(s => s.GetExecutableScenarios()).Where(s => filter.IsSatisfiedBy(s.Tags)))
{
BeforeScenario(feature, scenario, executionObjects);
var result = ExecuteScenario(scenario, feature, matches, executionObjects, options);
featureResult.AddScenarioResult(result);
AfterScenario(feature, scenario, result, executionObjects);
if (options.SuccessRequired && !result.Success)
{
break;
}
}
AfterFeature(feature, featureResult, executionObjects);
}
finally
{
CleanUpExecutionObjects(executionObjects);
}
return(featureResult);
}
public override void DoSetUp()
{
matcher = new StepMatcher();
}
List <FoundMatch> MatchStepsToActionMethods(IEnumerable <Step> steps, IEnumerable <ActionStepsClass> actionStepsClasses, StepMatcher matcher)
{
return((from step in steps
from actionStepClass in actionStepsClasses
let requiredType = actionStepClass.Type
from actionStepMethod in actionStepClass.ActionStepMethods
let match = matcher.GetMatch(step, actionStepMethod)
where match.IsMatch
select new FoundMatch
{
RequiredType = requiredType,
ActionStepMethod = actionStepMethod,
StepMatch = match,
})
.ToList());
}
