refactor: lock integration tests by default (#5)

Author: aaron-steinfeld

README.md

@@ -27,8 +27,10 @@ configured only once in a `dependencySettings` extension in settings.gradle.kts.
       on certain
       configurations (
       default: `annotationProcessor`, `compileClasspath`, `runtimeClasspath`, `testCompileClasspath`, `testRuntimeClasspath`)
+      - If integration tests are found, it will also add `integrationTestCompileClasspath` and
+        `integrationTestRuntimeClasspath`
     - If `useDependencyLocking` is specified (default: true), adds a project
-      task `resolveAndLockAll`which can be use in
+      task `resolveAndLockAll`which can be used in
       conjunction with the `--write-locks` flag to update all project lockfiles.
 
 Example usage in `settings.gradle.kts`:

src/main/java/org/hypertrace/gradle/dependency/DependencyPluginProjectExtension.java

@@ -1,30 +1,21 @@
 package org.hypertrace.gradle.dependency;
 
+import javax.inject.Inject;
 import org.gradle.api.model.ObjectFactory;
-import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.provider.ListProperty;
 import org.gradle.api.provider.Property;
 
-import javax.inject.Inject;
-import java.util.List;
-
 public class DependencyPluginProjectExtension {
   static final String EXTENSION_NAME = "dependencySettings";
-  private static final List<String> DEFAULT_LOCKED_CONFIGURATIONS =
-      List.of(
-          JavaPlugin.ANNOTATION_PROCESSOR_CONFIGURATION_NAME,
-          JavaPlugin.COMPILE_CLASSPATH_CONFIGURATION_NAME,
-          JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME,
-          JavaPlugin.TEST_COMPILE_CLASSPATH_CONFIGURATION_NAME,
-          JavaPlugin.TEST_RUNTIME_CLASSPATH_CONFIGURATION_NAME);
+
   public final ListProperty<String> configurationsToLock;
 
   public final Property<Boolean> autoApplyBom;
 
   @Inject
   public DependencyPluginProjectExtension(ObjectFactory objectFactory) {
     this.configurationsToLock =
-        objectFactory.listProperty(String.class).convention(DEFAULT_LOCKED_CONFIGURATIONS);
+        objectFactory.listProperty(String.class);
     this.autoApplyBom = objectFactory.property(Boolean.class).convention(true);
   }
 }

src/main/java/org/hypertrace/gradle/dependency/HypertraceDependencySettingsPlugin.java

@@ -1,5 +1,8 @@
 package org.hypertrace.gradle.dependency;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
 import org.gradle.api.GradleException;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
@@ -13,14 +16,20 @@
 import org.gradle.api.initialization.dsl.VersionCatalogBuilder;
 import org.gradle.api.plugins.JavaPlugin;
 import org.gradle.api.provider.Provider;
+import org.gradle.api.tasks.SourceSetContainer;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Optional;
-
 public class HypertraceDependencySettingsPlugin implements Plugin<Settings> {
   private static final String HYPERTRACE_REPOSITORY_URL =
       "https://hypertrace.jfrog.io/artifactory/maven";
   private static final String CONFLUENT_REPOSITORY_URL = "https://packages.confluent.io/maven";
+  private static final List<String> DEFAULT_LOCKED_CONFIGURATIONS =
+      List.of(
+          JavaPlugin.ANNOTATION_PROCESSOR_CONFIGURATION_NAME,
+          JavaPlugin.COMPILE_CLASSPATH_CONFIGURATION_NAME,
+          JavaPlugin.RUNTIME_CLASSPATH_CONFIGURATION_NAME,
+          JavaPlugin.TEST_COMPILE_CLASSPATH_CONFIGURATION_NAME,
+          JavaPlugin.TEST_RUNTIME_CLASSPATH_CONFIGURATION_NAME);
 
   @Override
   public void apply(@NotNull Settings settings) {
@@ -45,6 +54,7 @@ public void apply(@NotNull Settings settings) {
                         unused -> {
                           DependencyPluginProjectExtension projectExtension =
                               this.addProjectExtension(project);
+                          this.assignDefaultConfigurationsToLock(project, projectExtension);
                           this.addBomDependencyIfRequested(
                               project, settingExtension, projectExtension);
                           if (settingExtension.useDependencyLocking.get()) {
@@ -230,6 +240,31 @@ private void addDependencyLocking(
                     }));
   }
 
+  private void assignDefaultConfigurationsToLock(
+      Project targetProject, DependencyPluginProjectExtension extension) {
+    // Default to this list
+    extension.configurationsToLock.convention(DEFAULT_LOCKED_CONFIGURATIONS);
+    // But if an integration test plugin is applied (now or later) reassign the default
+    targetProject
+        .getPluginManager()
+        .withPlugin(
+            "org.hypertrace.integration-test-plugin",
+            plugin -> {
+              targetProject
+                  .getExtensions()
+                  .getByType(SourceSetContainer.class)
+                  .named(
+                      "integrationTest",
+                      sourceSet -> {
+                        List<String> configurationsToLock =
+                            new ArrayList<>(DEFAULT_LOCKED_CONFIGURATIONS);
+                        configurationsToLock.add(sourceSet.getCompileClasspathConfigurationName());
+                        configurationsToLock.add(sourceSet.getRuntimeClasspathConfigurationName());
+                        extension.configurationsToLock.convention(configurationsToLock);
+                      });
+            });
+  }
+
   /**
    * Adds a task to the target project that resolves all configurations that we've enabled for
    * locking for. In conjunction with the --write-locks flag, this allows an easy way to update the