Run the Spotless tests with the formatter inside the plugin

The Spotless tests declared the jars this build made in
palantirJavaFormat, which was the only way they could format: under
TestKit the default dependency had no version. They now run with
nothing declared, as a build that applies the plugin does, through the
jars the plugin carries.

BuildCacheTest keeps two tests of a declared formatter: declaring one
makes spotlessJava run again, and so does a change of the declared
jars. ConfigurationCacheTest keeps its test of the declared jars too,
and MultiProjectTest stays on a declared formatter, as resolving that
in the subprojects is what it tests.

With the step's formatter returning its input, every test that runs a
Spotless task still fails.

Author: abashev

gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/BuildCacheTest.java

@@ -31,7 +31,7 @@
 
 /**
  * spotlessJava is cacheable, and the open-java-format step is part of its cache key: the key changes with the
- * formatter's jars, and not with the directory the project is in.
+ * formatter, the one inside the plugin or the one a build declares, and not with the directory the project is in.
  *
  * <p>Every build here is spotlessApply, after the source is written again. The formatted file is what shows that
  * spotlessJava's output, whether it ran, was up to date or came from the cache, holds the source formatted: a step that
@@ -42,7 +42,7 @@
 @ValueSource(booleans = {true, false})
 final class BuildCacheTest {
 
-    /** ./gradlew writeImplClasspath generates this file. */
+    /** ./gradlew writeImplClasspath generates this file: the jars this build made, to declare as an override. */
     private static final Path CLASSPATH_FILE = Path.of("build/impl.classpath");
 
     private static final String MAIN_JAVA = "src/main/java/Main.java";
@@ -64,7 +64,7 @@ final class BuildCacheTest {
     private Path buildCacheDir;
 
     @Test
-    void spotlessJava_is_up_to_date_when_the_source_is_written_again_unchanged() throws IOException {
+    void spotlessJava_is_up_to_date_when_the_source_is_written_again_unchanged() {
         var project = project(projectDir);
         assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
         assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
@@ -74,7 +74,7 @@ void spotlessJava_is_up_to_date_when_the_source_is_written_again_unchanged() thr
     }
 
     @Test
-    void spotlessJava_runs_again_when_the_source_changes() throws IOException {
+    void spotlessJava_runs_again_when_the_source_changes() {
         var project = project(projectDir);
         assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
 
@@ -83,7 +83,7 @@ void spotlessJava_runs_again_when_the_source_changes() throws IOException {
     }
 
     @Test
-    void spotlessJava_comes_from_the_cache_when_the_source_changes_back() throws IOException {
+    void spotlessJava_comes_from_the_cache_when_the_source_changes_back() {
         var project = project(projectDir);
         assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
         assertThat(spotlessApply(project, OTHER_UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
@@ -93,7 +93,7 @@ void spotlessJava_comes_from_the_cache_when_the_source_changes_back() throws IOE
     }
 
     @Test
-    void spotlessJava_comes_from_the_cache_after_the_build_directory_is_deleted() throws IOException {
+    void spotlessJava_comes_from_the_cache_after_the_build_directory_is_deleted() {
         var project = project(projectDir);
         assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
 
@@ -104,7 +104,7 @@ void spotlessJava_comes_from_the_cache_after_the_build_directory_is_deleted() th
     }
 
     @Test
-    void spotlessJava_comes_from_the_cache_in_another_directory() throws IOException {
+    void spotlessJava_comes_from_the_cache_in_another_directory() {
         assertThat(spotlessApply(project(projectDir), UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
 
         // The same project somewhere else, as another checkout or another CI machine has it.
@@ -115,13 +115,25 @@ void spotlessJava_comes_from_the_cache_in_another_directory() throws IOException
     }
 
     @Test
-    void spotlessJava_runs_again_when_the_formatter_jars_change() throws IOException, URISyntaxException {
+    void spotlessJava_runs_again_when_the_build_declares_a_formatter() throws IOException {
         var project = project(projectDir);
         assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
 
+        // Without the build directory, only the cache could skip the task.
+        project.writeFile("formatter.classpath", formatterClasspath()).delete("build");
+
+        assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
+        assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
+    }
+
+    @Test
+    void spotlessJava_runs_again_when_the_declared_jars_change() throws IOException, URISyntaxException {
+        var project = project(projectDir).writeFile("formatter.classpath", formatterClasspath());
+        assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
+
         // Spotless signs the jars by name, size and content, as another formatter version changes them. The extra jar
         // is JUnit's, not one written into projectDir: the daemon keeps the formatter's jars open after the build, and
-        // Windows does not delete an open file. Without the build directory, only the cache could skip the task.
+        // Windows does not delete an open file.
         var extraJar = Path.of(
                 Test.class.getProtectionDomain().getCodeSource().getLocation().toURI());
         project.writeFile("formatter.classpath", formatterClasspath() + File.pathSeparator + extraJar)
@@ -131,16 +143,18 @@ void spotlessJava_runs_again_when_the_formatter_jars_change() throws IOException
         assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
     }
 
-    private GradleTestProject project(Path dir) throws IOException {
+    /** The formatter inside the plugin, unless the test writes formatter.classpath, which the build then declares. */
+    private GradleTestProject project(Path dir) {
         return new GradleTestProject(dir)
                 .configurationCache(configurationCache)
                 .withBuildCache(buildCacheDir)
                 .plugins("java", "dev.openjavaformat.java-format", "com.diffplug.spotless")
                 .withJavacInternalExports()
-                .writeFile("formatter.classpath", formatterClasspath())
                 .buildGradle("""
-                    dependencies {
-                        palantirJavaFormat files(file("formatter.classpath").text.split(File.pathSeparator))
+                    if (file("formatter.classpath").exists()) {
+                        dependencies {
+                            palantirJavaFormat files(file("formatter.classpath").text.split(File.pathSeparator))
+                        }
                     }
                     """);
     }

gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/ConfigurationCacheTest.java

@@ -38,7 +38,7 @@
  */
 final class ConfigurationCacheTest {
 
-    /** ./gradlew writeImplClasspath generates this file. */
+    /** ./gradlew writeImplClasspath generates this file: the jars this build made, to declare as an override. */
     private static final Path CLASSPATH_FILE = Path.of("build/impl.classpath");
 
     private static final String STORED = "Configuration cache entry stored.";
@@ -201,17 +201,12 @@ void required_idea_plugin_is_listed_from_a_reused_entry() {
         }
     }
 
+    /** With the formatter inside the plugin. */
     private GradleTestProject project(String... plugins) {
-        // Forward slashes: the path goes into a Groovy string, where a Windows backslash would start an escape.
         return new GradleTestProject(projectDir)
                 .configurationCache(true)
                 .plugins(plugins)
-                .withJavacInternalExports()
-                .buildGradle("""
-                    dependencies {
-                        palantirJavaFormat files(file("%s").text.split(File.pathSeparator))
-                    }
-                    """, CLASSPATH_FILE.toAbsolutePath().toString().replace('\\', '/'));
+                .withJavacInternalExports();
     }
 
     private static TaskOutcome spotlessJava(BuildResult result) {

gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/PalantirJavaFormatSpotlessPluginTest.java

@@ -32,11 +32,7 @@
 @ValueSource(booleans = {true, false})
 final class PalantirJavaFormatSpotlessPluginTest {
 
-    /** ./gradlew writeImplClasspath generates this file. */
     // Forward slashes: the path goes into a Groovy string, where a Windows backslash would start an escape.
-    private static final String CLASSPATH_FILE =
-            new File("build/impl.classpath").getAbsolutePath().replace('\\', '/');
-
     private static final String NATIVE_IMAGE_FILE =
             new File("build/nativeImage.path").getAbsolutePath().replace('\\', '/');
 
@@ -81,10 +77,9 @@ void formats_with_spotless_when_spotless_is_applied(
                     """, javaVersion)
                 .buildGradle("""
                     dependencies {
-                        palantirJavaFormat files(file("%s").text.split(File.pathSeparator))
                         %s
                     }
-                    """, CLASSPATH_FILE, extraDependencies)
+                    """, extraDependencies)
                 .writeFile(MAIN_JAVA, invalidJavaFile());
 
         BuildResult result = project.succeeds("spotlessApply", "--info");

gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/SpotlessExcludesTest.java

@@ -18,7 +18,6 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.palantir.javaformat.gradle.testing.GradleTestProject;
-import java.io.File;
 import java.nio.file.Path;
 import org.gradle.testkit.runner.BuildResult;
 import org.gradle.testkit.runner.TaskOutcome;
@@ -33,10 +32,6 @@
 @ValueSource(booleans = {true, false})
 final class SpotlessExcludesTest {
 
-    // Forward slashes: the path goes into a Groovy string, where a Windows backslash would start an escape.
-    private static final String CLASSPATH_FILE =
-            new File("build/impl.classpath").getAbsolutePath().replace('\\', '/');
-
     private static final String SOURCE_FILE = """
         package test;
         import java.lang.Void;
@@ -65,12 +60,7 @@ void setup() {
         project = new GradleTestProject(projectDir)
                 .configurationCache(configurationCache)
                 .plugins("java", "dev.openjavaformat.java-format", "com.diffplug.spotless")
-                .withJavacInternalExports()
-                .buildGradle("""
-                    dependencies {
-                        palantirJavaFormat files(file("%s").text.split(File.pathSeparator))
-                    }
-                    """, CLASSPATH_FILE);
+                .withJavacInternalExports();
     }
 
     @ParameterizedTest

gradle-open-java-format/src/test/java/com/palantir/javaformat/gradle/SupportsCurrentSpotlessTest.java

@@ -16,7 +16,6 @@
 package com.palantir.javaformat.gradle;
 
 import com.palantir.javaformat.gradle.testing.GradleTestProject;
-import java.io.File;
 import java.nio.file.Path;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
@@ -33,10 +32,6 @@
  */
 final class SupportsCurrentSpotlessTest {
 
-    // Forward slashes: the path goes into a Groovy string, where a Windows backslash would start an escape.
-    private static final String CLASSPATH_FILE =
-            new File("build/impl.classpath").getAbsolutePath().replace('\\', '/');
-
     @TempDir
     private Path projectDir;
 
@@ -47,14 +42,10 @@ void palantirjavaformatplugin_works_with_current_spotless() {
                 .plugins("java", "dev.openjavaformat.java-format", "com.diffplug.spotless")
                 .withJavacInternalExports()
                 .buildGradle("""
-                    dependencies {
-                        palantirJavaFormat files(file("%s").text.split(File.pathSeparator))
-                    }
-
                     // Forces realization of the spotlessJava task, creating the spotless steps. Any
                     // configuration resolved eagerly in them fails the configuration cache here.
                     project.getTasks().getByName("spotlessJava")
-                    """, CLASSPATH_FILE)
+                    """)
                 .succeeds("classes", "--info");
     }
 }