[NotInParallel] Support nested ConstraintKeys: combine class and method constraints

[DmitryKomarov]

Introduction

I have a large number of tests that rely on various unmanaged/shared resources, so I need flexible control over parallelism in TUnit.
In most cases, these resources are databases, Kafka instances, or other external systems.

Default behavior

By default, [NotInParallel] behaves like an override.
If I apply it on a method, it replaces the one defined on the class (or base class), instead of combining them.

Here is an example that works, but requires explicitly specifying all keys on each test:

public class DemoDefault
{
    public static readonly Func<Task> Action = async () => await Task.Delay(5000);

    public const string UnmanagedA = "A";
    public const string UnmanagedB = "B";

    public class BaseA {}

    public class BaseB {}

    public class ATests : BaseA
    {
        [Test]
        [NotInParallel(UnmanagedA)]
        public async Task DefaultTestA1() => await Action();

        [Test]
        [NotInParallel(UnmanagedA)]
        public async Task DefaultTestA2() => await Action();

        [Test]
        [NotInParallel([UnmanagedA, UnmanagedB])]
        public async Task DefaultTestAB() => await Action();
    }

    public class BTests : BaseB
    {
        [Test]
        [NotInParallel(UnmanagedB)]
        public async Task DefaultTestB1() => await Action();

        [Test]
        [NotInParallel(UnmanagedB)]
        public async Task DefaultTestB2() => await Action();

        [Test]
        [NotInParallel(UnmanagedB)]
        public async Task DefaultTestB3() => await Action();
    }
}

Problem

With many tests and shared resources, this approach becomes hard to maintain:

Constraint definitions are duplicated across tests

It’s easy to forget a key and accidentally introduce parallel conflicts

Base classes cannot effectively define shared constraints

Also, [DependsOn] is not suitable for my scenario. I don’t want to enforce sequential execution between tests — I want tests to run concurrently as long as they use different resources, and only prevent parallel execution when tests share the same resource.

Desired behavior

In my case, it would be much more convenient to combine (union) the keys instead of overriding them.

Something like this:

public class DemoDesired
{
    public static readonly Func<Task> Action = async () => await Task.Delay(5000);

    public const string UnmanagedA = "A";
    public const string UnmanagedB = "B";

    [NotInParallel(UnmanagedA)]
    public class BaseA {}

    [NotInParallel(UnmanagedB)]
    public class BaseB {}

    public class ATests : BaseA
    {
        [Test]
        public async Task DesiredTestA1() => await Action();

        [Test]
        public async Task DesiredTestA2() => await Action();

        [Test]
        [NotInParallel(UnmanagedB)]
        public async Task DesiredTestAB() => await Action();
    }

    public class BTests : BaseB
    {
        [Test]
        public async Task DesiredTestB1() => await Action();

        [Test]
        public async Task DesiredTestB2() => await Action();

        [Test]
        public async Task DesiredTestB3() => await Action();
    }
}

This way, I could define shared constraints once (e.g. on a base class) and only add extra ones when needed.

My workaround

I found a workaround, but it feels quite hacky:

[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class | AttributeTargets.Assembly)]
public class MyNotInParallelAttribute : Attribute, ITestDiscoveryEventReceiver
{
    public string[] ConstraintKeys { get; } = [];

    public int Order { get; } = int.MaxValue / 2;

    public MyNotInParallelAttribute()
    {
    }

    public MyNotInParallelAttribute(string constraintKey) : this([constraintKey])
    {
        if (constraintKey is null or { Length: < 1 })
        {
            throw new ArgumentException("No constraint key was provided");
        }
    }

    public MyNotInParallelAttribute(string[] constraintKeys)
    {
        if (constraintKeys.Length != constraintKeys.Distinct().Count())
        {
            throw new ArgumentException("Duplicate constraint keys are not allowed.");
        }

        ConstraintKeys = constraintKeys;
    }

    public ValueTask OnTestDiscovered(DiscoveredTestContext context)
    {
        if (context.TestContext.Parallelism.Constraints.Any(x => x is NotInParallelConstraint))
        {
            return default;
        }

        var keys = context.TestDetails.Attributes.GetAttributes<MyNotInParallelAttribute>().SelectMany(x => x.ConstraintKeys).Distinct().ToArray();

        context.AddParallelConstraint(new NotInParallelConstraint(keys)
        {
            Order = Order
        });

        return default;
    }

    public Type ScopeType => typeof(MyNotInParallelAttribute);
}

Question

Is there a more correct or idiomatic way to achieve this kind of behavior in TUnit?

If not, I would appreciate any feedback or recommendations regarding my current workaround.

[thomhurst]

Out of the box - No, there isn't a clean way to do this.

Your workaround is a good solution for now - But as you say, it's not ideal, and it's extra work on you having to maintain that attribute.

I'd need to build something into TUnit to allow these to be mergeable.

I'm thinking something like an InheritParentKeys property on the attribute or something.

    [NotInParallel(X)]
    public class ATests : BaseA
    {
        [Test]
        public async Task DesiredTestA1() => await Action();

        [Test]
        public async Task DesiredTestA2() => await Action();

        [Test]
        [NotInParallel(Y, InheritParentKeys = true)]
        public async Task DesiredTestAB() => await Action();
    }

[DmitryKomarov]

Thank you for the quick response!

I hope this feature makes it into TUnit. It would be great if something like InheritParentKeys could also be configurable as the default behavior.