Fix AutoCleanupExtension.deferAfterAll firing per @nested container

AfterAllCallback.afterAll() fires once per container the extension is
registered in, including each @nested class (since static @RegisterExtension
fields are inherited). This caused deferAfterAll cleanups to run as soon
as the first nested container completed.

Track the outermost container via beforeAll and only run deferAfterAll
cleanups when afterAll fires on that same context.

This was breaking ApacheHttpAsyncClientTest, where the shared async
clients were closed after the first nested test class finished, causing
all subsequent nested tests to fail with CancellationException.

Author: trask

testing-common/src/main/java/io/opentelemetry/instrumentation/testing/internal/AutoCleanupExtension.java

@@ -11,6 +11,7 @@
 import java.util.concurrent.ConcurrentLinkedDeque;
 import org.junit.jupiter.api.extension.AfterAllCallback;
 import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeAllCallback;
 import org.junit.jupiter.api.extension.ExtensionContext;
 
 /**
@@ -21,9 +22,13 @@
  * <p>This class is internal and is hence not for public use. Its APIs are unstable and can change
  * at any time.
  */
-public class AutoCleanupExtension implements AfterEachCallback, AfterAllCallback {
+public class AutoCleanupExtension
+    implements BeforeAllCallback, AfterEachCallback, AfterAllCallback {
   private final Deque<AutoCloseable> thingsToCleanUp = new ConcurrentLinkedDeque<>();
   private final Deque<AutoCloseable> thingsToCleanUpAfterAll = new ConcurrentLinkedDeque<>();
+  // Tracks the first (outermost) container the extension is registered in, so that afterAll only
+  // runs deferAfterAll cleanups once — not once per @Nested container.
+  private volatile ExtensionContext rootContext;
 
   public static AutoCleanupExtension create() {
     return new AutoCleanupExtension();
@@ -41,6 +46,13 @@ public void deferAfterAll(AutoCloseable cleanupAction) {
     thingsToCleanUpAfterAll.push(cleanupAction);
   }
 
+  @Override
+  public void beforeAll(ExtensionContext extensionContext) {
+    if (rootContext == null) {
+      rootContext = extensionContext;
+    }
+  }
+
   @Override
   public void afterEach(ExtensionContext extensionContext) throws Exception {
     List<Exception> exceptions = new ArrayList<>();
@@ -56,6 +68,11 @@ public void afterEach(ExtensionContext extensionContext) throws Exception {
 
   @Override
   public void afterAll(ExtensionContext extensionContext) throws Exception {
+    // afterAll fires once per container the extension is registered in, including each @Nested
+    // class. Only run deferAfterAll cleanups when the outermost container completes.
+    if (extensionContext != rootContext) {
+      return;
+    }
     List<Exception> exceptions = new ArrayList<>();
     while (!thingsToCleanUpAfterAll.isEmpty()) {
       try {

testing-common/src/test/java/io/opentelemetry/instrumentation/testing/junit/AutoCleanupExtensionTest.java

@@ -6,13 +6,15 @@
 package io.opentelemetry.instrumentation.testing.junit;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
 
 import io.opentelemetry.instrumentation.testing.internal.AutoCleanupExtension;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
 class AutoCleanupExtensionTest {
@@ -60,4 +62,27 @@ void shouldRunDeferCleanupInLifoOrder() throws Exception {
 
     assertThat(order).containsExactly(3, 2, 1);
   }
+
+  @Test
+  void shouldRunAfterAllCleanupOnlyOnceAcrossNestedContainers() throws Exception {
+    AutoCleanupExtension cleanup = AutoCleanupExtension.create();
+    AtomicInteger closed = new AtomicInteger(0);
+
+    ExtensionContext rootContext = mock(ExtensionContext.class);
+    ExtensionContext nestedContext = mock(ExtensionContext.class);
+
+    // Simulate JUnit registering the extension on the outer container, then entering a @Nested
+    // container. AfterAllCallback#afterAll fires once per container, so it will fire for the
+    // nested context first and then for the root context.
+    cleanup.beforeAll(rootContext);
+    cleanup.beforeAll(nestedContext);
+
+    cleanup.deferAfterAll(closed::incrementAndGet);
+
+    cleanup.afterAll(nestedContext);
+    assertThat(closed.get()).isEqualTo(0);
+
+    cleanup.afterAll(rootContext);
+    assertThat(closed.get()).isEqualTo(1);
+  }
 }