[NotInParallel] order at both class and test levels

[traiannemes]

My goal is to run in sequential mode tests at the class level then inside the class at the test level
In the following example I would expect that tests from Class1 run first in order and then when finished the same for tests from Class2. But they run in parallel, though at class level they share the same key.

[NotInParallel("Shared", Order = 1)]
public class Test1
{
    static readonly int MyConst = 1;

    [Test]
    [NotInParallel("Test1", Order = 1)]
    public async Task TestMethod1()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }

    [Test]
    [NotInParallel("Test1", Order = 2)]
    public async Task TestMethod2()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }

    [Test]
    [NotInParallel("Test1", Order = 3)]
    public async Task TestMethod3()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }

}

[NotInParallel("Shared", Order = 2)]
public class Test2
{
    static readonly int MyConst = 1;

    [Test]
    [NotInParallel("Test2", Order = 1)]
    public async Task TestMethod1()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }

    [Test]
    [NotInParallel("Test2", Order = 2)]
    public async Task TestMethod2()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }

    [Test]
    [NotInParallel("Test2", Order = 3)]
    public async Task TestMethod3()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }

}

[thomhurst]

[NotInParallel] attributes can be overridden, and use the priority:
Method > Class > Assembly.

I would recommend using [DependsOn] for better ordering:

public class Test1
{
    static readonly int MyConst = 1;

    [Test]
    public async Task TestMethod1()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }

    [Test]
    [DependsOn(nameof(TestMethod))]
    public async Task TestMethod2()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }

    [Test]
    [DependsOn(nameof(TestMethod2))]
    public async Task TestMethod3()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }

}

[DependsOn<Test1>]
public class Test2
{
    static readonly int MyConst = 1;

    [Test]
    public async Task TestMethod1()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }

    [Test]
    [DependsOn(nameof(TestMethod1))]
    public async Task TestMethod2()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }

    [Test]
    [DependsOn(nameof(TestMethod2))]
    public async Task TestMethod3()
    {
        await Task.Delay(1000);
        await Assert.That(MyConst).IsEqualTo(1);
    }
}

[traiannemes]

We have hundreds of tests that share the same TestContainer since those are resource intensive. So we needed order between most of them, at least within class level. But about one week ago after a test rehaul done in parallel plus upgrading to latest version of TUnit when running all tests (aka literally all) I saw that in one class the DependOn execution was not honored. So I transition to [NotInParallel] approach. But then when running all tests again another class with the same problem. Fixed it, too then ran again then another class, though in previous runs those classes were fine, reporting ok for tests. Maybe you get the idea, fixing one then another one pops for the same problem. Since it was hard to explain and report here I just decided to primary switch to NoInParallel approach. Now I guess as you explain here I could introduce some DependOn at class level, that's definitely doable. And still keep the NotInParallel with key and Order at method level.