diff --git a/gradle.properties b/gradle.properties index 16558bdabb..145e146f17 100644 --- a/gradle.properties +++ b/gradle.properties @@ -32,7 +32,7 @@ VER_PEGDOWN_DOCLET=1.3 # Used in multiple places VER_DURIAN=1.2.0 VER_JUNIT=4.12 -VER_ASSERTJ=3.5.2 +VER_ASSERTJ=3.10.0 VER_MOCKITO=2.13.0 # Used for Maven Plugin diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index 99340b4ad1..f6b961fd5a 100755 Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index ea720f986f..a95009c3b9 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,5 +1,5 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-4.9-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-4.6-bin.zip diff --git a/lib-extra/src/test/java/com/diffplug/spotless/extra/eclipse/EclipseCommonTests.java b/lib-extra/src/test/java/com/diffplug/spotless/extra/eclipse/EclipseCommonTests.java index 2af3d7a37a..8d1fba316c 100644 --- a/lib-extra/src/test/java/com/diffplug/spotless/extra/eclipse/EclipseCommonTests.java +++ b/lib-extra/src/test/java/com/diffplug/spotless/extra/eclipse/EclipseCommonTests.java @@ -19,6 +19,7 @@ import java.io.File; +import org.assertj.core.api.SoftAssertions; import org.junit.Test; import com.diffplug.spotless.FormatterStep; @@ -65,8 +66,8 @@ public abstract class EclipseCommonTests extends ResourceHarness { @Test public void testSupportedVersions() throws Exception { - String[] versions = getSupportedVersions(); - for (String version : versions) { + SoftAssertions softly = new SoftAssertions(); + for (String version : getSupportedVersions()) { String input = getTestInput(version); String expected = getTestExpectation(version); File inputFile = setFile("someInputFile").toContent(input); @@ -74,16 +75,17 @@ public void testSupportedVersions() throws Exception { try { step = createStep(version); } catch (Exception e) { - fail("Exception occured when instantiating step for version: " + version, e); + fail("Exception occurred when instantiating step for version: " + version, e); } String output = null; try { output = step.format(input, inputFile); } catch (Exception e) { - fail("Exception occured when formatting input with version: " + version, e); + fail("Exception occurred when formatting input with version: " + version, e); } - assertThat(output).as("Formatting output unexpected with version: " + version).isEqualTo(expected); + softly.assertThat(output).as("Formatting output unexpected with version: " + version).isEqualTo(expected); } + softly.assertAll(); } } diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessPlugin.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessPlugin.java index c4f00ef547..02f0af54bf 100644 --- a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessPlugin.java +++ b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessPlugin.java @@ -15,29 +15,15 @@ */ package com.diffplug.gradle.spotless; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.EXTENSION; + import org.gradle.api.Plugin; import org.gradle.api.Project; -import org.gradle.api.Task; -import org.gradle.api.execution.TaskExecutionGraph; import org.gradle.api.plugins.BasePlugin; -import org.gradle.api.plugins.JavaBasePlugin; - -import com.diffplug.spotless.SpotlessCache; - -import edu.umd.cs.findbugs.annotations.SuppressFBWarnings; -import groovy.lang.Closure; public class SpotlessPlugin implements Plugin { SpotlessExtension spotlessExtension; - static final String EXTENSION = "spotless"; - static final String CHECK = "Check"; - static final String APPLY = "Apply"; - - private static final String TASK_GROUP = "Verification"; - private static final String CHECK_DESCRIPTION = "Checks that sourcecode satisfies formatting steps."; - private static final String APPLY_DESCRIPTION = "Applies code formatting steps to sourcecode in-place."; - @Override public void apply(Project project) { // make sure there's a `clean` task @@ -55,67 +41,7 @@ public SpotlessExtension getExtension() { return spotlessExtension; } - @SuppressWarnings("rawtypes") void createTasks(Project project) { - Task rootCheckTask = project.task(EXTENSION + CHECK); - rootCheckTask.setGroup(TASK_GROUP); - rootCheckTask.setDescription(CHECK_DESCRIPTION); - Task rootApplyTask = project.task(EXTENSION + APPLY); - rootApplyTask.setGroup(TASK_GROUP); - rootApplyTask.setDescription(APPLY_DESCRIPTION); - - spotlessExtension.formats.forEach((key, value) -> { - // create the task that does the work - String taskName = EXTENSION + capitalize(key); - SpotlessTask spotlessTask = project.getTasks().create(taskName, SpotlessTask.class); - value.setupTask(spotlessTask); - - // create the check and apply control tasks - Task checkTask = project.getTasks().create(taskName + CHECK); - Task applyTask = project.getTasks().create(taskName + APPLY); - // the root tasks depend on them - rootCheckTask.dependsOn(checkTask); - rootApplyTask.dependsOn(applyTask); - // and they depend on the work task - checkTask.dependsOn(spotlessTask); - applyTask.dependsOn(spotlessTask); - - // when the task graph is ready, we'll configure the spotlessTask appropriately - project.getGradle().getTaskGraph().whenReady(new Closure(null) { - private static final long serialVersionUID = 1L; - - // called by gradle - @SuppressFBWarnings("UMAC_UNCALLABLE_METHOD_OF_ANONYMOUS_CLASS") - public Object doCall(TaskExecutionGraph graph) { - if (graph.hasTask(checkTask)) { - spotlessTask.setCheck(); - } - if (graph.hasTask(applyTask)) { - spotlessTask.setApply(); - } - return Closure.DONE; - } - }); - }); - - // Add our check task as a dependency on the global check task - // getTasks() returns a "live" collection, so this works even if the - // task doesn't exist at the time this call is made - if (spotlessExtension.enforceCheck) { - project.getTasks() - .matching(task -> task.getName().equals(JavaBasePlugin.CHECK_TASK_NAME)) - .all(task -> task.dependsOn(rootCheckTask)); - } - - // clear spotless' cache when the user does a clean, but only after any spotless tasks - Task clean = project.getTasks().getByName(BasePlugin.CLEAN_TASK_NAME); - clean.doLast(unused -> SpotlessCache.clear()); - project.getTasks() - .withType(SpotlessTask.class) - .all(task -> task.mustRunAfter(clean)); - } - - static String capitalize(String input) { - return Character.toUpperCase(input.charAt(0)) + input.substring(1); + SpotlessTaskSetup.detectAppropriateImplementation().accept(project, spotlessExtension); } } diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTask.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTask.java index 801e45f17d..2c865b42ad 100644 --- a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTask.java +++ b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTask.java @@ -144,8 +144,8 @@ public void setApply() { /** Returns the name of this format. */ String formatName() { String name = getName(); - if (name.startsWith(SpotlessPlugin.EXTENSION)) { - return name.substring(SpotlessPlugin.EXTENSION.length()).toLowerCase(Locale.ROOT); + if (name.startsWith(SpotlessTaskConstants.EXTENSION)) { + return name.substring(SpotlessTaskConstants.EXTENSION.length()).toLowerCase(Locale.ROOT); } else { return name; } @@ -157,7 +157,7 @@ public void performAction(IncrementalTaskInputs inputs) throws Exception { throw new GradleException("You must specify 'Iterable toFormat'"); } if (!check && !apply) { - throw new GradleException("Don't call " + getName() + " directly, call " + getName() + SpotlessPlugin.CHECK + " or " + getName() + SpotlessPlugin.APPLY); + throw new GradleException("Don't call " + getName() + " directly, call " + getName() + SpotlessTaskConstants.CHECK + " or " + getName() + SpotlessTaskConstants.APPLY); } // create the formatter diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskConstants.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskConstants.java new file mode 100644 index 0000000000..244b5fb844 --- /dev/null +++ b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskConstants.java @@ -0,0 +1,36 @@ +/* + * Copyright 2016 DiffPlug + * + * 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.diffplug.gradle.spotless; + +import java.util.Objects; + +final class SpotlessTaskConstants { + static final String EXTENSION = "spotless"; + static final String CHECK = "Check"; + static final String APPLY = "Apply"; + + static final String TASK_GROUP = "Verification"; + static final String CHECK_DESCRIPTION = "Checks that sourcecode satisfies formatting steps."; + static final String APPLY_DESCRIPTION = "Applies code formatting steps to sourcecode in-place."; + + static String capitalize(String input) { + Objects.requireNonNull(input, "input"); + return Character.toUpperCase(input.charAt(0)) + input.substring(1); + } + + // prevent instantiation + private SpotlessTaskConstants() {} +} diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskSetup.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskSetup.java new file mode 100644 index 0000000000..95f30fd2d9 --- /dev/null +++ b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskSetup.java @@ -0,0 +1,34 @@ +/* + * Copyright 2016 DiffPlug + * + * 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.diffplug.gradle.spotless; + +import java.util.function.BiConsumer; + +import org.gradle.api.Project; + +interface SpotlessTaskSetup extends BiConsumer { + static SpotlessTaskSetup detectAppropriateImplementation() { + try { + Class.forName("org.gradle.api.tasks.TaskProvider"); + // Instantiate SpotlessTaskSetupConfigAvoidance by its fully qualified name, so that + // classloaders don't attempt to load it when Spotless is running on a relatively + // young version of Gradle where org.gradle.api.tasks.TaskProvider doesn't exist. + return new com.diffplug.gradle.spotless.SpotlessTaskSetupConfigAvoidance(); + } catch (ClassNotFoundException e) { + return new com.diffplug.gradle.spotless.SpotlessTaskSetupLegacy(); + } + } +} diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskSetupConfigAvoidance.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskSetupConfigAvoidance.java new file mode 100644 index 0000000000..1bde4903db --- /dev/null +++ b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskSetupConfigAvoidance.java @@ -0,0 +1,93 @@ +/* + * Copyright 2016 DiffPlug + * + * 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.diffplug.gradle.spotless; + +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.APPLY; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.APPLY_DESCRIPTION; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.CHECK; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.CHECK_DESCRIPTION; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.EXTENSION; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.TASK_GROUP; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.capitalize; + +import org.gradle.api.Project; +import org.gradle.api.Task; +import org.gradle.api.plugins.BasePlugin; +import org.gradle.api.plugins.JavaBasePlugin; +import org.gradle.api.tasks.TaskProvider; + +import com.diffplug.spotless.SpotlessCache; + +final class SpotlessTaskSetupConfigAvoidance implements SpotlessTaskSetup { + @Override + public void accept(Project project, SpotlessExtension spotlessExtension) { + TaskProvider rootCheckTaskProvider = project.getTasks().register( + EXTENSION + CHECK, + task -> { + task.setGroup(TASK_GROUP); + task.setDescription(CHECK_DESCRIPTION); + }); + TaskProvider rootApplyTaskProvider = project.getTasks().register( + EXTENSION + APPLY, + task -> { + task.setGroup(TASK_GROUP); + task.setDescription(APPLY_DESCRIPTION); + }); + + spotlessExtension.formats.forEach((key, value) -> { + // create the task that does the work + String taskName = EXTENSION + capitalize(key); + TaskProvider spotlessTaskProvider = project.getTasks().register(taskName, SpotlessTask.class, value::setupTask); + + // create the check and apply control tasks + TaskProvider checkTaskProvider = project.getTasks().register(taskName + CHECK); + TaskProvider applyTaskProvider = project.getTasks().register(taskName + APPLY); + // the root tasks depend on them + rootCheckTaskProvider.configure(rootCheckTask -> rootCheckTask.dependsOn(checkTaskProvider)); + rootApplyTaskProvider.configure(rootApplyTask -> rootApplyTask.dependsOn(applyTaskProvider)); + // and they depend on the work task + checkTaskProvider.configure(checkTask -> checkTask.dependsOn(spotlessTaskProvider)); + applyTaskProvider.configure(applyTask -> applyTask.dependsOn(spotlessTaskProvider)); + + // when the task graph is ready, we'll configure the spotlessTask appropriately + project.getGradle().getTaskGraph().whenReady(graph -> { + if (checkTaskProvider.isPresent() && graph.hasTask(checkTaskProvider.get())) { + spotlessTaskProvider.configure(SpotlessTask::setCheck); + } + if (applyTaskProvider.isPresent() && graph.hasTask(applyTaskProvider.get())) { + spotlessTaskProvider.configure(SpotlessTask::setApply); + } + }); + }); + + // Add our check task as a dependency on the global check task. + // getTasks() returns a "live" collection and configureEach() is lazy, + // so this works even if the task doesn't exist at the time this call + // is made. + if (spotlessExtension.enforceCheck) { + project.getTasks() + .matching(task -> task.getName().equals(JavaBasePlugin.CHECK_TASK_NAME)) + .configureEach(task -> task.dependsOn(rootCheckTaskProvider)); + } + + // clear spotless' cache when the user does a clean, but only after any spotless tasks + TaskProvider cleanTaskProvider = project.getTasks().named(BasePlugin.CLEAN_TASK_NAME); + cleanTaskProvider.configure(task -> task.doLast(unused -> SpotlessCache.clear())); + project.getTasks() + .withType(SpotlessTask.class) + .configureEach(task -> task.mustRunAfter(cleanTaskProvider)); + } +} diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskSetupLegacy.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskSetupLegacy.java new file mode 100644 index 0000000000..e1a66e4b6b --- /dev/null +++ b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/SpotlessTaskSetupLegacy.java @@ -0,0 +1,86 @@ +/* + * Copyright 2016 DiffPlug + * + * 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.diffplug.gradle.spotless; + +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.APPLY; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.APPLY_DESCRIPTION; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.CHECK; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.CHECK_DESCRIPTION; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.EXTENSION; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.TASK_GROUP; +import static com.diffplug.gradle.spotless.SpotlessTaskConstants.capitalize; + +import org.gradle.api.Project; +import org.gradle.api.Task; +import org.gradle.api.plugins.BasePlugin; +import org.gradle.api.plugins.JavaBasePlugin; + +import com.diffplug.spotless.SpotlessCache; + +final class SpotlessTaskSetupLegacy implements SpotlessTaskSetup { + @Override + public void accept(Project project, SpotlessExtension spotlessExtension) { + Task rootCheckTask = project.task(EXTENSION + CHECK); + rootCheckTask.setGroup(TASK_GROUP); + rootCheckTask.setDescription(CHECK_DESCRIPTION); + Task rootApplyTask = project.task(EXTENSION + APPLY); + rootApplyTask.setGroup(TASK_GROUP); + rootApplyTask.setDescription(APPLY_DESCRIPTION); + + spotlessExtension.formats.forEach((key, value) -> { + // create the task that does the work + String taskName = EXTENSION + capitalize(key); + SpotlessTask spotlessTask = project.getTasks().create(taskName, SpotlessTask.class); + value.setupTask(spotlessTask); + + // create the check and apply control tasks + Task checkTask = project.getTasks().create(taskName + CHECK); + Task applyTask = project.getTasks().create(taskName + APPLY); + // the root tasks depend on them + rootCheckTask.dependsOn(checkTask); + rootApplyTask.dependsOn(applyTask); + // and they depend on the work task + checkTask.dependsOn(spotlessTask); + applyTask.dependsOn(spotlessTask); + + // when the task graph is ready, we'll configure the spotlessTask appropriately + project.getGradle().getTaskGraph().whenReady(graph -> { + if (graph.hasTask(checkTask)) { + spotlessTask.setCheck(); + } + if (graph.hasTask(applyTask)) { + spotlessTask.setApply(); + } + }); + }); + + // Add our check task as a dependency on the global check task + // getTasks() returns a "live" collection, so this works even if the + // task doesn't exist at the time this call is made + if (spotlessExtension.enforceCheck) { + project.getTasks() + .matching(task -> task.getName().equals(JavaBasePlugin.CHECK_TASK_NAME)) + .all(task -> task.dependsOn(rootCheckTask)); + } + + // clear spotless' cache when the user does a clean, but only after any spotless tasks + Task clean = project.getTasks().getByName(BasePlugin.CLEAN_TASK_NAME); + clean.doLast(unused -> SpotlessCache.clear()); + project.getTasks() + .withType(SpotlessTask.class) + .all(task -> task.mustRunAfter(clean)); + } +} diff --git a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/ErrorShouldRethrow.java b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/ErrorShouldRethrow.java index 646448e954..7343017702 100644 --- a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/ErrorShouldRethrow.java +++ b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/ErrorShouldRethrow.java @@ -15,19 +15,17 @@ */ package com.diffplug.gradle.spotless; +import static org.assertj.core.api.Assertions.assertThat; + import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import org.assertj.core.api.Assertions; import org.gradle.testkit.runner.BuildResult; import org.gradle.testkit.runner.TaskOutcome; import org.junit.Test; -import com.diffplug.common.base.CharMatcher; -import com.diffplug.common.base.Splitter; -import com.diffplug.common.base.StringPrinter; import com.diffplug.spotless.LineEnding; /** Tests the desired behavior from https://github.com/diffplug/spotless/issues/46. */ @@ -67,8 +65,8 @@ public void anyExceptionShouldFail() throws Exception { "} // spotless"); setFile("README.md").toContent("This code is fubar."); runWithFailure( - ":spotlessMiscStep 'no swearing' found problem in 'README.md':", - "No swearing!", + ":spotlessMisc", + "Step 'no swearing' found problem in 'README.md'", "java.lang.RuntimeException: No swearing!"); } @@ -79,7 +77,7 @@ public void unlessEnforceCheckIsFalse() throws Exception { " enforceCheck false", "} // spotless"); setFile("README.md").toContent("This code is fubar."); - runWithSuccess(":compileJava UP-TO-DATE"); + runWithSuccess(":compileJava NO-SOURCE"); } @Test @@ -113,28 +111,25 @@ public void failsIfNeitherStepNorFileExempted() throws Exception { "} // spotless"); setFile("README.md").toContent("This code is fubar."); runWithFailure( - ":spotlessMiscStep 'no swearing' found problem in 'README.md':", - "No swearing!", + ":spotlessMisc", + "Step 'no swearing' found problem in 'README.md'", "java.lang.RuntimeException: No swearing!"); } - private void runWithSuccess(String... messages) throws Exception { + private void runWithSuccess(String... messagePartsInOrder) throws Exception { BuildResult result = gradleRunner().withArguments("check").build(); - assertResultAndMessages(result, TaskOutcome.SUCCESS, messages); + assertResultAndOutputContainsMessages(result, TaskOutcome.SUCCESS, messagePartsInOrder); } - private void runWithFailure(String... messages) throws Exception { + private void runWithFailure(String... messagePartsInOrder) throws Exception { BuildResult result = gradleRunner().withArguments("check").buildAndFail(); - assertResultAndMessages(result, TaskOutcome.FAILED, messages); + assertResultAndOutputContainsMessages(result, TaskOutcome.FAILED, messagePartsInOrder); } - private void assertResultAndMessages(BuildResult result, TaskOutcome outcome, String... messages) { - String expectedToStartWith = StringPrinter.buildStringFromLines(messages).trim(); - int numNewlines = CharMatcher.is('\n').countIn(expectedToStartWith); - List actualLines = Splitter.on('\n').splitToList(LineEnding.toUnix(result.getOutput())); - String actualStart = String.join("\n", actualLines.subList(0, numNewlines + 1)); - Assertions.assertThat(actualStart).isEqualTo(expectedToStartWith); - Assertions.assertThat(result.tasks(outcome).size() + result.tasks(TaskOutcome.UP_TO_DATE).size()) + private void assertResultAndOutputContainsMessages(BuildResult result, TaskOutcome outcome, String... messagePartsInOrder) { + String actualOutput = LineEnding.toUnix(result.getOutput()); + assertThat(actualOutput).containsSubsequence(messagePartsInOrder); + assertThat(result.tasks(outcome).size() + result.tasks(TaskOutcome.UP_TO_DATE).size() + result.tasks(TaskOutcome.NO_SOURCE).size()) .isEqualTo(result.getTasks().size()); } } diff --git a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/GradleIntegrationTest.java b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/GradleIntegrationTest.java index 9f9a2618e6..b5e312e41b 100644 --- a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/GradleIntegrationTest.java +++ b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/GradleIntegrationTest.java @@ -58,8 +58,6 @@ public void gitAttributes() throws IOException { protected final GradleRunner gradleRunner() throws IOException { return GradleRunner.create() - // Test against Gradle 2.14.1 in order to maintain backwards compatibility. - // https://github.com/diffplug/spotless/issues/161 .withGradleVersion("2.14.1") .withProjectDir(rootFolder()) .withPluginClasspath(); diff --git a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/GroovyExtensionTest.java b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/GroovyExtensionTest.java index aaa3d7cd58..6d7636a463 100644 --- a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/GroovyExtensionTest.java +++ b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/GroovyExtensionTest.java @@ -15,10 +15,10 @@ */ package com.diffplug.gradle.spotless; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + import java.io.IOException; -import org.assertj.core.api.Assertions; -import org.junit.Assert; import org.junit.Test; public class GroovyExtensionTest extends GradleIntegrationTest { @@ -82,12 +82,9 @@ public void excludeJavaWithCustomTarget() throws IOException { " }", "}"); - try { - gradleRunner().withArguments("spotlessApply").build(); - Assert.fail("Exception expected when running 'excludeJava' in combination with 'target'."); - } catch (Throwable t) { - Assertions.assertThat(t).hasMessageContaining("'excludeJava' is not supported"); - } + assertThatThrownBy(() -> gradleRunner().withArguments("spotlessApply", "--stacktrace").build()) + .as("Exception expected when running 'excludeJava' in combination with 'target'.") + .hasMessageContaining("'excludeJava' is not supported"); } @Test @@ -103,12 +100,9 @@ public void groovyPluginMissingCheck() throws IOException { " }", "}"); - try { - gradleRunner().withArguments("spotlessApply").build(); - Assert.fail("Exception expected when using 'groovy' without 'target' if groovy-plugin is not applied."); - } catch (Throwable t) { - Assertions.assertThat(t).hasMessageContaining("must apply the groovy plugin before"); - } + assertThatThrownBy(() -> gradleRunner().withArguments("spotlessApply", "--stacktrace").build()) + .as("Exception expected when using 'groovy' without 'target' if groovy-plugin is not applied.") + .hasMessageContaining("must apply the groovy plugin before"); } } diff --git a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/HasBuiltinDelimiterForLicenseTest.java b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/HasBuiltinDelimiterForLicenseTest.java index 04ace06da8..49b9b1db9c 100644 --- a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/HasBuiltinDelimiterForLicenseTest.java +++ b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/HasBuiltinDelimiterForLicenseTest.java @@ -40,7 +40,6 @@ public void testWithCommonInterfaceForConfiguringLicences() throws IOException { " }", "}"); gradleRunner() - .withGradleVersion("4.6") .withArguments("spotlessApply") .forwardOutput() .build(); diff --git a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/PaddedCellTaskTest.java b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/PaddedCellTaskTest.java index a3d97c3351..fcef61771c 100644 --- a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/PaddedCellTaskTest.java +++ b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/PaddedCellTaskTest.java @@ -57,7 +57,7 @@ private class Bundle { } private SpotlessTask createCheckTask(String name, FormatterStep step) { - SpotlessTask task = project.getTasks().create("spotless" + SpotlessPlugin.capitalize(name), SpotlessTask.class); + SpotlessTask task = project.getTasks().create("spotless" + SpotlessTaskConstants.capitalize(name), SpotlessTask.class); task.setCheck(); task.addStep(step); task.setLineEndingsPolicy(LineEnding.UNIX.createPolicy()); @@ -66,7 +66,7 @@ private SpotlessTask createCheckTask(String name, FormatterStep step) { } private SpotlessTask createApplyTask(String name, FormatterStep step) { - SpotlessTask task = project.getTasks().create("spotless" + SpotlessPlugin.capitalize(name) + SpotlessPlugin.APPLY, SpotlessTask.class); + SpotlessTask task = project.getTasks().create("spotless" + SpotlessTaskConstants.capitalize(name) + SpotlessTaskConstants.APPLY, SpotlessTask.class); task.setApply(); task.addStep(step); task.setLineEndingsPolicy(LineEnding.UNIX.createPolicy());