public static async Task <Result <Option <object>, TestFailure> > Execute(this IntegrationTestCase testCase, object[] constructorArguments, object[] testMethodArguments, IMessageBus messageBus, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource)
{
var result = default(Result <Option <object>, TestFailure>?);
var interceptor = new MessageBusWrapper(messageBus, message =>
{
if (result.HasValue)
{
return;
}
if (message is TestFailed failedTest)
{
result = Result.Failure <Option <object>, TestFailure>(new TestFailure(new Exception(String.Join(Environment.NewLine, failedTest.Messages))));
}
if (message is TestSkipped skippedTest)
{
result = Result.Failure <Option <object>, TestFailure>(new TestFailure(skippedTest.Reason));
}
});
await new IntegrationTestCaseRunner(testCase, constructorArguments, testMethodArguments, interceptor, aggregator, cancellationTokenSource, value => result = value.MapFailure(ex => new TestFailure(ex))).RunAsync();
return(result.Value);
}
public static ExecutionJob Create(IntegrationTestCase testCase, IMessageBus messageBus)
{
var method = testCase.Method.ToRuntimeMethod();
return(Result
.Create(!(testCase is ErrorIntegrationTestCase), () => method, () => (testCase as ErrorIntegrationTestCase).ErrorMessage)
.Bind(ExecutionData.Create)
.Match
(
executionData => ExecutionJob.Create(method, executionData, (arguments, cts) => ExecuteTest(testCase, messageBus, arguments.methodArguments, arguments.constructorArguments, cts), abortMessage => AbortTest(testCase, messageBus, abortMessage)),
errorMessage => ExecutionJob.Create(method, ExecutionData.Empty, (arguments, cts) => FailTest(testCase, messageBus, errorMessage), abortMessage => AbortTest(testCase, messageBus, abortMessage))
));
}
private static void AbortTest(IntegrationTestCase testCase, IMessageBus messageBus, string abortMessage)
{
var test = new IntegrationTest(testCase);
SendStartMessages(testCase, messageBus);
messageBus.QueueMessage(new TestCaseStarting(testCase));
messageBus.QueueMessage(new TestStarting(test));
messageBus.QueueMessage(new TestSkipped(test, abortMessage));
messageBus.QueueMessage(new TestFinished(test, 0, null));
messageBus.QueueMessage(new TestCaseFinished(testCase, 0, 1, 1, 0));
SendStopMessages(testCase, messageBus);
}
private static Task <Result <Option <object>, TestFailure> > FailTest(IntegrationTestCase testCase, IMessageBus messageBus, string errorMessage)
{
var test = new IntegrationTest(testCase);
SendStartMessages(testCase, messageBus);
messageBus.QueueMessage(new TestCaseStarting(testCase));
messageBus.QueueMessage(new TestStarting(test));
messageBus.QueueMessage(new TestFailed(test, 0, null, new[] { typeof(InvalidOperationException).FullName }, new[] { errorMessage }, new[] { "" }, new[] { -1 }));
messageBus.QueueMessage(new TestFinished(test, 0, null));
messageBus.QueueMessage(new TestCaseFinished(testCase, 0, 1, 1, 0));
SendStopMessages(testCase, messageBus);
return(Task.FromResult(Result.Failure <Option <object>, TestFailure>(new TestFailure(new InvalidOperationException(errorMessage)))));
}
protected override bool FindTestsForType(ITestClass classInfo, bool includeSourceInformation, IMessageBus messageBus, ITestFrameworkDiscoveryOptions discoveryOptions)
{
foreach (var method in classInfo.Class.GetMethods(true))
{
if (method.IsAbstract || method.IsGenericMethodDefinition)
{
continue;
}
if (!method.IsIntegrationTest())
{
continue;
}
var testCollection = new TestCollection(_testAssembly, null, String.Empty);
var testClass = new TestClass(testCollection, classInfo.Class);
var testMethod = new TestMethod(testClass, method);
var runtimeMethod = method.ToRuntimeMethod();
var error = runtimeMethod
.GetParameters()
.Select(p => p.GetFromAttribute())
.TakeUntilFailure()
.Match(_ => null, _ => _);
if (error == null)
{
var testCase = new IntegrationTestCase(DiagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), discoveryOptions.MethodDisplayOptionsOrDefault(), testMethod);
messageBus.QueueMessage(new TestCaseDiscoveryMessage(testCase));
}
else
{
var testCase = new ErrorIntegrationTestCase(DiagnosticMessageSink, TestMethodDisplay.ClassAndMethod, TestMethodDisplayOptions.None, testMethod, error);
messageBus.QueueMessage(new TestCaseDiscoveryMessage(testCase));
}
}
return(true);
}
private static async Task <Result <Option <object>, TestFailure> > ExecuteTest(IntegrationTestCase testCase, IMessageBus messageBus, object[] methodArguments, object[] constructorArguments, CancellationTokenSource cancellationTokenSource)
{
SendStartMessages(testCase, messageBus);
var result = await testCase.Execute(constructorArguments, methodArguments, messageBus, new ExceptionAggregator(), cancellationTokenSource);
SendStopMessages(testCase, messageBus);
return(result);
}
private static void SendStopMessages(IntegrationTestCase testCase, IMessageBus messageBus)
{
messageBus.QueueMessage(new TestMethodFinished(new[] { testCase }, testCase.TestMethod, 0, 1, 1, 0));
messageBus.QueueMessage(new TestClassFinished(new[] { testCase }, testCase.TestMethod.TestClass, 0, 1, 1, 0));
messageBus.QueueMessage(new TestCollectionFinished(new[] { testCase }, testCase.TestMethod.TestClass.TestCollection, 0, 1, 1, 0));
}
private static void SendStartMessages(IntegrationTestCase testCase, IMessageBus messageBus)
{
messageBus.QueueMessage(new TestCollectionStarting(new[] { testCase }, testCase.TestMethod.TestClass.TestCollection));
messageBus.QueueMessage(new TestClassStarting(new[] { testCase }, testCase.TestMethod.TestClass));
messageBus.QueueMessage(new TestMethodStarting(new[] { testCase }, testCase.TestMethod));
}
public IntegrationTest(IntegrationTestCase testCase)
: base(testCase, testCase.DisplayName)
{
}
