public override bool Execute()
{
if (TestAssemblies.Length == 0)
throw new ArgumentException("At least one test assembly is required");
var logString = new StringBuilder();
TextWriter msbuildLogWriter = new StringWriter(logString);
var output = new PlainTextOutput(msbuildLogWriter);
WriteHeaderInto(output);
var config = NBehaveConfiguration.New
.DontIsolateInAppDomain()
.SetScenarioFiles(ScenarioFiles)
.SetDryRun(DryRun)
.SetAssemblies(TestAssemblies)
.SetEventListener(EventListeners.CreateEventListenerUsing(msbuildLogWriter, TextOutputFile, XmlOutputFile));
var runner = RunnerFactory.CreateTextRunner(config);
FeatureResults = runner.Run();
if (DryRun)
return true;
var message = logString.ToString();
Log.LogMessage(message);
if (FailBuild && FailBuildBasedOn(FeatureResults))
return false;
return true;
}
private static TestRunState GetTestRunState(FeatureResults results)
{
var state = TestRunState.Success;
if (results.NumberOfFailingScenarios > 0)
state = TestRunState.Failure;
if (results.NumberOfScenariosFound == 0)
state = TestRunState.NoTests;
return state;
}
private void FailBuildBasedOn(FeatureResults featureResults)
{
if (featureResults.NumberOfFailingScenarios == 0) return;
var exceptionMessage = new StringBuilder();
foreach (var result in featureResults.SelectMany(_=>_.ScenarioResults))
{
exceptionMessage.AppendLine(result.Message);
exceptionMessage.AppendLine(result.StackTrace);
exceptionMessage.AppendLine();
}
throw new BuildException(exceptionMessage.ToString());
}
private FeatureResults Run(IFeatureRunner featureRunner, IEnumerable<Feature> features, IRunContext context)
{
var result = new FeatureResults();
foreach (Feature feature in features)
{
FeatureResult featureResult = null;
try
{
context.FeatureStarted(feature);
featureResult = featureRunner.Run(feature);
result.Add(featureResult);
}
finally
{
context.FeatureFinished(featureResult);
}
}
return result;
}
public FeatureResults Run()
{
NBehaveInitializer.Initialize(configuration);
actionCatalog = TinyIoCContainer.Current.Resolve<ActionCatalog>();
var featureRunner = TinyIoCContainer.Current.Resolve<IFeatureRunner>();
var context = TinyIoCContainer.Current.Resolve<IRunContext>();
var results = new FeatureResults();
try
{
context.RunStarted();
LoadAssemblies();
var loader = new LoadScenarioFiles(configuration);
var files = loader.LoadFiles();
var parse = new ParseScenarioFiles(configuration);
var features = parse.LoadFiles(files);
results = Run(featureRunner, features, context);
}
finally
{
context.RunFinished(results);
}
return results;
}
public void ShouldUseWildcardAndRunAllScenariosInAllMatchingTextFiles()
{
_results = CreateBasicConfiguration().SetScenarioFiles(new[] { @"Features\\Feature*.feature" }).Build().Run();
Assert.That(_results.Count, Is.EqualTo(12));
Assert.That(_results.NumberOfScenariosFound, Is.EqualTo(17));
Assert.That(_results.NumberOfPassingScenarios, Is.EqualTo(8));
}
public void SetUp()
{
var scenarioText = "Feature: Config file support\r\n" +
"Scenario: Reading values from a config file\r\n" +
"Given an assembly with a matching configuration file\r\n" +
"When the value of setting foo is read\r\n" +
"Then the value should be bar";
SetupConfigFile();
runner = CreateTextRunner(new[] { "TestPlainTextAssembly.dll" }, scenarioText);
results = runner.Run();
}
public void SetUp()
{
var writer = new XmlTextWriter(new MemoryStream(), Encoding.UTF8);
var listener = new XmlOutputEventListener(writer);
const string scenarioText = "Feature: " + FeatureTitle + "\r\n" +
"Scenario: Reading values from a config file\r\n" +
"Given an assembly with a matching configuration file\r\n" +
"When the value of setting foo is read\r\n" +
"Then the value should be bar";
SetupConfigFile();
runner = CreateTextRunner(new[] { "TestPlainTextAssembly.dll" }, listener, scenarioText);
results = runner.Run();
xmlOut = new XmlDocument();
writer.BaseStream.Seek(0, SeekOrigin.Begin);
xmlOut.Load(writer.BaseStream);
}
public void SetUp()
{
_messages = new StringWriter();
var listener = new TextWriterEventListener(_messages);
_results = CreateBasicConfiguration()
.SetEventListener(listener)
.SetScenarioFiles(new[] { TestFeatures.FeatureNamedStory })
.Build()
.Run();
}
public void SetUp()
{
_featureResults = CreateBasicConfiguration()
.SetAssemblies(new[] { Path.GetFileName(GetType().Assembly.Location) })
.SetScenarioFiles(new[] { TestFeatures.FeatureInSwedish })
.Build()
.Run();
}
public void RunFinished(FeatureResults results)
{
if (OnRunFinished != null)
OnRunFinished(this, new EventArgs<FeatureResults>(results));
}
public void Should_not_crash_when_steps_are_written_in_lower_case()
{
_results = CreateBasicConfiguration().SetScenarioFiles(new[] { TestFeatures.FeatureWithLowerCaseSteps }).Build().Run();
Assert.That(_results.NumberOfPassingScenarios, Is.EqualTo(1));
}
public void ShouldSetScenarioPendingIfActionGivenInTokenStringDoesntExist()
{
_results = CreateBasicConfiguration().SetScenarioFiles(new[] { TestFeatures.ScenarioWithNoActionSteps })
.Build()
.Run();
Assert.That(_results.NumberOfPendingScenarios, Is.EqualTo(1));
}
protected override void Because()
{
_results = _config.Build().Run();
}
public void ShouldRunTextScenarioWhithNewlinesInGiven()
{
_results = CreateBasicConfiguration().SetScenarioFiles(new[] { TestFeatures.FeatureWithNewLineInGivenClause })
.Build()
.Run();
Assert.That(_results.NumberOfPassingScenarios, Is.EqualTo(1));
}
public void ShouldRunScenarioInTextFileWithScenarioTitle()
{
_results = CreateBasicConfiguration().SetScenarioFiles(new[] { TestFeatures.ScenariosWithoutFeature })
.Build()
.Run();
Assert.That(_results[0].ScenarioResults[0].ScenarioTitle, Is.EqualTo("greeting Morgan"));
Assert.That(_results[0].ScenarioResults[0].Result, Is.TypeOf(typeof(Passed)));
}
public void ShouldListAllPendingActionSteps()
{
_results = CreateBasicConfiguration().SetScenarioFiles(new[] { TestFeatures.ScenarioWithNoActionSteps }).Build().Run();
StringAssert.Contains("No matching Action found for \"Given something that has no ActionStep\"", _results[0].ScenarioResults[0].Message);
StringAssert.Contains("No matching Action found for \"And something else that has no ActionStep\"", _results[0].ScenarioResults[0].Message);
}
public void ShouldGetCorrectErrormessageFromFailedScenario()
{
_results = CreateBasicConfiguration().SetScenarioFiles(new[] { TestFeatures.FeatureWithFailingStep })
.Build()
.Run();
Assert.That(_results.NumberOfFailingScenarios, Is.EqualTo(1));
Assert.That(_results[0].ScenarioResults[0].Message.StartsWith("Should.Core.Exceptions.EqualException"), Is.True);
}
public void ShouldExecuteMoreThanOneScenarioInTextFile()
{
_results = CreateBasicConfiguration().SetScenarioFiles(new[] { TestFeatures.FeatureWithManyScenarios })
.Build()
.Run();
Assert.That(_results.NumberOfScenariosFound, Is.EqualTo(2));
Assert.That(_results.NumberOfPassingScenarios, Is.EqualTo(2));
}
private bool FailBuildBasedOn(FeatureResults resultEvent)
{
if (resultEvent.NumberOfFailingScenarios == 0)
return false;
var exceptionMessage = new StringBuilder();
foreach (var result in resultEvent.SelectMany(_=>_.ScenarioResults))
{
exceptionMessage.AppendLine(result.Message);
exceptionMessage.AppendLine(result.StackTrace);
exceptionMessage.AppendLine();
}
Log.LogError(exceptionMessage.ToString());
return true;
}
public void Should_not_crash_when_feature_file_ends_with_comment()
{
_results = CreateBasicConfiguration().SetScenarioFiles(new[] { TestFeatures.FeatureWithCommentOnLastRow }).Build().Run();
Assert.That(_results.NumberOfPassingScenarios, Is.EqualTo(1));
}
