public void BusShouldReportShutdownWhenMessageSinkReturnsFalse()
{
using (var bus = new SynchronousMessageBus(SpyMessageSink.Create(returnResult: false)))
{
Assert.False(bus.QueueMessage(Substitute.For <IMessageSinkMessage>()));
}
}
public async void CanRunTests()
{
Assert.SkipWhen(EnvironmentHelper.IsMono, "Mono does not fully support dynamic assemblies");
var assemblyInfo = new ReflectionAssemblyInfo(fixture.Assembly);
await using var disposalTracker = new DisposalTracker();
var testFramework = ExtensibilityPointFactory.GetTestFramework(assemblyInfo);
disposalTracker.Add(testFramework);
var messages = new List <_MessageSinkMessage>();
var testExecutor = testFramework.GetExecutor(assemblyInfo);
await testExecutor.RunAll(SpyMessageSink.Create(messages: messages), _TestFrameworkOptions.ForDiscovery(), _TestFrameworkOptions.ForExecution());
var assemblyStarting = Assert.Single(messages.OfType <_TestAssemblyStarting>());
Assert.Equal("DynamicAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null", assemblyStarting.AssemblyName);
Assert.Null(assemblyStarting.AssemblyPath);
Assert.Null(assemblyStarting.ConfigFilePath);
Assert.Single(messages.OfType <_TestFailed>());
Assert.Single(messages.OfType <_TestPassed>());
Assert.Empty(messages.OfType <_TestSkipped>());
}
public async ValueTask TheoryAcceptanceTest()
{
var code = @"
module FSharpTests
open Xunit
[<Theory>]
[<InlineData(42)>]
[<InlineData(2112)>]
let TestMethod(x : int) =
Assert.Equal(2112, x)
";
using var assembly = await FSharpAcceptanceTestV2Assembly.Create(code.Replace("\t", " "));
var controller = TestableXunit2.Create(assembly.FileName, null, true);
var settings = new FrontControllerFindAndRunSettings(_TestFrameworkOptions.ForDiscovery(), _TestFrameworkOptions.ForExecution());
using var sink = SpyMessageSink <_TestAssemblyFinished> .Create();
controller.FindAndRun(sink, settings);
sink.Finished.WaitOne();
Assert.Empty(sink.Messages.OfType <_TestSkipped>());
var passedTest = Assert.Single(sink.Messages.OfType <_TestPassed>());
var passedMetadata = sink.Messages.OfType <_TestStarting>().Single(ts => ts.TestUniqueID == passedTest.TestUniqueID);
Assert.Equal("FSharpTests.TestMethod(x: 2112)", passedMetadata.TestDisplayName);
var failedTest = Assert.Single(sink.Messages.OfType <_TestFailed>());
var failedMetadata = sink.Messages.OfType <_TestStarting>().Single(ts => ts.TestUniqueID == failedTest.TestUniqueID);
Assert.Equal("FSharpTests.TestMethod(x: 42)", failedMetadata.TestDisplayName);
}
public async ValueTask TheoryAcceptanceTest()
{
var code = @"
using System;
using Xunit;
public class TestClass
{
[Theory]
[InlineData(42)]
[InlineData(2112)]
public void TestMethod(int x) { Assert.Equal(2112, x); }
}";
using var assembly = await CSharpAcceptanceTestV2Assembly.Create(code);
var controller = TestableXunit2.Create(assembly.FileName, null, true);
var settings = new FrontControllerFindAndRunSettings(_TestFrameworkOptions.ForDiscovery(), _TestFrameworkOptions.ForExecution());
using var sink = SpyMessageSink <_TestAssemblyFinished> .Create();
controller.FindAndRun(sink, settings);
sink.Finished.WaitOne();
Assert.Empty(sink.Messages.OfType <_TestSkipped>());
var passedTest = Assert.Single(sink.Messages.OfType <_TestPassed>());
var passedMetadata = sink.Messages.OfType <_TestStarting>().Single(ts => ts.TestUniqueID == passedTest.TestUniqueID);
Assert.Equal("TestClass.TestMethod(x: 2112)", passedMetadata.TestDisplayName);
var failedTest = Assert.Single(sink.Messages.OfType <_TestFailed>());
var failedMetadata = sink.Messages.OfType <_TestStarting>().Single(ts => ts.TestUniqueID == failedTest.TestUniqueID);
Assert.Equal("TestClass.TestMethod(x: 42)", failedMetadata.TestDisplayName);
}
public static async ValueTask FailureInBeforeTestAssemblyFinished_ReportsCleanupFailure_DoesNotIncludeExceptionsFromAfterTestAssemblyStarting()
{
var thisAssembly = Assembly.GetExecutingAssembly();
var messages = new List <_MessageSinkMessage>();
var messageSink = SpyMessageSink.Create(messages: messages);
var testCases = new[] { TestCaseForTestCollection() };
await using var runner = TestableTestAssemblyRunner.Create(messageSink, testCases: testCases);
var startingException = new DivideByZeroException();
var finishedException = new InvalidOperationException();
runner.AfterTestAssemblyStarting_Callback = aggregator => aggregator.Add(startingException);
runner.BeforeTestAssemblyFinished_Callback = aggregator => aggregator.Add(finishedException);
await runner.RunAsync();
var assemblyStarting = Assert.Single(messages.OfType <_TestAssemblyStarting>());
var cleanupFailure = Assert.Single(messages.OfType <_TestAssemblyCleanupFailure>());
#if NETFRAMEWORK
Assert.Equal(thisAssembly.GetLocalCodeBase(), assemblyStarting.AssemblyPath);
Assert.Equal(runner.TestAssembly.ConfigFileName, assemblyStarting.ConfigFilePath);
#endif
Assert.Equal(typeof(InvalidOperationException).FullName, cleanupFailure.ExceptionTypes.Single());
}
public async ValueTask AsyncAcceptanceTest()
{
var code = @"
module FSharpTests
open Xunit
[<Fact>]
let AsyncFailing() =
async {
do! Async.Sleep(10)
Assert.True(false)
}
";
using var assembly = await FSharpAcceptanceTestV2Assembly.Create(code.Replace("\t", " "));
var controller = TestableXunit2.Create(assembly.FileName, null, true);
using var sink = SpyMessageSink <_TestAssemblyFinished> .Create();
var settings = new FrontControllerFindAndRunSettings(_TestFrameworkOptions.ForDiscovery(), _TestFrameworkOptions.ForExecution());
controller.FindAndRun(sink, settings);
sink.Finished.WaitOne();
var failures = sink.Messages.OfType <_TestFailed>();
var failure = Assert.Single(failures);
var failureStarting = sink.Messages.OfType <_TestStarting>().Single(s => s.TestUniqueID == failure.TestUniqueID);
Assert.Equal("FSharpTests.AsyncFailing", failureStarting.TestDisplayName);
}
public static async void FailureInBeforeTestAssemblyFinished_ReportsCleanupFailure_DoesNotIncludeExceptionsFromAfterTestAssemblyStarting()
{
var thisAssembly = Assembly.GetExecutingAssembly();
var thisAppDomain = AppDomain.CurrentDomain;
var messages = new List <IMessageSinkMessage>();
var messageSink = SpyMessageSink.Create(messages: messages);
var testCases = new[] { Mocks.TestCase() };
var runner = TestableTestAssemblyRunner.Create(messageSink, testCases: testCases);
var startingException = new DivideByZeroException();
var finishedException = new InvalidOperationException();
runner.AfterTestAssemblyStarting_Callback = aggregator => aggregator.Add(startingException);
runner.BeforeTestAssemblyFinished_Callback = aggregator => aggregator.Add(finishedException);
await runner.RunAsync();
var cleanupFailure = Assert.Single(messages.OfType <ITestAssemblyCleanupFailure>());
#if NETFRAMEWORK
Assert.Equal(thisAssembly.GetLocalCodeBase(), cleanupFailure.TestAssembly.Assembly.AssemblyPath);
Assert.Equal(thisAppDomain.SetupInformation.ConfigurationFile, cleanupFailure.TestAssembly.ConfigFileName);
#endif
Assert.Equal(testCases, cleanupFailure.TestCases);
Assert.Equal(typeof(InvalidOperationException).FullName, cleanupFailure.ExceptionTypes.Single());
}
public static void Timeout()
{
var testMethod = Mocks.TestMethod(timeout: 42);
var testCase = new XunitTestCase(SpyMessageSink.Create(), TestMethodDisplay.ClassAndMethod, TestMethodDisplayOptions.None, testMethod);
Assert.Equal(42, testCase.Timeout);
}
public static void CustomDisplayName()
{
var testMethod = Mocks.TestMethod(displayName: "Custom Display Name");
var testCase = new XunitTestCase(SpyMessageSink.Create(), TestMethodDisplay.ClassAndMethod, testMethod);
Assert.Equal("Custom Display Name", testCase.DisplayName);
}
public static void OrderIsUnpredictable()
{
var orderer = new DefaultTestCaseOrderer(SpyMessageSink.Create());
var result = orderer.OrderTestCases(TestCases);
Assert.NotEqual(TestCases, result);
}
public static void SkipReason()
{
var testMethod = Mocks.TestMethod("MockType", "MockMethod", skip: "Skip Reason");
var testCase = new XunitTestCase(SpyMessageSink.Create(), TestMethodDisplay.ClassAndMethod, testMethod);
Assert.Equal("Skip Reason", testCase.SkipReason);
}
TestableXunitTestAssemblyRunner(ITestAssembly testAssembly,
IEnumerable <IXunitTestCase> testCases,
List <IMessageSinkMessage> diagnosticMessages,
IMessageSink executionMessageSink,
ITestFrameworkExecutionOptions executionOptions)
: base(testAssembly, testCases, SpyMessageSink.Create(messages: diagnosticMessages), executionMessageSink, executionOptions)
{
DiagnosticMessages = diagnosticMessages;
}
public static async ValueTask Cancellation_TestAssemblyStarting_DoesNotCallExtensibilityCallbacks()
{
var messageSink = SpyMessageSink.Create(msg => !(msg is _TestAssemblyStarting));
var runner = TestableTestAssemblyRunner.Create(messageSink);
await runner.RunAsync();
Assert.False(runner.AfterTestAssemblyStarting_Called);
Assert.False(runner.BeforeTestAssemblyFinished_Called);
}
public static TestableXunitDelayEnumeratedTheoryTestCaseRunner Create <TClassUnderTest>(
string methodName,
IMessageBus messageBus,
string displayName = "MockDisplayName") =>
new TestableXunitDelayEnumeratedTheoryTestCaseRunner(
TestData.XunitTestCase <TClassUnderTest>(methodName),
displayName,
SpyMessageSink.Create(),
messageBus
);
public static async void Cancellation_TestAssemblyFinished_CallsCallExtensibilityCallbacks()
{
var messageSink = SpyMessageSink.Create(msg => !(msg is ITestAssemblyFinished));
var runner = TestableTestAssemblyRunner.Create(messageSink);
await runner.RunAsync();
Assert.True(runner.AfterTestAssemblyStarting_Called);
Assert.True(runner.BeforeTestAssemblyFinished_Called);
}
public void MessagesAreDispatchedImmediatelyFromBus()
{
var msg1 = new _MessageSinkMessage();
var dispatchedMessages = new List <_MessageSinkMessage>();
using (var bus = new SynchronousMessageBus(SpyMessageSink.Create(messages: dispatchedMessages)))
Assert.True(bus.QueueMessage(msg1));
Assert.Collection(dispatchedMessages, message => Assert.Same(msg1, message));
}
public static void GuardClause()
{
var assembly = Substitute.For <IAssemblyInfo>();
var sourceProvider = Substitute.For <ISourceInformationProvider>();
var diagnosticMessageSink = SpyMessageSink.Create();
Assert.Throws <ArgumentNullException>("assemblyInfo", () => new XunitTestFrameworkDiscoverer(null, sourceProvider, diagnosticMessageSink));
Assert.Throws <ArgumentNullException>("sourceProvider", () => new XunitTestFrameworkDiscoverer(assembly, null, diagnosticMessageSink));
Assert.Throws <ArgumentNullException>("diagnosticMessageSink", () => new XunitTestFrameworkDiscoverer(assembly, sourceProvider, null));
}
public static void DefaultBehavior()
{
var testMethod = Mocks.TestMethod("MockType", "MockMethod");
var testCase = new XunitTestCase(SpyMessageSink.Create(), TestMethodDisplay.ClassAndMethod, testMethod);
Assert.Equal("MockType.MockMethod", testCase.DisplayName);
Assert.Null(testCase.SkipReason);
Assert.Empty(testCase.Traits);
}
public static void TraitsOnTestClass()
{
var trait1 = Mocks.TraitAttribute("Trait1", "Value1");
var trait2 = Mocks.TraitAttribute("Trait2", "Value2");
var testMethod = Mocks.TestMethod(classAttributes: new[] { trait1, trait2 });
var testCase = new XunitTestCase(SpyMessageSink.Create(), TestMethodDisplay.ClassAndMethod, testMethod);
Assert.Equal("Value1", Assert.Single(testCase.Traits["Trait1"]));
Assert.Equal("Value2", Assert.Single(testCase.Traits["Trait2"]));
}
public static void OrderIsStable()
{
var orderer = new DefaultTestCaseOrderer(SpyMessageSink.Create());
var result1 = orderer.OrderTestCases(TestCases);
var result2 = orderer.OrderTestCases(TestCases);
var result3 = orderer.OrderTestCases(TestCases);
Assert.Equal(result1, result2);
Assert.Equal(result2, result3);
}
TestableXunitTestCollectionRunner(ITestCollection testCollection,
IEnumerable <IXunitTestCase> testCases,
List <IMessageSinkMessage> diagnosticMessages,
IMessageBus messageBus,
ITestCaseOrderer testCaseOrderer,
ExceptionAggregator aggregator,
CancellationTokenSource cancellationTokenSource)
: base(testCollection, testCases, SpyMessageSink.Create(messages: diagnosticMessages), messageBus, testCaseOrderer, aggregator, cancellationTokenSource)
{
DiagnosticMessages = diagnosticMessages;
}
public static void UsingTestCollectionDefinitionSetsTypeInfo()
{
var testType = Mocks.TypeInfo("type", attributes: new[] { Mocks.CollectionAttribute("This is a test collection") });
var collectionDefinitionType = Mocks.TypeInfo("collectionDefinition", attributes: new[] { Mocks.CollectionDefinitionAttribute("This is a test collection") });
var assembly = Mocks.TestAssembly(@"C:\Foo\bar.dll", types: new[] { collectionDefinitionType });
var factory = new CollectionPerAssemblyTestCollectionFactory(assembly, SpyMessageSink.Create());
var result = factory.Get(testType);
Assert.Same(collectionDefinitionType, result.CollectionDefinition);
}
public void TryingToQueueMessageAfterDisposingThrows()
{
var bus = new MessageBus(SpyMessageSink.Create());
bus.Dispose();
var exception = Record.Exception(
() => bus.QueueMessage(Substitute.For <IMessageSinkMessage>())
);
Assert.IsType <ObjectDisposedException>(exception);
}
public static TestableXunitTestCollectionRunner Create(IXunitTestCase testCase)
{
return(new TestableXunitTestCollectionRunner(
testCase.TestMethod.TestClass.TestCollection,
new[] { testCase },
SpyMessageSink.Create(),
new SpyMessageBus(),
new MockTestCaseOrderer(),
new ExceptionAggregator(),
new CancellationTokenSource()
));
}
public static void CustomDisplayNameWithArguments()
{
var param1 = Mocks.ParameterInfo("p1");
var param2 = Mocks.ParameterInfo("p2");
var param3 = Mocks.ParameterInfo("p3");
var testMethod = Mocks.TestMethod(displayName: "Custom Display Name", parameters: new[] { param1, param2, param3 });
var arguments = new object[] { 42, "Hello, world!", 'A' };
var testCase = new XunitTestCase(SpyMessageSink.Create(), TestMethodDisplay.ClassAndMethod, testMethod, arguments);
Assert.Equal("Custom Display Name(p1: 42, p2: \"Hello, world!\", p3: 'A')", testCase.DisplayName);
}
public async void FactWithoutParameters_ReturnsTestCaseThatRunsFact()
{
var discoverer = TestableFactDiscoverer.Create();
var testMethod = Mocks.TestMethod(typeof(ClassUnderTest), "FactWithNoParameters");
var testCases = discoverer.Discover(options, testMethod, factAttribute);
var testCase = Assert.Single(testCases);
await testCase.RunAsync(SpyMessageSink.Create(), messageBus, new object[0], aggregator, cancellationTokenSource);
Assert.Single(messageBus.Messages.OfType <ITestPassed>());
}
public static TestableXunitTheoryTestCaseRunner Create <TClassUnderTest>(string methodName, IMessageBus messageBus, string displayName = null)
{
return(new TestableXunitTheoryTestCaseRunner(
Mocks.XunitTestCase <TClassUnderTest>(methodName),
displayName,
null,
new object[0],
SpyMessageSink.Create(),
messageBus,
new ExceptionAggregator(),
new CancellationTokenSource()
));
}
public static void ReturnsDefaultTestCollectionForUndecoratedTestClass()
{
var type1 = Mocks.TypeInfo("type1");
var type2 = Mocks.TypeInfo("type2");
var assembly = Mocks.TestAssembly(@"C:\Foo\bar.dll");
var factory = new CollectionPerAssemblyTestCollectionFactory(assembly, SpyMessageSink.Create());
var result1 = factory.Get(type1);
var result2 = factory.Get(type2);
Assert.Same(result1, result2);
Assert.Equal("Test collection for bar.dll", result1.DisplayName);
}
TestableXunitTestClassRunner(ITestClass testClass,
IReflectionTypeInfo @class,
IEnumerable <IXunitTestCase> testCases,
List <IMessageSinkMessage> diagnosticMessages,
IMessageBus messageBus,
ITestCaseOrderer testCaseOrderer,
ExceptionAggregator aggregator,
CancellationTokenSource cancellationTokenSource,
IDictionary <Type, object> collectionFixtureMappings)
: base(testClass, @class, testCases, SpyMessageSink.Create(messages: diagnosticMessages), messageBus, testCaseOrderer, aggregator, cancellationTokenSource, collectionFixtureMappings)
{
DiagnosticMessages = diagnosticMessages;
}
public void SerializationTestsForXunitTestCase()
{
var messageSink = SpyMessageSink.Create();
var testMethod = Mocks.TestMethod <ClassWithSingleTest>(nameof(ClassWithSingleTest.TestMethod));
var testCase = new XunitTestCase(messageSink, TestMethodDisplay.ClassAndMethod, TestMethodDisplayOptions.None, testMethod);
framework.ReportDiscoveredTestCase_Public(testCase, includeSourceInformation: true, messageBus);
var msg = Assert.Single(messageBus.Messages);
var discoveryMsg = Assert.IsAssignableFrom <_TestCaseDiscovered>(msg);
Assert.Equal(":F:XunitTestFrameworkDiscovererTests+ClassWithSingleTest:TestMethod:1:0:0:(null)", discoveryMsg.Serialization);
}
