Rename 'test/test-init-script' to 'test/init-scripts'

test/init-scripts/src/test/groovy/com/gradle/gradlebuildaction/BaseInitScriptTest.groovy

@@ -0,0 +1,240 @@
+package com.gradle.gradlebuildaction
+
+import com.fasterxml.jackson.core.JsonFactory
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.dataformat.smile.SmileFactory
+import org.gradle.testkit.runner.BuildResult
+import org.gradle.testkit.runner.GradleRunner
+import org.gradle.testkit.runner.internal.DefaultGradleRunner
+import org.gradle.util.GradleVersion
+import ratpack.groovy.test.embed.GroovyEmbeddedApp
+import spock.lang.AutoCleanup
+import spock.lang.Specification
+import spock.lang.TempDir
+
+import java.nio.file.Files
+import java.util.zip.GZIPOutputStream
+
+class BaseInitScriptTest extends Specification {
+
+    static final TestGradleVersion GRADLE_3_5 = new TestGradleVersion(GradleVersion.version('3.5.1'), 7, 9)
+    static final TestGradleVersion GRADLE_4_0 = new TestGradleVersion(GradleVersion.version('4.0.2'), 7, 9)
+    static final TestGradleVersion GRADLE_4_10 = new TestGradleVersion(GradleVersion.version('4.10.3'), 7, 10)
+    static final TestGradleVersion GRADLE_5_0 = new TestGradleVersion(GradleVersion.version('5.0'), 8, 11)
+    static final TestGradleVersion GRADLE_5_6 = new TestGradleVersion(GradleVersion.version('5.6.4'), 8, 12)
+    static final TestGradleVersion GRADLE_6_0 = new TestGradleVersion(GradleVersion.version('6.0.1'), 8, 13)
+    static final TestGradleVersion GRADLE_6_7 = new TestGradleVersion(GradleVersion.version('6.7'), 8, 15)
+    static final TestGradleVersion GRADLE_7_0 = new TestGradleVersion(GradleVersion.version('7.0.2'), 8, 16)
+    static final TestGradleVersion GRADLE_7_4 = new TestGradleVersion(GradleVersion.version('7.4.2'), 8, 17)
+
+    static final List<TestGradleVersion> ALL_VERSIONS = [
+        GRADLE_3_5, // First version where TestKit supports environment variables
+        GRADLE_4_0,
+        GRADLE_4_10,
+        GRADLE_5_0,
+        GRADLE_5_6,
+        GRADLE_6_0,
+        GRADLE_6_7,
+        GRADLE_7_0,
+        GRADLE_7_4,
+    ]
+
+    static final List<TestGradleVersion> CONFIGURATION_CACHE_VERSIONS =
+        [GRADLE_7_0, GRADLE_7_4]
+
+    static final String PUBLIC_BUILD_SCAN_ID = 'i2wepy2gr7ovw'
+    static final String DEFAULT_SCAN_UPLOAD_TOKEN = 'scan-upload-token'
+    static final String ROOT_PROJECT_NAME = 'test-init-script'
+
+    File settingsFile
+    File buildFile
+
+    @TempDir
+    File testProjectDir
+
+    @AutoCleanup
+    def mockScansServer = GroovyEmbeddedApp.of {
+        def jsonWriter = new ObjectMapper(new JsonFactory()).writer()
+        def smileWriter = new ObjectMapper(new SmileFactory()).writer()
+
+        handlers {
+            post('in/:gradleVersion/:pluginVersion') {
+                def scanUrlString = "${mockScansServer.address}s/$PUBLIC_BUILD_SCAN_ID"
+                def body = [
+                    id     : PUBLIC_BUILD_SCAN_ID,
+                    scanUrl: scanUrlString.toString(),
+                ]
+                def out = new ByteArrayOutputStream()
+                new GZIPOutputStream(out).withStream { smileWriter.writeValue(it, body) }
+                context.response
+                    .contentType('application/vnd.gradle.scan-ack')
+                    .send(out.toByteArray())
+            }
+            prefix('scans/publish') {
+                post('gradle/:pluginVersion/token') {
+                    def pluginVersion = context.pathTokens.pluginVersion
+                    def scanUrlString = "${mockScansServer.address}s/$PUBLIC_BUILD_SCAN_ID"
+                    def body = [
+                        id             : PUBLIC_BUILD_SCAN_ID,
+                        scanUrl        : scanUrlString.toString(),
+                        scanUploadUrl  : "${mockScansServer.address.toString()}scans/publish/gradle/$pluginVersion/upload".toString(),
+                        scanUploadToken: DEFAULT_SCAN_UPLOAD_TOKEN
+                    ]
+                    context.response
+                        .contentType('application/vnd.gradle.scan-ack+json')
+                        .send(jsonWriter.writeValueAsBytes(body))
+                }
+                post('gradle/:pluginVersion/upload') {
+                    context.request.getBody(1024 * 1024 * 10).then {
+                        context.response
+                            .contentType('application/vnd.gradle.scan-upload-ack+json')
+                            .send()
+                    }
+                }
+                notFound()
+            }
+        }
+    }
+
+    def setup() {
+        settingsFile = new File(testProjectDir, 'settings.gradle')
+        buildFile = new File(testProjectDir, 'build.gradle')
+
+        File srcInitScriptsDir = new File("../../src/resources")
+        File targetInitScriptsDir = new File(testProjectDir, "initScripts")
+        targetInitScriptsDir.mkdirs()
+
+        for (File srcInitScript : srcInitScriptsDir.listFiles()) {
+            File targetInitScript = new File(targetInitScriptsDir, srcInitScript.name)
+            Files.copy(srcInitScript.toPath(), targetInitScript.toPath())
+        }
+        settingsFile << "rootProject.name = '${ROOT_PROJECT_NAME}'\n"
+        buildFile << ''
+    }
+
+    def declareGePluginApplication(GradleVersion gradleVersion) {
+        settingsFile.text = maybeAddPluginsToSettings(gradleVersion) + settingsFile.text
+        buildFile.text = maybeAddPluginsToRootProject(gradleVersion) + buildFile.text
+    }
+
+    String maybeAddPluginsToSettings(GradleVersion gradleVersion) {
+        if (gradleVersion < GradleVersion.version('5.0')) {
+            '' // applied in build.gradle
+        } else if (gradleVersion < GradleVersion.version('6.0')) {
+            '' // applied in build.gradle
+        } else {
+            """
+              plugins {
+                id 'com.gradle.enterprise' version '3.4.1'
+              }
+              gradleEnterprise {
+                server = '$mockScansServer.address'
+                buildScan {
+                  publishAlways()
+                }
+              }
+            """
+        }
+    }
+
+    String maybeAddPluginsToRootProject(GradleVersion gradleVersion) {
+        if (gradleVersion < GradleVersion.version('5.0')) {
+            """
+              plugins {
+                id 'com.gradle.build-scan' version '1.16'
+              }
+              buildScan {
+                server = '$mockScansServer.address'
+                publishAlways()
+              }
+            """
+        } else if (gradleVersion < GradleVersion.version('6.0')) {
+            """
+              plugins {
+                id 'com.gradle.build-scan' version '3.4.1'
+              }
+              gradleEnterprise {
+                server = '$mockScansServer.address'
+                buildScan {
+                  publishAlways()
+                }
+              }
+            """
+        } else {
+            '' // applied in settings.gradle
+        }
+    }
+
+    def addFailingTaskToBuild() {
+        buildFile << '''
+task expectFailure {
+    doLast {
+        throw new RuntimeException("Expected to fail")
+    }
+}
+'''
+    }
+
+    BuildResult run(List<String> args, String initScript, GradleVersion gradleVersion = GradleVersion.current(), List<String> jvmArgs = [], Map<String, String> envVars = [:]) {
+        createRunner(initScript, args, gradleVersion, jvmArgs, envVars).build()
+    }
+
+    BuildResult runAndFail(List<String> args, String initScript, GradleVersion gradleVersion = GradleVersion.current(), List<String> jvmArgs = [], Map<String, String> envVars = [:]) {
+        createRunner(initScript, args, gradleVersion, jvmArgs, envVars).buildAndFail()
+    }
+
+    GradleRunner createRunner(String initScript, List<String> args, GradleVersion gradleVersion = GradleVersion.current(), List<String> jvmArgs = [], Map<String, String> envVars = [:]) {
+        File initScriptsDir = new File(testProjectDir, "initScripts")
+        args << '-I' << new File(initScriptsDir, initScript).absolutePath
+
+        envVars['RUNNER_TEMP'] = testProjectDir.absolutePath
+        envVars['GITHUB_ACTION'] = 'github-step-id'
+
+        def runner = ((DefaultGradleRunner) GradleRunner.create())
+            .withJvmArguments(jvmArgs)
+            .withGradleVersion(gradleVersion.version)
+            .withProjectDir(testProjectDir)
+            .withArguments(args)
+            .forwardOutput()
+
+        if (envVars) {
+            runner.withEnvironment(envVars)
+        }
+
+        runner
+    }
+
+    static final class TestGradleVersion {
+
+        final GradleVersion gradleVersion
+        private final Integer jdkMin
+        private final Integer jdkMax
+
+        TestGradleVersion(GradleVersion gradleVersion, Integer jdkMin, Integer jdkMax) {
+            this.gradleVersion = gradleVersion
+            this.jdkMin = jdkMin
+            this.jdkMax = jdkMax
+        }
+
+        boolean isCompatibleWithCurrentJvm() {
+            def jvmVersion = getJvmVersion()
+            jdkMin <= jvmVersion && jvmVersion <= jdkMax
+        }
+
+        private static int getJvmVersion() {
+            String version = System.getProperty('java.version')
+            if (version.startsWith('1.')) {
+                Integer.parseInt(version.substring(2, 3))
+            } else {
+                Integer.parseInt(version.substring(0, version.indexOf('.')))
+            }
+        }
+
+        @Override
+        String toString() {
+            return "Gradle " + gradleVersion.version
+        }
+
+    }
+
+}

test/init-scripts/src/test/groovy/com/gradle/gradlebuildaction/TestBuildResultRecorder.groovy

@@ -0,0 +1,141 @@
+package com.gradle.gradlebuildaction
+
+import groovy.json.JsonSlurper
+
+import static org.junit.Assume.assumeTrue
+
+class TestBuildResultRecorder extends BaseInitScriptTest {
+    def initScript = 'build-result-capture.init.gradle'
+
+    def "produces build results file for build with #testGradleVersion"() {
+        assumeTrue testGradleVersion.compatibleWithCurrentJvm
+
+        when:
+        run(['help'], initScript, testGradleVersion.gradleVersion)
+
+        then:
+        assertResults('help', testGradleVersion, false, false)
+
+        where:
+        testGradleVersion << ALL_VERSIONS
+    }
+
+    def "produces build results file for failing build with #testGradleVersion"() {
+        assumeTrue testGradleVersion.compatibleWithCurrentJvm
+
+        when:
+        addFailingTaskToBuild()
+        runAndFail(['expectFailure'], initScript, testGradleVersion.gradleVersion)
+
+        then:
+        assertResults('expectFailure', testGradleVersion, true, false)
+
+        where:
+        testGradleVersion << ALL_VERSIONS
+    }
+
+    def "produces build results file for build with --configuration-cache on #testGradleVersion"() {
+        assumeTrue testGradleVersion.compatibleWithCurrentJvm
+
+        when:
+        run(['help', '--configuration-cache'], initScript, testGradleVersion.gradleVersion)
+
+        then:
+        assertResults('help', testGradleVersion, false, false)
+        assert buildResultFile.delete()
+
+        when:
+        run(['help', '--configuration-cache'], initScript, testGradleVersion.gradleVersion)
+
+        then:
+        assertResults('help', testGradleVersion, false, false)
+
+        where:
+        testGradleVersion << CONFIGURATION_CACHE_VERSIONS
+    }
+
+    def "produces build results file for #testGradleVersion with build scan published"() {
+        assumeTrue testGradleVersion.compatibleWithCurrentJvm
+
+        when:
+        declareGePluginApplication(testGradleVersion.gradleVersion)
+        run(['help'], initScript, testGradleVersion.gradleVersion)
+
+        then:
+        assertResults('help', testGradleVersion, false, true)
+
+        where:
+        testGradleVersion << ALL_VERSIONS
+    }
+
+    def "produces build results file for #testGradleVersion with ge-plugin and no build scan published"() {
+        assumeTrue testGradleVersion.compatibleWithCurrentJvm
+
+        when:
+        declareGePluginApplication(testGradleVersion.gradleVersion)
+        run(['help', '--no-scan'], initScript, testGradleVersion.gradleVersion)
+
+        then:
+        assertResults('help', testGradleVersion, false, false)
+
+        where:
+        testGradleVersion << ALL_VERSIONS
+    }
+
+    def "produces build results file for failing build on #testGradleVersion with build scan published"() {
+        assumeTrue testGradleVersion.compatibleWithCurrentJvm
+
+        when:
+        declareGePluginApplication(testGradleVersion.gradleVersion)
+        addFailingTaskToBuild()
+        runAndFail(['expectFailure'], initScript, testGradleVersion.gradleVersion)
+
+        then:
+        assertResults('expectFailure', testGradleVersion, true, true)
+
+        where:
+        testGradleVersion << ALL_VERSIONS
+    }
+
+    def "produces build results file for build with --configuration-cache on #testGradleVersion with build scan published"() {
+        assumeTrue testGradleVersion.compatibleWithCurrentJvm
+
+        when:
+        declareGePluginApplication(testGradleVersion.gradleVersion)
+        run(['help', '--configuration-cache'], initScript, testGradleVersion.gradleVersion)
+
+        then:
+        assertResults('help', testGradleVersion, false, true)
+        assert buildResultFile.delete()
+
+        when:
+        run(['help', '--configuration-cache'], initScript, testGradleVersion.gradleVersion)
+
+        then:
+        assertResults('help', testGradleVersion, false, true)
+
+        where:
+        testGradleVersion << CONFIGURATION_CACHE_VERSIONS
+    }
+
+    void assertResults(String task, TestGradleVersion testGradleVersion, boolean hasFailure, boolean hasBuildScan) {
+        def results = new JsonSlurper().parse(buildResultFile)
+        assert results['rootProjectName'] == ROOT_PROJECT_NAME
+        assert results['rootProjectDir'] == testProjectDir.canonicalPath
+        assert results['requestedTasks'] == task
+        assert results['gradleVersion'] == testGradleVersion.gradleVersion.version
+        assert results['gradleHomeDir'] != null
+        assert results['buildFailed'] == hasFailure
+        assert results['buildScanUri'] == (hasBuildScan ? "${mockScansServer.address}s/${PUBLIC_BUILD_SCAN_ID}" : null)
+    }
+
+    private File getBuildResultFile() {
+        def buildResultsDir = new File(testProjectDir, '.build-results')
+        assert buildResultsDir.directory
+        assert buildResultsDir.listFiles().size() == 1
+        def resultsFile = buildResultsDir.listFiles()[0]
+        assert resultsFile.name.startsWith('github-step-id')
+        assert resultsFile.text.count('rootProjectName') == 1
+        return resultsFile
+    }
+}