Create plugin for internalClusterTest task (#56067)

This commit creates a new gradle plugin to provide a separate task name
and source set for running ESIntegTestCase tests. The only project
converted to use the new plugin in this PR is server, as an example. The
remaining cases in x-pack will be handled in followups.

backport of #55896

Author: rjernst

TESTING.asciidoc

@@ -165,8 +165,7 @@ class PrecommitTasks {
             }
 
             SourceSet sourceSet = project.sourceSets.getByName(sourceSetName)
-            FileCollection runtime = sourceSet.runtimeClasspath
-            classpath = runtime.plus(sourceSet.compileClasspath)
+            classpath = project.files { sourceSet.runtimeClasspath.plus(sourceSet.compileClasspath) }
 
             targetCompatibility = BuildParams.runtimeJavaVersion.majorVersion
             if (BuildParams.runtimeJavaVersion > JavaVersion.VERSION_13) {

buildSrc/src/main/groovy/org/elasticsearch/gradle/precommit/PrecommitTasks.groovy

@@ -20,6 +20,7 @@
 
 import groovy.lang.Closure;
 import org.elasticsearch.gradle.util.GradleUtils;
+import org.elasticsearch.gradle.util.Util;
 import org.gradle.api.DefaultTask;
 import org.gradle.api.NamedDomainObjectContainer;
 import org.gradle.api.Task;
@@ -46,9 +47,12 @@
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
 import java.nio.file.attribute.BasicFileAttributes;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
@@ -62,6 +66,8 @@ public class TestingConventionsTasks extends DefaultTask {
 
     private final NamedDomainObjectContainer<TestingConventionRule> naming;
 
+    private List<String> tasks = null;
+
     public TestingConventionsTasks() {
         setDescription("Tests various testing conventions");
         // Run only after everything is compiled
@@ -74,15 +80,16 @@ public Map<String, Set<File>> getClassFilesPerEnabledTask() {
         return getProject().getTasks()
             .withType(Test.class)
             .stream()
+            .filter(t -> tasks == null || tasks.contains(t.getName()))
             .filter(Task::getEnabled)
             .collect(Collectors.toMap(Task::getPath, task -> task.getCandidateClassFiles().getFiles()));
     }
 
     @Input
     public Map<String, File> getTestClassNames() {
         if (testClassNames == null) {
-            testClassNames = GradleUtils.getJavaSourceSets(getProject())
-                .getByName("test")
+            testClassNames = Util.getJavaTestSourceSet(getProject())
+                .get()
                 .getOutput()
                 .getClassesDirs()
                 .getFiles()
@@ -108,6 +115,10 @@ public void naming(Closure<TestingConventionRule> action) {
         naming.configure(action);
     }
 
+    public void setTasks(String... tasks) {
+        this.tasks = Arrays.asList(tasks);
+    }
+
     @Input
     public Set<String> getMainClassNamedLikeTests() {
         SourceSetContainer javaSourceSets = GradleUtils.getJavaSourceSets(getProject());
@@ -319,6 +330,7 @@ private boolean seemsLikeATest(Class<?> clazz) {
     }
 
     private boolean implementsNamingConvention(Class<?> clazz) {
+        Objects.requireNonNull(clazz);
         return implementsNamingConvention(clazz.getName());
     }
 
@@ -349,13 +361,7 @@ private FileCollection getTestsClassPath() {
         // the classes these don't influence the checks done by this task.
         // A side effect is that we could mark as up-to-date with missing dependencies, but these will be found when
         // running the tests.
-        return getProject().files(
-            getProject().getConfigurations().getByName("testRuntime").resolve(),
-            GradleUtils.getJavaSourceSets(getProject())
-                .stream()
-                .flatMap(sourceSet -> sourceSet.getOutput().getClassesDirs().getFiles().stream())
-                .collect(Collectors.toList())
-        );
+        return Util.getJavaTestSourceSet(getProject()).get().getRuntimeClasspath();
     }
 
     private Map<String, File> walkPathAndLoadClasses(File testRoot) {

buildSrc/src/main/java/org/elasticsearch/gradle/precommit/TestingConventionsTasks.java

@@ -0,0 +1,41 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you 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.elasticsearch.gradle.test;
+
+import org.elasticsearch.gradle.util.GradleUtils;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.tasks.SourceSet;
+
+public class InternalClusterTestPlugin implements Plugin<Project> {
+
+    public static final String SOURCE_SET_NAME = "internalClusterTest";
+
+    @Override
+    public void apply(Project project) {
+        GradleUtils.addTestSourceSet(project, SOURCE_SET_NAME);
+
+        // TODO: fix usages of IT tests depending on Tests methods so this extension is not necessary
+        GradleUtils.extendSourceSet(project, SourceSet.TEST_SOURCE_SET_NAME, SOURCE_SET_NAME);
+
+        // add alias task that is easier to type
+        project.getTasks().register("icTest").configure(alias -> alias.dependsOn(SOURCE_SET_NAME));
+    }
+}

buildSrc/src/main/java/org/elasticsearch/gradle/test/InternalClusterTestPlugin.java

@@ -18,23 +18,34 @@
  */
 package org.elasticsearch.gradle.util;
 
+import org.elasticsearch.gradle.ElasticsearchJavaPlugin;
 import org.gradle.api.Action;
 import org.gradle.api.GradleException;
 import org.gradle.api.NamedDomainObjectContainer;
 import org.gradle.api.PolymorphicDomainObjectContainer;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
 import org.gradle.api.UnknownTaskException;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.plugins.JavaBasePlugin;
 import org.gradle.api.plugins.JavaPluginConvention;
 import org.gradle.api.provider.Provider;
 import org.gradle.api.services.BuildService;
 import org.gradle.api.services.BuildServiceRegistration;
 import org.gradle.api.services.BuildServiceRegistry;
+import org.gradle.api.tasks.SourceSet;
 import org.gradle.api.tasks.SourceSetContainer;
 import org.gradle.api.tasks.TaskContainer;
 import org.gradle.api.tasks.TaskProvider;
+import org.gradle.api.tasks.testing.Test;
+import org.gradle.plugins.ide.eclipse.model.EclipseModel;
+import org.gradle.plugins.ide.idea.model.IdeaModel;
 
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.function.Function;
 
 public abstract class GradleUtils {
 
@@ -120,4 +131,79 @@ public static <T extends BuildService<?>> Provider<T> getBuildService(BuildServi
 
         return (Provider<T>) registration.getService();
     }
+
+    /**
+     * Add a source set and task of the same name that runs tests.
+     *
+     * IDEs are also configured if setup, and the test task is added to check. The new test source
+     * set extends from the normal test source set to allow sharing of utilities.
+     *
+     * @return A task provider for the newly created test task
+     */
+    public static TaskProvider<?> addTestSourceSet(Project project, String sourceSetName) {
+        project.getPluginManager().apply(ElasticsearchJavaPlugin.class);
+
+        // create our test source set and task
+        SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
+        SourceSet testSourceSet = sourceSets.create(sourceSetName);
+        TaskProvider<Test> testTask = project.getTasks().register(sourceSetName, Test.class);
+        testTask.configure(task -> {
+            task.setGroup(JavaBasePlugin.VERIFICATION_GROUP);
+            task.setTestClassesDirs(testSourceSet.getOutput().getClassesDirs());
+            task.setClasspath(testSourceSet.getRuntimeClasspath());
+        });
+
+        Configuration testCompileConfig = project.getConfigurations().getByName(testSourceSet.getCompileClasspathConfigurationName());
+        Configuration testRuntimeConfig = project.getConfigurations().getByName(testSourceSet.getRuntimeClasspathConfigurationName());
+        testSourceSet.setCompileClasspath(testCompileConfig);
+        testSourceSet.setRuntimeClasspath(project.getObjects().fileCollection().from(testSourceSet.getOutput(), testRuntimeConfig));
+
+        extendSourceSet(project, SourceSet.MAIN_SOURCE_SET_NAME, sourceSetName);
+
+        // setup IDEs
+        String runtimeClasspathName = testSourceSet.getRuntimeClasspathConfigurationName();
+        Configuration runtimeClasspathConfiguration = project.getConfigurations().getByName(runtimeClasspathName);
+        project.getPluginManager().withPlugin("idea", p -> {
+            IdeaModel idea = project.getExtensions().getByType(IdeaModel.class);
+            idea.getModule().setTestSourceDirs(testSourceSet.getJava().getSrcDirs());
+            idea.getModule().getScopes().put("TEST", Map.of("plus", List.of(runtimeClasspathConfiguration)));
+        });
+        project.getPluginManager().withPlugin("eclipse", p -> {
+            EclipseModel eclipse = project.getExtensions().getByType(EclipseModel.class);
+            eclipse.getClasspath().setSourceSets(List.of(testSourceSet));
+            eclipse.getClasspath().getPlusConfigurations().add(runtimeClasspathConfiguration);
+        });
+
+        // add to the check task
+        project.getTasks().named(JavaBasePlugin.CHECK_TASK_NAME).configure(check -> check.dependsOn(testTask));
+
+        return testTask;
+    }
+
+    /**
+     * Extend the configurations of one source set from another.
+     */
+    public static void extendSourceSet(Project project, String parentSourceSetName, String childSourceSetName) {
+        final List<Function<SourceSet, String>> configNameFunctions = Arrays.asList(
+            SourceSet::getCompileConfigurationName,
+            SourceSet::getImplementationConfigurationName,
+            SourceSet::getRuntimeConfigurationName,
+            SourceSet::getRuntimeOnlyConfigurationName
+        );
+        SourceSetContainer sourceSets = project.getExtensions().getByType(SourceSetContainer.class);
+        SourceSet parent = sourceSets.getByName(parentSourceSetName);
+        SourceSet child = sourceSets.getByName(childSourceSetName);
+
+        for (Function<SourceSet, String> configNameFunction : configNameFunctions) {
+            String parentConfigName = configNameFunction.apply(parent);
+            String childConfigName = configNameFunction.apply(child);
+            Configuration parentConfig = project.getConfigurations().getByName(parentConfigName);
+            Configuration childConfig = project.getConfigurations().getByName(childConfigName);
+            childConfig.extendsFrom(parentConfig);
+        }
+
+        // tie this new test source set to the main and test source sets
+        child.setCompileClasspath(project.getObjects().fileCollection().from(child.getCompileClasspath(), parent.getOutput()));
+        child.setRuntimeClasspath(project.getObjects().fileCollection().from(child.getRuntimeClasspath(), parent.getOutput()));
+    }
 }

buildSrc/src/main/java/org/elasticsearch/gradle/util/GradleUtils.java

@@ -0,0 +1,20 @@
+#
+# Licensed to Elasticsearch under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch licenses this file to you 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.
+#
+
+implementation-class=org.elasticsearch.gradle.test.InternalClusterTestPlugin

buildSrc/src/main/resources/META-INF/gradle-plugins/elasticsearch.internal-cluster-test.properties

@@ -22,6 +22,7 @@ import org.elasticsearch.gradle.info.BuildParams
 apply plugin: 'elasticsearch.build'
 apply plugin: 'nebula.optional-base'
 apply plugin: 'nebula.maven-base-publish'
+apply plugin: 'elasticsearch.internal-cluster-test'
 
 publishing {
   publications {
@@ -130,10 +131,14 @@ dependencies {
     // tests use the locally compiled version of server
     exclude group: 'org.elasticsearch', module: 'server'
   }
+  internalClusterTestCompile(project(":test:framework")) {
+    exclude group: 'org.elasticsearch', module: 'server'
+  }
 }
 
 compileJava.options.compilerArgs << "-Xlint:-cast,-rawtypes,-unchecked"
 compileTestJava.options.compilerArgs << "-Xlint:-cast,-rawtypes,-unchecked"
+compileInternalClusterTestJava.options.compilerArgs << "-Xlint:-cast,-rawtypes,-unchecked"
 
 // Until this project is always being formatted with spotless, we need to
 // guard against `spotless()` not existing.
@@ -170,6 +175,7 @@ testingConventions {
       baseClass "org.elasticsearch.test.ESSingleNodeTestCase"
     }
   }
+  tasks = ['test']
 }
 
 task generateModulesList {
@@ -328,20 +334,12 @@ dependencyLicenses {
 }
 
 
-task integTest(type: Test) {
-  description = 'Multi-node tests'
-  mustRunAfter test
-
-  include '**/*IT.class'
+tasks.named('internalClusterTest').configure {
   if (org.elasticsearch.gradle.info.BuildParams.isSnapshotBuild() == false) {
     systemProperty 'es.datastreams_feature_enabled', 'true'
   }
 }
 
-check.dependsOn integTest
-
-task internalClusterTest {
-  dependsOn integTest
+licenseHeaders {
+  excludes << 'org/elasticsearch/client/documentation/placeholder.txt'
 }
-
-