feat: Run classes in parallel if they are in a single collection (#17)

* Run classes in parallel if they are in a single collection

* Don't break default behavior

* Bump version to 2.3.0

* Fix release build

* Update Analyzer to 2.0.162

---------

Co-authored-by: Preben Huybrechts <[email protected]>

Directory.Build.props

@@ -35,7 +35,7 @@
 
   <!-- Analyzers -->
   <ItemGroup>  
-    <PackageReference Include="Meziantou.Analyzer" Version="1.0.644">
+    <PackageReference Include="Meziantou.Analyzer" Version="2.0.162">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>

Meziantou.Xunit.ParallelTestFramework.Tests/CollectionConcurrencyFixture.cs

@@ -0,0 +1,19 @@
+namespace Meziantou.Xunit.ParallelTestFramework.Tests;
+
+public class CollectionConcurrencyFixture
+{
+    private int concurrency;
+
+    public async Task<int> CheckConcurrencyAsync()
+    {
+        Interlocked.Increment(ref concurrency);
+        await Task.Delay(TimeSpan.FromMilliseconds(1000)).ConfigureAwait(false);
+
+        var overlap = concurrency;
+
+        await Task.Delay(TimeSpan.FromMilliseconds(1000)).ConfigureAwait(false);
+        Interlocked.Decrement(ref concurrency);
+
+        return overlap;
+    }
+}

Meziantou.Xunit.ParallelTestFramework.Tests/ParallelCollectionMultiClass1AttributeTests.cs

@@ -0,0 +1,26 @@
+using Xunit;
+
+namespace Meziantou.Xunit.ParallelTestFramework.Tests;
+
+[Collection("ParallelMultiClass")]
+public class ParallelCollectionMultiClass1AttributeTests
+{
+    private readonly CollectionConcurrencyFixture fixture;
+
+    public ParallelCollectionMultiClass1AttributeTests(CollectionConcurrencyFixture fixture)
+    {
+        this.fixture = fixture;
+    }
+
+    [Fact]
+    public async Task Fact1()
+    {
+        Assert.Equal(2, await fixture.CheckConcurrencyAsync().ConfigureAwait(false));
+    }
+
+    [Fact]
+    public async Task Fact2()
+    {
+        Assert.Equal(2, await fixture.CheckConcurrencyAsync().ConfigureAwait(false));
+    }
+}

Meziantou.Xunit.ParallelTestFramework.Tests/ParallelCollectionMultiClass2AttributeTests.cs

@@ -0,0 +1,26 @@
+using Xunit;
+
+namespace Meziantou.Xunit.ParallelTestFramework.Tests;
+
+[Collection("ParallelMultiClass")]
+public class ParallelCollectionMultiClass2AttributeTests
+{
+    private readonly CollectionConcurrencyFixture fixture;
+
+    public ParallelCollectionMultiClass2AttributeTests(CollectionConcurrencyFixture fixture)
+    {
+        this.fixture = fixture;
+    }
+
+    [Fact]
+    public async Task Fact1()
+    {
+        Assert.Equal(2, await fixture.CheckConcurrencyAsync().ConfigureAwait(false));
+    }
+
+    [Fact]
+    public async Task Fact2()
+    {
+        Assert.Equal(2, await fixture.CheckConcurrencyAsync().ConfigureAwait(false));
+    }
+}

Meziantou.Xunit.ParallelTestFramework.Tests/ParallelMultiClassCollectionFixture.cs

@@ -0,0 +1,9 @@
+using Xunit;
+
+namespace Meziantou.Xunit.ParallelTestFramework.Tests;
+
+[CollectionDefinition("ParallelMultiClass")]
+[EnableParallelization]
+public class ParallelMultiClassCollectionFixture : ICollectionFixture<CollectionConcurrencyFixture>
+{
+}

Meziantou.Xunit.ParallelTestFramework/Meziantou.Xunit.ParallelTestFramework.csproj

@@ -7,7 +7,7 @@
     <Description>Run xUnit test cases in parallel</Description>
     <IsPackable>True</IsPackable>
     <PackageReadmeFile>README.md</PackageReadmeFile>
-    <Version>2.2.0</Version>
+    <Version>2.3.0</Version>
   </PropertyGroup>
 
   <ItemGroup>

Meziantou.Xunit.ParallelTestFramework/ParallelTestCollectionRunner.cs

@@ -1,3 +1,4 @@
+using Xunit;
 using Xunit.Abstractions;
 using Xunit.Sdk;
 
@@ -12,4 +13,36 @@ public ParallelTestCollectionRunner(ITestCollection testCollection, IEnumerable<
 
     protected override Task<RunSummary> RunTestClassAsync(ITestClass testClass, IReflectionTypeInfo @class, IEnumerable<IXunitTestCase> testCases)
         => new ParallelTestClassRunner(testClass, @class, testCases, DiagnosticMessageSink, MessageBus, TestCaseOrderer, new ExceptionAggregator(Aggregator), CancellationTokenSource, CollectionFixtureMappings).RunAsync();
+
+
+    protected override async Task<RunSummary> RunTestClassesAsync()
+    {
+
+        if (TestCollection.CollectionDefinition != null)
+        {
+            var enableParallelizationAttribute = TestCollection.CollectionDefinition.GetCustomAttributes(typeof(EnableParallelizationAttribute)).Any();
+            if (enableParallelizationAttribute)
+            {
+                var summary = new RunSummary();
+
+                var classTasks = TestCases.GroupBy(tc => tc.TestMethod.TestClass, TestClassComparer.Instance)
+                    .Select(tc => RunTestClassAsync(tc.Key, (IReflectionTypeInfo)tc.Key.Class, tc));
+
+                var classSummaries = await Task.WhenAll(classTasks)
+#if !NETSTANDARD
+                    .WaitAsync(CancellationTokenSource.Token)
+#endif
+                    .ConfigureAwait(false);
+                foreach (var classSummary in classSummaries)
+                {
+                    summary.Aggregate(classSummary);
+                }
+
+                return summary;
+            }
+        }
+
+        // Fall back to default behavior
+        return await base.RunTestClassesAsync().ConfigureAwait(false);
+    }
 }

README.md

@@ -83,3 +83,43 @@ public class SequentialTests
 ````
 
 The code is greatly inspired by the sample from [Travis Mortimer](https://github.com/tmort93): <https://github.com/xunit/xunit/issues/1986#issuecomment-831322722>
+
+
+## Parallel in a collection
+
+Using the `EnableParallelizationAttribute` on an `ICollectionFixture<T>` enables the parallel execution between classes in a collection.
+If you want to enable parallisation inside a class you still need to add the `EnableParallelizationAttribute` on the test class aswell.
+
+```c#
+[CollectionDefinition("MyFixture Collection")]
+[EnableParallelization] // This enables the parallel execution of classes in a collection 
+public class MyFixtureCollection : ICollectionFixture<MyFixture>
+{
+}
+
+[Collection("MyFixture Collection")]
+public class MyFirstTestClass
+{
+    private readonly MyFixture fixture;
+
+    public ParallelCollectionMultiClass1AttributeTests(MyFixture fixture)
+    {
+        this.fixture = fixture;
+    }
+
+    //...
+}
+
+[Collection("MyFixture Collection")]
+public class MySecondTestClass
+{
+    private readonly MyFixture fixture;
+
+    public ParallelCollectionMultiClass1AttributeTests(MyFixture fixture)
+    {
+        this.fixture = fixture;
+    }
+
+    //...
+}
+```