public void DeserializedTestCaseContainsSameDataAsOriginalTestCase() { var testCollection = new XunitTestCollection(); var type = typeof(ClassUnderTest); var method = type.GetMethod("FactMethod"); var fact = CustomAttributeData.GetCustomAttributes(method).Single(cad => cad.AttributeType == typeof(FactAttribute)); var testCase = new XunitTestCase(testCollection, Reflector.Wrap(type.Assembly), Reflector.Wrap(type), Reflector.Wrap(method), Reflector.Wrap(fact)); var serialized = SerializationHelper.Serialize(testCase); var result = SerializationHelper.Deserialize<XunitTestCase>(serialized); Assert.Equal(testCase.Assembly.AssemblyPath, result.Assembly.AssemblyPath); Assert.Equal(testCase.Assembly.Name, result.Assembly.Name); Assert.Equal(testCase.Class.Name, result.Class.Name); Assert.Equal(testCase.Method.Name, result.Method.Name); Assert.Equal(testCase.DisplayName, result.DisplayName); Assert.Null(result.Arguments); Assert.Equal(testCase.SkipReason, result.SkipReason); Assert.Collection(result.Traits.Keys, key => { Assert.Equal("name", key); Assert.Equal("value", Assert.Single(result.Traits[key])); }); }
/// <inheritdoc/> public IEnumerable <IXunitTestCase> Discover(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo factAttribute) { var defaultMethodDisplay = discoveryOptions.MethodDisplayOrDefault(); // Special case Skip, because we want a single Skip (not one per data item), and a skipped test may // not actually have any data (which is quasi-legal, since it's skipped). if (factAttribute.GetNamedArgument <string>("Skip") != null) { return new[] { new XunitTestCase(defaultMethodDisplay, testMethod) } } ; var dataAttributes = testMethod.Method.GetCustomAttributes(typeof(DataAttribute)); if (discoveryOptions.PreEnumerateTheoriesOrDefault()) { try { var results = new List <XunitTestCase>(); foreach (var dataAttribute in dataAttributes) { var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First(); var discoverer = ExtensibilityPointFactory.GetDataDiscoverer(discovererAttribute); if (!discoverer.SupportsDiscoveryEnumeration(dataAttribute, testMethod.Method)) { return new XunitTestCase[] { new XunitTheoryTestCase(defaultMethodDisplay, testMethod) } } ; // GetData may return null, but that's okay; we'll let the NullRef happen and then catch it // down below so that we get the composite test case. foreach (var dataRow in discoverer.GetData(dataAttribute, testMethod.Method)) { // Attempt to serialize the test case, since we need a way to uniquely identify a test // and serialization is the best way to do that. If it's not serializable, this will // throw and we will fall back to a single theory test case that gets its data // at runtime. var testCase = new XunitTestCase(defaultMethodDisplay, testMethod, dataRow); SerializationHelper.Serialize(testCase); results.Add(testCase); } } // REVIEW: Could we re-write LambdaTestCase to just be for exceptions? if (results.Count == 0) { results.Add(new LambdaTestCase(defaultMethodDisplay, testMethod, () => { throw new InvalidOperationException(String.Format("No data found for {0}.{1}", testMethod.TestClass.Class.Name, testMethod.Method.Name)); })); } return(results); } catch { } } return(new XunitTestCase[] { new XunitTheoryTestCase(defaultMethodDisplay, testMethod) }); } }
private KeyValuePair <string, ITestCase> Deserialize(XunitTestFrameworkDiscoverer discoverer, ITestFrameworkExecutor executor, string serialization) { var testCase = default(ITestCase); try { if (serialization.Length > 3 && serialization.StartsWith(":F:")) { // Format from TestCaseDescriptorFactory: ":F:{typeName}:{methodName}:{defaultMethodDisplay}" var parts = serialization.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries); if (parts.Length > 3) { var typeInfo = discoverer.AssemblyInfo.GetType(parts[1]); var testClass = discoverer.CreateTestClass(typeInfo); var methodInfo = testClass.Class.GetMethod(parts[2], true); var testMethod = new TestMethod(testClass, methodInfo); var defaultMethodDisplay = (TestMethodDisplay)int.Parse(parts[3]); testCase = new XunitTestCase(DiagnosticMessageSink, defaultMethodDisplay, testMethod); } } if (testCase == null) { testCase = executor.Deserialize(serialization); } return(new KeyValuePair <string, ITestCase>(testCase.UniqueID, testCase)); } catch (Exception ex) { return(new KeyValuePair <string, ITestCase>(ex.ToString(), null)); } }
public static void SkipReason() { var testMethod = Mocks.TestMethod("MockType", "MockMethod", skip: "Skip Reason"); var testCase = new XunitTestCase(testMethod); Assert.Equal("Skip Reason", testCase.SkipReason); }
public static void SkipReason() { var testMethod = Mocks.TestMethod("MockType", "MockMethod", skip: "Skip Reason"); var testCase = new XunitTestCase(SpyMessageSink.Create(), TestMethodDisplay.ClassAndMethod, TestMethodDisplayOptions.None, testMethod); Assert.Equal("Skip Reason", testCase.SkipReason); }
public void CanSerializeFactBasedTestCase() { var type = typeof(ClassUnderTest); var method = type.GetMethod("FactMethod"); var fact = CustomAttributeData.GetCustomAttributes(method).Single(cad => cad.AttributeType == typeof(FactAttribute)); var testCase = new XunitTestCase(Reflector.Wrap(type.Assembly), Reflector.Wrap(type), Reflector.Wrap(method), Reflector.Wrap(fact)); Assert.DoesNotThrow(() => SerializationHelper.Serialize(testCase)); }
private ITestCase UpdateTestCaseWithSourceInfo(XunitTestCase testCase, bool includeSourceInformation) { if (includeSourceInformation && sourceProvider != null) { testCase.SourceInformation = sourceProvider.GetSourceInformation(testCase); } return(testCase); }
public static void DefaultBehavior() { var testMethod = Mocks.TestMethod("MockType", "MockMethod"); var testCase = new XunitTestCase(testMethod); Assert.Equal("MockType.MockMethod", testCase.DisplayName); Assert.Null(testCase.SkipReason); Assert.Empty(testCase.Traits); }
public static void DefaultBehavior() { var testMethod = Mocks.TestMethod("MockType", "MockMethod"); var testCase = new XunitTestCase(SpyMessageSink.Create(), TestMethodDisplay.ClassAndMethod, TestMethodDisplayOptions.None, testMethod); Assert.Equal("MockType.MockMethod", testCase.DisplayName); Assert.Null(testCase.SkipReason); Assert.Empty(testCase.Traits); }
public void SkipReason() { var fact = Mocks.FactAttribute(skip: "Skip Reason"); var method = Mocks.MethodInfo(); var type = Mocks.TypeInfo(methods: new[] { method }); var assmInfo = Mocks.AssemblyInfo(types: new[] { type }); var testCase = new XunitTestCase(assmInfo, type, method, fact); Assert.Equal("Skip Reason", testCase.SkipReason); }
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, TestMethodDisplayOptions.None, testMethod); Assert.Equal("Value1", Assert.Single(testCase.Traits["Trait1"])); Assert.Equal("Value2", Assert.Single(testCase.Traits["Trait2"])); }
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(testMethod); Assert.Equal("Value1", Assert.Single(testCase.Traits["Trait1"])); Assert.Equal("Value2", Assert.Single(testCase.Traits["Trait2"])); }
public void DeserializedTestWithNonSerializableArgumentsThrows() { var type = typeof(ClassUnderTest); var method = type.GetMethod("FactMethod"); var fact = CustomAttributeData.GetCustomAttributes(method).Single(cad => cad.AttributeType == typeof(FactAttribute)); var testCase = new XunitTestCase(Reflector.Wrap(type.Assembly), Reflector.Wrap(type), Reflector.Wrap(method), Reflector.Wrap(fact), new object[] { new ClassUnderTest() }); var ex = Record.Exception(() => SerializationHelper.Serialize(testCase)); Assert.IsType<SerializationException>(ex); }
public static void DisposesArguments() { var disposable1 = Substitute.For<IDisposable>(); var disposable2 = Substitute.For<IDisposable>(); var testMethod = Mocks.TestMethod(); var testCase = new XunitTestCase(testMethod, new[] { disposable1, disposable2 }); testCase.Dispose(); disposable1.Received(1).Dispose(); disposable2.Received(1).Dispose(); }
/// <inheritdoc/> public IEnumerable<IXunitTestCase> Discover(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo factAttribute) { var methodDisplay = discoveryOptions.MethodDisplayOrDefault(); IXunitTestCase testCase; if (testMethod.Method.GetParameters().Any()) testCase = new ExecutionErrorTestCase(diagnosticMessageSink, methodDisplay, testMethod, "[Fact] methods are not allowed to have parameters. Did you mean to use [Theory]?"); else testCase = new XunitTestCase(diagnosticMessageSink, methodDisplay, testMethod); return new[] { testCase }; }
/// <inheritdoc/> public IEnumerable <IXunitTestCase> Discover(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo testClass, IMethodInfo testMethod, IAttributeInfo factAttribute) { // Special case Skip, because we want a single Skip (not one per data item), and a skipped test may // not actually have any data (which is quasi-legal, since it's skipped). if (factAttribute.GetNamedArgument <string>("Skip") != null) { return new[] { new XunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute) } } ; try { using (var memoryStream = new MemoryStream()) { var results = new List <XunitTestCase>(); var dataAttributes = testMethod.GetCustomAttributes(typeof(DataAttribute)); foreach (var dataAttribute in dataAttributes) { var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First(); var args = discovererAttribute.GetConstructorArguments().Cast <string>().ToList(); var discovererType = Reflector.GetType(args[1], args[0]); var discoverer = ExtensibilityPointFactory.GetDataDiscoverer(discovererType); // GetData may return null, but that's okay; we'll let the NullRef happen and then catch it // down below so that we get the composite test case. foreach (object[] dataRow in discoverer.GetData(dataAttribute, testMethod)) { // Attempt to serialize the test case, since we need a way to uniquely identify a test // and serialization is the best way to do that. If it's not serializable, this will // throw and we will fall back to a single theory test case that gets its data // at runtime. var testCase = new XunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute, dataRow); SerializationHelper.Serialize(testCase); results.Add(testCase); } } // REVIEW: Could we re-write LambdaTestCase to just be for exceptions? if (results.Count == 0) { results.Add(new LambdaTestCase(testCollection, assembly, testClass, testMethod, factAttribute, () => { throw new InvalidOperationException("No data found for " + testClass.Name + "." + testMethod.Name); })); } return(results); } } catch { return(new XunitTestCase[] { new XunitTheoryTestCase(testCollection, assembly, testClass, testMethod, factAttribute) }); } } }
public void DefaultFactAttribute() { var fact = Mocks.FactAttribute(); var method = Mocks.MethodInfo(); var type = Mocks.TypeInfo(methods: new[] { method }); var assmInfo = Mocks.AssemblyInfo(types: new[] { type }); var testCase = new XunitTestCase(assmInfo, type, method, fact); Assert.Equal("MockType.MockMethod", testCase.DisplayName); Assert.Null(testCase.SkipReason); Assert.Empty(testCase.Traits); }
public void Traits() { var fact = Mocks.FactAttribute(); var trait1 = Mocks.TraitAttribute("Trait1", "Value1"); var trait2 = Mocks.TraitAttribute("Trait2", "Value2"); var method = Mocks.MethodInfo(attributes: new[] { trait1, trait2 }); var type = Mocks.TypeInfo(methods: new[] { method }); var assmInfo = Mocks.AssemblyInfo(types: new[] { type }); var testCase = new XunitTestCase(assmInfo, type, method, fact); Assert.Equal("Value1", testCase.Traits["Trait1"]); Assert.Equal("Value2", testCase.Traits["Trait2"]); }
/// <inheritdoc/> public IEnumerable<IXunitTestCase> Discover(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo factAttribute) { var defaultMethodDisplay = discoveryOptions.MethodDisplayOrDefault(); // Special case Skip, because we want a single Skip (not one per data item), and a skipped test may // not actually have any data (which is quasi-legal, since it's skipped). if (factAttribute.GetNamedArgument<string>("Skip") != null) return new[] { new XunitTestCase(diagnosticMessageSink, defaultMethodDisplay, testMethod) }; var dataAttributes = testMethod.Method.GetCustomAttributes(typeof(DataAttribute)); if (discoveryOptions.PreEnumerateTheoriesOrDefault()) { try { var results = new List<XunitTestCase>(); foreach (var dataAttribute in dataAttributes) { var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First(); var discoverer = ExtensibilityPointFactory.GetDataDiscoverer(diagnosticMessageSink, discovererAttribute); if (!discoverer.SupportsDiscoveryEnumeration(dataAttribute, testMethod.Method)) return new XunitTestCase[] { new XunitTheoryTestCase(diagnosticMessageSink, defaultMethodDisplay, testMethod) }; // GetData may return null, but that's okay; we'll let the NullRef happen and then catch it // down below so that we get the composite test case. foreach (var dataRow in discoverer.GetData(dataAttribute, testMethod.Method)) { // Attempt to serialize the test case, since we need a way to uniquely identify a test // and serialization is the best way to do that. If it's not serializable, this will // throw and we will fall back to a single theory test case that gets its data // at runtime. var testCase = new XunitTestCase(diagnosticMessageSink, defaultMethodDisplay, testMethod, dataRow); SerializationHelper.Serialize(testCase); results.Add(testCase); } } if (results.Count == 0) results.Add(new ExecutionErrorTestCase(diagnosticMessageSink, defaultMethodDisplay, testMethod, String.Format("No data found for {0}.{1}", testMethod.TestClass.Class.Name, testMethod.Method.Name))); return results; } catch { } // If there are serialization issues with the theory data, fall through to return just the XunitTestCase } return new XunitTestCase[] { new XunitTheoryTestCase(diagnosticMessageSink, defaultMethodDisplay, testMethod) }; }
/// <inheritdoc/> public IEnumerable<IXunitTestCase> Discover(ITestMethod testMethod, IAttributeInfo factAttribute) { // Special case Skip, because we want a single Skip (not one per data item), and a skipped test may // not actually have any data (which is quasi-legal, since it's skipped). if (factAttribute.GetNamedArgument<string>("Skip") != null) return new[] { new XunitTestCase(testMethod) }; var dataAttributes = testMethod.Method.GetCustomAttributes(typeof(DataAttribute)); try { using (var memoryStream = new MemoryStream()) { var results = new List<XunitTestCase>(); foreach (var dataAttribute in dataAttributes) { var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First(); var discoverer = ExtensibilityPointFactory.GetDataDiscoverer(discovererAttribute); if (!discoverer.SupportsDiscoveryEnumeration(dataAttribute, testMethod.Method)) return new XunitTestCase[] { new XunitTheoryTestCase(testMethod) }; // GetData may return null, but that's okay; we'll let the NullRef happen and then catch it // down below so that we get the composite test case. foreach (var dataRow in discoverer.GetData(dataAttribute, testMethod.Method)) { // Attempt to serialize the test case, since we need a way to uniquely identify a test // and serialization is the best way to do that. If it's not serializable, this will // throw and we will fall back to a single theory test case that gets its data // at runtime. var testCase = new XunitTestCase(testMethod, dataRow); SerializationHelper.Serialize(testCase); results.Add(testCase); } } // REVIEW: Could we re-write LambdaTestCase to just be for exceptions? if (results.Count == 0) results.Add(new LambdaTestCase(testMethod, () => { throw new InvalidOperationException(String.Format("No data found for {0}.{1}", testMethod.TestClass.Class.Name, testMethod.Method.Name)); })); return results; } } catch { return new XunitTestCase[] { new XunitTheoryTestCase(testMethod) }; } }
public void DeserializedTestWithSerializableArgumentsPreservesArguments() { var type = typeof(ClassUnderTest); var method = type.GetMethod("FactMethod"); var fact = CustomAttributeData.GetCustomAttributes(method).Single(cad => cad.AttributeType == typeof(FactAttribute)); var testCase = new XunitTestCase(Reflector.Wrap(type.Assembly), Reflector.Wrap(type), Reflector.Wrap(method), Reflector.Wrap(fact), new object[] { 42, 21.12, "Hello world" }); var serialized = SerializationHelper.Serialize(testCase); var result = SerializationHelper.Deserialize<XunitTestCase>(serialized); Assert.Collection(result.Arguments, arg => Assert.Equal(42, arg), arg => Assert.Equal(21.12, arg), arg => Assert.Equal("Hello world", arg)); }
/// <summary> /// Creates test cases for a skipped theory. By default, returns a single instance of <see cref="XunitTestCase"/> /// (which inherently discovers the skip reason via the fact attribute). /// </summary> /// <param name="discoveryOptions">The discovery options to be used.</param> /// <param name="testMethod">The test method the test cases belong to.</param> /// <param name="theoryAttribute">The theory attribute attached to the test method.</param> /// <param name="skipReason">The skip reason that decorates <paramref name="theoryAttribute"/>.</param> /// <returns>The test cases</returns> protected virtual ValueTask <IReadOnlyCollection <IXunitTestCase> > CreateTestCasesForSkippedTheory( _ITestFrameworkDiscoveryOptions discoveryOptions, _ITestMethod testMethod, _IAttributeInfo theoryAttribute, string skipReason) { // TODO: Skip reason should be passed down into the test case var testCase = new XunitTestCase( discoveryOptions.MethodDisplayOrDefault(), discoveryOptions.MethodDisplayOptionsOrDefault(), testMethod ); return(new(new[] { testCase })); }
public void DisposesArguments() { var disposable1 = Substitute.For<IDisposable>(); var disposable2 = Substitute.For<IDisposable>(); var testCollection = new XunitTestCollection(); var fact = Mocks.FactAttribute(); var method = Mocks.MethodInfo(); var type = Mocks.TypeInfo(methods: new[] { method }); var assmInfo = Mocks.AssemblyInfo(types: new[] { type }); var testCase = new XunitTestCase(testCollection, assmInfo, type, method, fact, new[] { disposable1, disposable2 }); testCase.Dispose(); disposable1.Received(1).Dispose(); disposable2.Received(1).Dispose(); }
/// <summary> /// Creates test cases for a skipped theory. By default, returns a single instance of <see cref="XunitTestCase"/> /// (which inherently discovers the skip reason via the fact attribute). /// </summary> /// <param name="discoveryOptions">The discovery options to be used.</param> /// <param name="testMethod">The test method the test cases belong to.</param> /// <param name="theoryAttribute">The theory attribute attached to the test method.</param> /// <param name="skipReason">The skip reason that decorates <paramref name="theoryAttribute"/>.</param> /// <returns>The test cases</returns> protected virtual IEnumerable <IXunitTestCase> CreateTestCasesForSkip( _ITestFrameworkDiscoveryOptions discoveryOptions, _ITestMethod testMethod, _IAttributeInfo theoryAttribute, string skipReason) { // TODO: Skip reason should be passed down into the test case var testCase = new XunitTestCase( DiagnosticMessageSink, discoveryOptions.MethodDisplayOrDefault(), discoveryOptions.MethodDisplayOptionsOrDefault(), testMethod ); return(new[] { testCase }); }
/// <inheritdoc/> public IEnumerable<XunitTestCase> Discover(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo testClass, IMethodInfo testMethod, IAttributeInfo factAttribute) { // Special case Skip, because we want a single Skip (not one per data item), and a skipped test may // not actually have any data (which is quasi-legal, since it's skipped). if (factAttribute.GetNamedArgument<string>("Skip") != null) return new[] { new XunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute) }; try { using (var memoryStream = new MemoryStream()) { List<XunitTestCase> results = new List<XunitTestCase>(); var dataAttributes = testMethod.GetCustomAttributes(typeof(DataAttribute)); foreach (var dataAttribute in dataAttributes) { var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First(); var args = discovererAttribute.GetConstructorArguments().Cast<string>().ToList(); var discovererType = Reflector.GetType(args[1], args[0]); IDataDiscoverer discoverer = (IDataDiscoverer)Activator.CreateInstance(discovererType); // GetData may return null, but that's okay; we'll let the NullRef happen and then catch it // down below so that we get the composite test case. foreach (object[] dataRow in discoverer.GetData(dataAttribute, testMethod)) { // Attempt to serialize the test case, since we need a way to uniquely identify a test // and serialization is the best way to do that. If it's not serializable, this will // throw and we will fall back to a single theory test case that gets its data // at runtime. var testCase = new XunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute, dataRow); SerializationHelper.Serialize(testCase); results.Add(testCase); } } // REVIEW: Could we re-write LambdaTestCase to just be for exceptions? if (results.Count == 0) results.Add(new LambdaTestCase(testCollection, assembly, testClass, testMethod, factAttribute, () => { throw new InvalidOperationException("No data found for " + testClass.Name + "." + testMethod.Name); })); return results; } } catch { return new XunitTestCase[] { new XunitTheoryTestCase(testCollection, assembly, testClass, testMethod, factAttribute) }; } }
/// <inheritdoc/> public IEnumerable <IXunitTestCase> Discover(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo factAttribute) { var methodDisplay = discoveryOptions.MethodDisplayOrDefault(); IXunitTestCase testCase; if (testMethod.Method.GetParameters().Any()) { testCase = new LambdaTestCase(methodDisplay, testMethod, () => { throw new InvalidOperationException("[Fact] methods are not allowed to have parameters. Did you mean to use [Theory]?"); }); } else { testCase = new XunitTestCase(methodDisplay, testMethod); } return(new[] { testCase }); }
/// <inheritdoc/> public IEnumerable <IXunitTestCase> Discover(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo factAttribute) { var methodDisplay = discoveryOptions.MethodDisplayOrDefault(); IXunitTestCase testCase; if (testMethod.Method.GetParameters().Any()) { testCase = new ExecutionErrorTestCase(diagnosticMessageSink, methodDisplay, testMethod, "[Fact] methods are not allowed to have parameters. Did you mean to use [Theory]?"); } else { testCase = new XunitTestCase(diagnosticMessageSink, methodDisplay, testMethod); } return(new[] { testCase }); }
private IEnumerable<IXunitTestCase> discoverTestCases(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod) { if (!discoveryOptions.PreEnumerateTheoriesOrDefault()) return new XunitTestCase[] { new XunitTheoryTestCase(_messageSink, TestMethodDisplay.Method, testMethod) }; var withValuesAttributes = testMethod.Method.GetCustomAttributes(typeof(WithValuesAttribute).AssemblyQualifiedName); var testCase = new List<XunitTestCase>(); foreach (var withValuesAttribute in withValuesAttributes) { var discovererAttribute = withValuesAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute).AssemblyQualifiedName).Single(); var discoverer = ExtensibilityPointFactory.GetDataDiscoverer(_messageSink, discovererAttribute); if (!discoverer.SupportsDiscoveryEnumeration(withValuesAttribute, testMethod.Method)) return new XunitTestCase[] { new XunitTheoryTestCase(_messageSink, TestMethodDisplay.Method, testMethod) }; foreach (var data in discoverer.GetData(withValuesAttribute, testMethod.Method)) { var test = new XunitTestCase(_messageSink, TestMethodDisplay.Method, testMethod, data); testCase.Add(test); } } return testCase; }
public static void CustomDisplayName() { var testMethod = Mocks.TestMethod(displayName: "Custom Display Name"); var testCase = new XunitTestCase(SpyMessageSink.Create(), TestMethodDisplay.ClassAndMethod, TestMethodDisplayOptions.None, testMethod); Assert.Equal("Custom Display Name", testCase.DisplayName); }
public static void TooManyTestArguments() { var param = Mocks.ParameterInfo("p1"); var testMethod = Mocks.TestMethod(parameters: new[] { param }); var arguments = new object[] { 42, 21.12M }; var testCase = new XunitTestCase(testMethod, arguments); Assert.Equal(String.Format("MockType.MockMethod(p1: 42, ???: {0})", 21.12), testCase.DisplayName); }
/// <inheritdoc/> public IEnumerable <IXunitTestCase> Discover(ITestFrameworkDiscoveryOptions discoveryOptions, ITestMethod testMethod, IAttributeInfo factAttribute) { var defaultMethodDisplay = discoveryOptions.MethodDisplayOrDefault(); // Special case Skip, because we want a single Skip (not one per data item), and a skipped test may // not actually have any data (which is quasi-legal, since it's skipped). if (factAttribute.GetNamedArgument <string>("Skip") != null) { return new[] { new XunitTestCase(diagnosticMessageSink, defaultMethodDisplay, testMethod) } } ; var dataAttributes = testMethod.Method.GetCustomAttributes(typeof(DataAttribute)); if (discoveryOptions.PreEnumerateTheoriesOrDefault()) { try { var results = new List <XunitTestCase>(); foreach (var dataAttribute in dataAttributes) { var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First(); var discoverer = ExtensibilityPointFactory.GetDataDiscoverer(diagnosticMessageSink, discovererAttribute); if (!discoverer.SupportsDiscoveryEnumeration(dataAttribute, testMethod.Method)) { return new XunitTestCase[] { new XunitTheoryTestCase(diagnosticMessageSink, defaultMethodDisplay, testMethod) } } ; // GetData may return null, but that's okay; we'll let the NullRef happen and then catch it // down below so that we get the composite test case. foreach (var dataRow in discoverer.GetData(dataAttribute, testMethod.Method)) { // Determine whether we can serialize the test case, since we need a way to uniquely // identify a test and serialization is the best way to do that. If it's not serializable, // this will throw and we will fall back to a single theory test case that gets its data at runtime. var testCase = new XunitTestCase(diagnosticMessageSink, defaultMethodDisplay, testMethod, dataRow); if (!SerializationHelper.IsSerializable(dataRow)) { return new XunitTestCase[] { new XunitTheoryTestCase(diagnosticMessageSink, defaultMethodDisplay, testMethod) } } ; results.Add(testCase); } } if (results.Count == 0) { results.Add(new ExecutionErrorTestCase(diagnosticMessageSink, defaultMethodDisplay, testMethod, string.Format("No data found for {0}.{1}", testMethod.TestClass.Class.Name, testMethod.Method.Name))); } return(results); } catch { } // If something goes wrong, fall through to return just the XunitTestCase } return(new XunitTestCase[] { new XunitTheoryTestCase(diagnosticMessageSink, defaultMethodDisplay, testMethod) }); } }
/// <summary> /// Converts a <see cref="XunitTestCase"/> into an equivalent test case for the discoverer. /// </summary> /// <param name="testCase">The test case to convert.</param> /// <param name="defaultMethodDisplay">The default test method display.</param> /// <param name="diagnosticMessageSink">The message sink used to send diagnostic messages.</param> /// <param name="timeout">The amount of time the test case is allowed to run in milliseconds, or a value less than 1 to indicate no timeout.</param> /// <param name="useStaThread">Whether to use an STA thread to execute tests.</param> /// <returns>The converted test case (the default implementation returns a <see cref="TimeoutXunitTestCase"/>).</returns> protected virtual XunitTestCase ConvertXunitTestCase(XunitTestCase testCase, TestMethodDisplay defaultMethodDisplay, IMessageSink diagnosticMessageSink, int timeout, bool useStaThread) { return(new TimeoutXunitTestCase(diagnosticMessageSink, defaultMethodDisplay, testCase.TestMethod, testCase.TestMethodArguments, timeout, useStaThread)); }
public void TooManyTestArguments() { var fact = Mocks.FactAttribute(); var param = Mocks.ParameterInfo("p1"); var method = Mocks.MethodInfo(parameters: new[] { param }); var type = Mocks.TypeInfo(methods: new[] { method }); var assmInfo = Mocks.AssemblyInfo(types: new[] { type }); var arguments = new object[] { 42, 21.12 }; var testCase = new XunitTestCase(assmInfo, type, method, fact, arguments); Assert.Equal("MockType.MockMethod(p1: 42, ???: 21.12)", testCase.DisplayName); }
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, TestMethodDisplayOptions.None, testMethod, arguments); Assert.Equal("Custom Display Name(p1: 42, p2: \"Hello, world!\", p3: 'A')", testCase.DisplayName); }
private ITestCase UpdateTestCaseWithSourceInfo(XunitTestCase testCase, bool includeSourceInformation) { if (includeSourceInformation && sourceProvider != null) testCase.SourceInformation = sourceProvider.GetSourceInformation(testCase); return testCase; }
public void NotEnoughTestArguments() { var testCollection = new XunitTestCollection(); var fact = Mocks.FactAttribute(); var param = Mocks.ParameterInfo("p1"); var method = Mocks.MethodInfo(parameters: new[] { param }); var type = Mocks.TypeInfo(methods: new[] { method }); var assmInfo = Mocks.AssemblyInfo(types: new[] { type }); var testCase = new XunitTestCase(testCollection, assmInfo, type, method, fact, arguments: new object[0]); Assert.Equal("MockType.MockMethod(p1: ???)", testCase.DisplayName); }
public static void CustomDisplayName() { var testMethod = Mocks.TestMethod(displayName: "Custom Display Name"); var testCase = new XunitTestCase(testMethod); Assert.Equal("Custom Display Name", testCase.DisplayName); }
public void CustomDisplayName() { var fact = Mocks.FactAttribute(displayName: "Custom Display Name"); var method = Mocks.MethodInfo(); var type = Mocks.TypeInfo(methods: new[] { method }); var assmInfo = Mocks.AssemblyInfo(types: new[] { type }); var testCase = new XunitTestCase(assmInfo, type, method, fact); Assert.Equal("Custom Display Name", testCase.DisplayName); }
public static void CustomTraitWithoutDiscoverer() { var trait = Mocks.TraitAttribute<BadTraitAttribute>(); var testMethod = Mocks.TestMethod(classAttributes: new[] { trait }); var messages = new List<IMessageSinkMessage>(); var spy = SpyMessageSink.Create(messages: messages); var testCase = new XunitTestCase(spy, TestMethodDisplay.ClassAndMethod, TestMethodDisplayOptions.None, testMethod); Assert.Empty(testCase.Traits); var diagnosticMessages = messages.OfType<IDiagnosticMessage>(); var diagnosticMessage = Assert.Single(diagnosticMessages); Assert.Equal("Trait attribute on 'MockType.MockMethod' did not have [TraitDiscoverer]", diagnosticMessage.Message); }
public void CorrectNumberOfTestArguments() { var fact = Mocks.FactAttribute(); var param1 = Mocks.ParameterInfo("p1"); var param2 = Mocks.ParameterInfo("p2"); var param3 = Mocks.ParameterInfo("p3"); var method = Mocks.MethodInfo(parameters: new[] { param1, param2, param3 }); var type = Mocks.TypeInfo(methods: new[] { method }); var assmInfo = Mocks.AssemblyInfo(types: new[] { type }); var arguments = new object[] { 42, "Hello, world!", 'A' }; var testCase = new XunitTestCase(assmInfo, type, method, fact, arguments); Assert.Equal("MockType.MockMethod(p1: 42, p2: \"Hello, world!\", p3: 'A')", testCase.DisplayName); }