Allow multiple 'whitebox(...) { ... }' calls for one test suite

jjohannes · jjohannes · commit dc00d604b06e · 2022-08-18T11:59:30.000+02:00
Resolves #1
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -12,7 +12,9 @@ java {
 }
 
 dependencies {
+    testImplementation("org.spockframework:spock-core:2.1-groovy-3.0")
     testImplementation("org.gradle.exemplar:samples-check:1.0.0")
+    testRuntimeOnly("org.junit.vintage:junit-vintage-engine")
 }
 
 pluginPublishConventions {
@@ -30,5 +32,7 @@ pluginPublishConventions {
 }
 
 tasks.test {
+    useJUnitPlatform()
+    maxParallelForks = 4
     inputs.dir(layout.projectDirectory.dir("samples"))
 }
diff --git a/src/main/java/org/gradlex/javamodule/testing/JavaModuleTestingExtension.java b/src/main/java/org/gradlex/javamodule/testing/JavaModuleTestingExtension.java
@@ -72,7 +72,6 @@ public void blackbox(TestSuite jvmTestSuite) {
      */
     public void whitebox(TestSuite jvmTestSuite) {
         whitebox(jvmTestSuite, NO_OP_ACTION);
-
     }
 
     /**
@@ -114,7 +113,7 @@ private void configureJvmTestSuiteForBlackbox(JvmTestSuite jvmTestSuite) {
         tasks.named(sourceSet.getName(), Test.class, t -> {
             // Classpath consists only of Jars to include classes+resources in one place
             t.setClasspath(configurations.getByName(sourceSet.getRuntimeClasspathConfigurationName()).plus(project.files(jarTask)));
-            // Rest test classes dir to allow switching back from 'whitebox' to 'blackbox'
+            // Reset test classes dir
             t.setTestClassesDirs(sourceSet.getOutput().getClassesDirs());
         });
     }
@@ -129,13 +128,19 @@ private void configureJvmTestSuiteForWhitebox(JvmTestSuite jvmTestSuite, Whitebo
         tasks.named(testSources.getCompileJavaTaskName(), JavaCompile.class, compileJava -> {
             SourceSet sourcesUnderTest = whiteboxJvmTestSuite.getSourcesUnderTest().get();
             compileJava.setClasspath(sourcesUnderTest.getOutput().plus(configurations.getByName(testSources.getCompileClasspathConfigurationName())));
-            compileJava.getOptions().getCompilerArgumentProviders().add(new WhiteboxTestCompileArgumentProvider(
-                    sourcesUnderTest.getJava().getSrcDirs(),
-                    testSources.getJava().getSrcDirs(),
-                    compileJava,
-                    whiteboxJvmTestSuite.getRequires(),
-                    moduleDetector,
-                    moduleInfoParser));
+
+            WhiteboxTestCompileArgumentProvider argumentProvider = (WhiteboxTestCompileArgumentProvider) compileJava.getOptions().getCompilerArgumentProviders().stream()
+                    .filter(p -> p instanceof WhiteboxTestCompileArgumentProvider).findFirst().orElseGet(() -> {
+                        WhiteboxTestCompileArgumentProvider newProvider = new WhiteboxTestCompileArgumentProvider(
+                                sourcesUnderTest.getJava().getSrcDirs(),
+                                testSources.getJava().getSrcDirs(),
+                                compileJava,
+                                moduleDetector,
+                                moduleInfoParser);
+                        compileJava.getOptions().getCompilerArgumentProviders().add(newProvider);
+                        return newProvider;
+                    });
+            argumentProvider.testRequires(whiteboxJvmTestSuite.getRequires().get());
         });
 
         tasks.named(testSources.getName(), Test.class, test -> {
@@ -145,15 +150,19 @@ private void configureJvmTestSuiteForWhitebox(JvmTestSuite jvmTestSuite, Whitebo
             // Add main classes here so that Gradle finds module-info.class and treats this as a test with module path
             test.setTestClassesDirs(sourcesUnderTest.getOutput().getClassesDirs().plus(testSources.getOutput().getClassesDirs()));
 
-            test.getJvmArgumentProviders().add(new WhiteboxTestRuntimeArgumentProvider(
-                    sourcesUnderTest.getJava().getSrcDirs(),
-                    testSources.getJava().getClassesDirectory(),
-                    sourcesUnderTest.getOutput().getResourcesDir(),
-                    testSources.getOutput().getResourcesDir(),
-                    whiteboxJvmTestSuite.getRequires(),
-                    whiteboxJvmTestSuite.getOpensTo(),
-                    moduleInfoParser
-            ));
+            WhiteboxTestRuntimeArgumentProvider argumentProvider = (WhiteboxTestRuntimeArgumentProvider) test.getJvmArgumentProviders().stream()
+                    .filter(p -> p instanceof WhiteboxTestRuntimeArgumentProvider).findFirst().orElseGet(() -> {
+                        WhiteboxTestRuntimeArgumentProvider newProvider = new WhiteboxTestRuntimeArgumentProvider(
+                                sourcesUnderTest.getJava().getSrcDirs(),
+                                testSources.getJava().getClassesDirectory(),
+                                sourcesUnderTest.getOutput().getResourcesDir(),
+                                testSources.getOutput().getResourcesDir(),
+                                moduleInfoParser);
+                        test.getJvmArgumentProviders().add(newProvider);
+                        return newProvider;
+                    });
+            argumentProvider.testRequires(whiteboxJvmTestSuite.getRequires().get());
+            argumentProvider.testOpensTo(whiteboxJvmTestSuite.getOpensTo().get());
         });
 
         Configuration implementation = configurations.getByName(testSources.getImplementationConfigurationName());
diff --git a/src/main/java/org/gradlex/javamodule/testing/internal/provider/WhiteboxTestCompileArgumentProvider.java b/src/main/java/org/gradlex/javamodule/testing/internal/provider/WhiteboxTestCompileArgumentProvider.java
@@ -16,9 +16,7 @@
 
 package org.gradlex.javamodule.testing.internal.provider;
 
-
 import org.gradlex.javamodule.testing.internal.ModuleInfoParser;
-import org.gradle.api.provider.Provider;
 import org.gradle.api.tasks.compile.JavaCompile;
 import org.gradle.internal.jvm.JavaModuleDetector;
 import org.gradle.process.CommandLineArgumentProvider;
@@ -33,19 +31,25 @@ public class WhiteboxTestCompileArgumentProvider implements CommandLineArgumentP
     private final Set<File> mainSourceFolders;
     private final Set<File> testSourceFolders;
     private final JavaCompile task;
-    private final Provider<List<String>> testRequires;
     private final JavaModuleDetector moduleDetector;
     private final ModuleInfoParser moduleInfoParser;
 
-    public WhiteboxTestCompileArgumentProvider(Set<File> mainSourceFolders, Set<File> testSourceFolders, JavaCompile task, Provider<List<String>> testRequires, JavaModuleDetector moduleDetector, ModuleInfoParser moduleInfoParser) {
+    private final List<String> allTestRequires = new ArrayList<>();
+
+    public WhiteboxTestCompileArgumentProvider(
+            Set<File> mainSourceFolders, Set<File> testSourceFolders, JavaCompile task,
+            JavaModuleDetector moduleDetector, ModuleInfoParser moduleInfoParser) {
         this.mainSourceFolders = mainSourceFolders;
         this.testSourceFolders = testSourceFolders;
         this.task = task;
-        this.testRequires = testRequires;
         this.moduleDetector = moduleDetector;
         this.moduleInfoParser = moduleInfoParser;
     }
 
+    public void testRequires(List<String> testRequires) {
+        allTestRequires.addAll(testRequires);
+    }
+
     @Override
     public Iterable<String> asArguments() {
         String moduleName = moduleInfoParser.moduleName(mainSourceFolders);
@@ -58,7 +62,7 @@ public Iterable<String> asArguments() {
         args.add("--module-path");
         args.add(moduleDetector.inferModulePath(true, task.getClasspath()).getFiles().stream().map(File::getPath).collect(Collectors.joining(cpSeparator)));
 
-        for (String testRequires : testRequires.get()) {
+        for (String testRequires : allTestRequires) {
             args.add("--add-modules");
             args.add(testRequires);
             args.add("--add-reads");
diff --git a/src/main/java/org/gradlex/javamodule/testing/internal/provider/WhiteboxTestRuntimeArgumentProvider.java b/src/main/java/org/gradlex/javamodule/testing/internal/provider/WhiteboxTestRuntimeArgumentProvider.java
@@ -31,23 +31,30 @@ public class WhiteboxTestRuntimeArgumentProvider implements CommandLineArgumentP
     private final Provider<Directory> testClassesFolders;
     private final File resourcesUnderTest;
     private final File testResources;
-    private final Provider<List<String>> testRequires;
-    private final Provider<List<String>> opensTo;
     private final ModuleInfoParser moduleInfoParser;
 
+    private final List<String> allTestRequires = new ArrayList<>();
+    private final List<String> allTestOpensTo = new ArrayList<>();
+
     public WhiteboxTestRuntimeArgumentProvider(Set<File> mainSourceFolders,
            Provider<Directory> testClassesFolders, File resourcesUnderTest, File testResources,
-           Provider<List<String>> testRequires, Provider<List<String>> opensTo, ModuleInfoParser moduleInfoParser) {
+           ModuleInfoParser moduleInfoParser) {
 
         this.mainSourceFolders = mainSourceFolders;
         this.testClassesFolders = testClassesFolders;
         this.resourcesUnderTest = resourcesUnderTest;
         this.testResources = testResources;
-        this.testRequires = testRequires;
-        this.opensTo = opensTo;
         this.moduleInfoParser = moduleInfoParser;
     }
 
+    public void testRequires(List<String> testRequires) {
+        allTestRequires.addAll(testRequires);
+    }
+
+    public void testOpensTo(List<String> testRequires) {
+        allTestOpensTo.addAll(testRequires);
+    }
+
     @Override
     public Iterable<String> asArguments() {
         String moduleName = moduleInfoParser.moduleName(mainSourceFolders);
@@ -62,15 +69,15 @@ public Iterable<String> asArguments() {
 
         List<String> args = new ArrayList<>();
 
-        for (String testRequires : testRequires.get()) {
+        for (String testRequires : allTestRequires) {
             args.add("--add-modules");
             args.add(testRequires);
             args.add("--add-reads");
             args.add(moduleName + "=" + testRequires);
         }
 
         for (String packageName : allTestClassPackages) {
-            for (String opensTo : opensTo.get()) {
+            for (String opensTo : allTestOpensTo) {
                 args.add("--add-opens");
                 args.add(moduleName + "/" + packageName + "=" + opensTo);
             }
diff --git a/src/test/groovy/org/gradlex/javamodule/testing/test/CustomizationTest.groovy b/src/test/groovy/org/gradlex/javamodule/testing/test/CustomizationTest.groovy
@@ -0,0 +1,79 @@
+package org.gradlex.javamodule.testing.test
+
+import org.gradle.testkit.runner.TaskOutcome
+import org.gradlex.javamodule.testing.test.fixture.GradleBuild
+import spock.lang.Specification
+
+class CustomizationTest extends Specification {
+
+    @Delegate
+    GradleBuild build = new GradleBuild()
+
+    def "can customize whitebox test suites in multiple steps"() {
+        given:
+        appBuildFile << '''
+            javaModuleTesting.whitebox(testing.suites["test"]) {
+                requires.add("org.junit.jupiter.api")
+            }
+            javaModuleTesting.whitebox(testing.suites["test"]) {
+                opensTo.add("org.junit.platform.commons")
+            }
+        '''
+        appModuleInfoFile << '''
+            module org.gradlex.test.app { 
+            }
+        '''
+
+        when:
+        def result = runTests()
+
+        then:
+        result.task(":app:test").outcome == TaskOutcome.SUCCESS
+    }
+
+    def "repetitive blackbox calls on the same test suite have no effect"() {
+        given:
+        appBuildFile << '''
+            javaModuleTesting.blackbox(testing.suites["test"])
+            javaModuleTesting.blackbox(testing.suites["test"])
+        '''
+        appModuleInfoFile << '''
+            module org.gradlex.test.app { 
+            }
+        '''
+        appTestModuleInfoFile << '''
+            module org.gradlex.test.app.test { 
+                requires org.junit.jupiter.api;
+            }
+        '''
+
+        when:
+        def result = runTests()
+
+        then:
+        result.task(":app:test").outcome == TaskOutcome.SUCCESS
+    }
+
+    def "repetitive blackbox calls on the same test suite have no effect"() {
+        given:
+        appBuildFile << '''
+            javaModuleTesting.blackbox(testing.suites["test"])
+            javaModuleTesting.blackbox(testing.suites["test"])
+        '''
+        appModuleInfoFile << '''
+            module org.gradlex.test.app { 
+            }
+        '''
+        appTestModuleInfoFile << '''
+            module org.gradlex.test.app.test { 
+                requires org.junit.jupiter.api;
+            }
+        '''
+
+        when:
+        def result = runTests()
+
+        then:
+        result.task(":app:test").outcome == TaskOutcome.SUCCESS
+    }
+}
diff --git a/src/test/groovy/org/gradlex/javamodule/testing/test/fixture/GradleBuild.groovy b/src/test/groovy/org/gradlex/javamodule/testing/test/fixture/GradleBuild.groovy
@@ -0,0 +1,98 @@
+package org.gradlex.javamodule.testing.test.fixture
+
+import org.gradle.testkit.runner.BuildResult
+import org.gradle.testkit.runner.GradleRunner
+
+import java.lang.management.ManagementFactory
+import java.nio.file.Files
+
+class GradleBuild {
+
+    final File projectDir
+    final File settingsFile
+    final File appBuildFile
+    final File appModuleInfoFile
+    final File appTestModuleInfoFile
+
+    final String gradleVersionUnderTest = System.getProperty("gradleVersionUnderTest")
+
+    GradleBuild(File projectDir = Files.createTempDirectory("gradle-build").toFile()) {
+        this.projectDir = projectDir
+        this.settingsFile = file("settings.gradle.kts")
+        this.appBuildFile = file("app/build.gradle.kts")
+        this.appModuleInfoFile = file("app/src/main/java/module-info.java")
+        this.appTestModuleInfoFile = file("app/src/test/java/module-info.java")
+
+        settingsFile << '''
+            dependencyResolutionManagement { repositories.mavenCentral() }
+            rootProject.name = "test-project"
+            include("app")
+        '''
+        appBuildFile << '''
+            plugins {
+                id("org.gradlex.java-module-dependencies") version "1.0"
+                id("org.gradlex.java-module-testing")
+                id("application")
+            }
+            dependencies {
+                testImplementation(platform("org.junit:junit-bom:5.9.0"))
+            }
+            application {
+                mainModule.set("org.gradlex.test.app")
+                mainClass.set("org.gradlex.test.app.Main")
+            }
+            tasks.register("printRuntimeJars") {
+                doLast { println(configurations.runtimeClasspath.get().files.map { it.name }) }
+            }
+            tasks.register("printCompileJars") {
+                doLast { println(configurations.compileClasspath.get().files.map { it.name }) }
+            }
+        '''
+
+        file("app/src/test/java/com/example/AppTest.java") << '''
+            package com.example;
+            
+            import org.junit.jupiter.api.Test;
+            
+            public class AppTest {
+                
+                @Test
+                void testApp() {
+                }
+            }
+        '''
+    }
+
+    File file(String path) {
+        new File(projectDir, path).tap {
+            it.getParentFile().mkdirs()
+        }
+    }
+
+    BuildResult build() {
+        runner('build').build()
+    }
+
+    BuildResult run() {
+        runner('run').build()
+    }
+
+    BuildResult runTests() {
+        runner(':app:test', '-q').build()
+    }
+
+    BuildResult fail() {
+        runner('build').buildAndFail()
+    }
+
+    GradleRunner runner(String... args) {
+        GradleRunner.create()
+                .forwardOutput()
+                .withPluginClasspath()
+                .withProjectDir(projectDir)
+                .withArguments(Arrays.asList(args) + '-s')
+                .withDebug(ManagementFactory.getRuntimeMXBean().getInputArguments().toString().contains("-agentlib:jdwp")).with {
+            gradleVersionUnderTest ? it.withGradleVersion(gradleVersionUnderTest) : it
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,9 @@ java {`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`dependencies {`
	`15`	`+ testImplementation("org.spockframework:spock-core:2.1-groovy-3.0")`
`15`	`16`	`testImplementation("org.gradle.exemplar:samples-check:1.0.0")`
	`17`	`+ testRuntimeOnly("org.junit.vintage:junit-vintage-engine")`
`16`	`18`	`}`
`17`	`19`
`18`	`20`	`pluginPublishConventions {`
`@@ -30,5 +32,7 @@ pluginPublishConventions {`
`30`	`32`	`}`
`31`	`33`
`32`	`34`	`tasks.test {`
	`35`	`+ useJUnitPlatform()`
	`36`	`+ maxParallelForks = 4`
`33`	`37`	`inputs.dir(layout.projectDirectory.dir("samples"))`
`34`	`38`	`}`