uploadInBackground can be configured even Develocity plugin is already applied (#36)

Allow uploadInBackground to be configured when Develocity plugin already applied.

This is necessary for the Develocity Build Validation Scripts, but could also be useful for CI plugins.

Where this will change behavior for CI users is if the project is currently configuring uploadInBackground = true on CI. The CI plugins disable this if configured to do so.

Author: erichaagdev

src/main/resources/develocity-injection.init.gradle

@@ -110,7 +110,6 @@ if (buildScanCaptureEnabled) {
 }
 
 void enableDevelocityInjection() {
-    def BUILD_SCAN_PLUGIN_ID = 'com.gradle.build-scan'
     def BUILD_SCAN_PLUGIN_CLASS = 'com.gradle.scan.plugin.BuildScanPlugin'
 
     def GRADLE_ENTERPRISE_PLUGIN_ID = 'com.gradle.enterprise'
@@ -196,8 +195,6 @@ void enableDevelocityInjection() {
                             // Develocity plugin publishes scans by default
                             buildScanExtension.publishAlways()
                         }
-                        // uploadInBackground not available for build-scan-plugin 1.16
-                        if (buildScanExtension.metaClass.respondsTo(buildScanExtension, 'setUploadInBackground', Boolean)) buildScanExtension.uploadInBackground = buildScanUploadInBackground
                         buildScanExtension.value CI_AUTO_INJECTION_CUSTOM_VALUE_NAME, ciAutoInjectionCustomValueValue
                         if (isAtLeast(develocityPluginVersion, '2.1') && atLeastGradle5) {
                             logger.lifecycle("Setting captureFileFingerprints: $develocityCaptureFileFingerprints")
@@ -227,6 +224,9 @@ void enableDevelocityInjection() {
                             develocity.buildScan.termsOfUseUrl = buildScanTermsOfUseUrl
                             develocity.buildScan.termsOfUseAgree = buildScanTermsOfUseAgree
                         }
+
+                        logger.lifecycle("Setting uploadInBackground: $buildScanUploadInBackground")
+                        develocity.buildScan.uploadInBackground = buildScanUploadInBackground
                     },
                     { buildScan ->
                         afterEvaluate {
@@ -247,6 +247,12 @@ void enableDevelocityInjection() {
                                 buildScan.licenseAgree = buildScanTermsOfUseAgree
                             }
                         }
+
+                        // uploadInBackground available for build-scan-plugin 3.3.4 and later only
+                        if (buildScan.metaClass.respondsTo(buildScan, 'setUploadInBackground', Boolean)) {
+                            logger.lifecycle("Setting uploadInBackground: $buildScanUploadInBackground")
+                            buildScan.uploadInBackground = buildScanUploadInBackground
+                        }
                     }
                 )
 
@@ -282,7 +288,6 @@ void enableDevelocityInjection() {
                     }
 
                     eachDevelocitySettingsExtension(settings) { ext ->
-                        ext.buildScan.uploadInBackground = buildScanUploadInBackground
                         ext.buildScan.value CI_AUTO_INJECTION_CUSTOM_VALUE_NAME, ciAutoInjectionCustomValueValue
                     }
 
@@ -319,6 +324,9 @@ void enableDevelocityInjection() {
                         develocity.buildScan.termsOfUseUrl = buildScanTermsOfUseUrl
                         develocity.buildScan.termsOfUseAgree = buildScanTermsOfUseAgree
                     }
+
+                    logger.lifecycle("Setting uploadInBackground: $buildScanUploadInBackground")
+                    develocity.buildScan.uploadInBackground = buildScanUploadInBackground
                 },
                 { gradleEnterprise ->
                     if (develocityUrl && develocityEnforceUrl) {
@@ -338,6 +346,12 @@ void enableDevelocityInjection() {
                         gradleEnterprise.buildScan.termsOfServiceUrl = buildScanTermsOfUseUrl
                         gradleEnterprise.buildScan.termsOfServiceAgree = buildScanTermsOfUseAgree
                     }
+
+                    // uploadInBackground available for gradle-enterprise-plugin 3.3.4 and later only
+                    if (gradleEnterprise.buildScan.metaClass.respondsTo(gradleEnterprise.buildScan, 'setUploadInBackground', Boolean)) {
+                        logger.lifecycle("Setting uploadInBackground: $buildScanUploadInBackground")
+                        gradleEnterprise.buildScan.uploadInBackground = buildScanUploadInBackground
+                    }
                 }
             )
 

src/test/groovy/com/gradle/BaseInitScriptTest.groovy

@@ -368,6 +368,14 @@ abstract class BaseInitScriptTest extends Specification {
             return pluginId != BUILD_SCAN && pluginVersionAtLeast('3.16')
         }
 
+        boolean isCompatibleWithUploadInBackground() {
+            if (pluginId == BUILD_SCAN || pluginId == GRADLE_ENTERPRISE) {
+                // Only BS & GE plugins 3.3.4+ support uploadInBackground
+                return pluginVersionAtLeast('3.3.4')
+            }
+            return true
+        }
+
         String getConfigBlock(URI serverUri) {
             switch (pluginId) {
                 case DEVELOCITY:

src/test/groovy/com/gradle/TestDevelocityInjection.groovy

@@ -260,6 +260,48 @@ class TestDevelocityInjection extends BaseInitScriptTest {
         [testGradle, testDvPlugin] << getVersionsToTestForExistingDvPlugin()
     }
 
+    @Requires({data.testGradle.compatibleWithCurrentJvm})
+    def "can configure uploadInBackground when Develocity plugin is applied by the init script"() {
+        when:
+        def result = run(testGradle, testConfig(testDvPlugin.version).withUploadInBackground(true))
+
+        then:
+        if (testGradle.gradleVersion < GRADLE_5) {
+            // Gradle 4.x and earlier will always inject build-scan-plugin 1.16 which doesn't have uploadInBackground
+            outputMissesUploadInBackground(result)
+        } else {
+            outputContainsUploadInBackground(result, true)
+        }
+
+        and:
+        outputContainsBuildScanUrl(result)
+
+        where:
+        [testGradle, testDvPlugin] << getVersionsToTestForPluginInjection()
+    }
+
+    @Requires({data.testGradle.compatibleWithCurrentJvm})
+    def "can configure uploadInBackground when Develocity plugin already applied"() {
+        given:
+        declareDvPluginApplication(testGradle, testDvPlugin, null, mockScansServer.address)
+
+        when:
+        def result = run(testGradle, testConfig().withoutDevelocityPluginVersion())
+
+        then:
+        if (testDvPlugin.compatibleWithUploadInBackground) {
+            outputContainsUploadInBackground(result, true)
+        } else {
+            outputMissesUploadInBackground(result)
+        }
+
+        and:
+        outputContainsBuildScanUrl(result)
+
+        where:
+        [testGradle, testDvPlugin] << getVersionsToTestForExistingDvPlugin()
+    }
+
     @Requires({data.testGradle.compatibleWithCurrentJvm})
     def "can configure alternative repository for plugins when Develocity plugin is applied by the init script"() {
         when:
@@ -485,6 +527,18 @@ class TestDevelocityInjection extends BaseInitScriptTest {
         assert 1 == result.output.count(message)
     }
 
+    void outputContainsUploadInBackground(BuildResult result, boolean uploadInBackground) {
+        def message = "Setting uploadInBackground: $uploadInBackground"
+        assert result.output.contains(message)
+        assert 1 == result.output.count(message)
+    }
+
+    void outputMissesUploadInBackground(BuildResult result) {
+        def message = "Setting uploadInBackground:"
+        assert !result.output.contains(message)
+        assert 0 == result.output.count(message)
+    }
+
     private BuildResult run(TestGradleVersion testGradle, DvInjectionTestConfig config, List<String> args = ["help"]) {
         return run(args, testGradle, config.envVars)
     }
@@ -508,6 +562,7 @@ class TestDevelocityInjection extends BaseInitScriptTest {
         boolean captureFileFingerprints = false
         String termsOfUseUrl = null
         String termsOfUseAgree = null
+        boolean uploadInBackground = true // Need to upload in background since our Mock server doesn't cope with foreground upload
 
         DvInjectionTestConfig(URI serverAddress, String develocityPluginVersion) {
             this.serverUrl = serverAddress.toString()
@@ -552,13 +607,18 @@ class TestDevelocityInjection extends BaseInitScriptTest {
             return this
         }
 
+        DvInjectionTestConfig withUploadInBackground(boolean uploadInBackground) {
+            this.uploadInBackground = uploadInBackground
+            return this
+        }
+
         Map<String, String> getEnvVars() {
             Map<String, String> envVars = [
                 DEVELOCITY_INJECTION_INIT_SCRIPT_NAME     : "develocity-injection.init.gradle",
                 DEVELOCITY_INJECTION_ENABLED              : "true",
                 DEVELOCITY_URL                            : serverUrl,
                 DEVELOCITY_ALLOW_UNTRUSTED_SERVER         : "true",
-                DEVELOCITY_BUILD_SCAN_UPLOAD_IN_BACKGROUND: "true", // Need to upload in background since our Mock server doesn't cope with foreground upload
+                DEVELOCITY_BUILD_SCAN_UPLOAD_IN_BACKGROUND: String.valueOf(uploadInBackground),
                 DEVELOCITY_AUTO_INJECTION_CUSTOM_VALUE    : 'gradle-actions'
             ]
             if (enforceUrl) envVars.put("DEVELOCITY_ENFORCE_URL", "true")