/// <summary>
/// Finds the tests on a test method.
/// </summary>
/// <param name="testCollection">The test collection that the test method belongs to.</param>
/// <param name="type">The test class that the test method belongs to.</param>
/// <param name="method">The test method.</param>
/// <param name="includeSourceInformation">Set to <c>true</c> to indicate that source information should be included.</param>
/// <param name="messageBus">The message bus to report discovery messages to.</param>
/// <returns>Return <c>true</c> to continue test discovery, <c>false</c>, otherwise.</returns>
protected virtual bool FindTestsForMethod(ITestCollection testCollection, ITypeInfo type, IMethodInfo method, bool includeSourceInformation, IMessageBus messageBus)
{
var factAttribute = method.GetCustomAttributes(typeof(FactAttribute)).FirstOrDefault();
if (factAttribute == null)
return true;
var testCaseDiscovererAttribute = factAttribute.GetCustomAttributes(typeof(XunitTestCaseDiscovererAttribute)).FirstOrDefault();
if (testCaseDiscovererAttribute == null)
return true;
var args = testCaseDiscovererAttribute.GetConstructorArguments().Cast<string>().ToList();
var discovererType = Reflector.GetType(args[1], args[0]);
if (discovererType == null)
return true;
var discoverer = GetDiscoverer(discovererType);
if (discoverer == null)
return true;
foreach (var testCase in discoverer.Discover(testCollection, AssemblyInfo, type, method, factAttribute))
if (!ReportDiscoveredTestCase(testCase, includeSourceInformation, messageBus))
return false;
return true;
}
public CulturedXunitTestCase(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, string culture)
: base(testCollection, assembly, type, method, factAttribute)
{
this.culture = culture;
Traits.Add("Culture", culture);
}
void Initialize(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, object[] arguments)
{
string displayNameBase = factAttribute.GetNamedArgument<string>("DisplayName") ?? type.Name + "." + method.Name;
ITypeInfo[] resolvedTypes = null;
if (arguments != null && method.IsGenericMethodDefinition)
{
resolvedTypes = ResolveGenericTypes(method, arguments);
method = method.MakeGenericMethod(resolvedTypes);
}
Assembly = assembly;
Class = type;
Method = method;
Arguments = arguments;
DisplayName = GetDisplayNameWithArguments(displayNameBase, arguments, resolvedTypes);
SkipReason = factAttribute.GetNamedArgument<string>("Skip");
Traits = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
TestCollection = testCollection;
foreach (var traitAttribute in Method.GetCustomAttributes(typeof(ITraitAttribute))
.Concat(Class.GetCustomAttributes(typeof(ITraitAttribute))))
{
var discovererAttribute = traitAttribute.GetCustomAttributes(typeof(TraitDiscovererAttribute)).First();
var discoverer = ExtensibilityPointFactory.GetTraitDiscoverer(discovererAttribute);
if (discoverer != null)
foreach (var keyValuePair in discoverer.GetTraits(traitAttribute))
Traits.Add(keyValuePair.Key, keyValuePair.Value);
}
uniqueID = new Lazy<string>(GetUniqueID, true);
}
void Initialize(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, object[] arguments)
{
string displayNameBase = factAttribute.GetNamedArgument<string>("DisplayName") ?? type.Name + "." + method.Name;
ITypeInfo[] resolvedTypes = null;
if (arguments != null && method.IsGenericMethodDefinition)
{
resolvedTypes = ResolveGenericTypes(method, arguments);
method = method.MakeGenericMethod(resolvedTypes);
}
Assembly = assembly;
Class = type;
Method = method;
Arguments = arguments;
DisplayName = GetDisplayNameWithArguments(displayNameBase, arguments, resolvedTypes);
SkipReason = factAttribute.GetNamedArgument<string>("Skip");
Traits = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
TestCollection = testCollection;
foreach (IAttributeInfo traitAttribute in Method.GetCustomAttributes(typeof(TraitAttribute))
.Concat(Class.GetCustomAttributes(typeof(TraitAttribute))))
{
var ctorArgs = traitAttribute.GetConstructorArguments().ToList();
Traits.Add((string)ctorArgs[0], (string)ctorArgs[1]);
}
uniqueID = new Lazy<string>(GetUniqueID, true);
}
protected override Task<RunSummary> RunTestCollectionAsync(IMessageBus messageBus,
ITestCollection testCollection,
IEnumerable<IXunitTestCase> testCases,
CancellationTokenSource cancellationTokenSource)
{
return new XunitTestCollectionRunnerWithAssemblyFixture(assemblyFixtureMappings, testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource).RunAsync();
}
/// <summary>
/// Initializes a new instance of the <see cref="TestCollectionFinished"/> class.
/// </summary>
public TestCollectionFinished(IEnumerable<ITestCase> testCases, ITestCollection testCollection, decimal executionTime, int testsRun, int testsFailed, int testsSkipped)
: base(testCases, testCollection)
{
ExecutionTime = executionTime;
TestsRun = testsRun;
TestsFailed = testsFailed;
TestsSkipped = testsSkipped;
}
public TestClassFinished(ITestCollection testCollection, string className, decimal executionTime, int testsRun, int testsFailed, int testsSkipped)
: base(testCollection, className)
{
ExecutionTime = executionTime;
TestsRun = testsRun;
TestsFailed = testsFailed;
TestsSkipped = testsSkipped;
}
public virtual string DisplayName(ITestCollection testCollection)
{
var id = assemblyMappings.GetOrAdd(
testCollection.TestAssembly.Assembly.Name,
key => Interlocked.Increment(ref assemblyCount));
return String.Concat(testCollection.DisplayName, " (", id, ")");
}
/// <summary>
/// Initializes a new instance of the <see cref="TestClassCleanupFailure"/> class.
/// </summary>
public TestCollectionCleanupFailure(IEnumerable<ITestCase> testCases, ITestCollection testCollection, string[] exceptionTypes, string[] messages, string[] stackTraces, int[] exceptionParentIndices)
: base(testCases, testCollection)
{
StackTraces = stackTraces;
Messages = messages;
ExceptionTypes = exceptionTypes;
ExceptionParentIndices = exceptionParentIndices;
}
/// <summary>
/// Initializes a new instance of the <see cref="TestClass"/> class.
/// </summary>
/// <param name="testCollection">The test collection the class belongs to</param>
/// <param name="class">The test class</param>
public TestClass(ITestCollection testCollection, ITypeInfo @class)
{
Guard.ArgumentNotNull("testCollection", testCollection);
Guard.ArgumentNotNull("class", @class);
Class = @class;
TestCollection = testCollection;
}
/// <inheritdoc/>
public void SetData(XunitSerializationInfo info)
{
TestCollection = info.GetValue<ITestCollection>("TestCollection");
var assemblyName = info.GetString("ClassAssemblyName");
var typeName = info.GetString("ClassTypeName");
Class = Reflector.Wrap(Reflector.GetType(assemblyName, typeName));
}
/// <inheritdoc/>
protected TestClass(SerializationInfo info, StreamingContext context)
{
TestCollection = info.GetValue<ITestCollection>("TestCollection");
var assemblyName = info.GetString("ClassAssemblyName");
var typeName = info.GetString("ClassTypeName");
Class = Reflector.Wrap(Reflector.GetType(assemblyName, typeName));
}
/// <inheritdoc/>
public void Deserialize(IXunitSerializationInfo info)
{
TestCollection = info.GetValue<ITestCollection>("TestCollection");
var assemblyName = info.GetValue<string>("ClassAssemblyName");
var typeName = info.GetValue<string>("ClassTypeName");
Class = Reflector.Wrap(SerializationHelper.GetType(assemblyName, typeName));
}
/// <summary>
/// Initializes a new instance of the <see cref="XunitTestCase"/> class.
/// </summary>
/// <param name="testCollection">The test collection this test case belongs to.</param>
/// <param name="assembly">The test assembly.</param>
/// <param name="type">The test class.</param>
/// <param name="method">The test method.</param>
/// <param name="factAttribute">The instance of the <see cref="FactAttribute"/>.</param>
/// <param name="arguments">The arguments for the test method.</param>
public XunitTestCase(ITestCollection testCollection,
IAssemblyInfo assembly,
ITypeInfo type,
IMethodInfo method,
IAttributeInfo factAttribute,
object[] arguments = null)
{
Initialize(testCollection, assembly, type, method, factAttribute, arguments);
}
/// <summary>
/// Initializes a new instance of the <see cref="Xunit1"/> class.
/// </summary>
/// <param name="sourceInformationProvider">Source code information provider.</param>
/// <param name="assemblyFileName">The test assembly.</param>
/// <param name="configFileName">The test assembly configuration file.</param>
/// <param name="shadowCopy">If set to <c>true</c>, runs tests in a shadow copied app domain, which allows
/// tests to be discovered and run without locking assembly files on disk.</param>
public Xunit1(ISourceInformationProvider sourceInformationProvider, string assemblyFileName, string configFileName = null, bool shadowCopy = true)
{
this.sourceInformationProvider = sourceInformationProvider;
this.assemblyFileName = assemblyFileName;
this.configFileName = configFileName;
executor = CreateExecutor(assemblyFileName, configFileName, shadowCopy);
testCollection = new Xunit1TestCollection(assemblyFileName);
}
/// <summary>
/// Initializes a new instance of the <see cref="TestClassCleanupFailure"/> class.
/// </summary>
public TestCollectionCleanupFailure(IEnumerable<ITestCase> testCases, ITestCollection testCollection, Exception ex)
: base(testCases, testCollection)
{
var failureInfo = ExceptionUtility.ConvertExceptionToFailureInformation(ex);
ExceptionTypes = failureInfo.ExceptionTypes;
Messages = failureInfo.Messages;
StackTraces = failureInfo.StackTraces;
ExceptionParentIndices = failureInfo.ExceptionParentIndices;
}
public IEnumerable<IXunitTestCase> Discover(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo testClass, IMethodInfo testMethod, IAttributeInfo factAttribute)
{
var ctorArgs = factAttribute.GetConstructorArguments().ToArray();
var cultures = Reflector.ConvertArguments(ctorArgs, new[] { typeof(string[]) }).Cast<string[]>().Single();
if (cultures == null || cultures.Length == 0)
cultures = new[] { "en-US", "fr-FR" };
return cultures.Select(culture => new CulturedXunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute, culture)).ToList();
}
protected override Task<RunSummary> RunTestCollectionAsync (IMessageBus messageBus, ITestCollection testCollection, IEnumerable<IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource)
{
var vsixCollection = testCollection as VsixTestCollection;
if (vsixCollection != null) {
var runner = new VsixTestCollectionRunner (vsixCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator (Aggregator), cancellationTokenSource);
disposables.Add (runner);
return runner.RunAsync ();
}
return new XunitTestCollectionRunner (testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator (Aggregator), cancellationTokenSource).RunAsync();
}
public TestCollectionRunner(Dictionary<Type, object> assemblyFixtureMappings,
ITestCollection testCollection,
IEnumerable<IXunitTestCase> testCases,
IMessageSink diagnosticMessageSink,
IMessageBus messageBus,
ITestCaseOrderer testCaseOrderer,
ExceptionAggregator aggregator,
CancellationTokenSource cancellationTokenSource)
: base(testCollection, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource)
{
this.assemblyFixtureMappings = assemblyFixtureMappings;
this.diagnosticMessageSink = diagnosticMessageSink;
}
public virtual string DisplayName(ITestCollection testCollection)
{
int id;
lock (assemblyMappings)
{
if (!assemblyMappings.TryGetValue(testCollection.TestAssembly.Assembly.Name, out id))
{
id = Interlocked.Increment(ref assemblyCount);
assemblyMappings[testCollection.TestAssembly.Assembly.Name] = id;
}
}
return $"{testCollection.DisplayName} ({id})";
}
/// <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) };
}
}
Xunit1RunSummary RunTestCollection(ITestCollection testCollection, IEnumerable <ITestCase> testCases, IMessageSink messageSink)
{
var results = new Xunit1RunSummary();
results.Continue = messageSink.OnMessage(new TestCollectionStarting(testCases, testCollection));
if (results.Continue)
{
foreach (var testClassGroup in testCases.GroupBy(tc => tc.TestMethod.TestClass, Comparer.Instance))
{
var classResults = RunTestClass(testClassGroup.Key, testClassGroup.ToList(), messageSink);
results.Aggregate(classResults);
if (!classResults.Continue)
{
break;
}
}
}
results.Continue = messageSink.OnMessage(new TestCollectionFinished(testCases, testCollection, results.Time, results.Total, results.Failed, results.Skipped)) && results.Continue;
return(results);
}
protected override async Task<RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable<IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource)
{
var summary = new RunSummary();
var defaultCases = new List<IXunitTestCase>();
var observationTestCases = new List<ObservationTestCase>();
foreach (var testCase in testCases)
{
if (testCase is ObservationTestCase)
observationTestCases.Add(testCase as ObservationTestCase);
else
defaultCases.Add(testCase);
}
if (observationTestCases.Any())
{
summary.Aggregate(
await new ObservationTestCollectionRunner(
testCollection,
observationTestCases,
DiagnosticMessageSink,
messageBus,
TestCaseOrderer,
new ExceptionAggregator(Aggregator),
cancellationTokenSource
)
.RunAsync()
);
}
if (defaultCases.Any())
{
summary.Aggregate(
await base.RunTestCollectionAsync(messageBus, testCollection, defaultCases, cancellationTokenSource)
);
}
return summary;
}
private ClusterBase ClusterFixture(ITestCollection testCollection)
{
var clusterType = GetClusterForCollection(testCollection);
ClusterBase cluster = null;
if (clusterType == null)
{
return(null);
}
if (_assemblyFixtureMappings.ContainsKey(clusterType))
{
return(_assemblyFixtureMappings[clusterType] as ClusterBase);
}
Aggregator.Run(() =>
{
var o = Activator.CreateInstance(clusterType);
_assemblyFixtureMappings.Add(clusterType, o);
cluster = o as ClusterBase;
});
return(cluster);
}
/// <summary>
/// Test collections are not bound to a specific class, however they
/// are named by default with the type name as a suffix. We try to
/// get the class name from the DisplayName and then use reflection to
/// find the class and OrderAttribute.
/// </summary>
private static int GetOrder(
ITestCollection testCollection)
{
var i = testCollection.DisplayName.LastIndexOf(' ');
if (i <= -1)
{
return(0);
}
var className = testCollection.DisplayName.Substring(i + 1);
var type = Type.GetType(className);
if (type == null)
{
return(0);
}
var attr = type.GetCustomAttribute <OrderAttribute>();
return(attr?.I ?? 0);
}
public virtual void PolymorphicCollectionAddMutlipleItemsOfOneType(string roleObjectType)
{
var payment = FindById <PolymorphicPayment>(4);
var inv = FindById <InvoiceAsPayableItem>(1);
string invId = inv.GetPropertyByName("Id").Title;
ITestObject inv2 = GetTestService("Invoice As Payable Items").GetAction("New Instance").InvokeReturnObject().Save();
string inv2Id = inv2.GetPropertyByName("Id").Title;
ITestCollection links = payment.GetPropertyByName("Payable Item Links").ContentAsCollection;
ITestCollection items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
links.AssertCountIs(0);
items.AssertCountIs(0);
//Add an Invoice
payment.GetAction("Add Payable Item").InvokeReturnObject(inv);
links.AssertCountIs(1);
ITestObject link1 = links.ElementAt(0);
link1.GetPropertyByName("Associated Role Object Type").AssertValueIsEqual(roleObjectType);
link1.GetPropertyByName("Associated Role Object Id").AssertValueIsEqual(invId);
items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
ITestObject item = items.AssertCountIs(1).ElementAt(0);
item.AssertIsType(typeof(InvoiceAsPayableItem));
//Add an expense claim
payment.GetAction("Add Payable Item").InvokeReturnObject(inv2);
links.AssertCountIs(2);
ITestObject link2 = links.ElementAt(1);
link2.GetPropertyByName("Associated Role Object Type").AssertValueIsEqual(roleObjectType);
link2.GetPropertyByName("Associated Role Object Id").AssertValueIsEqual(inv2Id);
items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
item = items.AssertCountIs(2).ElementAt(1);
item.AssertIsType(typeof(InvoiceAsPayableItem));
}
public virtual void PolymorphicCollectionAddDifferentItems(string roleType1, string roleType2)
{
var payment = FindById("Polymorphic Payments", 5);
var inv = FindById("Invoice As Payable Items", 1);
string invId = inv.GetPropertyByName("Id").Title;
ITestObject exp = GetTestService("Expense Claim As Payable Items").GetAction("New Instance").InvokeReturnObject().Save();
string expId = exp.GetPropertyByName("Id").Title;
ITestCollection links = payment.GetPropertyByName("Payable Item Links").ContentAsCollection;
ITestCollection items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
links.AssertCountIs(0);
items.AssertCountIs(0);
//Add an Invoice
payment.GetAction("Add Payable Item").InvokeReturnObject(inv);
links.AssertCountIs(1);
ITestObject link1 = links.ElementAt(0);
link1.GetPropertyByName("Associated Role Object Type").AssertValueIsEqual(roleType1);
link1.GetPropertyByName("Associated Role Object Id").AssertValueIsEqual(invId);
items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
ITestObject item = items.AssertCountIs(1).ElementAt(0);
item.AssertIsType(typeof(InvoiceAsPayableItem));
//Add an expense claim
payment.GetAction("Add Payable Item").InvokeReturnObject(exp);
links.AssertCountIs(2);
ITestObject link2 = links.ElementAt(1);
link2.GetPropertyByName("Associated Role Object Type").AssertValueIsEqual(roleType2);
link2.GetPropertyByName("Associated Role Object Id").AssertValueIsEqual(expId);
items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
item = items.AssertCountIs(2).ElementAt(1);
item.AssertIsType(typeof(ExpenseClaimAsPayableItem));
}
private int FindExecutionOrder(ITestCollection collection)
{
int?order = null;
for (int i = 0; i < _orderedCollections.Length; i++)
{
if (_orderedCollections[i] == collection.DisplayName)
{
order = i;
break;
}
}
if (order is null)
{
throw new ArgumentException(
$"Collection \"{collection.DisplayName}\" not found in execution list.",
nameof(collection)
);
}
return((int)order);
}
void Initialize(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo factAttribute, object[] arguments)
{
string displayNameBase = factAttribute.GetNamedArgument <string>("DisplayName") ?? type.Name + "." + method.Name;
ITypeInfo[] resolvedTypes = null;
if (arguments != null && method.IsGenericMethodDefinition)
{
resolvedTypes = ResolveGenericTypes(method, arguments);
method = method.MakeGenericMethod(resolvedTypes);
}
Assembly = assembly;
Class = type;
Method = method;
Arguments = arguments;
DisplayName = GetDisplayNameWithArguments(displayNameBase, arguments, resolvedTypes);
SkipReason = factAttribute.GetNamedArgument <string>("Skip");
Traits = new Dictionary <string, List <string> >(StringComparer.OrdinalIgnoreCase);
TestCollection = testCollection;
foreach (var traitAttribute in Method.GetCustomAttributes(typeof(ITraitAttribute))
.Concat(Class.GetCustomAttributes(typeof(ITraitAttribute))))
{
var discovererAttribute = traitAttribute.GetCustomAttributes(typeof(TraitDiscovererAttribute)).First();
var discoverer = ExtensibilityPointFactory.GetTraitDiscoverer(discovererAttribute);
if (discoverer != null)
{
foreach (var keyValuePair in discoverer.GetTraits(traitAttribute))
{
Traits.Add(keyValuePair.Key, keyValuePair.Value);
}
}
}
uniqueID = new Lazy <string>(GetUniqueID, true);
}
public virtual void AttemptToAddSameItemTwice()
{
var payment = FindById("Polymorphic Payments", 6);
var inv = FindById("Invoice As Payable Items", 1);
string invId = inv.GetPropertyByName("Id").Title;
ITestCollection links = payment.GetPropertyByName("Payable Item Links").ContentAsCollection;
ITestCollection items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
links.AssertCountIs(0);
items.AssertCountIs(0);
//Add an Invoice
payment.GetAction("Add Payable Item").InvokeReturnObject(inv);
links.AssertCountIs(1);
items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
items.AssertCountIs(1);
//Try adding same expense claim again
payment.GetAction("Add Payable Item").InvokeReturnObject(inv);
links.AssertCountIs(1); //Should still be 1
items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
items.AssertCountIs(1);
}
public virtual void RemoveItem()
{
var payment = FindById("Polymorphic Payments", 7);
var inv = FindById("Invoice As Payable Items", 1);
string invId = inv.GetPropertyByName("Id").Title;
ITestCollection links = payment.GetPropertyByName("Payable Item Links").ContentAsCollection;
ITestCollection items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
links.AssertCountIs(0);
items.AssertCountIs(0);
//Add an Invoice
payment.GetAction("Add Payable Item").InvokeReturnObject(inv);
links.AssertCountIs(1);
items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
ITestCollection item = items.AssertCountIs(1);
//Now remove the invoice
payment.GetAction("Remove Payable Item").InvokeReturnObject(inv);
links.AssertCountIs(0);
items = payment.GetPropertyByName("Payable Items").ContentAsCollection;
items.AssertCountIs(0);
}
protected override async Task <RunSummary> RunTestCollectionAsync(
IMessageBus messageBus,
ITestCollection testCollection,
IEnumerable <IXunitTestCase> testCases,
CancellationTokenSource cancellationTokenSource)
{
var runner = new XunitTestCollectionRunnerWithAssemblyFixture(
_assemblyFixtureMappings,
testCollection,
testCases,
DiagnosticMessageSink,
messageBus,
TestCaseOrderer,
new ExceptionAggregator(Aggregator),
cancellationTokenSource
);
var summary = await runner.RunAsync();
var fixture = (TestsFixture)_assemblyFixtureMappings.Single().Value;
fixture.RunSummary.Aggregate(summary);
return(summary);
}
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus bus, ITestCollection col, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cts) =>
new TestCollectionRunner(
assemblyFixtureMappings, col, testCases, DiagnosticMessageSink, bus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cts
).RunAsync();
/// <summary>
/// Initializes a new instance of the <see cref="LambdaTestCase"/> class.
/// </summary>
/// <param name="testCollection">The test collection this test case belongs to.</param>
/// <param name="assembly">The test assembly.</param>
/// <param name="testClass">The test class.</param>
/// <param name="testMethod">The test method.</param>
/// <param name="factAttribute">The instance of <see cref="FactAttribute"/>.</param>
/// <param name="lambda">The code to run for the test.</param>
public LambdaTestCase(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo testClass, IMethodInfo testMethod, IAttributeInfo factAttribute, Action lambda)
: base(testCollection, assembly, testClass, testMethod, factAttribute)
{
this.lambda = lambda;
}
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource)
{
Task <RunSummary> result = null;
ExecutionContext.Run(_context, state => result = new CollectionRunner(_assemblyFixtureMappings, testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource).RunAsync(), state: null);
return(result);
}
XElement GetTestCollectionElement(ITestCollection testCollection)
{
return(_testCollectionElements.GetOrAdd(testCollection, tc => new XElement("collection")));
}
/// <summary>
/// Initializes a new instance of the <see cref="TestCollectionMessage"/> class.
/// </summary>
internal TestCollectionMessage(ITestCase testCase, ITestCollection testCollection)
: base(testCase, testCollection.TestAssembly)
{
TestCollection = testCollection;
}
/// <summary>
/// Initializes a new instance of the <see cref="LambdaTestCase"/> class.
/// </summary>
/// <param name="testCollection">The test collection this test case belongs to.</param>
/// <param name="assembly">The test assembly.</param>
/// <param name="testClass">The test class.</param>
/// <param name="testMethod">The test method.</param>
/// <param name="factAttribute">The instance of <see cref="FactAttribute"/>.</param>
/// <param name="lambda">The code to run for the test.</param>
public LambdaTestCase(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo testClass, IMethodInfo testMethod, IAttributeInfo factAttribute, Action lambda)
: base(testCollection, assembly, testClass, testMethod, factAttribute)
{
this.lambda = lambda;
}
/// <summary> /// Override this method to run the tests in an individual test collection. /// </summary> /// <param name="messageBus">The message bus to report run status to.</param> /// <param name="testCollection">The test collection that is being run.</param> /// <param name="testCases">The test cases to be run.</param> /// <param name="cancellationTokenSource">The task cancellation token source, used to cancel the test run.</param> /// <returns>Returns summary information about the tests that were run.</returns> protected abstract Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <TTestCase> testCases, CancellationTokenSource cancellationTokenSource);
/// <summary>
/// Initializes a new instance of the <see cref="XunitTestClass"/> class.
/// </summary>
public XunitTestClass(ITestCollection testCollection, ITypeInfo @class)
{
Class = @class;
TestCollection = testCollection;
}
void LogTestCollectionDetails(ITestCollection collection, Action <string> log = null, StringBuilder sb = null)
{
do_log($" Test collection: {collection.DisplayName}", log, sb);
}
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource) => new XunitInjectingTestCollectionRunner(testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource).RunAsync();
public TestMethodStarting(ITestCollection testCollection, string className, string methodName)
: base(testCollection)
{
ClassName = className;
MethodName = methodName;
}
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <ITestCase> testCases, CancellationTokenSource cancellationTokenSource)
{
if (cancelInRunTestCollectionAsync)
{
cancellationTokenSource.Cancel();
}
RunTestCollectionAsync_AggregatorResult = Aggregator.ToException();
CollectionsRun.Add(Tuple.Create(testCollection, testCases));
return(Task.FromResult(result));
}
/// <summary>
/// Initializes a new instance of the <see cref="TestCollectionMessage"/> class.
/// </summary>
public TestCollectionMessage(IEnumerable<ITestCase> testCases, ITestCollection testCollection)
: base(testCases, testCollection.TestAssembly)
{
TestCollection = testCollection;
}
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource)
{
return(new CollectionRunner(testCollection, testCases, DiagnosticMessageSink, messageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), cancellationTokenSource, _assemblyFixtureMappings).RunAsync());
}
public TestMethodFinished(ITestCollection testCollection, string className, string methodName)
: base(testCollection)
{
ClassName = className;
MethodName = methodName;
}
RunSummary RunTestClass(ITestCollection testCollection, string className, IList<Xunit1TestCase> testCases, IMessageSink messageSink)
{
var handler = new TestClassCallbackHandler(testCases, messageSink);
var results = handler.TestClassResults;
results.Continue = messageSink.OnMessage(new TestClassStarting(testCollection, className));
if (results.Continue)
{
try
{
var methodNames = testCases.Select(tc => tc.Method.Name).ToList();
executor.RunTests(className, methodNames, handler);
handler.LastNodeArrived.WaitOne();
}
catch (Exception ex)
{
var stackTrace = ex.StackTrace;
var rethrowIndex = stackTrace.IndexOf("$$RethrowMarker$$");
if (rethrowIndex > -1)
stackTrace = stackTrace.Substring(0, rethrowIndex);
results.Continue = messageSink.OnMessage(new ErrorMessage(ex.GetType().FullName, ex.Message, stackTrace)) && results.Continue;
}
}
results.Continue = messageSink.OnMessage(new TestClassFinished(testCollection, className, results.Time, results.Total, results.Failed, results.Skipped)) && results.Continue;
return results;
}
public CollectionRunner(Dictionary <Type, object> assemblyFixtureMappings, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, IMessageSink diagnosticMessageSink, IMessageBus messageBus, ITestCaseOrderer testCaseOrderer, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource)
: base(testCollection, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource)
{
_assemblyFixtureMappings = assemblyFixtureMappings;
}
public TestCollectionMessage(ITestCollection testCollection)
{
TestCollection = testCollection;
}
XElement GetTestCollectionElement(ITestCollection testCollection)
{
lock (testCollectionElements)
return(testCollectionElements.GetOrAdd(testCollection.UniqueID, () => new XElement("collection")));
}
public static XunitTheoryTestCase XunitTheoryTestCase <TClassUnderTest>(string methodName, ITestCollection collection = null, IMessageSink diagnosticMessageSink = null)
{
var method = TestMethod(typeof(TClassUnderTest), methodName, collection);
return(new XunitTheoryTestCase(diagnosticMessageSink ?? new Xunit.NullMessageSink(), TestMethodDisplay.ClassAndMethod, method));
}
public TestFrameworkCollectionRunner(ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, IMessageSink diagnosticMessageSink, IMessageBus messageBus, ITestCaseOrderer testCaseOrderer, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource) : base(testCollection, testCases, diagnosticMessageSink, messageBus, testCaseOrderer, aggregator, cancellationTokenSource)
{
_diagnosticMessageSink = diagnosticMessageSink;
}
/// <inheritdoc/>
public IEnumerable <IXunitTestCase> Discover(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo testClass, IMethodInfo testMethod, IAttributeInfo factAttribute)
{
yield return(new XunitTestCase(testCollection, assembly, testClass, testMethod, factAttribute));
}
RunSummary RunTestClass(ITestCollection testCollection, string className, IList<Xunit1TestCase> testCases, IMessageSink messageSink)
{
var handler = new TestClassCallbackHandler(testCases, messageSink);
var results = handler.TestClassResults;
results.Continue = messageSink.OnMessage(new TestClassStarting(testCollection, className));
if (results.Continue)
{
try
{
var methodNames = testCases.Select(tc => tc.Method.Name).ToList();
executor.RunTests(className, methodNames, handler);
handler.LastNodeArrived.WaitOne();
}
catch (Exception ex)
{
var failureInformation = Xunit1ExceptionUtility.ConvertToFailureInformation(ex);
results.Continue = messageSink.OnMessage(new ErrorMessage(failureInformation.ExceptionTypes, failureInformation.Messages, failureInformation.StackTraces, failureInformation.ExceptionParentIndices)) && results.Continue;
}
}
results.Continue = messageSink.OnMessage(new TestClassFinished(testCollection, className, results.Time, results.Total, results.Failed, results.Skipped)) && results.Continue;
return results;
}
/// <summary>
/// Initializes a new instance of the <see cref="XunitTheoryTestCase"/> class.
/// </summary>
/// <param name="testCollection">The test collection this theory belongs to.</param>
/// <param name="assembly">The test assembly.</param>
/// <param name="type">The type under test.</param>
/// <param name="method">The method under test.</param>
/// <param name="theoryAttribute">The theory attribute.</param>
public XunitTheoryTestCase(ITestCollection testCollection, IAssemblyInfo assembly, ITypeInfo type, IMethodInfo method, IAttributeInfo theoryAttribute)
: base(testCollection, assembly, type, method, theoryAttribute) { }
RunSummary RunTestCollection(ITestCollection testCollection, IEnumerable<Xunit1TestCase> testCases, IMessageSink messageSink)
{
var results = new RunSummary();
results.Continue = messageSink.OnMessage(new TestCollectionStarting(testCollection));
if (results.Continue)
foreach (var testClassGroup in testCases.GroupBy(tc => tc.Class.Name))
{
var classResults = RunTestClass(testCollection, testClassGroup.Key, testClassGroup.ToList(), messageSink);
results.Aggregate(classResults);
if (!classResults.Continue)
break;
}
results.Continue = messageSink.OnMessage(new TestCollectionFinished(testCollection, results.Time, results.Total, results.Failed, results.Skipped)) && results.Continue;
return results;
}
public TestClassStarting(ITestCollection testCollection, string className)
: base(testCollection)
{
ClassName = className;
}
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource)
{
TestCasesRun.Add(Tuple.Create(Thread.CurrentThread.ManagedThreadId, testCases));
Thread.Sleep(5); // Hold onto the worker thread long enough to ensure tests all get spread around
return(Task.FromResult(new RunSummary()));
}
protected override Task <RunSummary> RunTestCollectionAsync(IMessageBus messageBus, ITestCollection testCollection, IEnumerable <IXunitTestCase> testCases, CancellationTokenSource cancellationTokenSource)
{
var collectionRunner = new XunitTestCollectionRunner(messageBus, testCollection, testCases, TestCaseOrderer, cancellationTokenSource);
return(collectionRunner.RunAsync());
}
