Support Cartesian products of environments in MultiEnvTestEngine

api/client-testextension/src/main/java/org/projectnessie/client/ext/MultiVersionApiTest.java

@@ -24,23 +24,20 @@
 import org.junit.platform.commons.util.AnnotationUtils;
 import org.junit.platform.engine.ConfigurationParameters;
 import org.junit.platform.engine.UniqueId;
+import org.projectnessie.junit.engine.MultiEnvSegmentType;
 import org.projectnessie.junit.engine.MultiEnvTestExtension;
 
 /**
  * Runs the related suite of tests for several Nessie API versions as specified by the {@link
  * NessieApiVersions} annotation.
  */
+@MultiEnvSegmentType(MultiVersionApiTest.API_VERSION_SEGMENT_TYPE)
 public class MultiVersionApiTest implements MultiEnvTestExtension, ExecutionCondition {
   public static final String API_VERSION_SEGMENT_TYPE = "nessie-api";
 
   // API version to be used for tests not annotated with `@ForNessieApiVersions`
   private static final NessieApiVersion DEFAULT_API_VERSION = NessieApiVersion.V2;
 
-  @Override
-  public String segmentType() {
-    return API_VERSION_SEGMENT_TYPE;
-  }
-
   @Override
   public List<String> allEnvironmentIds(ConfigurationParameters configuration) {
     return Arrays.stream(NessieApiVersion.values()).map(Enum::name).collect(Collectors.toList());

compatibility/common/src/main/java/org/projectnessie/tools/compatibility/internal/AbstractMultiVersionExtension.java

@@ -39,6 +39,7 @@
 import org.junit.platform.engine.ConfigurationParameters;
 import org.junit.platform.engine.UniqueId;
 import org.junit.platform.engine.UniqueId.Segment;
+import org.projectnessie.junit.engine.MultiEnvSegmentType;
 import org.projectnessie.junit.engine.MultiEnvTestExtension;
 import org.projectnessie.tools.compatibility.api.NessieVersion;
 import org.projectnessie.tools.compatibility.api.Version;
@@ -49,18 +50,14 @@
  *
  * <p>Implements extension to handle {@link VersionCondition}.
  */
+@MultiEnvSegmentType(AbstractMultiVersionExtension.NESSIE_VERSION_SEGMENT_TYPE)
 abstract class AbstractMultiVersionExtension
     implements BeforeAllCallback, BeforeEachCallback, ExecutionCondition, MultiEnvTestExtension {
 
-  private static final String NESSIE_VERSION_SEGMENT_TYPE = "nessie-version";
+  static final String NESSIE_VERSION_SEGMENT_TYPE = "nessie-version";
 
   private static final ConditionEvaluationResult PASS = enabled(null);
 
-  @Override
-  public String segmentType() {
-    return NESSIE_VERSION_SEGMENT_TYPE;
-  }
-
   @Override
   public List<String> allEnvironmentIds(ConfigurationParameters configuration) {
     try {

compatibility/common/src/test/java/org/projectnessie/tools/compatibility/internal/TestNessieCompatibilityExtensions.java

@@ -76,8 +76,7 @@ void noVersions() {
         .hasMessageContaining("TestEngine with ID 'nessie-multi-env' failed to discover tests")
         .cause()
         .hasMessageContaining(
-            "MultiEnvTestEngine was enabled, but test extensions did not discover any environment IDs")
-        .hasMessageContaining("OlderNessieClientsExtension");
+            "MultiEnvTestEngine was enabled, but test extensions [OlderNessieClientsExtension] did not discover any environment IDs.");
   }
 
   @Test

testing/multi-env-test-engine/build.gradle.kts

@@ -28,6 +28,10 @@ dependencies {
   api("org.junit.jupiter:junit-jupiter-api")
   compileOnly("org.junit.jupiter:junit-jupiter-engine")
   implementation("org.junit.platform:junit-platform-launcher")
+  implementation(libs.guava)
+
+  compileOnly(libs.immutables.value.annotations)
+  annotationProcessor(libs.immutables.value.processor)
 
   testImplementation("org.junit.platform:junit-platform-testkit")
   testCompileOnly("org.junit.jupiter:junit-jupiter-engine")

testing/multi-env-test-engine/src/main/java/org/projectnessie/junit/engine/MultiEnvAnnotationUtils.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2024 Dremio
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.projectnessie.junit.engine;
+
+import java.lang.annotation.Annotation;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.platform.commons.util.AnnotationUtils;
+
+public final class MultiEnvAnnotationUtils {
+  private MultiEnvAnnotationUtils() {}
+
+  public static <A extends Annotation> Set<A> findNestedRepeatableAnnotationsOn(
+      Class<?> classToSearch, Class<A> annotationType) {
+    Set<A> annotations = new HashSet<>();
+    // Find annotations following the class nesting chain
+    for (Class<?> cl = classToSearch; cl != null; cl = cl.getDeclaringClass()) {
+      annotations.addAll(AnnotationUtils.findRepeatableAnnotations(cl, annotationType));
+    }
+    return annotations;
+  }
+
+  public static Stream<Class<? extends MultiEnvTestExtension>> findNestedMultiEnvTestExtensionsOn(
+      Class<?> classToSearch) {
+    //noinspection unchecked
+    return findNestedRepeatableAnnotationsOn(classToSearch, ExtendWith.class).stream()
+        .flatMap(extendWithAnnotation -> Arrays.stream(extendWithAnnotation.value()))
+        .filter(MultiEnvTestExtension.class::isAssignableFrom)
+        .map(e -> (Class<? extends MultiEnvTestExtension>) e);
+  }
+
+  public static String segmentTypeOf(Class<? extends MultiEnvTestExtension> extensionClass) {
+    MultiEnvSegmentType segmentTypeAnnotation =
+        extensionClass.getAnnotation(MultiEnvSegmentType.class);
+
+    if (segmentTypeAnnotation == null) {
+      throw new IllegalStateException(
+          String.format(
+              "%s is missing a MultiEnvSegmentType annotation.", extensionClass.getName()));
+    }
+
+    return segmentTypeAnnotation.value();
+  }
+
+  public static String segmentTypeOf(MultiEnvTestExtension extension) {
+    return segmentTypeOf(extension.getClass());
+  }
+}

testing/multi-env-test-engine/src/main/java/org/projectnessie/junit/engine/MultiEnvExtensionRegistry.java

@@ -15,14 +15,11 @@
  */
 package org.projectnessie.junit.engine;
 
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
+import static org.projectnessie.junit.engine.MultiEnvAnnotationUtils.findNestedMultiEnvTestExtensionsOn;
+
 import java.util.stream.Stream;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.engine.config.DefaultJupiterConfiguration;
 import org.junit.jupiter.engine.extension.MutableExtensionRegistry;
-import org.junit.platform.commons.util.AnnotationUtils;
 
 /**
  * A helper class for collecting instances of {@link MultiEnvTestExtension}.
@@ -34,36 +31,16 @@ public class MultiEnvExtensionRegistry {
   private final MutableExtensionRegistry registry;
 
   public MultiEnvExtensionRegistry() {
-    this.registry =
+    registry =
         MutableExtensionRegistry.createRegistryWithDefaultExtensions(
             new DefaultJupiterConfiguration(new EmptyConfigurationParameters()));
   }
 
   public void registerExtensions(Class<?> testClass) {
-    AnnotationUtils.findRepeatableAnnotations(testClass, ExtendWith.class).stream()
-        .flatMap(e -> Arrays.stream(e.value()))
-        .filter(MultiEnvTestExtension.class::isAssignableFrom)
-        .forEach(registry::registerExtension);
-  }
-
-  public Stream<MultiEnvTestExtension> stream() {
-    return registry.stream(MultiEnvTestExtension.class);
+    findNestedMultiEnvTestExtensionsOn(testClass).forEach(registry::registerExtension);
   }
 
   public Stream<? extends MultiEnvTestExtension> stream(Class<?> testClass) {
-    Set<ExtendWith> annotations = new HashSet<>();
-    // Find annotations following the class nesting chain
-    for (Class<?> cl = testClass; cl != null; cl = cl.getDeclaringClass()) {
-      annotations.addAll(AnnotationUtils.findRepeatableAnnotations(cl, ExtendWith.class));
-    }
-
-    @SuppressWarnings("unchecked")
-    Stream<? extends MultiEnvTestExtension> r =
-        (Stream<? extends MultiEnvTestExtension>)
-            annotations.stream()
-                .flatMap(e -> Arrays.stream(e.value()))
-                .filter(MultiEnvTestExtension.class::isAssignableFrom)
-                .flatMap(registry::stream);
-    return r;
+    return findNestedMultiEnvTestExtensionsOn(testClass).flatMap(registry::stream);
   }
 }

testing/multi-env-test-engine/src/main/java/org/projectnessie/junit/engine/MultiEnvSegmentType.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2024 Dremio
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.projectnessie.junit.engine;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface MultiEnvSegmentType {
+  String value();
+}