private static void RunTestMethod(IMessageBus messageBus,
object[] constructorArguments,
IEnumerable <XunitTestCase> testCases,
RunSummary classSummary,
ExceptionAggregator aggregator,
CancellationTokenSource cancellationTokenSource)
{
foreach (var testCase in testCases)
{
using (var delegatingBus = new DelegatingMessageBus <ITestCaseFinished>(messageBus))
{
testCase.Run(delegatingBus, constructorArguments, aggregator, cancellationTokenSource);
delegatingBus.Finished.WaitOne();
classSummary.Total += delegatingBus.FinalMessage.TestsRun;
classSummary.Failed += delegatingBus.FinalMessage.TestsFailed;
classSummary.Skipped += delegatingBus.FinalMessage.TestsSkipped;
classSummary.Time += delegatingBus.FinalMessage.ExecutionTime;
}
if (cancellationTokenSource.IsCancellationRequested)
{
break;
}
}
}
/// <inheritdoc/>
public virtual async Task <RunSummary> RunAsync(IMessageBus messageBus, object[] constructorArguments, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource)
{
var summary = new RunSummary();
if (!messageBus.QueueMessage(new TestCaseStarting(this)))
{
cancellationTokenSource.Cancel();
}
else
{
using (var delegatingBus = new DelegatingMessageBus(messageBus,
msg =>
{
if (msg is ITestResultMessage)
{
summary.Total++;
summary.Time += ((ITestResultMessage)msg).ExecutionTime;
}
if (msg is ITestFailed)
{
summary.Failed++;
}
if (msg is ITestSkipped)
{
summary.Skipped++;
}
}))
{
await RunTestsAsync(delegatingBus, constructorArguments, aggregator, cancellationTokenSource);
}
}
if (!messageBus.QueueMessage(new TestCaseFinished(this, summary.Time, summary.Total, summary.Failed, summary.Skipped)))
{
cancellationTokenSource.Cancel();
}
return(summary);
}
/// <summary>
/// Executes the test case, returning 0 or more result messages through the message sink.
/// </summary>
/// <param name="messageBus">The message bus to report results to.</param>
/// <param name="constructorArguments">The arguments to pass to the constructor.</param>
/// <param name="aggregator">The error aggregator to use for catching exception.</param>
/// <param name="cancellationTokenSource">The cancellation token source that indicates whether cancellation has been requested.</param>
public virtual void Run(IMessageBus messageBus, object[] constructorArguments, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource)
{
int totalFailed = 0;
int totalRun = 0;
int totalSkipped = 0;
decimal executionTime = 0M;
if (!messageBus.QueueMessage(new TestCaseStarting(this)))
{
cancellationTokenSource.Cancel();
}
else
{
using (var delegatingBus = new DelegatingMessageBus(messageBus, msg =>
{
if (msg is ITestResultMessage)
{
totalRun++;
executionTime += ((ITestResultMessage)msg).ExecutionTime;
}
if (msg is ITestFailed)
{
totalFailed++;
}
if (msg is ITestSkipped)
{
totalSkipped++;
}
}))
RunTests(delegatingBus, constructorArguments, aggregator, cancellationTokenSource);
}
if (!messageBus.QueueMessage(new TestCaseFinished(this, executionTime, totalRun, totalFailed, totalSkipped)))
{
cancellationTokenSource.Cancel();
}
}
private static async Task RunTestMethodAsync(IMessageBus messageBus,
object[] constructorArguments,
IEnumerable<XunitTestCase> testCases,
RunSummary classSummary,
ExceptionAggregator aggregator,
CancellationTokenSource cancellationTokenSource)
{
foreach (var testCase in testCases)
{
using (var delegatingBus = new DelegatingMessageBus<ITestCaseFinished>(messageBus))
{
await testCase.RunAsync(delegatingBus, constructorArguments, aggregator, cancellationTokenSource);
delegatingBus.Finished.WaitOne();
classSummary.Total += delegatingBus.FinalMessage.TestsRun;
classSummary.Failed += delegatingBus.FinalMessage.TestsFailed;
classSummary.Skipped += delegatingBus.FinalMessage.TestsSkipped;
classSummary.Time += delegatingBus.FinalMessage.ExecutionTime;
}
if (cancellationTokenSource.IsCancellationRequested)
break;
}
}
/// <summary>
/// Executes the test case, returning 0 or more result messages through the message sink.
/// </summary>
/// <param name="messageBus">The message bus to report results to.</param>
/// <param name="constructorArguments">The arguments to pass to the constructor.</param>
/// <param name="aggregator">The error aggregator to use for catching exception.</param>
/// <param name="cancellationTokenSource">The cancellation token source that indicates whether cancellation has been requested.</param>
public virtual async Task RunAsync(IMessageBus messageBus, object[] constructorArguments, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource)
{
int totalFailed = 0;
int totalRun = 0;
int totalSkipped = 0;
decimal executionTime = 0M;
if (!messageBus.QueueMessage(new TestCaseStarting(this)))
cancellationTokenSource.Cancel();
else
{
using (var delegatingBus = new DelegatingMessageBus(messageBus,
msg =>
{
if (msg is ITestResultMessage)
{
totalRun++;
executionTime += ((ITestResultMessage)msg).ExecutionTime;
}
if (msg is ITestFailed)
totalFailed++;
if (msg is ITestSkipped)
totalSkipped++;
}))
{
await RunTestsAsync(delegatingBus, constructorArguments, aggregator, cancellationTokenSource);
}
}
if (!messageBus.QueueMessage(new TestCaseFinished(this, executionTime, totalRun, totalFailed, totalSkipped)))
cancellationTokenSource.Cancel();
}
private async Task<RunSummary> InvokeStepsAsync(
ICollection<IStepDefinition> backGroundStepDefinitions, ICollection<IStepDefinition> scenarioStepDefinitions)
{
var filters = this.scenarioClass.Assembly.GetCustomAttributes(typeof(Attribute))
.Concat(this.scenarioClass.GetCustomAttributes(typeof(Attribute)))
.Concat(this.scenarioMethod.GetCustomAttributes(typeof(Attribute)))
.OfType<IFilter<IStepDefinition>>();
var stepDefinitions = filters
.Aggregate(
backGroundStepDefinitions.Concat(scenarioStepDefinitions),
(current, filter) => filter.Filter(current))
.ToArray();
var summary = new RunSummary();
string skipReason = null;
var teardowns = new List<Action>();
var stepNumber = 0;
foreach (var stepDefinition in stepDefinitions)
{
stepDefinition.SkipReason = stepDefinition.SkipReason ?? skipReason;
var stepDisplayName = GetStepDisplayName(
this.scenario.DisplayName,
++stepNumber,
stepNumber <= backGroundStepDefinitions.Count,
stepDefinition.Text,
this.scenarioMethodArguments);
var step = new Step(this.scenario, stepDisplayName);
var interceptingBus = new DelegatingMessageBus(
this.messageBus,
message =>
{
if (message is ITestFailed && stepDefinition.FailureBehavior == RemainingSteps.Skip)
{
skipReason = string.Format(
CultureInfo.InvariantCulture,
"Failed to execute preceding step: {0}",
step.DisplayName);
}
});
var stepRunner = new StepRunner(
step,
stepDefinition.Body,
interceptingBus,
this.scenarioClass,
this.constructorArguments,
this.scenarioMethod,
this.scenarioMethodArguments,
stepDefinition.SkipReason,
new ExceptionAggregator(this.aggregator),
this.cancellationTokenSource);
summary.Aggregate(await stepRunner.RunAsync());
teardowns.AddRange(stepRunner.Disposables.Select(disposable => (Action)disposable.Dispose)
.Concat(stepDefinition.Teardowns.Where(teardown => teardown != null)).ToArray());
}
if (teardowns.Any())
{
teardowns.Reverse();
var teardownTimer = new ExecutionTimer();
var teardownAggregator = new ExceptionAggregator();
foreach (var teardown in teardowns)
{
teardownTimer.Aggregate(() => teardownAggregator.Run(() => teardown()));
}
summary.Time += teardownTimer.Total;
if (teardownAggregator.HasExceptions)
{
summary.Failed++;
summary.Total++;
var stepDisplayName = GetStepDisplayName(
this.scenario.DisplayName,
++stepNumber,
false,
"(Teardown)",
this.scenarioMethodArguments);
this.messageBus.Queue(
new Step(this.scenario, stepDisplayName),
test => new TestFailed(test, teardownTimer.Total, null, teardownAggregator.ToException()),
this.cancellationTokenSource);
}
}
return summary;
}
/// <inheritdoc/>
public virtual async Task<RunSummary> RunAsync(IMessageBus messageBus, object[] constructorArguments, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource)
{
var summary = new RunSummary();
if (!messageBus.QueueMessage(new TestCaseStarting(this)))
cancellationTokenSource.Cancel();
else
{
using (var delegatingBus = new DelegatingMessageBus(messageBus,
msg =>
{
if (msg is ITestResultMessage)
{
summary.Total++;
summary.Time += ((ITestResultMessage)msg).ExecutionTime;
}
if (msg is ITestFailed)
summary.Failed++;
if (msg is ITestSkipped)
summary.Skipped++;
}))
{
await RunTestsAsync(delegatingBus, constructorArguments, aggregator, cancellationTokenSource);
}
}
if (!messageBus.QueueMessage(new TestCaseFinished(this, summary.Time, summary.Total, summary.Failed, summary.Skipped)))
cancellationTokenSource.Cancel();
return summary;
}