private bool ExecuteChain(Scenario scenario, ScenarioContext storyContext, InvocationChain chain, string line)
{
string successPart = "";
_lastResult = null;
foreach (var invocation in chain.Invocations)
{
try
{
InvokeContextMember(storyContext, invocation);
successPart += invocation.MatchedText + " ";
}
catch (TargetInvocationException ex)
{
if (ex.InnerException is ScenarioPendingException)
{
_listener.ScenarioPending(new ScenarioPendingInfo(scenario, line));
}
else
{
_listener.ScenarioFailed(new ScenarioFailureInfo(scenario, successPart.Trim(),
invocation.MatchedText, GetExceptionMessage(ex)));
}
return false;
}
}
return true;
}
public bool ExecuteScenario(Scenario scenario, ScenarioContext storyContext)
{
_eventBus.Raise(new ScenarioStarting { Scenario = scenario});
//_scenarioInterpreter.NewScenario();
foreach (var line in (scenario.Background ?? new ScenarioLine[0]).Union(scenario.Body))
{
LineStatus status = _lineExecuter.ExecuteLine(scenario, storyContext, line.Text);
if (LineStatus.Failed == status)
{
_eventBus.Raise(new ScenarioFinished { Scenario = scenario, Status = ExecutionStatus.Failed });
return false;
}
if (LineStatus.Pending == status)
{
_eventBus.Raise(new ScenarioFinished { Scenario = scenario, Status = ExecutionStatus.Pending });
return true;
}
}
_eventBus.Raise(new ScenarioFinished { Scenario = scenario, Status = ExecutionStatus.Passed});
//_eventBus.Raise(new ScenarioSucceededEvent { Scenario = scenario });
return true;
}
protected override Story GetStory()
{
ScenarioLine[] body = GetScenarioBody("when I do something", "then I should see something");
Scenario scenario = new Scenario("", "scenario-id", "scenario name", body);
return new Story("foo bar baz", "bar", new IScenario[] {scenario});
}
bool FilterIncludes(string[] storyTags, string[] scenarioTags)
{
var scenario = new Scenario() {Tags = storyTags};
var story = new Story("", "", new[] { scenario }) { Tags = scenarioTags };
return Filter.Include(story, scenario);
}
private void AppendStoryCode(StringBuilder codeBuilder, Story story, Scenario[] scenarios)
{
var i = 0;
foreach (var scenario in scenarios)
{
codeBuilder.AppendLine(@"
scenario = scenarios[" + i + @"];
using (StartScenario(story, scenario)) {
#line 1 """ + story.Id + @"""
#line hidden");
foreach (var line in GetLines(scenario))
{
codeBuilder.AppendFormat(@"
if (ShouldContinue) {{
#line {0}
ExecuteLine(@""{1}"");
#line hidden
}}
", line.LineNumber, line.Text.Replace("\"", "\"\""));
}
codeBuilder.AppendLine("}");
codeBuilder.AppendLine(@"CollectScenarioResult();");
i++;
}
}
public ScenarioFailureInfo(Scenario scenario, string successPart, string failedPart, string message)
{
_scenario = scenario;
_successPart = successPart;
_failedPart = failedPart;
_message = message;
}
public TestImplementation BuildImplementation(Scenario scenario, StoryContext context)
{
var impl = new TestImplementation();
foreach (var line in scenario.Body)
{
impl.CodeBuilder.Append(BuildConsoleWriteScenarioLine(line.Text));
impl.CodeBuilder.AppendLine("#line " + line.LineNumber);
var lineVariations = GenerateLineVariations(line.Text);
ScenarioLineImplementation functionLine = null;
foreach (var variation in lineVariations)
{
if (null != (functionLine = BuildCodeFromScenarioLine(variation, context)))
break;
}
if (functionLine == null)
{
impl.CodeBuilder.AppendLine(
@" Assert.Ignore(@""Could not interpret: '" + line.Text + "'\");");
impl.CodeBuilder.AppendLine("#line hidden");
break;
}
impl.Contexts.Add(functionLine.Context);
impl.CodeBuilder.AppendLine(functionLine.Code);
impl.CodeBuilder.AppendLine("#line hidden");
impl.Namespaces = impl.Namespaces.Union(functionLine.Namespaces).Distinct();
}
AppendDisposeCalls(impl.CodeBuilder, impl.Contexts);
return impl;
}
public StorEvilScenarioElement(StorEvilTestProvider provider, UnitTestElement parent, IProject project,
string title, Scenario scenario)
: base(provider, parent, project, title)
{
_namespace = new UnitTestNamespace(project.Name);
Scenario = scenario;
}
private string GetScenarioBody(Scenario scenario)
{
var sourceLines = (scenario.Background ?? new ScenarioLine[0]).Union(scenario.Body);
var lines = sourceLines.Select((l, i) => GetScenarioLine(l));
return string.Join("\r\n", lines.ToArray());
}
public ScenarioOutline(string id, string name, Scenario scenario, string[] fieldNames,
string[][] examples)
{
Id = id;
Name = name;
Scenario = scenario;
FieldNames = fieldNames;
Examples = examples;
}
public void ScenarioFailed(Scenario scenario, string successPart, string failedPart, string message)
{
Output(successPart + " [" + failedPart + "] -- failed");
Output("----------");
Output(message);
_server.TaskException(_remoteTask, new[] {new TaskException("StorEvil failure", message, ""),});
Result = TaskResult.Exception;
}
protected void SimulateSuccessfulScenario(string id, string name, string[] lines)
{
var successScenario = new Scenario(id, name, lines.Select(l=> new ScenarioLine{Text = l}).ToArray());
Listener.ScenarioStarting(successScenario);
foreach (var line in lines)
Listener.Success(successScenario, line);
Listener.ScenarioSucceeded(successScenario);
}
public StorEvilScenarioElement(StorEvilTestProvider provider, UnitTestElement parent, IProject project,
string title, Scenario scenario)
: base(provider, parent, project, title)
{
var root = project.Location.ToDirectoryInfo().FullName;
var pathPieces = PathHelper.GetRelativePathPieces(root, scenario.Location.Path);
var pathJoined = project.Name + " " + string.Join(" - ", pathPieces);
_namespace = new UnitTestNamespace(pathJoined);
Scenario = scenario;
}
protected void SimulateSuccessfulScenario(string id, string name, string[] lines)
{
var successScenario = new Scenario("", id, name, lines.Select(l=> new ScenarioLine{Text = l}).ToArray());
Listener.Handle(new ScenarioStarting { Scenario = successScenario });
foreach (var line in lines)
Listener.Handle(new LinePassed{Line = line});
// Listener.Handle(new ScenarioSucceededEvent {Scenario = successScenario});
}
public void CouldNotInterpret(Scenario scenario, string line)
{
Output("Could not interpret:\r\n" + line);
var suggestion = new ImplementationHelper().Suggest(line);
Output("You could try the following:");
Output(suggestion);
Result = TaskResult.Skipped;
}
public virtual NUnitTest GetTestFromScenario(Scenario scenario, StoryContext context)
{
TestImplementation impl = _implementationBuilder.BuildImplementation(scenario, context);
string declarations = BuildContextDeclarations(impl.Contexts);
var name = BuildMethodName(scenario);
var categories = BuildCategories(scenario);
var body = BuildTestBody(impl.CodeBuilder, name, declarations, categories);
return new NUnitTest(name, body, impl.Contexts, impl.Namespaces);
}
public bool ExecuteScenario(Scenario scenario, ScenarioContext scenarioContext)
{
_eventBus.Raise(new ScenarioStarting { Scenario = scenario});
//_scenarioInterpreter.NewScenario();
var result = ExecutionStatus.Passed;
foreach (var line in (scenario.Background ?? new ScenarioLine[0]).Union(scenario.Body))
{
LineStatus status = _lineExecuter.ExecuteLine(scenario, scenarioContext, line.Text);
if (LineStatus.Failed == status)
{
result = ExecutionStatus.Failed;
break;
}
if (LineStatus.Pending == status)
{
result = ExecutionStatus.Pending;
break;
}
}
if (!TryToDisposeScenarioContext(scenarioContext))
{
result = ExecutionStatus.Failed;
}
switch (result)
{
case ExecutionStatus.Failed:
{
_eventBus.Raise(new ScenarioFailed { Scenario = scenario, ExceptionInfo = _exceptionInfo});
return false;
}
case ExecutionStatus.Pending:
{
_eventBus.Raise(new ScenarioPending { Scenario = scenario });
return true;
}
default:
{
_eventBus.Raise(new ScenarioPassed { Scenario = scenario });
return true;
}
}
}
public bool ExecuteScenario(Scenario scenario, ScenarioContext storyContext)
{
_listener.ScenarioStarting(scenario);
_scenarioInterpreter.NewScenario();
foreach (var line in scenario.Body)
{
LineStatus status = _lineExecuter.ExecuteLine(scenario, storyContext, line.Text);
if (LineStatus.Failed == status)
return false;
if (LineStatus.Pending ==status)
return true;
}
_listener.ScenarioSucceeded(scenario);
return true;
}
public LineStatus ExecuteLine(Scenario scenario, ScenarioContext storyContext, string line)
{
// Debug.WriteLine("SLE: " + line);
InvocationChain chain = GetMatchingChain(storyContext, line);
if (chain == null)
{
var suggestion = _implementationHelper.Suggest(line);
_listener.ScenarioPending(new ScenarioPendingInfo(scenario, line, suggestion));
return LineStatus.Pending;
}
if (!ExecuteChain(scenario, storyContext, chain, line))
return LineStatus.Failed;
_listener.Success(scenario, line);
return LineStatus.Passed;
}
private static string BuildMethodName(Scenario scenario)
{
string baseName = GetBaseName(scenario);
var name = StripNonNameCharacters(baseName.Trim());
if (name.Length > 254)
name = name.Substring(0, 254);
// just make up a random name for now
if (name.Length == 0)
return "_" + Guid.NewGuid().ToString().Replace("-", "");
// make sure it starts with letter, else prepend _
if (char.IsLetter(name[0]))
return name;
return "_" + name;
}
public LineStatus ExecuteLine(Scenario scenario, ScenarioContext storyContext, string line)
{
DebugTrace.Trace("ScenarioLineExecter.ExecuteLine", line);
InvocationChain chain = GetMatchingChain(storyContext, line);
if (chain == null)
{
var suggestion = _implementationHelper.Suggest(line);
_eventBus.Raise(new LinePending {Scenario = scenario, Line = line, Suggestion = suggestion });
return LineStatus.Pending;
}
if (!ExecuteChain(scenario, storyContext, chain, line))
return LineStatus.Failed;
_eventBus.Raise(new LinePassed { Scenario = scenario, Line = line });
return LineStatus.Passed;
}
private bool ExecuteChain(Scenario scenario, ScenarioContext storyContext, InvocationChain chain, string line)
{
string successPart = "";
_lastResult = null;
foreach (var invocation in chain.Invocations)
{
try
{
InvokeContextMember(storyContext, invocation);
successPart += invocation.MatchedText + " ";
}
catch (TargetInvocationException ex)
{
if (ex.InnerException is ScenarioPendingException)
{
_eventBus.Raise(new LinePending { Scenario = scenario, Line = line });
}
else
{
_eventBus.Raise(new LineFailed
{
Scenario = scenario,
Line = line,
SuccessPart = successPart.Trim(),
FailedPart = invocation.MatchedText,
ExceptionInfo = GetExceptionMessage(ex)
});
}
return false;
}
}
return true;
}
protected void SimulatePendingScenario()
{
var pendingScenario = new Scenario();
Listener.Handle(new ScenarioStarting { Scenario = pendingScenario });
Listener.Handle(new LinePending() { Line = "could not interpret message"});
}
protected void SimulateFailedScenario()
{
var failureScenario = new Scenario();
Listener.Handle(new ScenarioStarting { Scenario = failureScenario });
Listener.Handle(new LineFailed {SuccessPart = "success part", FailedPart = "failed part", ExceptionInfo = "failure message"});
}
protected override void SimulateRunner()
{
SimulateStoryStarting("storyId", "storySummary");
var pendingScenario = new Scenario();
Listener.Handle(new ScenarioStarting { Scenario = pendingScenario });
Listener.Handle(new LinePending{Line= "foo bar baz"});
Listener.Handle(new ScenarioPending());
var failedScenario = new Scenario();
Listener.Handle(new ScenarioStarting { Scenario = failedScenario});
Listener.Handle(new LineFailed {SuccessPart = "success-part", FailedPart = "failed-part", ExceptionInfo = "failure-message" });
Listener.Handle(new ScenarioFailed());
SimulateSuccessfulScenario("scenario-id", "scenario-name", new[] {"line1", "line2"});
}
protected override void SimulateRunner()
{
SimulateStoryStarting("storyId", "storySummary");
var testScenario = new Scenario();
Listener.Handle(new ScenarioStarting { Scenario = testScenario });
Listener.Handle(new LinePending { Line = "foo bar baz", Suggestion = TestSuggestion });
Listener.Handle(new ScenarioPending { Scenario = testScenario });
}
protected override void SimulateRunner()
{
SimulateStoryStarting("storyId", "storySummary");
var testScenario = new Scenario();
Listener.Handle(new ScenarioStarting { Scenario = testScenario });
Listener.Handle(new LineFailed {SuccessPart = "success-part", FailedPart = "failed-part",ExceptionInfo = "failure-message" });
Listener.Handle(new ScenarioFailed());
}
public void Success(Scenario scenario, string line)
{
DoWrite(ConsoleColor.Green, line);
}
public void ScenarioSucceeded(Scenario scenario)
{
DoWrite(ConsoleColor.Green, "Scenario succeeded");
}
public void ScenarioStarting(Scenario scenario)
{
DoWrite(ConsoleColor.White, "\r\nSCENARIO: " + scenario.Name);
}
