public ScenarioContext(StoryContext parentContext, IEnumerable <Type> implementingTypes,
IDictionary <Type, object> outerContexts)
{
_cache = new Dictionary <Type, object>(outerContexts);
_parentContext = parentContext;
ImplementingTypes = implementingTypes;
}
public string GenerateFixture(Story story, StoryContext context)
{
var tests = new StringBuilder();
var contextSet = new TestContextSet();
IEnumerable<string> namespaces = new string[0];
foreach (var scenario in story.Scenarios)
{
foreach (var s in _preprocessor.Preprocess(scenario))
{
NUnitTest test = MethodGenerator.GetTestFromScenario(s, context);
tests.Append(" " + test.Body);
tests.AppendLine();
contextSet.AddRange(test.ContextTypes);
namespaces = namespaces.Union(test.Namespaces).Distinct();
}
}
var usingStatements = namespaces.Select(x => string.Format("using {0};", x));
var usings = string.Join("\r\n", usingStatements.ToArray());
var writeStoryToConsole = "Console.WriteLine(@\"" + story.Summary.Replace("\"", "\"\"") + "\r\n" + " \");";
const string ns = "StorEvilSpecifications";
var categories = string.Join("", (story.Tags ?? new string[0]).Select(t => string.Format(@"[Category(""{0}"")]", t)).ToArray());
return string.Format(FixtureFormat, ns, usings, GetFixtureName(story), tests, writeStoryToConsole, categories, story.Id);
}
public ScenarioContext(StoryContext parentContext, IEnumerable<Type> implementingTypes,
IDictionary<Type, object> outerContexts)
{
_cache = new Dictionary<Type, object>(outerContexts);
_parentContext = parentContext;
ImplementingTypes = implementingTypes;
}
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;
}
protected void BeforeAll()
{
_eventBus = StorEvilEvents.Bus;
_storyContext = TestSession.SessionContext(GetType().Assembly.Location).GetContextForStory();
_interpreter = new StandardScenarioInterpreter();
_scenarioLineExecuter = new ScenarioLineExecuter(_interpreter, _eventBus);
}
public void SetupContext()
{
var mapper = new SessionContext();
mapper.AddContext <TestMappingContext>();
mapper.AddContext <DependentMappingContext>();
StoryContext = mapper.GetContextForStory();
ScenarioContext = StoryContext.GetScenarioContext();
}
protected override void Execute(Story story, IEnumerable<Scenario> scenarios, StoryContext context)
{
using (var remoteHandler = _factory.GetHandler(story, scenarios, ResultListener))
{
var handler = remoteHandler.Handler;
handler.HandleStory(story);
Result += handler.GetResult();
}
}
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);
}
protected override void Execute(Story story, IEnumerable<Scenario> scenariosMatchingFilter, StoryContext context)
{
int failed = 0;
foreach (var scenario in scenariosMatchingFilter)
{
using (var scenarioContext = context.GetScenarioContext())
{
if (!_scenarioRunner.ExecuteScenario(scenario, scenarioContext))
failed++;
}
}
Result.Failed = Result.Failed + failed;
}
private ScenarioLineImplementation BuildCodeFromScenarioLine(string line, StoryContext storyContext)
{
var scenarioContext = storyContext.GetScenarioContext();
LineInfo invocation = null;
invocation = _invocationGenerator.MapMethod(scenarioContext, line);
if (invocation == null)
return null;
var chosenType = invocation.ImplementingType;
return new ScenarioLineImplementation("context" + chosenType.Name + invocation.Code + ";", chosenType,
"context" + chosenType.Name, invocation.Namespaces);
}
public void SetupContext()
{
var mapper = new SessionContext();
mapper.AddContext<TestMappingContext>();
mapper.AddContext<DependentMappingContext>();
StoryContext = mapper.GetContextForStory();
ScenarioContext = StoryContext.GetScenarioContext();
}
public string GenerateFixture(Story story, StoryContext context)
{
return new TestFixtureClassGenerator().Generate(story, "StorEvilSpecs");
}
public StoryContext GetContextForStory()
{
return _context ?? (_context = new StoryContext(this));
}
public FakeSessionContext(StoryContext context)
{
_context = context;
}
protected IDisposable StartScenario(Story story, Scenario scenario)
{
_eventBus.Raise(new ScenarioStarting {Scenario = scenario});
if (CurrentStoryContext == null)
CurrentStoryContext = _context.GetContextForStory();
CurrentScenarioContext = CurrentStoryContext.GetScenarioContext();
CurrentScenario = scenario;
LastStatus = LineStatus.Passed;
//ScenarioInterpreter.NewScenario();
return CurrentScenarioContext;
}
protected abstract void Execute(Story story, IEnumerable<Scenario> scenariosMatchingFilter, StoryContext context);
public FakeStoryContextFactory(StoryContext context)
{
_context = context;
}
