private void InvokeStep(ITestRunStep step, TestRunExecutionContext context, TestRunResult result,
ITestRunLogger logger)
{
context.Step = step;
try
{
step.Run(context);
}
catch (TestRunAssertException)
{
result.AddStep(new TestRunStepResult(context.StepNumber, step.ToString(), false));
throw;
}
catch (Exception ex)
{
result.IsSuccess = false;
if (context.FirstException == null)
{
result.FailException = ex;
context.FirstException = ex;
}
else
{
context.LastException = ex;
}
}
result.AddStep(new TestRunStepResult(context.StepNumber, step.ToString(), result.IsSuccess));
}
private TestRunResult RunInternal(TestRun testRun, ITestRunLogger logger,
out TestRunExecutionContext context)
{
if (testRun == null)
{
throw new ArgumentNullException(nameof(testRun));
}
if (logger == null)
{
logger = new ConsoleTestRunLogger();
}
logger.LogWithTime($"Started to run \"{testRun.Name}\" test.");
context = new TestRunExecutionContext
{
StartedAt = DateTime.Now,
Logger = logger
};
Initialize(context);
context.Logger.LogWithTime("Run OnBeforeTestRun.");
OnBeforeTestRun(context);
var result = new TestRunResult(testRun.Name);
context.Logger.LogWithTime("Run Test.");
InvokeTestRun(testRun, context, result, logger);
return(result);
}
/// <summary>
/// Run test run.
/// </summary>
/// <param name="testRun">Test run.</param>
/// <param name="logger">Logger. Console is used by default.</param>
/// <returns>Test run result.</returns>
public virtual TestRunResult Run(TestRun testRun, ITestRunLogger logger = null)
{
TestRunExecutionContext context = null;
try
{
return(RunInternal(testRun, logger, out context));
}
finally
{
context?.Logger.LogWithTime("Run OnAfterTestRun.");
OnAfterTestRun(context);
}
}
private void Initialize(TestRunExecutionContext context)
{
if (!isInitialized)
{
lock (SyncRoot)
{
if (!isInitialized)
{
context.Logger.LogWithTime("Run initialization.");
OnInitialize(context);
isInitialized = true;
}
}
}
}
/// <summary>
/// Run test run with assert method. OnAfterTestRun will be called afterwards.
/// </summary>
/// <param name="testRun">Test run.</param>
/// <param name="assert">Assert method.</param>
/// <param name="logger">Logger. Console is used by default.</param>
/// <returns>Test run result.</returns>
public virtual TestRunResult RunWithAssert(
TestRun testRun,
Action <TestRun, TestRunResult> assert,
ITestRunLogger logger = null)
{
TestRunExecutionContext context = null;
try
{
var result = RunInternal(testRun, logger, out context);
context.Logger.LogWithTime("Run asserts.");
assert(testRun, result);
return(result);
}
finally
{
context?.Logger.LogWithTime("Run OnAfterTestRun.");
OnAfterTestRun(context);
}
}
private void InvokeTestRun(TestRun testRun, TestRunExecutionContext context, TestRunResult result,
ITestRunLogger logger)
{
context.TestRun = testRun;
context.ServiceProvider = ServiceProviderFactory.Create();
OnBeforeTestRun(context);
try
{
int stepNumber = 1;
foreach (ITestRunStep testRunStep in testRun.Steps)
{
context.StepNumber = stepNumber++;
InvokeStep(testRunStep, context, result, logger);
}
}
finally
{
context.Step = null;
var disposableServiceProvider = context.ServiceProvider as IDisposable;
disposableServiceProvider?.Dispose();
OnAfterTestRun(context);
}
}
/// <summary>
/// The method is called after all test were done.
/// </summary>
/// <param name="context">Test run execution context. It may be null if called from
/// Dispose method.</param>
public virtual void OnShutdown(TestRunExecutionContext context)
{
}
/// <summary>
/// The method is called after every test run. Here you can implement all
/// finalization steps (connections close, rollback, etc).
/// </summary>
/// <param name="context">Test run execution context.</param>
public virtual void OnAfterTestRun(TestRunExecutionContext context)
{
}
/// <summary>
/// The method is called before every test run. Here you can implement all
/// preparation steps for test, for example init test data.
/// </summary>
/// <param name="context">Test run execution context.</param>
public virtual void OnBeforeTestRun(TestRunExecutionContext context)
{
}
/// <summary>
/// Setup and initialize tests environment. Setup context resolver if needed.
/// </summary>
/// <param name="context">Test run execution context.</param>
public virtual void OnInitialize(TestRunExecutionContext context)
{
}
/// <summary>
/// Throw exception and format it with current execution context.
/// </summary>
/// <param name="message">Message to display to user.</param>
/// <param name="context">Current test execution context.</param>
/// <param name="step">Test run step instance.</param>
public static void ThrowWithExecutionContext(string message, TestRunExecutionContext context, ITestRunStep step)
{
throw new TestRunAssertException(message);
}
