public async void After_Failing_SeesCleaningUp()
{
var invoker = TestableTestInvoker.Create <NonDisposableClass>("Failing", displayName: "Test display name");
await invoker.RunAsync();
var context = invoker.AfterTestMethodInvoked_Context;
Assert.NotNull(context);
Assert.Equal(TestEngineStatus.Running, context.TestAssemblyStatus);
Assert.Equal(TestEngineStatus.Running, context.TestCollectionStatus);
Assert.Equal(TestEngineStatus.Running, context.TestClassStatus);
Assert.Equal(TestEngineStatus.Running, context.TestMethodStatus);
Assert.Equal(TestEngineStatus.Running, context.TestCaseStatus);
Assert.Equal(TestEngineStatus.CleaningUp, context.TestStatus);
var test = context.Test;
Assert.NotNull(test);
Assert.Equal("Test display name", test.DisplayName);
var testState = context.TestState;
Assert.NotNull(testState);
Assert.Equal(
"Assert.True() Failure" + Environment.NewLine +
"Expected: True" + Environment.NewLine +
"Actual: False",
Assert.Single(testState.ExceptionMessages !)
);
Assert.Equal(-1, Assert.Single(testState.ExceptionParentIndices !));
Assert.Single(testState.ExceptionStackTraces !);
Assert.Equal(typeof(TrueException).FullName, Assert.Single(testState.ExceptionTypes !));
Assert.True(testState.ExecutionTime > 0m);
Assert.Equal(FailureCause.Assertion, testState.FailureCause);
Assert.Equal(TestResult.Failed, testState.Result);
}
public async void After_Exception_SeesCleaningUp()
{
var invoker = TestableTestInvoker.Create <NonDisposableClass>("FactWithParameter", displayName: "Test display name");
await invoker.RunAsync();
var context = invoker.AfterTestMethodInvoked_Context;
Assert.NotNull(context);
Assert.Equal(TestEngineStatus.Running, context.TestAssemblyStatus);
Assert.Equal(TestEngineStatus.Running, context.TestCollectionStatus);
Assert.Equal(TestEngineStatus.Running, context.TestClassStatus);
Assert.Equal(TestEngineStatus.Running, context.TestMethodStatus);
Assert.Equal(TestEngineStatus.Running, context.TestCaseStatus);
Assert.Equal(TestEngineStatus.CleaningUp, context.TestStatus);
var test = context.Test;
Assert.NotNull(test);
Assert.Equal("Test display name", test.DisplayName);
var testState = context.TestState;
Assert.NotNull(testState);
Assert.Equal("The test method expected 1 parameter value, but 0 parameter values were provided.", Assert.Single(testState.ExceptionMessages !));
Assert.Equal(-1, Assert.Single(testState.ExceptionParentIndices !));
Assert.Single(testState.ExceptionStackTraces !);
Assert.Equal(typeof(InvalidOperationException).FullName, Assert.Single(testState.ExceptionTypes !));
Assert.True(testState.ExecutionTime > 0m);
Assert.Equal(FailureCause.Exception, testState.FailureCause);
Assert.Equal(TestResult.Failed, testState.Result);
}
public async void After_Passing_SeesCleaningUp()
{
var invoker = TestableTestInvoker.Create <NonDisposableClass>("Passing", displayName: "Test display name");
await invoker.RunAsync();
var context = invoker.AfterTestMethodInvoked_Context;
Assert.NotNull(context);
Assert.Equal(TestEngineStatus.Running, context.TestAssemblyStatus);
Assert.Equal(TestEngineStatus.Running, context.TestCollectionStatus);
Assert.Equal(TestEngineStatus.Running, context.TestClassStatus);
Assert.Equal(TestEngineStatus.Running, context.TestMethodStatus);
Assert.Equal(TestEngineStatus.Running, context.TestCaseStatus);
Assert.Equal(TestEngineStatus.CleaningUp, context.TestStatus);
var test = context.Test;
Assert.NotNull(test);
Assert.Equal("Test display name", test.DisplayName);
var testState = context.TestState;
Assert.NotNull(testState);
Assert.Null(testState.ExceptionMessages);
Assert.Null(testState.ExceptionParentIndices);
Assert.Null(testState.ExceptionStackTraces);
Assert.Null(testState.ExceptionTypes);
Assert.True(testState.ExecutionTime > 0m);
Assert.Null(testState.FailureCause);
Assert.Equal(TestResult.Passed, testState.Result);
}
public static async void CancellationRequested_DisposeCalledIfClassConstructed()
{
var classConstructed = false;
bool cancelThunk(_MessageSinkMessage msg)
{
if (msg is _TestClassConstructionFinished)
{
classConstructed = true;
}
return(!classConstructed);
}
var messageBus = new SpyMessageBus(cancelThunk);
var invoker = TestableTestInvoker.Create <DisposableClass>("Passing", messageBus, "Display Name");
await invoker.RunAsync();
Assert.Collection(
messageBus.Messages,
msg => Assert.IsType <_TestClassConstructionStarting>(msg),
msg => Assert.IsType <_TestClassConstructionFinished>(msg),
msg => Assert.IsType <_TestClassDisposeStarting>(msg),
msg => Assert.IsType <_TestClassDisposeFinished>(msg)
);
}
public static async void Messages_NonStaticTestMethod_WithDispose()
{
var messageBus = new SpyMessageBus();
var invoker = TestableTestInvoker.Create <DisposableClass>("Passing", messageBus, "Display Name");
await invoker.RunAsync();
Assert.Collection(messageBus.Messages,
msg => Assert.IsAssignableFrom <ITestClassConstructionStarting>(msg),
msg => Assert.IsAssignableFrom <ITestClassConstructionFinished>(msg),
msg =>
{
var starting = Assert.IsAssignableFrom <ITestClassDisposeStarting>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, starting.TestCollection);
Assert.Same(invoker.TestCase, starting.TestCase);
Assert.Equal("Display Name", starting.Test.DisplayName);
},
msg =>
{
var finished = Assert.IsAssignableFrom <ITestClassDisposeFinished>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, finished.TestCollection);
Assert.Same(invoker.TestCase, finished.TestCase);
Assert.Equal("Display Name", finished.Test.DisplayName);
}
);
}
public static async void Passing()
{
var invoker = TestableTestInvoker.Create <NonDisposableClass>("Passing");
var result = await invoker.RunAsync();
Assert.NotEqual(0m, result);
Assert.Null(invoker.Aggregator.ToException());
}
public static async void NotEnoughParameterValues()
{
var invoker = TestableTestInvoker.Create <NonDisposableClass>("FactWithParameter");
await invoker.RunAsync();
var ex = Assert.IsType <InvalidOperationException>(invoker.Aggregator.ToException());
Assert.Equal("The test method expected 1 parameter value, but 0 parameter values were provided.", ex.Message);
}
public static async void TooManyParameterValues()
{
var invoker = TestableTestInvoker.Create <NonDisposableClass>("Passing", testMethodArguments: new object[] { 42 });
await invoker.RunAsync();
var ex = Assert.IsType <InvalidOperationException>(invoker.Aggregator.ToException());
Assert.Equal("The test method expected 0 parameter values, but 1 parameter value was provided.", ex.Message);
}
public static async void Failing()
{
var messageBus = new SpyMessageBus();
var invoker = TestableTestInvoker.Create <NonDisposableClass>("Failing", messageBus);
var result = await invoker.RunAsync();
Assert.NotEqual(0m, result);
Assert.IsType <TrueException>(invoker.Aggregator.ToException());
}
public static async void Messages_StaticTestMethod()
{
var messageBus = new SpyMessageBus();
var invoker = TestableTestInvoker.Create <NonDisposableClass>("StaticPassing", messageBus);
await invoker.RunAsync();
Assert.Empty(messageBus.Messages);
Assert.True(invoker.BeforeTestMethodInvoked_Called);
Assert.True(invoker.AfterTestMethodInvoked_Called);
}
public static async ValueTask ClassCreationFailure_LogsExceptionIntoAggregator()
{
var invoker = TestableTestInvoker.Create <NonCreateableClass>("Passing");
await invoker.RunAsync();
var ex = invoker.Aggregator.ToException();
Assert.IsType <MissingMethodException>(ex);
Assert.Equal("Constructor on type 'TestInvokerTests+NonCreateableClass' not found.", ex.Message);
}
public static async void Messages_NonStaticTestMethod_NoDispose()
{
var messageBus = new SpyMessageBus();
var invoker = TestableTestInvoker.Create <NonDisposableClass>("Passing", messageBus, "Display Name");
await invoker.RunAsync();
Assert.Collection(
messageBus.Messages,
msg => Assert.IsType <_TestClassConstructionStarting>(msg),
msg => Assert.IsType <_TestClassConstructionFinished>(msg)
);
}
public static async void CancellationRequested_DoesNotInvokeTestMethod()
{
var invoker = TestableTestInvoker.Create <NonDisposableClass>("Failing");
invoker.TokenSource.Cancel();
var result = await invoker.RunAsync();
Assert.Equal(0m, result);
Assert.Null(invoker.Aggregator.ToException());
Assert.False(invoker.BeforeTestMethodInvoked_Called);
Assert.False(invoker.AfterTestMethodInvoked_Called);
}
public async void Executing_SeesRunning()
{
var invoker = TestableTestInvoker.Create <NonDisposableClass>("Passing", displayName: "Test display name");
await invoker.RunAsync();
var context = invoker.InvokeTestMethodAsync_Context;
Assert.NotNull(context);
Assert.Equal(TestEngineStatus.Running, context.TestAssemblyStatus);
Assert.Equal(TestEngineStatus.Running, context.TestCollectionStatus);
Assert.Equal(TestEngineStatus.Running, context.TestClassStatus);
Assert.Equal(TestEngineStatus.Running, context.TestMethodStatus);
Assert.Equal(TestEngineStatus.Running, context.TestCaseStatus);
Assert.Equal(TestEngineStatus.Running, context.TestStatus);
var test = context.Test;
Assert.NotNull(test);
Assert.Equal("Test display name", test.DisplayName);
Assert.Null(context.TestState);
}
