Check the formatted files in the Spotless tests

A Spotless test passed as long as its task did: three of them would
have passed with a step that formats nothing, as they did while the
configuration cache lost the formatter.

spotlessJava_is_up_to_date_until_the_formatter_jars_change ran
spotlessCheck on a formatted file, which a step that changes nothing
passes. It now runs spotlessApply on the unformatted source each time
and checks the file it leaves; line endings no longer matter, so the
build no longer sets lineEndings to PRESERVE.

format_ignores_excluded_directories passed when nothing was formatted
at all. It now runs spotlessApply with a file outside the excluded
directory too, and checks that the one is formatted and the other is
left as it was. format_checks_non_generated_files passed on any
failure of the check, a lint error from a failing formatter as well;
it now looks for the format violation.

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

Author: abashev

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

@@ -104,22 +104,20 @@ void spotlessJava_is_up_to_date_until_the_formatter_jars_change() throws IOExcep
                 .plugins("java", "dev.openjavaformat.java-format", "com.diffplug.spotless")
                 .withJavacInternalExports()
                 .writeFile("formatter.classpath", jars)
-                // By default Spotless checks for the platform's line endings, CRLF on Windows; PRESERVE keeps the
-                // file's own.
                 .buildGradle("""
                     dependencies {
                         palantirJavaFormat files(file("formatter.classpath").text.split(File.pathSeparator))
                     }
-                    spotless {
-                        lineEndings = 'PRESERVE'
-                    }
-                    """)
-                .writeFile(MAIN_JAVA, FORMATTED);
+                    """);
 
-        assertThat(spotlessJava(project.succeeds("spotlessCheck"))).isEqualTo(TaskOutcome.SUCCESS);
-        var unchanged = project.succeeds("spotlessCheck");
+        // spotlessApply of the same source each time, and the file it leaves: a step that changes nothing is up to
+        // date just as well, and passes a spotlessCheck of a formatted file.
+        assertThat(spotlessJava(spotlessApply(project))).isEqualTo(TaskOutcome.SUCCESS);
+        assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
+        var unchanged = spotlessApply(project);
         assertThat(unchanged.getOutput()).contains(REUSED);
         assertThat(spotlessJava(unchanged)).isEqualTo(TaskOutcome.UP_TO_DATE);
+        assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
 
         // 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
@@ -128,7 +126,13 @@ palantirJavaFormat files(file("formatter.classpath").text.split(File.pathSeparat
                 Test.class.getProtectionDomain().getCodeSource().getLocation().toURI());
         project.writeFile("formatter.classpath", jars + File.pathSeparator + extraJar);
 
-        assertThat(spotlessJava(project.succeeds("spotlessCheck"))).isEqualTo(TaskOutcome.SUCCESS);
+        assertThat(spotlessJava(spotlessApply(project))).isEqualTo(TaskOutcome.SUCCESS);
+        assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED);
+    }
+
+    /** spotlessApply of the unformatted source, written again: only its time changes. */
+    private static BuildResult spotlessApply(GradleTestProject project) {
+        return project.writeFile(MAIN_JAVA, UNFORMATTED).succeeds("spotlessApply");
     }
 
     @Test

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

@@ -43,6 +43,15 @@ final class SpotlessExcludesTest {
         public class Test { Void test() { return null; } }
         """;
 
+    /**
+     * Formatted next to a file in an excluded directory. If it stays as it is, the formatter did not run, and the
+     * excluded file staying as it is proves nothing.
+     */
+    private static final String MAIN_JAVA = "src/main/java/Main.java";
+
+    private static final String UNFORMATTED_MAIN = "class Main {\n        int x;\n}\n";
+    private static final String FORMATTED_MAIN = "class Main {\n    int x;\n}\n";
+
     @Parameter
     private boolean configurationCache;
 
@@ -81,12 +90,17 @@ void format_ignores_excluded_directories(String srcDir) {
                     java { srcDir '%s' }
                 }
             }
-            """, srcDir).writeFile(srcDir + "/test/Test.java", SOURCE_FILE);
+            """, srcDir)
+                .writeFile(srcDir + "/test/Test.java", SOURCE_FILE)
+                .writeFile(MAIN_JAVA, UNFORMATTED_MAIN);
 
-        BuildResult result = project.succeeds("spotlessJavaCheck");
+        BuildResult result = project.succeeds("spotlessApply");
 
         assertThat(result.task(":spotlessJava")).isNotNull().extracting(task -> task.getOutcome())
                 .isEqualTo(TaskOutcome.SUCCESS);
+        assertThat(project.readFile(srcDir + "/test/Test.java")).isEqualTo(SOURCE_FILE);
+        // Spotless writes the platform's line endings, CRLF on Windows.
+        assertThat(project.readFile(MAIN_JAVA)).isEqualToNormalizingNewlines(FORMATTED_MAIN);
     }
 
     @ParameterizedTest
@@ -108,5 +122,10 @@ void format_checks_non_generated_files(String srcDir) {
 
         assertThat(result.task(":spotlessJava")).isNotNull().extracting(task -> task.getOutcome())
                 .isEqualTo(TaskOutcome.SUCCESS);
+        // A formatter that fails reports a lint error instead, which fails the check just as well.
+        assertThat(result.getOutput())
+                .contains("format violations")
+                .contains("Test.java")
+                .doesNotContain("lint error");
     }
 }