public FactDiscovererTests()
{
aggregator = new ExceptionAggregator();
cancellationTokenSource = new CancellationTokenSource();
factAttribute = Mocks.FactAttribute();
messageBus = new SpyMessageBus();
options = TestFrameworkOptions.ForDiscovery();
}
public static async void Cancellation_TriggersCancellationTokenSource(Type messageTypeToCancelOn)
{
var messageBus = new SpyMessageBus(msg => !(messageTypeToCancelOn.IsAssignableFrom(msg.GetType())));
var runner = TestableTestCaseRunner.Create(messageBus);
await runner.RunAsync();
Assert.True(runner.TokenSource.IsCancellationRequested);
}
public async void Cancellation_TriggersCancellationTokenSource(Type messageTypeToCancelOn)
{
var testCase = Mocks.ExecutionErrorTestCase("This is my error message");
var messageBus = new SpyMessageBus(msg => !(messageTypeToCancelOn.IsAssignableFrom(msg.GetType())));
var runner = new ExecutionErrorTestCaseRunner(testCase, messageBus, aggregator, tokenSource);
await runner.RunAsync();
Assert.True(tokenSource.IsCancellationRequested);
}
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 DisposesArguments()
{
ClassUnderTest.DataWasDisposed = false;
var messageBus = new SpyMessageBus();
var runner = TestableXunitDelayEnumeratedTheoryTestCaseRunner.Create <ClassUnderTest>("TestWithDisposableData", messageBus);
await runner.RunAsync();
Assert.True(ClassUnderTest.DataWasDisposed);
}
public async void Cancellation_TriggersCancellationTokenSource(Type messageTypeToCancelOn)
{
var testCase = Mocks.ExecutionErrorTestCase("This is my error message");
var messageBus = new SpyMessageBus(msg => !(messageTypeToCancelOn.IsAssignableFrom(msg.GetType())));
var runner = new ExecutionErrorTestCaseRunner(testCase, messageBus, aggregator, tokenSource);
await runner.RunAsync();
Assert.True(tokenSource.IsCancellationRequested);
}
public static async void Cancellation_TestCaseFinished_CallsExtensibilityMethods()
{
var messageBus = new SpyMessageBus(msg => !(msg is ITestCaseFinished));
var runner = TestableTestCaseRunner.Create(messageBus);
await runner.RunAsync();
Assert.True(runner.AfterTestCaseStarting_Called);
Assert.True(runner.BeforeTestCaseFinished_Called);
}
public async void Cancellation_TriggersCancellationTokenSource(Type messageTypeToCancelOn, bool shouldTestPass)
{
var testCase = Mocks.LambdaTestCase(() => Assert.True(shouldTestPass));
var messageBus = new SpyMessageBus(msg => !(messageTypeToCancelOn.IsAssignableFrom(msg.GetType())));
var runner = new LambdaTestCaseRunner(testCase, messageBus, aggregator, tokenSource);
await runner.RunAsync();
Assert.True(tokenSource.IsCancellationRequested);
}
public static async void Cancellation_TestMethodStarting_DoesNotCallExtensibilityMethods()
{
var messageBus = new SpyMessageBus(msg => !(msg is ITestMethodStarting));
var runner = TestableTestMethodRunner.Create(messageBus);
await runner.RunAsync();
Assert.True(runner.TokenSource.IsCancellationRequested);
Assert.False(runner.AfterTestMethodStarting_Called);
Assert.False(runner.BeforeTestMethodFinished_Called);
}
public static async void Cancellation_TestClassFinished_CallsExtensibilityCallbacks()
{
var messageBus = new SpyMessageBus(msg => !(msg is ITestClassFinished));
var runner = TestableTestClassRunner.Create(messageBus);
await runner.RunAsync();
Assert.True(runner.TokenSource.IsCancellationRequested);
Assert.True(runner.AfterTestClassStarting_Called);
Assert.True(runner.BeforeTestClassFinished_Called);
}
public static async void Cancellation_TestClassCleanupFailure_SetsCancellationToken()
{
var messageBus = new SpyMessageBus(msg => !(msg is ITestClassCleanupFailure));
var runner = TestableTestClassRunner.Create(messageBus);
runner.BeforeTestClassFinished_Callback = aggregator => aggregator.Add(new Exception());
await runner.RunAsync();
Assert.True(runner.TokenSource.IsCancellationRequested);
}
public async void ThrowingEnumerator()
{
var messageBus = new SpyMessageBus();
var runner = TestableXunitTheoryTestCaseRunner.Create <ClassWithThrowingEnumerator>("Test", messageBus, "Display Name");
var summary = await runner.RunAsync();
var passed = messageBus.Messages.OfType <ITestPassed>().Single();
Assert.Equal("Display Name(c: [ClassWithThrowingEnumerator { }])", passed.Test.DisplayName);
}
public static async void RunTestMethodAsync_AggregatorIncludesPassedInExceptions()
{
var messageBus = new SpyMessageBus();
var ex = new DivideByZeroException();
var runner = TestableTestClassRunner.Create(messageBus, aggregatorSeedException: ex);
await runner.RunAsync();
Assert.Same(ex, runner.RunTestMethodAsync_AggregatorResult);
Assert.Empty(messageBus.Messages.OfType <ITestClassCleanupFailure>());
}
public static async void NotEnoughParameterValues()
{
var messageBus = new SpyMessageBus();
var invoker = TestableTestInvoker.Create <NonDisposableClass>("FactWithParameter", messageBus);
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 messageBus = new SpyMessageBus();
var invoker = TestableTestInvoker.Create <NonDisposableClass>("Passing", messageBus, 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 Cancellation_AllOthers_CallsExtensibilityMethods(Type messageTypeToCancelOn, bool shouldTestPass, string skipReason = null)
{
var messageBus = new SpyMessageBus(msg => !(messageTypeToCancelOn.IsAssignableFrom(msg.GetType())));
var runner = TestableTestRunner.Create(messageBus, skipReason: skipReason, lambda: () => Assert.True(shouldTestPass));
await runner.RunAsync();
Assert.True(runner.TokenSource.IsCancellationRequested);
Assert.True(runner.AfterTestStarting_Called);
Assert.True(runner.BeforeTestFinished_Called);
}
public static async void Output()
{
var messageBus = new SpyMessageBus();
var runner = TestableTestRunner.Create(messageBus, output: "This is my text output");
await runner.RunAsync();
var passed = messageBus.Messages.OfType <ITestPassed>().Single();
Assert.Equal("This is my text output", passed.Output);
}
public async void ThrowingToString()
{
var messageBus = new SpyMessageBus();
var runner = TestableXunitTheoryTestCaseRunner.Create <ClassWithThrowingToString>("Test", messageBus, "Display Name");
var summary = await runner.RunAsync();
var passed = messageBus.Messages.OfType <ITestPassed>().Single();
Assert.Equal("Display Name(c: TargetInvocationException was thrown formatting an object of type \"XunitTheoryTestCaseRunnerTests+ClassWithThrowingToString\")", passed.Test.DisplayName);
}
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 async void ThrowingToString()
{
var messageBus = new SpyMessageBus();
var runner = TestableXunitDelayEnumeratedTheoryTestCaseRunner.Create <ClassWithThrowingToString>("Test", messageBus, "Display Name");
await runner.RunAsync();
var passed = messageBus.Messages.OfType <_TestPassed>().Single();
var passedStarting = messageBus.Messages.OfType <_TestStarting>().Where(ts => ts.TestUniqueID == passed.TestUniqueID).Single();
Assert.Equal("Display Name(c: TargetInvocationException was thrown formatting an object of type \"XunitDelayEnumeratedTheoryTestCaseRunnerTests+ClassWithThrowingToString\")", passedStarting.TestDisplayName);
}
public async void ThrowingEnumerator()
{
var messageBus = new SpyMessageBus();
var runner = TestableXunitDelayEnumeratedTheoryTestCaseRunner.Create <ClassWithThrowingEnumerator>("Test", messageBus, "Display Name");
var summary = await runner.RunAsync();
var passed = messageBus.Messages.OfType <_TestPassed>().Single();
var passedStarting = messageBus.Messages.OfType <_TestStarting>().Where(ts => ts.TestUniqueID == passed.TestUniqueID).Single();
Assert.Equal("Display Name(c: [ClassWithThrowingEnumerator { }])", passedStarting.TestDisplayName);
}
public static async void WithPreSeededException_ReturnsTestFailed_NoCleanupFailureMessage()
{
var messageBus = new SpyMessageBus();
var ex = new DivideByZeroException();
var runner = TestableTestRunner.Create(messageBus, aggregatorSeedException: ex);
await runner.RunAsync();
var failed = Assert.Single(messageBus.Messages.OfType <ITestFailed>());
Assert.Equal(typeof(DivideByZeroException).FullName, failed.ExceptionTypes.Single());
Assert.Empty(messageBus.Messages.OfType <ITestCleanupFailure>());
}
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 FailureInAfterTestClassStarting_GivesErroredAggregatorToTestMethodRunner_NoCleanupFailureMessage()
{
var messageBus = new SpyMessageBus();
var runner = TestableTestClassRunner.Create(messageBus);
var ex = new DivideByZeroException();
runner.AfterTestClassStarting_Callback = aggregator => aggregator.Add(ex);
await runner.RunAsync();
Assert.Same(ex, runner.RunTestMethodAsync_AggregatorResult);
Assert.Empty(messageBus.Messages.OfType <ITestClassCleanupFailure>());
}
public static async void CancellationRequested_DoesNotInvokeTestMethod()
{
var messageBus = new SpyMessageBus();
var invoker = TestableTestInvoker.Create <NonDisposableClass>("Failing", messageBus);
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 DiscovererWhichThrowsReturnsASingleFailedTest()
{
var testCase = TestableXunitTheoryTestCase.Create(typeof(ClassUnderTest), "TestWithThrowingData");
var bus = new SpyMessageBus<ITestCaseFinished>();
await testCase.RunAsync(bus);
bus.Finished.WaitOne();
var resultMessages = bus.Messages.OfType<ITestResultMessage>();
var failed = (ITestFailed)Assert.Single(resultMessages);
Assert.Equal("XunitTheoryTestCaseTests+RunAsync+ClassUnderTest.TestWithThrowingData", failed.TestDisplayName);
Assert.Equal("System.DivideByZeroException : Attempted to divide by zero.", failed.Message);
Assert.Contains("XunitTheoryTestCaseTests.RunAsync.ClassUnderTest.get_ThrowingData()", failed.StackTrace);
}
public ReportDiscoveredTestCase()
{
messageBus = new SpyMessageBus();
var sourceProvider = Substitute.For <_ISourceInformationProvider>();
sourceProvider
.GetSourceInformation(null, null)
.ReturnsForAnyArgs(new _SourceInformation {
FileName = "Source File", LineNumber = 42
});
framework = TestableXunitTestFrameworkDiscoverer.Create(sourceProvider: sourceProvider);
}
public static async void Success()
{
var messageBus = new SpyMessageBus();
var attribute = new SpyBeforeAfterTest();
var invoker = TestableXunitTestInvoker.Create(messageBus, "Display Name", new List <BeforeAfterTestAttribute> {
attribute
});
await invoker.RunAsync();
Assert.Null(invoker.Aggregator.ToException());
Assert.Collection(messageBus.Messages,
msg => Assert.IsAssignableFrom <ITestClassConstructionStarting>(msg), // From TestInvoker
msg => Assert.IsAssignableFrom <ITestClassConstructionFinished>(msg), // From TestInvoker
msg =>
{
var beforeStarting = Assert.IsAssignableFrom <IBeforeTestStarting>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, beforeStarting.TestCollection);
Assert.Same(invoker.TestCase, beforeStarting.TestCase);
Assert.Equal("Display Name", beforeStarting.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", beforeStarting.AttributeName);
},
msg =>
{
var beforeFinished = Assert.IsAssignableFrom <IBeforeTestFinished>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, beforeFinished.TestCollection);
Assert.Same(invoker.TestCase, beforeFinished.TestCase);
Assert.Equal("Display Name", beforeFinished.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", beforeFinished.AttributeName);
},
// Test method is invoked here; no directly observable message (tested below)
msg =>
{
var afterStarting = Assert.IsAssignableFrom <IAfterTestStarting>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, afterStarting.TestCollection);
Assert.Same(invoker.TestCase, afterStarting.TestCase);
Assert.Equal("Display Name", afterStarting.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", afterStarting.AttributeName);
},
msg =>
{
var afterFinished = Assert.IsAssignableFrom <IAfterTestFinished>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, afterFinished.TestCollection);
Assert.Same(invoker.TestCase, afterFinished.TestCase);
Assert.Equal("Display Name", afterFinished.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", afterFinished.AttributeName);
}
);
}
public async void EnumeratesDataAtRuntimeAndExecutesOneTestForEachDataRow()
{
var testCase = TestableXunitTheoryTestCase.Create(typeof(ClassUnderTest), "TestWithData");
var bus = new SpyMessageBus<ITestCaseFinished>();
await testCase.RunAsync(bus);
bus.Finished.WaitOne();
var resultMessages = bus.Messages.OfType<ITestResultMessage>();
Assert.Equal(2, resultMessages.Count());
var passed = (ITestPassed)Assert.Single(resultMessages, msg => msg is ITestPassed);
Assert.Equal("XunitTheoryTestCaseTests+RunAsync+ClassUnderTest.TestWithData(x: 42, y: 21.12, z: \"Hello\")", passed.TestDisplayName);
var failed = (ITestFailed)Assert.Single(resultMessages, msg => msg is ITestFailed);
Assert.Equal("XunitTheoryTestCaseTests+RunAsync+ClassUnderTest.TestWithData(x: 0, y: 0, z: \"World!\")", failed.TestDisplayName);
}
public void DiscovererWhichThrowsReturnsASingleFailedTest()
{
var testCase = TestableXunitTheoryTestCase.Create(typeof(ClassUnderTest), "TestWithThrowingData");
var bus = new SpyMessageBus <ITestCaseFinished>();
testCase.Run(bus);
bus.Finished.WaitOne();
var resultMessages = bus.Messages.OfType <ITestResultMessage>();
var failed = (ITestFailed)Assert.Single(resultMessages);
Assert.Equal("XunitTheoryTestCaseTests+Run+ClassUnderTest.TestWithThrowingData", failed.TestDisplayName);
Assert.Equal("System.DivideByZeroException : Attempted to divide by zero.", failed.Message);
Assert.Contains("XunitTheoryTestCaseTests.Run.ClassUnderTest.get_ThrowingData()", failed.StackTrace);
}
public static async void FailureInAfterTestStarting_ReturnsTestFailed_NoCleanupFailureMessage()
{
var messageBus = new SpyMessageBus();
var runner = TestableTestRunner.Create(messageBus);
var ex = new DivideByZeroException();
runner.AfterTestStarting_Callback = aggregator => aggregator.Add(ex);
await runner.RunAsync();
var failed = Assert.Single(messageBus.Messages.OfType <ITestFailed>());
Assert.Equal(typeof(DivideByZeroException).FullName, failed.ExceptionTypes.Single());
Assert.Empty(messageBus.Messages.OfType <ITestCleanupFailure>());
}
public static async void FailedBefore()
{
var messageBus = new SpyMessageBus();
var attribute = new SpyBeforeAfterTest { ThrowInBefore = true };
var invoker = TestableXunitTestInvoker.Create(messageBus, "Display Name", new List<BeforeAfterTestAttribute> { attribute }, lambda: () => Assert.True(false));
await invoker.RunAsync();
Assert.IsType<SpyBeforeAfterTest.BeforeException>(invoker.Aggregator.ToException());
Assert.Collection(messageBus.Messages,
msg => Assert.IsAssignableFrom<ITestClassConstructionStarting>(msg),
msg => Assert.IsAssignableFrom<ITestClassConstructionFinished>(msg),
msg => Assert.IsAssignableFrom<IBeforeTestStarting>(msg),
msg => Assert.IsAssignableFrom<IBeforeTestFinished>(msg)
);
}
public static async void Success()
{
var messageBus = new SpyMessageBus();
var attribute = new SpyBeforeAfterTest();
var invoker = TestableXunitTestInvoker.Create(messageBus, "Display Name", new List<BeforeAfterTestAttribute> { attribute });
await invoker.RunAsync();
Assert.Null(invoker.Aggregator.ToException());
Assert.Collection(messageBus.Messages,
msg => Assert.IsAssignableFrom<ITestClassConstructionStarting>(msg), // From TestInvoker
msg => Assert.IsAssignableFrom<ITestClassConstructionFinished>(msg), // From TestInvoker
msg =>
{
var beforeStarting = Assert.IsAssignableFrom<IBeforeTestStarting>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, beforeStarting.TestCollection);
Assert.Same(invoker.TestCase, beforeStarting.TestCase);
Assert.Equal("Display Name", beforeStarting.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", beforeStarting.AttributeName);
},
msg =>
{
var beforeFinished = Assert.IsAssignableFrom<IBeforeTestFinished>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, beforeFinished.TestCollection);
Assert.Same(invoker.TestCase, beforeFinished.TestCase);
Assert.Equal("Display Name", beforeFinished.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", beforeFinished.AttributeName);
},
// Test method is invoked here; no directly observable message (tested below)
msg =>
{
var afterStarting = Assert.IsAssignableFrom<IAfterTestStarting>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, afterStarting.TestCollection);
Assert.Same(invoker.TestCase, afterStarting.TestCase);
Assert.Equal("Display Name", afterStarting.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", afterStarting.AttributeName);
},
msg =>
{
var afterFinished = Assert.IsAssignableFrom<IAfterTestFinished>(msg);
Assert.Same(invoker.TestCase.TestMethod.TestClass.TestCollection, afterFinished.TestCollection);
Assert.Same(invoker.TestCase, afterFinished.TestCase);
Assert.Equal("Display Name", afterFinished.Test.DisplayName);
Assert.Equal("SpyBeforeAfterTest", afterFinished.AttributeName);
}
);
}
public void WriteLine(string outputText, string expected)
{
var output = new TestOutputHelper();
var messageBus = new SpyMessageBus();
var testCase = Mocks.TestCase();
var test = Mocks.Test(testCase, "Test Display Name");
output.Initialize(messageBus, test);
output.WriteLine(outputText);
var message = Assert.Single(messageBus.Messages);
var outputMessage = Assert.IsAssignableFrom <ITestOutput>(message);
Assert.Equal(expected + Environment.NewLine, outputMessage.Output);
Assert.Equal(expected + Environment.NewLine, output.Output);
}
public static async void EnumeratesDataAtRuntimeAndExecutesOneTestForEachDataRow()
{
var messageBus = new SpyMessageBus();
var runner = TestableXunitTheoryTestCaseRunner.Create <ClassUnderTest>("TestWithData", messageBus, "Display Name");
var summary = await runner.RunAsync();
Assert.NotEqual(0m, summary.Time);
Assert.Equal(2, summary.Total);
Assert.Equal(1, summary.Failed);
var passed = messageBus.Messages.OfType <ITestPassed>().Single();
Assert.Equal($"Display Name(x: 42, y: {21.12}, z: \"Hello\")", passed.Test.DisplayName);
var failed = messageBus.Messages.OfType <ITestFailed>().Single();
Assert.Equal("Display Name(x: 0, y: 0, z: \"World!\")", failed.Test.DisplayName);
}
public static async void FailureInBeforeTestCaseFinished_ReportsCleanupFailure_DoesNotIncludeExceptionsFromAfterTestCaseStarting()
{
var messageBus = new SpyMessageBus();
var testCase = Mocks.TestCase <TestAssemblyRunnerTests.RunAsync>("Messages");
var runner = TestableTestCaseRunner.Create(messageBus, testCase);
var startingException = new DivideByZeroException();
var finishedException = new InvalidOperationException();
runner.AfterTestCaseStarting_Callback = aggregator => aggregator.Add(startingException);
runner.BeforeTestCaseFinished_Callback = aggregator => aggregator.Add(finishedException);
await runner.RunAsync();
var cleanupFailure = Assert.Single(messageBus.Messages.OfType <_TestCaseCleanupFailure>());
Assert.Equal(typeof(InvalidOperationException).FullName, cleanupFailure.ExceptionTypes.Single());
}
public async void IssuesTestCaseMessagesAndCallsRunTests()
{
var testCase = TestableXunitTestCase.Create();
var bus = new SpyMessageBus<ITestCaseFinished>();
await testCase.RunAsync(bus);
bus.Finished.WaitOne();
Assert.Collection(bus.Messages,
message =>
{
var testCaseStarting = Assert.IsAssignableFrom<ITestCaseStarting>(message);
Assert.Same(testCase, testCaseStarting.TestCase);
},
message => Assert.IsType<SpyMessage>(message),
message =>
{
var testCaseFinished = Assert.IsAssignableFrom<ITestCaseFinished>(message);
Assert.Same(testCase, testCaseFinished.TestCase);
Assert.Equal(0, testCaseFinished.TestsRun);
Assert.Equal(0, testCaseFinished.TestsFailed);
Assert.Equal(0, testCaseFinished.TestsSkipped);
Assert.Equal(0M, testCaseFinished.ExecutionTime);
}
);
}
public async void CountsTestResultMessages()
{
var testCase = TestableXunitTestCase.Create(msgBus =>
{
msgBus.QueueMessage(Substitute.For<ITestResultMessage>());
msgBus.QueueMessage(Substitute.For<ITestPassed>());
msgBus.QueueMessage(Substitute.For<ITestFailed>());
msgBus.QueueMessage(Substitute.For<ITestSkipped>());
});
var bus = new SpyMessageBus<ITestCaseFinished>();
await testCase.RunAsync(bus);
bus.Finished.WaitOne();
var testCaseFinished = Assert.IsAssignableFrom<ITestCaseFinished>(bus.Messages.Last());
Assert.Equal(4, testCaseFinished.TestsRun);
}
public async void CountsTestsSkipped()
{
var testCase = TestableXunitTestCase.Create(msgBus =>
{
msgBus.QueueMessage(new TestSkipped());
msgBus.QueueMessage(new TestSkipped());
});
var bus = new SpyMessageBus<ITestCaseFinished>();
await testCase.RunAsync(bus);
bus.Finished.WaitOne();
var testCaseFinished = Assert.IsAssignableFrom<ITestCaseFinished>(bus.Messages.Last());
Assert.Equal(2, testCaseFinished.TestsSkipped);
}
public async void AggregatesTestRunTime()
{
var testCase = TestableXunitTestCase.Create(msgBus =>
{
msgBus.QueueMessage(new TestPassed { ExecutionTime = 1.2M });
msgBus.QueueMessage(new TestFailed { ExecutionTime = 2.3M });
});
var bus = new SpyMessageBus<ITestCaseFinished>();
await testCase.RunAsync(bus);
bus.Finished.WaitOne();
var testCaseFinished = Assert.IsAssignableFrom<ITestCaseFinished>(bus.Messages.Last());
Assert.Equal(3.5M, testCaseFinished.ExecutionTime);
}
public async void Cancellation_TriggersCancellationTokenSource(Type messageTypeToCancelOn, bool shouldTestPass)
{
var testCase = Mocks.LambdaTestCase(() => Assert.True(shouldTestPass));
var messageBus = new SpyMessageBus(msg => !(messageTypeToCancelOn.IsAssignableFrom(msg.GetType())));
var runner = new LambdaTestCaseRunner(testCase, messageBus, aggregator, tokenSource);
await runner.RunAsync();
Assert.True(tokenSource.IsCancellationRequested);
}
