Translate tests to Java

Author: jjohannes

build.gradle.kts

@@ -1,20 +1,16 @@
 plugins {
-    id("groovy")
     id("org.gradlex.internal.plugin-publish-conventions") version "0.6"
 }
 
 group = "org.gradlex"
 version = "1.0.1"
 
 java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
+    toolchain.languageVersion = JavaLanguageVersion.of(21)
 }
 
-dependencies {
-    testImplementation("org.spockframework:spock-core:2.1-groovy-3.0")
-    testImplementation("org.gradle.exemplar:samples-check:1.0.3")
-    testRuntimeOnly("org.junit.vintage:junit-vintage-engine")
+tasks.compileJava {
+    options.release = 8
 }
 
 pluginPublishConventions {
@@ -31,7 +27,14 @@ pluginPublishConventions {
     }
 }
 
-tasks.test {
-    useJUnitPlatform()
-    maxParallelForks = 4
+testing.suites.named<JvmTestSuite>("test") {
+    useJUnitJupiter()
+    dependencies {
+        implementation("org.assertj:assertj-core:3.27.3")
+    }
+    targets.configureEach {
+        testTask {
+            maxParallelForks = 4
+        }
+    }
 }

src/test/groovy/org/gradlex/javamodule/packaging/test/JavaModulePackagingTest.groovy

@@ -0,0 +1,89 @@
+/*
+ * Copyright the GradleX team.
+ *
+ * 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 org.gradlex.javamodule.packaging.test;
+
+import org.assertj.core.api.Assertions;
+import org.gradlex.javamodule.packaging.test.fixture.GradleBuild;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.Locale;
+import java.util.stream.Stream;
+
+import static org.gradle.testkit.runner.TaskOutcome.FAILED;
+import static org.gradle.testkit.runner.TaskOutcome.SUCCESS;
+import static org.gradlex.javamodule.packaging.test.fixture.GradleBuild.hostOs;
+import static org.gradlex.javamodule.packaging.test.fixture.GradleBuild.runsOnLinux;
+import static org.gradlex.javamodule.packaging.test.fixture.GradleBuild.runsOnMacos;
+import static org.gradlex.javamodule.packaging.test.fixture.GradleBuild.runsOnWindows;
+
+class JavaModulePackagingTest {
+
+    GradleBuild build = new GradleBuild();
+
+    private static Stream<Arguments> testTargets() {
+        return Stream.of(
+                Arguments.of("windows", "windows", runsOnWindows()),
+                Arguments.of("macos", "macos", runsOnMacos()),
+                Arguments.of("ubuntu", "linux", runsOnLinux()));
+    }
+
+    @ParameterizedTest
+    @MethodSource("testTargets")
+    void can_use_plugin(String label, String os, boolean success) {
+        var taskToRun = ":app:assemble" + capitalize(label);
+        var taskToCheck = ":app:jpackage" + capitalize(label);
+        var macosArch = System.getProperty("os.arch").contains("aarch") ? "aarch64" : "x86-64";
+        build.appBuildFile.appendText("""
+                    version = "1.0"
+                    javaModulePackaging {
+                        target("macos") {
+                            operatingSystem = "macos"
+                            architecture = "%s"
+                        }
+                        target("ubuntu") {
+                            operatingSystem = "linux"
+                            architecture = "x86-64"
+                        }
+                        target("windows") {
+                            operatingSystem = "windows"
+                            architecture = "x86-64"
+                        }
+                    }
+                """.formatted(macosArch));
+        build.appModuleInfoFile.writeText("""              
+                    module org.example.app {
+                    }
+                """);
+
+        var buildResult = success ? build.build(taskToRun) : build.fail(taskToRun);
+        var taskResult = buildResult.task(taskToCheck);
+
+        Assertions.assertThat(taskResult).isNotNull();
+        Assertions.assertThat(taskResult.getOutcome()).isEqualTo(success ? SUCCESS : FAILED);
+        if (!success) {
+            Assertions.assertThat(buildResult.getOutput()).contains(
+                    "> Running on %s; cannot build for %s".formatted(hostOs(), os));
+        }
+    }
+
+    private static String capitalize(String str) {
+        return str.substring(0, 1).toUpperCase(Locale.ROOT) + str.substring(1);
+    }
+
+}

src/test/groovy/org/gradlex/javamodule/packaging/test/fixture/GradleBuild.groovy

@@ -0,0 +1,61 @@
+/*
+ * Copyright the GradleX team.
+ *
+ * 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 org.gradlex.javamodule.packaging.test.fixture;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Comparator;
+import java.util.stream.Stream;
+
+public class Directory {
+
+    private final Path directory;
+
+    Directory(Path directory) {
+        this.directory = directory;
+        Io.unchecked(() -> Files.createDirectories(directory));
+    }
+
+    public WritableFile file(String path) {
+        Path file = directory.resolve(path);
+        Io.unchecked(() -> Files.createDirectories(file.getParent()));
+        return new WritableFile(file);
+    }
+
+    public Directory dir(String path) {
+        Path dir = directory.resolve(path);
+        Io.unchecked(() -> Files.createDirectories(dir));
+        return new Directory(dir);
+    }
+
+    public void delete() {
+        try (Stream<Path> walk = Files.walk(directory)) {
+            walk.sorted(Comparator.reverseOrder()).forEach(p -> Io.unchecked(p, Files::delete));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public Path getAsPath() {
+        return directory;
+    }
+
+    public String canonicalPath() {
+        return Io.unchecked(() -> getAsPath().toFile().getCanonicalPath());
+    }
+}