public void CollectsTestCases()
    {
        var visitor = new TestDiscoverySink();
        var testCase1 = Substitute.For<ITestCase>();
        var testCase2 = Substitute.For<ITestCase>();
        var testCase3 = Substitute.For<ITestCase>();

        visitor.OnMessageWithTypes(new DiscoveryMessage(testCase1),null);
        visitor.OnMessageWithTypes(new DiscoveryMessage(testCase2),null);
        visitor.OnMessageWithTypes(new DiscoveryMessage(testCase3), null);
        visitor.OnMessageWithTypes(Substitute.For<IMessageSinkMessage>(), null); // Ignored

        Assert.Collection(visitor.TestCases,
            msg => Assert.Same(testCase1, msg),
            msg => Assert.Same(testCase2, msg),
            msg => Assert.Same(testCase3, msg)
        );
    }
    public static void TheoriesWithSerializableData_ReturnAsIndividualTestCases()
    {
        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(ClassWithTheory).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));
    }
 protected TestableXunitTestFrameworkDiscoverer(IAssemblyInfo assembly,
                                                ISourceInformationProvider sourceProvider,
                                                IMessageSink diagnosticMessageSink,
                                                IXunitTestCollectionFactory collectionFactory)
     : base(assembly,
            sourceProvider ?? Substitute.For<ISourceInformationProvider>(),
            diagnosticMessageSink ?? new Xunit.NullMessageSink(),
            collectionFactory)
 {
     Assembly = assembly;
     Sink = new TestDiscoverySink();
 }
    public static void TheoryWithNonSerializableData_ReturnsAsASingleTestCase()
    {
        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(ClassWithNonSerializableTheoryData).FullName, false, sink, TestFrameworkOptions.ForDiscovery());
        sink.Finished.WaitOne();

        var testCase = Assert.Single(sink.TestCases);
        Assert.IsType<XunitTheoryTestCase>(testCase);

        var deserialized = SerializationHelper.Deserialize<ITestCase>(SerializationHelper.Serialize(testCase));
        Assert.IsType<XunitTheoryTestCase>(deserialized);
    }
예제 #5
0
        public void TheoryWithInlineData()
        {
            string code = @"
module FSharpTests

open Xunit

[<Theory>]
[<InlineData>]
[<InlineData(42)>]
[<InlineData(42, 21.12)>]
let TestMethod (x:int) =
    Assert.True(true)
";

            using (var assembly = FSharpAcceptanceTestV2Assembly.Create(code))
            using (var controller = new TestableXunit2(assembly.FileName, null, true))
            {
                var sink = new TestDiscoverySink();

                controller.Find(includeSourceInformation: false, messageSink: sink, discoveryOptions: TestFrameworkOptions.ForDiscovery());
                sink.Finished.WaitOne();

                Assert.Collection(sink.TestCases.OrderBy(tc => tc.DisplayName),
                    testCase => Assert.Equal("FSharpTests.TestMethod(x: ???)", testCase.DisplayName),
                    testCase => Assert.Equal("FSharpTests.TestMethod(x: 42)", testCase.DisplayName),
                    testCase => Assert.Equal("FSharpTests.TestMethod(x: 42, ???: 21.12)", testCase.DisplayName)
                );
            }
        }
예제 #6
0
        public void FactAcceptanceTest()
        {
            string code = @"
module FSharpTests

open Xunit

[<Fact>]
[<Trait(""Name!"", ""Value!"")>]
let Trait() =
    Assert.True(true)

[<Fact(Skip = ""Skipping"")>]
let Skipped() =
    Assert.True(false)

[<Fact(DisplayName=""Custom Test Name"")>]
let CustomName() =
    Assert.True(true)
";

            using (var assembly = FSharpAcceptanceTestV2Assembly.Create(code))
            using (var controller = new TestableXunit2(assembly.FileName, null, true))
            {
                var sink = new TestDiscoverySink();

                controller.Find(includeSourceInformation: false, messageSink: sink, discoveryOptions: TestFrameworkOptions.ForDiscovery());
                sink.Finished.WaitOne();

                Assert.Collection(sink.TestCases.OrderBy(tc => tc.DisplayName),
                    testCase => Assert.Equal("Custom Test Name", testCase.DisplayName),
                    testCase =>
                    {
                        Assert.Equal("FSharpTests.Skipped", testCase.DisplayName);
                        Assert.Equal("Skipping", testCase.SkipReason);
                    },
                    testCase =>
                    {
                        Assert.Equal("FSharpTests.Trait", testCase.DisplayName);
                        Assert.Collection(testCase.Traits,
                            kvp =>
                            {
                                Assert.Equal("Name!", kvp.Key);
                                Assert.Equal("Value!", kvp.Value.Single());
                            }
                        );
                    }
                );
            }
        }
예제 #7
0
        public void FindByAssemblyReturnsAllTestMethodsFromExecutorXml()
        {
            var xml = @"
<assembly>
    <class name='Type1'>
        <method name='Method1 Display Name' type='Type1' method='Method1'/>
    </class>
    <class name='SpecialType'>
        <method name='SpecialType.SkippedMethod' type='SpecialType' method='SkippedMethod' skip='I am not run'/>
        <method name='SpecialType.MethodWithTraits' type='SpecialType' method='MethodWithTraits'>
            <traits>
                <trait name='Trait1' value='Value1'/>
                <trait name='Trait2' value='Value2'/>
            </traits>
        </method>
    </class>
</assembly>";

            using (var xunit1 = new TestableXunit1())
            {
                xunit1.Executor
                      .WhenForAnyArgs(x => x.EnumerateTests(null))
                      .Do(callInfo => callInfo.Arg<ICallbackEventHandler>().RaiseCallbackEvent(xml));
                var sink = new TestDiscoverySink();

                xunit1.Find(false, sink);
                sink.Finished.WaitOne();

                Assert.Collection(sink.TestCases,
                    testCase =>
                    {
                        Assert.Equal("Type1", testCase.TestMethod.TestClass.Class.Name);
                        Assert.Equal("Method1", testCase.TestMethod.Method.Name);
                        Assert.Equal("Method1 Display Name", testCase.DisplayName);
                        Assert.Null(testCase.SkipReason);
                        Assert.Empty(testCase.Traits);
                    },
                    testCase =>
                    {
                        Assert.Equal("SpecialType", testCase.TestMethod.TestClass.Class.Name);
                        Assert.Equal("SkippedMethod", testCase.TestMethod.Method.Name);
                        Assert.Equal("SpecialType.SkippedMethod", testCase.DisplayName);
                        Assert.Equal("I am not run", testCase.SkipReason);
                    },
                    testCase =>
                    {
                        Assert.Equal("SpecialType", testCase.TestMethod.TestClass.Class.Name);
                        Assert.Equal("MethodWithTraits", testCase.TestMethod.Method.Name);
                        Assert.Equal("SpecialType.MethodWithTraits", testCase.DisplayName);
                        Assert.Collection(testCase.Traits.Keys,
                            key =>
                            {
                                Assert.Equal("Trait1", key);
                                Assert.Collection(testCase.Traits[key],
                                    value => Assert.Equal("Value1", value)
                                );
                            },
                            key =>
                            {
                                Assert.Equal("Trait2", key);
                                Assert.Collection(testCase.Traits[key],
                                    value => Assert.Equal("Value2", value)
                                );
                            }
                        );
                    }
                );
            }
        }
예제 #8
0
        public void TestCasesUseInformationFromSourceInformationProvider()
        {
            var xml = @"
<assembly>
    <class name='Type2'>
        <method name='Type2.Method1' type='Type2' method='Method1'/>
        <method name='Type2.Method2' type='Type2' method='Method2'/>
    </class>
</assembly>";

            using (var xunit1 = new TestableXunit1())
            {
                xunit1.Executor
                      .WhenForAnyArgs(x => x.EnumerateTests(null))
                      .Do(callInfo => callInfo.Arg<ICallbackEventHandler>().RaiseCallbackEvent(xml));
                xunit1.SourceInformationProvider
                      .GetSourceInformation(null)
                      .ReturnsForAnyArgs(callInfo => new SourceInformation { FileName = "File for " + callInfo.Arg<ITestCase>().DisplayName });
                var sink = new TestDiscoverySink();

                xunit1.Find(true, sink);
                sink.Finished.WaitOne();

                Assert.Collection(sink.TestCases,
                    testCase => Assert.Equal("File for Type2.Method1", testCase.SourceInformation.FileName),
                    testCase => Assert.Equal("File for Type2.Method2", testCase.SourceInformation.FileName)
                );
            }
        }
예제 #9
0
        public void FindByTypesReturnsOnlyMethodsInTheGivenType()
        {
            var xml = @"
<assembly>
    <class name='Type1'>
        <method name='Method1 Display Name' type='Type1' method='Method1'/>
    </class>
    <class name='Type2'>
        <method name='Type2.Method1' type='Type2' method='Method1'/>
        <method name='Type2.Method2' type='Type2' method='Method2'/>
    </class>
</assembly>";

            using (var xunit1 = new TestableXunit1())
            {
                xunit1.Executor
                      .WhenForAnyArgs(x => x.EnumerateTests(null))
                      .Do(callInfo => callInfo.Arg<ICallbackEventHandler>().RaiseCallbackEvent(xml));
                var sink = new TestDiscoverySink();

                xunit1.Find("Type2", false, sink);
                sink.Finished.WaitOne();

                Assert.Collection(sink.TestCases,
                    testCase => Assert.Equal("Type2.Method1", testCase.DisplayName),
                    testCase => Assert.Equal("Type2.Method2", testCase.DisplayName)
                );
            }
        }