Test spotlessJava with the build cache

No test ran a build with the build cache on, so nothing showed that
spotlessJava is taken from it only when it should be. BuildCacheTest
does, with the configuration cache and without: spotlessJava is up to
date when the source is written again unchanged, runs when the source
or the formatter's jars change, and comes from the cache when the
source changes back, after the build directory is deleted and in a
copy of the project in another directory.

Each build is spotlessApply, and each test checks the file it leaves.
That shows the output spotlessJava ran for, kept or took from the
cache is the source formatted; a step that changes nothing passes a
spotlessCheck of a formatted file as well.

GradleTestProject can now run its builds with the build cache, in a
directory of the test's own: TestKit builds share one Gradle user
home, and with it the default local cache. It can also delete a file
or a directory of the project.

Author: abashev

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

@@ -0,0 +1,159 @@
+/*
+ * 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 com.palantir.javaformat.gradle;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.palantir.javaformat.gradle.testing.GradleTestProject;
+import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import org.gradle.testkit.runner.TaskOutcome;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.ValueSource;
+
+/**
+ * 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.
+ *
+ * <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
+ * leaves the source as it is passes a spotlessCheck of a formatted file just as well. Writing the same source again is
+ * the change that must not count, as only its time changes.
+ */
+@ParameterizedClass(name = "configuration cache {0}")
+@ValueSource(booleans = {true, false})
+final class BuildCacheTest {
+
+    /** ./gradlew writeImplClasspath generates this file. */
+    private static final Path CLASSPATH_FILE = Path.of("build/impl.classpath");
+
+    private static final String MAIN_JAVA = "src/main/java/Main.java";
+    private static final String UNFORMATTED = "class Main {\n        int x;\n}\n";
+    private static final String FORMATTED = "class Main {\n    int x;\n}\n";
+    private static final String OTHER_UNFORMATTED = "class Main {\n        int y;\n}\n";
+    private static final String OTHER_FORMATTED = "class Main {\n    int y;\n}\n";
+
+    @Parameter
+    private boolean configurationCache;
+
+    @TempDir
+    private Path projectDir;
+
+    @TempDir
+    private Path otherProjectDir;
+
+    @TempDir
+    private Path buildCacheDir;
+
+    @Test
+    void spotlessJava_is_up_to_date_when_the_source_is_written_again_unchanged() throws IOException {
+        var project = project(projectDir);
+        assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
+        assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
+
+        assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.UP_TO_DATE);
+        assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
+    }
+
+    @Test
+    void spotlessJava_runs_again_when_the_source_changes() throws IOException {
+        var project = project(projectDir);
+        assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
+
+        assertThat(spotlessApply(project, OTHER_UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
+        assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(OTHER_FORMATTED);
+    }
+
+    @Test
+    void spotlessJava_comes_from_the_cache_when_the_source_changes_back() throws IOException {
+        var project = project(projectDir);
+        assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
+        assertThat(spotlessApply(project, OTHER_UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
+
+        assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.FROM_CACHE);
+        assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
+    }
+
+    @Test
+    void spotlessJava_comes_from_the_cache_after_the_build_directory_is_deleted() throws IOException {
+        var project = project(projectDir);
+        assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
+
+        project.delete("build");
+
+        assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.FROM_CACHE);
+        assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
+    }
+
+    @Test
+    void spotlessJava_comes_from_the_cache_in_another_directory() throws IOException {
+        assertThat(spotlessApply(project(projectDir), UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
+
+        // The same project somewhere else, as another checkout or another CI machine has it.
+        var moved = project(otherProjectDir);
+
+        assertThat(spotlessApply(moved, UNFORMATTED)).isEqualTo(TaskOutcome.FROM_CACHE);
+        assertThat(moved.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
+    }
+
+    @Test
+    void spotlessJava_runs_again_when_the_formatter_jars_change() throws IOException, URISyntaxException {
+        var project = project(projectDir);
+        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.
+        var extraJar = Path.of(
+                Test.class.getProtectionDomain().getCodeSource().getLocation().toURI());
+        project.writeFile("formatter.classpath", formatterClasspath() + File.pathSeparator + extraJar)
+                .delete("build");
+
+        assertThat(spotlessApply(project, UNFORMATTED)).isEqualTo(TaskOutcome.SUCCESS);
+        assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
+    }
+
+    private GradleTestProject project(Path dir) throws IOException {
+        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))
+                    }
+                    """);
+    }
+
+    private static String formatterClasspath() throws IOException {
+        return Files.readString(CLASSPATH_FILE).trim();
+    }
+
+    /** Writes the source and runs spotlessApply; returns what spotlessJava did for it. */
+    private static TaskOutcome spotlessApply(GradleTestProject project, String source) {
+        var task =
+                project.writeFile(MAIN_JAVA, source).succeeds("spotlessApply").task(":spotlessJava");
+        assertThat(task).isNotNull();
+        return task.getOutcome();
+    }
+}

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

@@ -25,11 +25,14 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Comparator;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.Properties;
 import java.util.Set;
+import java.util.stream.Stream;
 import org.gradle.testkit.runner.BuildResult;
 import org.gradle.testkit.runner.GradleRunner;
 
@@ -61,6 +64,7 @@ public final class GradleTestProject {
     private final StringBuilder gradleProperties = new StringBuilder();
     private boolean configurationCache = true;
     private boolean spotlessOnClasspath = true;
+    private Optional<Path> buildCacheDir = Optional.empty();
 
     public GradleTestProject(Path projectDir) {
         this.projectDir = projectDir;
@@ -109,6 +113,15 @@ public GradleTestProject configurationCache(boolean enabled) {
         return this;
     }
 
+    /**
+     * Runs the builds with the build cache, kept in {@code directory}. Not the default local cache: TestKit builds share
+     * one Gradle user home, and with it that cache, so a test would read what another test stored.
+     */
+    public GradleTestProject withBuildCache(Path directory) {
+        this.buildCacheDir = Optional.of(directory);
+        return this;
+    }
+
     /**
      * Leaves the Spotless jars out of the classpath injected next to the plugin under test. build.gradle puts them there
      * so that generated projects can apply Spotless, which gives every other test Spotless classes whether it applies
@@ -134,6 +147,22 @@ public GradleTestProject writeFile(String relativePath, String content) {
         return this;
     }
 
+    /** Deletes a file, or a directory with everything in it, if it is there. */
+    public GradleTestProject delete(String relativePath) {
+        Path target = file(relativePath);
+        if (!Files.exists(target)) {
+            return this;
+        }
+        try (Stream<Path> paths = Files.walk(target)) {
+            for (var path : paths.sorted(Comparator.reverseOrder()).toList()) {
+                Files.delete(path);
+            }
+        } catch (IOException e) {
+            throw new UncheckedIOException("Could not delete " + relativePath, e);
+        }
+        return this;
+    }
+
     public String readFile(String relativePath) {
         try {
             return Files.readString(file(relativePath), StandardCharsets.UTF_8);
@@ -158,6 +187,9 @@ private GradleRunner runner(String... arguments) {
         // Every build looks at the files afresh. A test changes files between two builds faster than file system
         // watching reports it, and the second build then took a deleted output for one still there.
         allArguments.add("--no-watch-fs");
+        if (buildCacheDir.isPresent()) {
+            allArguments.add("--build-cache");
+        }
         GradleRunner runner = GradleRunner.create()
                 .withProjectDir(projectDir.toFile())
                 .withGradleVersion(GRADLE_VERSION)
@@ -186,7 +218,12 @@ private void write() {
         plugins.forEach(id -> script.append("    id '").append(id).append("'\n"));
         script.append("}\n\nrepositories {\n    mavenCentral()\n}\n\n").append(buildGradle);
 
-        writeFile("settings.gradle", "rootProject.name = 'test-project'\n");
+        StringBuilder settings = new StringBuilder("rootProject.name = 'test-project'\n");
+        // Forward slashes: the path goes into a Groovy string, where a Windows backslash would start an escape.
+        buildCacheDir.ifPresent(dir -> settings.append("\nbuildCache {\n    local {\n        directory = file('")
+                .append(dir.toAbsolutePath().toString().replace('\\', '/'))
+                .append("')\n    }\n}\n"));
+        writeFile("settings.gradle", settings.toString());
         writeFile("build.gradle", script.toString());
         writeFile("gradle.properties", gradleProperties.toString());
     }