Is it valid to use a non-static @RegisterExtension field when the extension implements BeforeAllCallback?

[madlexa]

Hi JUnit team! I'm a developer at JetBrains maintaining the JUnit plugin for IntelliJ IDEA. I'd like to get your input on a question that came up in our issue tracker.

Context

IntelliJ IDEA warns when a non-static @RegisterExtension field's type implements BeforeAllCallback or AfterAllCallback (see IDEA-362874). The warning says [extension] should be registered at the class level.

This is based on the @RegisterExtension Javadoc:

"Thus, if such an instance extension implements class-level or instance-level extension APIs such as BeforeAllCallback, AfterAllCallback, TestInstanceFactory, or TestInstancePostProcessor those APIs will not be honored."

The Problem

WireMock's documentation describes non-static usage:

"if the extension fields are declared at the instance scope (without the static modifier) each WireMock server will be created and started before each test method and stopped after the end of the test method."

WireMockExtension implements both BeforeAllCallback and BeforeEachCallback. As a non-static field, BeforeAllCallback is skipped and BeforeEachCallback runs instead - which is the behavior WireMock's docs describe. Users write code like this and it works at runtime, but IntelliJ warns.

The pattern in question (simplified):

class MyExtension implements BeforeAllCallback {
    @Override
    public void beforeAll(ExtensionContext context) { }
}

class MyTest {
    @RegisterExtension
    MyExtension ext = new MyExtension(); // IntelliJ warns here

    @Test
    void test() { }
}

Question

Is this a valid usage pattern that IntelliJ should support, or should libraries like WireMock not recommend it?

If it's not valid - please write a comment in IDEA-362874 confirming this. And we can open an issue in WireMock and similar libraries. IntelliJ can then keep the current warning.

If it is valid - how should IDEs detect when to warn? We don't want to silently drop the warning for all extensions that implement BeforeAllCallback, as that would hide real mistakes.

[mpkorstanje]

For completeness, do you have an example of an extension that should always be declared through a static field? I.e. is there a concrete example that prompted Intelij to implement a warning in the first place?

[mpkorstanje]

@madlexa rather than an example from the documentation, I was looking for an example of an existing extension where issuing a warning would be justified. The current example, the Wiremock extension, implements the BeforeAllCallback with the expectation that it won't be called for some usages. If all known extensions are implemented with that same expectation then there is nothing to warn about in the first place.

If we are dealing with a hypothetical then I don't think issuing a warning to users would be correct, nor would asking extension authors to change their extension be correct.

[mpkorstanje]

It's not strictly prohibited but methods of those Extension interfaces will not be called if the field isn't static so it's correct to issue a warning.

@marcphilipp with the way the hierarchical extension context is designed, we've made it very easy to create extensions that are declared using a static or non-static field and still function correctly. So I don't think issuing a warning here is categorically correct. The extension authors have chosen to support both use-cases.

The alternatives for extension authors would be much messier. They'd have to implement two extensions, one for static and for non-static use.

[madlexa]

A few clarifications.

IntelliJ warns when code is compiled but likely not what the developer intended. Examples: @ParameterizedTest without a source, a non-static inner class without @Nested. A non-static @RegisterExtension field that implements BeforeAllCallback is the same case - the developer expects beforeAll() to run, but the docs say it will not.

WireMock works differently. It implements both BeforeAllCallback and BeforeEachCallback. For a non-static field, the instance-level callback runs instead. This is by design, not a mistake.

We are considering two rules. Could you tell us if this approach is correct?

1. Warn at the field - only when the type implements BeforeAllCallback/AfterAllCallback but does not also implement BeforeEachCallback/AfterEachCallback. Extension authors do not need separate versions - implementing both callbacks is enough to signal dual usage.
2. Warn at the extension class - when it implements both BeforeAllCallback and BeforeEachCallback (or AfterAllCallback and AfterEachCallback). These two interfaces require different field declarations: BeforeAllCallback needs a static field, BeforeEachCallback needs a non-static field. The class should document which usage is intended.

Our goal is to help users avoid mistakes and to follow JUnit documentation and the recommendations of the JUnit team. We want to make sure IntelliJ warnings are accurate and useful - not noisy. Your guidance here would help us get this right.

[marcphilipp]

I think (1) is an improvement to the current situation. However, I think (2) would yield to many false-positives since there are extensions that are not intended to be used with fields at all.