Configuring deterministic execution order for multiple @ExtendWith annotations in JUnit 5

Answer: No global ordering mechanism exists

JUnit 5 does not provide a flag or configuration that makes the declaration order of @ExtendWith annotations deterministic. The platform discovers extensions via reflection and invokes their lifecycle callbacks in an unspecified order that may vary between JVMs, classloaders, or JUnit releases.

Confirmed facts

• The only way to obtain a defined invocation order is for each extension to implement the org.junit.jupiter.api.extension.Orderable interface (or be declared as a @RegisterExtension field with an @Order annotation).
• There is no junit-platform.properties property that forces annotation‑order‑based sorting.
• If you cannot modify the original extensions, you can create a wrapper extension that implements Orderable and delegates to the wrapped extensions in the sequence you choose.

Steps to achieve a stable order without changing the original extensions

1. Create a wrapper class that implements BeforeEachCallback, AfterEachCallback (or any other lifecycle interfaces you need) and Orderable.
2. In the wrapper’s constructor, accept the original extension instances (or their class references) and store them in a list that reflects the desired order.
3. Implement the lifecycle methods to iterate over the stored extensions and delegate the call to each one in that list.
4. Implement getOrder() to return a value that positions the wrapper relative to any other ordered extensions you may have.
5. Annotate your test class with @ExtendWith(YourWrapper.class) (remove the individual @ExtendWith annotations for the wrapped extensions).

public class OrderedExtensionWrapper implements BeforeEachCallback, AfterEachCallback, Orderable {
    private final List<BeforeEachCallback> befores = new ArrayList<>();
    private final List<AfterEachCallback>  afters  = new ArrayList<>();
    private final int order;

    public OrderedExtensionWrapper(int order, Extension... extensions) {
        this.order = order;
        for (Extension e : extensions) {
            if (e instanceof BeforeEachCallback) befores.add((BeforeEachCallback) e);
            if (e instanceof AfterEachCallback)  afters.add((AfterEachCallback)  e);
        }
    }

    @Override
    public int getOrder() {
        return order;
    }

    @Override
    public void beforeEach(ExtensionContext context) throws Exception {
        for (BeforeEachCallback cb : befores) {
            cb.beforeEach(context);
        }
    }

    @Override
    public void afterEach(ExtensionContext context) throws Exception {
        for (AfterEachCallback cb : afters) {
            cb.afterEach(context);
        }
    }
}

// Usage in a test class
@ExtendWith(OrderedExtensionWrapper.class)
public class MyTest {
    @Test
    void something() { /* … */ }
}

When to ask for a diagnostic detail
If you are using a JUnit 5 version prior to 5.7 (where Orderable was introduced), the wrapper approach is the only viable path; otherwise, simply implement Orderable directly on each extension. Knowing your exact JUnit version would confirm whether Orderable is available, but the wrapper works on all 5.x releases.