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); }