public void DefaultTestCollectionFactoryIsCollectionPerClass()
{
var assembly = Mocks.AssemblyInfo();
var sourceInfoProvider = Substitute.For <ISourceInformationProvider>();
var discoverer = new XunitTestFrameworkDiscoverer(assembly, sourceInfoProvider);
Assert.IsType <CollectionPerClassTestCollectionFactory>(discoverer.TestCollectionFactory);
Assert.Equal(XunitTestFrameworkDiscoverer.DisplayName + " [collection-per-class, parallel]", discoverer.TestFrameworkDisplayName);
}
public TestCaseBulkDeserializerTests()
{
var sourceInformationProvider = new NullSourceInformationProvider();
var diagnosticMessageSink = new Xunit.NullMessageSink();
var assembly = typeof(TestCaseBulkDeserializerTests).Assembly;
var assemblyInfo = Reflector.Wrap(assembly);
discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceInformationProvider, diagnosticMessageSink);
executor = new XunitTestFrameworkExecutor(assembly.GetName(), sourceInformationProvider, diagnosticMessageSink);
}
private static IXunitTestCase[] TestCases(IAssemblyInfo assemblyInfo)
{
using var discoverySink = new TestDiscoverySink();
using var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, SourceInformationProvider, DiagnosticMessageSink);
discoverer.Find(false, discoverySink, TestFrameworkOptions.ForDiscovery());
discoverySink.Finished.WaitOne();
return(discoverySink.TestCases.Cast <IXunitTestCase>().ToArray());
}
public static void TheoryWithNonSerializableData_ReturnsAsASingleTestCase()
{
var assemblyInfo = Reflector.Wrap(Assembly.GetExecutingAssembly());
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, configFileName: null, _NullSourceInformationProvider.Instance, SpyMessageSink.Create());
var sink = new TestDiscoverySink();
discoverer.Find(typeof(ClassWithNonSerializableTheoryData).FullName !, sink, _TestFrameworkOptions.ForDiscovery());
sink.Finished.WaitOne();
Assert.Single(sink.TestCases);
}
public void IncompatibleOrInvalidTypesGetDefaultBehavior(string factoryTypeName)
{
var attr = Mocks.CollectionBehaviorAttribute(factoryTypeName, "test.xunit2");
var assembly = Mocks.AssemblyInfo(attributes: new[] { attr });
var sourceInfoProvider = Substitute.For <ISourceInformationProvider>();
var discoverer = new XunitTestFrameworkDiscoverer(assembly, sourceInfoProvider);
Assert.IsType <CollectionPerClassTestCollectionFactory>(discoverer.TestCollectionFactory);
Assert.Equal(XunitTestFrameworkDiscoverer.DisplayName + " [collection-per-class, parallel]", discoverer.TestFrameworkDisplayName);
}
public void UserCanChooseFromBuiltInCollectionFactories_NonParallel()
{
var attr = Mocks.CollectionBehaviorAttribute(CollectionBehavior.CollectionPerAssembly, disableTestParallelization: true);
var assembly = Mocks.AssemblyInfo(attributes: new[] { attr });
var sourceInfoProvider = Substitute.For <ISourceInformationProvider>();
var discoverer = new XunitTestFrameworkDiscoverer(assembly, sourceInfoProvider);
Assert.IsType <CollectionPerAssemblyTestCollectionFactory>(discoverer.TestCollectionFactory);
Assert.Equal(XunitTestFrameworkDiscoverer.DisplayName + " [collection-per-assembly, non-parallel]", discoverer.TestFrameworkDisplayName);
}
public static void UserCanChooseFromBuiltInCollectionFactories_NonParallel(CollectionBehavior behavior, Type expectedType, string expectedDisplayText)
{
var attr = Mocks.CollectionBehaviorAttribute(behavior, disableTestParallelization: true);
var assembly = Mocks.AssemblyInfo(attributes: new[] { attr });
var sourceInfoProvider = Substitute.For <ISourceInformationProvider>();
var discoverer = new XunitTestFrameworkDiscoverer(assembly, sourceInfoProvider);
Assert.IsType(expectedType, discoverer.TestCollectionFactory);
Assert.Equal(String.Format("{0} [{1}, non-parallel]", XunitTestFrameworkDiscoverer.DisplayName, expectedDisplayText), discoverer.TestFrameworkDisplayName);
}
public void UserCanChooseCustomCollectionFactory()
{
var factoryType = typeof(MyTestCollectionFactory);
var attr = Mocks.CollectionBehaviorAttribute(factoryType.FullName, factoryType.Assembly.FullName);
var assembly = Mocks.AssemblyInfo(attributes: new[] { attr });
var sourceInfoProvider = Substitute.For <ISourceInformationProvider>();
var discoverer = new XunitTestFrameworkDiscoverer(assembly, sourceInfoProvider);
Assert.IsType <MyTestCollectionFactory>(discoverer.TestCollectionFactory);
Assert.Equal(XunitTestFrameworkDiscoverer.DisplayName + " [My Factory, parallel]", discoverer.TestFrameworkDisplayName);
}
public RealDiscovery()
{
var sourceInformationProvider = new NullSourceInformationProvider();
var diagnosticMessageSink = new Xunit.NullMessageSink();
var assembly = typeof(TestCaseBulkDeserializerTests).Assembly;
var assemblyInfo = Reflector.Wrap(assembly);
discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceInformationProvider, diagnosticMessageSink);
var discoverySink = new SpyMessageSink <IDiscoveryCompleteMessage>();
discoverer.Find("TestCaseDescriptorFactoryTests+TestClass", false, discoverySink, TestFrameworkOptions.ForDiscovery());
discoverySink.Finished.WaitOne();
testCases = discoverySink.Messages.OfType <ITestCaseDiscoveryMessage>().Select(m => m.TestCase).ToList();
}
public static void TheoryWithNonSerializableData_ReturnsAsASingleTestCase()
{
var sourceProvider = new NullSourceInformationProvider();
var assemblyInfo = Reflector.Wrap(Assembly.GetExecutingAssembly());
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceProvider);
var visitor = new TestDiscoveryVisitor();
discoverer.Find(typeof(ClassWithNonSerializableTheoryData).FullName, false, visitor, TestFrameworkOptions.ForDiscovery());
visitor.Finished.WaitOne();
var testCase = Assert.Single(visitor.TestCases);
Assert.IsType <XunitTheoryTestCase>(testCase);
var deserialized = SerializationHelper.Deserialize <ITestCase>(SerializationHelper.Serialize(testCase));
Assert.IsType <XunitTheoryTestCase>(deserialized);
}
public static void TheoriesAlwaysComeBackAsSingleXunitTheoryTestCase()
{
var sourceProvider = new NullSourceInformationProvider();
var assemblyInfo = Reflector.Wrap(Assembly.GetExecutingAssembly());
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceProvider);
var visitor = new TestDiscoveryVisitor();
discoverer.Find(typeof(ClassWithTheory).FullName, false, visitor, new XunitDiscoveryOptions());
visitor.Finished.WaitOne();
var testCase = Assert.Single(visitor.TestCases);
Assert.IsType <XunitTheoryTestCase>(testCase);
var deserialized = SerializationHelper.Deserialize <ITestCase>(SerializationHelper.Serialize(testCase));
Assert.IsType <XunitTheoryTestCase>(deserialized);
}
public static void TheoriesWithSerializableData_ReturnAsIndividualTestCases()
{
var assemblyInfo = Reflector.Wrap(Assembly.GetExecutingAssembly());
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, configFileName: null, _NullSourceInformationProvider.Instance, SpyMessageSink.Create());
var sink = new TestDiscoverySink();
discoverer.Find(typeof(ClassWithTheory).FullName !, sink, _TestFrameworkOptions.ForDiscovery());
sink.Finished.WaitOne();
Assert.Collection(
sink.TestCases.OrderBy(tc => tc.TestCaseDisplayName),
testCase => Assert.Equal("XunitTestFrameworkDiscovererTests+SerializationAcceptanceTests+ClassWithTheory.Test(x: \"hello\")", testCase.TestCaseDisplayName),
testCase => Assert.Equal("XunitTestFrameworkDiscovererTests+SerializationAcceptanceTests+ClassWithTheory.Test(x: 1)", testCase.TestCaseDisplayName)
);
var first = sink.TestCases[0];
var second = sink.TestCases[1];
Assert.NotEqual(first.TestCaseUniqueID, second.TestCaseUniqueID);
}
public static void SerializedTestsInSameCollectionRemainInSameCollection()
{
var sourceProvider = new NullSourceInformationProvider();
var assemblyInfo = Reflector.Wrap(Assembly.GetExecutingAssembly());
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceProvider);
var visitor = new TestDiscoveryVisitor();
discoverer.Find(typeof(ClassUnderTest).FullName, false, visitor, new XunitDiscoveryOptions());
visitor.Finished.WaitOne();
var first = visitor.TestCases[0];
var second = visitor.TestCases[1];
Assert.True(TestCollectionComparer.Instance.Equals(first.TestCollection, second.TestCollection));
var serializedFirst = SerializationHelper.Deserialize <ITestCase>(SerializationHelper.Serialize(first));
var serializedSecond = SerializationHelper.Deserialize <ITestCase>(SerializationHelper.Serialize(second));
Assert.NotSame(serializedFirst.TestCollection, serializedSecond.TestCollection);
Assert.True(TestCollectionComparer.Instance.Equals(serializedFirst.TestCollection, serializedSecond.TestCollection));
}
public static void TheoriesWithSerializableData_ReturnAsIndividualTestCases()
{
var sourceProvider = new NullSourceInformationProvider();
var assemblyInfo = Reflector.Wrap(Assembly.GetExecutingAssembly());
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceProvider);
var visitor = new TestDiscoveryVisitor();
discoverer.Find(typeof(ClassWithTheory).FullName, false, visitor, TestFrameworkOptions.ForDiscovery());
visitor.Finished.WaitOne();
var first = visitor.TestCases[0];
var second = visitor.TestCases[1];
Assert.NotEqual(first.UniqueID, second.UniqueID);
Assert.True(TestCollectionComparer.Instance.Equals(first.TestMethod.TestClass.TestCollection, second.TestMethod.TestClass.TestCollection));
var serializedFirst = SerializationHelper.Deserialize <ITestCase>(SerializationHelper.Serialize(first));
var serializedSecond = SerializationHelper.Deserialize <ITestCase>(SerializationHelper.Serialize(second));
Assert.NotSame(serializedFirst.TestMethod.TestClass.TestCollection, serializedSecond.TestMethod.TestClass.TestCollection);
Assert.True(TestCollectionComparer.Instance.Equals(serializedFirst.TestMethod.TestClass.TestCollection, serializedSecond.TestMethod.TestClass.TestCollection));
}
public static void SerializedTestsInSameCollectionRemainInSameCollection()
{
var sourceProvider = new NullSourceInformationProvider();
var assemblyInfo = Reflector.Wrap(Assembly.GetExecutingAssembly());
var discoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceProvider, SpyMessageSink.Create());
var sink = new TestDiscoverySink();
discoverer.Find(typeof(ClassWithFacts).FullName, false, sink, TestFrameworkOptions.ForDiscovery());
sink.Finished.WaitOne();
var first = sink.TestCases[0];
var second = sink.TestCases[1];
Assert.NotEqual(first.UniqueID, second.UniqueID);
Assert.True(TestCollectionComparer.Instance.Equals(first.TestMethod.TestClass.TestCollection, second.TestMethod.TestClass.TestCollection));
var serializedFirst = SerializationHelper.Deserialize <ITestCase>(SerializationHelper.Serialize(first));
var serializedSecond = SerializationHelper.Deserialize <ITestCase>(SerializationHelper.Serialize(second));
Assert.NotSame(serializedFirst.TestMethod.TestClass.TestCollection, serializedSecond.TestMethod.TestClass.TestCollection);
Assert.True(TestCollectionComparer.Instance.Equals(serializedFirst.TestMethod.TestClass.TestCollection, serializedSecond.TestMethod.TestClass.TestCollection));
}
public CombinationTestFrameworkDiscoverer(IAssemblyInfo assemblyInfo, ISourceInformationProvider sourceProvider, IMessageSink diagnosticMessageSink)
{
_xunitTestFrameworkDiscoverer = new XunitTestFrameworkDiscoverer(assemblyInfo, sourceProvider, diagnosticMessageSink);
_integrationTestFrameworkDiscoverer = new IntegrationTestFrameworkDiscoverer(assemblyInfo, sourceProvider, diagnosticMessageSink);
}
