diff --git a/.github/workflows/ci-full-check.yml b/.github/workflows/ci-full-check.yml index 616d733..16c9339 100644 --- a/.github/workflows/ci-full-check.yml +++ b/.github/workflows/ci-full-check.yml @@ -46,12 +46,12 @@ jobs: with: cache-key-prefix: ${{github.run_number}}- - gradle-enterprise-injection: - uses: ./.github/workflows/integ-test-inject-gradle-enterprise.yml + develocity-injection: + uses: ./.github/workflows/integ-test-inject-develocity.yml with: cache-key-prefix: ${{github.run_number}}- secrets: - GRADLE_ENTERPRISE_ACCESS_KEY: ${{ secrets.GE_SOLUTIONS_ACCESS_TOKEN }} + DEVELOCITY_ACCESS_KEY: ${{ secrets.GE_SOLUTIONS_ACCESS_TOKEN }} provision-gradle-versions: uses: ./.github/workflows/integ-test-provision-gradle-versions.yml diff --git a/.github/workflows/ci-quick-check.yml b/.github/workflows/ci-quick-check.yml index 626a405..e6ae89b 100644 --- a/.github/workflows/ci-quick-check.yml +++ b/.github/workflows/ci-quick-check.yml @@ -73,14 +73,14 @@ jobs: runner-os: '["ubuntu-latest"]' download-dist: true - gradle-enterprise-injection: + develocity-injection: needs: build-distribution - uses: ./.github/workflows/integ-test-inject-gradle-enterprise.yml + uses: ./.github/workflows/integ-test-inject-develocity.yml with: runner-os: '["ubuntu-latest"]' download-dist: true secrets: - GRADLE_ENTERPRISE_ACCESS_KEY: ${{ secrets.GE_SOLUTIONS_ACCESS_TOKEN }} + DEVELOCITY_ACCESS_KEY: ${{ secrets.GE_SOLUTIONS_ACCESS_TOKEN }} provision-gradle-versions: needs: build-distribution diff --git a/.github/workflows/integ-test-inject-gradle-enterprise.yml b/.github/workflows/integ-test-inject-develocity.yml similarity index 79% rename from .github/workflows/integ-test-inject-gradle-enterprise.yml rename to .github/workflows/integ-test-inject-develocity.yml index 4a0b0b9..684a2f0 100644 --- a/.github/workflows/integ-test-inject-gradle-enterprise.yml +++ b/.github/workflows/integ-test-inject-develocity.yml @@ -1,4 +1,4 @@ -name: Test gradle enterprise injection +name: Test develocity injection on: workflow_call: @@ -12,21 +12,21 @@ on: type: boolean default: false secrets: - GRADLE_ENTERPRISE_ACCESS_KEY: + DEVELOCITY_ACCESS_KEY: required: true env: DOWNLOAD_DIST: ${{ inputs.download-dist }} GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: provision-gradle-versions-${{ inputs.cache-key-prefix }} GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true - GRADLE_ENTERPRISE_INJECTION_ENABLED: true - GRADLE_ENTERPRISE_URL: https://ge.solutions-team.gradle.com - GRADLE_ENTERPRISE_PLUGIN_VERSION: 3.16.1 - GRADLE_ENTERPRISE_CCUD_PLUGIN_VERSION: 1.12.1 - GRADLE_ENTERPRISE_ACCESS_KEY: ${{ secrets.GRADLE_ENTERPRISE_ACCESS_KEY }} + DEVELOCITY_INJECTION_ENABLED: true + DEVELOCITY_URL: https://ge.solutions-team.gradle.com + DEVELOCITY_PLUGIN_VERSION: 3.16.1 + DEVELOCITY_CCUD_PLUGIN_VERSION: 1.12.1 + DEVELOCITY_ACCESS_KEY: ${{ secrets.DEVELOCITY_ACCESS_KEY }} jobs: - inject-gradle-enterprise: + inject-develocity: strategy: matrix: gradle: [current, 7.6.2, 6.9.4, 5.6.4] diff --git a/README.md b/README.md index d4a4fd0..96dd383 100644 --- a/README.md +++ b/README.md @@ -783,27 +783,27 @@ To reduce storage costs for these artifacts, you can set the `artifact-retention -# Gradle Enterprise plugin injection +# Develocity plugin injection -The `gradle-build-action` provides support for injecting and configuring the Gradle Enterprise Gradle plugin into any Gradle build, without any modification to the project sources. +The `gradle-build-action` provides support for injecting and configuring the Develocity Gradle plugin into any Gradle build, without any modification to the project sources. This is achieved via an init-script installed into Gradle User Home, which is enabled and parameterized via environment variables. The same auto-injection behavior is available for the Common Custom User Data Gradle plugin, which enriches any build scans published with additional useful information. -## Enabling Gradle Enterprise injection +## Enabling Develocity injection -In order to enable Gradle Enterprise for your build, you must provide the required configuration via environment variables. +In order to enable Develocity for your build, you must provide the required configuration via environment variables. Here's a minimal example: ```yaml -name: Run build with Gradle Enterprise injection +name: Run build with Develocity injection env: - GRADLE_ENTERPRISE_INJECTION_ENABLED: true - GRADLE_ENTERPRISE_URL: https://ge.gradle.org - GRADLE_ENTERPRISE_PLUGIN_VERSION: 3.16.1 - GRADLE_ENTERPRISE_ACCESS_KEY: ${{ secrets.GE_ACCESS_KEY }} # Required to publish scans to ge.gradle.org + DEVELOCITY_INJECTION_ENABLED: true + DEVELOCITY_URL: https://ge.gradle.org + DEVELOCITY_PLUGIN_VERSION: 3.16.1 + DEVELOCITY_ACCESS_KEY: ${{ secrets.DEVELOCITY_ACCESS_KEY }} # Required to publish scans to ge.gradle.org jobs: build: @@ -812,36 +812,36 @@ jobs: - uses: actions/checkout@v4 - name: Setup Gradle uses: gradle/gradle-build-action@v2 - - name: Run a Gradle build with Gradle Enterprise injection enabled + - name: Run a Gradle build with Develocity injection enabled run: ./gradlew build ``` -This configuration will automatically apply `v3.16.1` of the [Gradle Enterprise Gradle plugin](https://docs.gradle.com/enterprise/gradle-plugin/), and publish build scans to https://ge.gradle.org. +This configuration will automatically apply `v3.16.1` of the [Develocity Gradle plugin](https://docs.gradle.com/enterprise/gradle-plugin/), and publish build scans to https://ge.gradle.org. -Note that the `ge.gradle.org` server requires authentication in order to publish scans. The provided `GRADLE_ENTERPRISE_ACCESS_KEY` isn't required by the Gradle Enterprise injection script, +Note that the `ge.gradle.org` server requires authentication in order to publish scans. The provided `DEVELOCITY_ACCESS_KEY` isn't required by the Develocity injection script, but will be used by the GE plugin in order to authenticate with the server. -## Configuring Gradle Enterprise injection +## Configuring Develocity injection The `init-script` supports a number of additional configuration parameters that you may fine useful. All configuration options (required and optional) are detailed below: -| Variable | Required | Description | -| --- | --- | --- | -| GRADLE_ENTERPRISE_INJECTION_ENABLED | :white_check_mark: | enables Gradle Enterprise injection | -| GRADLE_ENTERPRISE_URL | :white_check_mark: | the URL of the Gradle Enterprise server | -| GRADLE_ENTERPRISE_ALLOW_UNTRUSTED_SERVER | | allow communication with an untrusted server; set to _true_ if your Gradle Enterprise instance is using a self-signed certificate | -| GRADLE_ENTERPRISE_ENFORCE_URL | | enforce the configured Gradle Enterprise URL over a URL configured in the project's build; set to _true_ to enforce publication of build scans to the configured Gradle Enterprise URL | -| GRADLE_ENTERPRISE_PLUGIN_VERSION | :white_check_mark: | the version of the [Gradle Enterprise Gradle plugin](https://docs.gradle.com/enterprise/gradle-plugin/) to apply | -| GRADLE_ENTERPRISE_CCUD_PLUGIN_VERSION | | the version of the [Common Custom User Data Gradle plugin](https://github.com/gradle/common-custom-user-data-gradle-plugin) to apply, if any | -| GRADLE_ENTERPRISE_PLUGIN_REPOSITORY_URL | | the URL of the repository to use when resolving the GE and CCUD plugins; the Gradle Plugin Portal is used by default | +| Variable | Required | Description | +|-----------------------------------| --- | --- | +| DEVELOCITY_INJECTION_ENABLED | :white_check_mark: | enables Develocity injection | +| DEVELOCITY_URL | :white_check_mark: | the URL of the Develocity server | +| DEVELOCITY_ALLOW_UNTRUSTED_SERVER | | allow communication with an untrusted server; set to _true_ if your Develocity instance is using a self-signed certificate | +| DEVELOCITY_ENFORCE_URL | | enforce the configured Develocity URL over a URL configured in the project's build; set to _true_ to enforce publication of build scans to the configured Develocity URL | +| DEVELOCITY_PLUGIN_VERSION | :white_check_mark: | the version of the [Develocity Gradle plugin](https://docs.gradle.com/enterprise/gradle-plugin/) to apply | +| DEVELOCITY_CCUD_PLUGIN_VERSION | | the version of the [Common Custom User Data Gradle plugin](https://github.com/gradle/common-custom-user-data-gradle-plugin) to apply, if any | +| DEVELOCITY_PLUGIN_REPOSITORY_URL | | the URL of the repository to use when resolving the GE and CCUD plugins; the Gradle Plugin Portal is used by default | ## Publishing to scans.gradle.com -Gradle Enterprise injection is designed to enable publishing of build scans to a Gradle Enterprise instance, +Develocity injection is designed to enable publishing of build scans to a Develocity instance, and is not suitable for publishing to the public Build Scans instance (https://scans.gradle.com). In order to publish Build Scans to scans.gradle.com, you need to: -- Apply the Gradle Enterprise plugin to your build configuration ([see docs](https://docs.gradle.com/enterprise/get-started/#applying_the_plugin)) +- Apply the Develocity plugin to your build configuration ([see docs](https://docs.gradle.com/enterprise/get-started/#applying_the_plugin)) - Programmatically accept the Terms of Service for scans.gradle.com ([see docs](https://docs.gradle.com/enterprise/gradle-plugin/#connecting_to_scans_gradle_com)) - Execute the build with `--scan` or configure your build with `publishAlways()` ([see docs](https://docs.gradle.com/enterprise/get-started/#always_publishing_a_build_scan)) diff --git a/src/cache-base.ts b/src/cache-base.ts index d63ee3f..a97835a 100644 --- a/src/cache-base.ts +++ b/src/cache-base.ts @@ -203,7 +203,7 @@ export class GradleStateCache { 'gradle-build-action.build-result-capture-service.plugin.groovy', 'gradle-build-action.github-dependency-graph.init.gradle', 'gradle-build-action.github-dependency-graph-gradle-plugin-apply.groovy', - 'gradle-build-action.inject-gradle-enterprise.init.gradle' + 'gradle-build-action.inject-develocity.init.gradle' ] for (const initScriptFilename of initScriptFilenames) { const initScriptContent = this.readResourceFileAsString('init-scripts', initScriptFilename) diff --git a/src/resources/init-scripts/gradle-build-action.inject-gradle-enterprise.init.gradle b/src/resources/init-scripts/gradle-build-action.inject-develocity.init.gradle similarity index 75% rename from src/resources/init-scripts/gradle-build-action.inject-gradle-enterprise.init.gradle rename to src/resources/init-scripts/gradle-build-action.inject-develocity.init.gradle index 279ca72..57e342c 100644 --- a/src/resources/init-scripts/gradle-build-action.inject-gradle-enterprise.init.gradle +++ b/src/resources/init-scripts/gradle-build-action.inject-develocity.init.gradle @@ -15,21 +15,21 @@ initscript { } // finish early if injection is disabled - def gradleInjectionEnabled = getInputParam("gradle-enterprise.injection-enabled") + def gradleInjectionEnabled = getInputParam("develocity.injection-enabled") if (gradleInjectionEnabled != "true") { return } - def pluginRepositoryUrl = getInputParam('gradle-enterprise.plugin-repository.url') - def gePluginVersion = getInputParam('gradle-enterprise.plugin.version') - def ccudPluginVersion = getInputParam('gradle-enterprise.ccud-plugin.version') + def pluginRepositoryUrl = getInputParam('develocity.plugin-repository.url') + def gePluginVersion = getInputParam('develocity.plugin.version') + def ccudPluginVersion = getInputParam('develocity.ccud-plugin.version') def atLeastGradle5 = GradleVersion.current() >= GradleVersion.version('5.0') def atLeastGradle4 = GradleVersion.current() >= GradleVersion.version('4.0') if (gePluginVersion || ccudPluginVersion && atLeastGradle4) { pluginRepositoryUrl = pluginRepositoryUrl ?: 'https://plugins.gradle.org/m2' - logger.quiet("Gradle Enterprise plugins resolution: $pluginRepositoryUrl") + logger.quiet("Develocity plugins resolution: $pluginRepositoryUrl") repositories { maven { url pluginRepositoryUrl } @@ -52,9 +52,9 @@ initscript { 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' -def GRADLE_ENTERPRISE_PLUGIN_CLASS = 'com.gradle.enterprise.gradleplugin.GradleEnterprisePlugin' -def GRADLE_ENTERPRISE_EXTENSION_CLASS = 'com.gradle.enterprise.gradleplugin.GradleEnterpriseExtension' +def DEVELOCITY_PLUGIN_ID = 'com.gradle.enterprise' +def DEVELOCITY_PLUGIN_CLASS = 'com.gradle.enterprise.gradleplugin.GradleEnterprisePlugin' +def DEVELOCITY_EXTENSION_CLASS = 'com.gradle.enterprise.gradleplugin.GradleEnterpriseExtension' def CI_AUTO_INJECTION_CUSTOM_VALUE_NAME = 'CI auto injection' def CI_AUTO_INJECTION_CUSTOM_VALUE_VALUE = 'gradle-build-action' def CCUD_PLUGIN_ID = 'com.gradle.common-custom-user-data-gradle-plugin' @@ -71,17 +71,17 @@ def getInputParam = { String name -> } // finish early if injection is disabled -def gradleInjectionEnabled = getInputParam("gradle-enterprise.injection-enabled") +def gradleInjectionEnabled = getInputParam("develocity.injection-enabled") if (gradleInjectionEnabled != "true") { return } -def geUrl = getInputParam('gradle-enterprise.url') -def geAllowUntrustedServer = Boolean.parseBoolean(getInputParam('gradle-enterprise.allow-untrusted-server')) -def geEnforceUrl = Boolean.parseBoolean(getInputParam('gradle-enterprise.enforce-url')) -def buildScanUploadInBackground = Boolean.parseBoolean(getInputParam('gradle-enterprise.build-scan.upload-in-background')) -def gePluginVersion = getInputParam('gradle-enterprise.plugin.version') -def ccudPluginVersion = getInputParam('gradle-enterprise.ccud-plugin.version') +def geUrl = getInputParam('develocity.url') +def geAllowUntrustedServer = Boolean.parseBoolean(getInputParam('develocity.allow-untrusted-server')) +def geEnforceUrl = Boolean.parseBoolean(getInputParam('develocity.enforce-url')) +def buildScanUploadInBackground = Boolean.parseBoolean(getInputParam('develocity.build-scan.upload-in-background')) +def gePluginVersion = getInputParam('develocity.plugin.version') +def ccudPluginVersion = getInputParam('develocity.ccud-plugin.version') def atLeastGradle4 = GradleVersion.current() >= GradleVersion.version('4.0') @@ -103,7 +103,7 @@ if (GradleVersion.current() < GradleVersion.version('6.0')) { } if (!scanPluginComponent) { logger.quiet("Applying $BUILD_SCAN_PLUGIN_CLASS via init script") - logger.quiet("Connection to Gradle Enterprise: $geUrl, allowUntrustedServer: $geAllowUntrustedServer") + logger.quiet("Connection to Develocity: $geUrl, allowUntrustedServer: $geAllowUntrustedServer") applyPluginExternally(pluginManager, BUILD_SCAN_PLUGIN_CLASS) buildScan.server = geUrl buildScan.allowUntrustedServer = geAllowUntrustedServer @@ -115,7 +115,7 @@ if (GradleVersion.current() < GradleVersion.version('6.0')) { if (geUrl && geEnforceUrl) { pluginManager.withPlugin(BUILD_SCAN_PLUGIN_ID) { afterEvaluate { - logger.quiet("Enforcing Gradle Enterprise: $geUrl, allowUntrustedServer: $geAllowUntrustedServer") + logger.quiet("Enforcing Develocity: $geUrl, allowUntrustedServer: $geAllowUntrustedServer") buildScan.server = geUrl buildScan.allowUntrustedServer = geAllowUntrustedServer } @@ -137,11 +137,11 @@ if (GradleVersion.current() < GradleVersion.version('6.0')) { } else { gradle.settingsEvaluated { settings -> if (gePluginVersion) { - if (!settings.pluginManager.hasPlugin(GRADLE_ENTERPRISE_PLUGIN_ID)) { - logger.quiet("Applying $GRADLE_ENTERPRISE_PLUGIN_CLASS via init script") - logger.quiet("Connection to Gradle Enterprise: $geUrl, allowUntrustedServer: $geAllowUntrustedServer") - applyPluginExternally(settings.pluginManager, GRADLE_ENTERPRISE_PLUGIN_CLASS) - extensionsWithPublicType(settings, GRADLE_ENTERPRISE_EXTENSION_CLASS).collect { settings[it.name] }.each { ext -> + if (!settings.pluginManager.hasPlugin(DEVELOCITY_PLUGIN_ID)) { + logger.quiet("Applying $DEVELOCITY_PLUGIN_CLASS via init script") + logger.quiet("Connection to Develocity: $geUrl, allowUntrustedServer: $geAllowUntrustedServer") + applyPluginExternally(settings.pluginManager, DEVELOCITY_PLUGIN_CLASS) + extensionsWithPublicType(settings, DEVELOCITY_EXTENSION_CLASS).collect { settings[it.name] }.each { ext -> ext.server = geUrl ext.allowUntrustedServer = geAllowUntrustedServer ext.buildScan.publishAlways() @@ -151,8 +151,8 @@ if (GradleVersion.current() < GradleVersion.version('6.0')) { } if (geUrl && geEnforceUrl) { - extensionsWithPublicType(settings, GRADLE_ENTERPRISE_EXTENSION_CLASS).collect { settings[it.name] }.each { ext -> - logger.quiet("Enforcing Gradle Enterprise: $geUrl, allowUntrustedServer: $geAllowUntrustedServer") + extensionsWithPublicType(settings, DEVELOCITY_EXTENSION_CLASS).collect { settings[it.name] }.each { ext -> + logger.quiet("Enforcing Develocity: $geUrl, allowUntrustedServer: $geAllowUntrustedServer") ext.server = geUrl ext.allowUntrustedServer = geAllowUntrustedServer } @@ -169,7 +169,7 @@ if (GradleVersion.current() < GradleVersion.version('6.0')) { } void applyPluginExternally(def pluginManager, String pluginClassName) { - def externallyApplied = 'gradle.enterprise.externally-applied' + def externallyApplied = 'develocity.externally-applied' def oldValue = System.getProperty(externallyApplied) System.setProperty(externallyApplied, 'true') try { diff --git a/test/init-scripts/src/test/groovy/com/gradle/gradlebuildaction/TestGradleEnterpriseInjection.groovy b/test/init-scripts/src/test/groovy/com/gradle/gradlebuildaction/TestDevelocityInjection.groovy similarity index 70% rename from test/init-scripts/src/test/groovy/com/gradle/gradlebuildaction/TestGradleEnterpriseInjection.groovy rename to test/init-scripts/src/test/groovy/com/gradle/gradlebuildaction/TestDevelocityInjection.groovy index cbcede0..cc60a87 100644 --- a/test/init-scripts/src/test/groovy/com/gradle/gradlebuildaction/TestGradleEnterpriseInjection.groovy +++ b/test/init-scripts/src/test/groovy/com/gradle/gradlebuildaction/TestDevelocityInjection.groovy @@ -5,28 +5,28 @@ import org.gradle.util.GradleVersion import static org.junit.Assume.assumeTrue -class TestGradleEnterpriseInjection extends BaseInitScriptTest { +class TestDevelocityInjection extends BaseInitScriptTest { static final List CCUD_COMPATIBLE_VERSIONS = ALL_VERSIONS - [GRADLE_3_X] - def initScript = 'gradle-build-action.inject-gradle-enterprise.init.gradle' + def initScript = 'gradle-build-action.inject-develocity.init.gradle' private static final GradleVersion GRADLE_6 = GradleVersion.version('6.0') - def "does not apply GE plugins when not requested"() { + def "does not apply Develocity plugins when not requested"() { assumeTrue testGradleVersion.compatibleWithCurrentJvm when: def result = run([], initScript, testGradleVersion.gradleVersion) then: - outputMissesGePluginApplicationViaInitScript(result) + outputMissesDevelocityPluginApplicationViaInitScript(result) outputMissesCcudPluginApplicationViaInitScript(result) where: testGradleVersion << ALL_VERSIONS } - def "does not override GE plugin when already defined in project"() { + def "does not override Develocity plugin when already defined in project"() { assumeTrue testGradleVersion.compatibleWithCurrentJvm given: @@ -36,7 +36,7 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { def result = run(testGradleVersion, testConfig()) then: - outputMissesGePluginApplicationViaInitScript(result) + outputMissesDevelocityPluginApplicationViaInitScript(result) outputMissesCcudPluginApplicationViaInitScript(result) and: @@ -46,14 +46,14 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { testGradleVersion << ALL_VERSIONS } - def "applies GE plugin via init script when not defined in project"() { + def "applies Develocity plugin via init script when not defined in project"() { assumeTrue testGradleVersion.compatibleWithCurrentJvm when: def result = run(testGradleVersion, testConfig()) then: - outputContainsGePluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) + outputContainsDevelocityPluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) outputMissesCcudPluginApplicationViaInitScript(result) and: @@ -63,14 +63,14 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { testGradleVersion << ALL_VERSIONS } - def "applies GE and CCUD plugins via init script when not defined in project"() { + def "applies Develocity and CCUD plugins via init script when not defined in project"() { assumeTrue testGradleVersion.compatibleWithCurrentJvm when: def result = run(testGradleVersion, testConfig().withCCUDPlugin()) then: - outputContainsGePluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) + outputContainsDevelocityPluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) outputContainsCcudPluginApplicationViaInitScript(result) and: @@ -80,7 +80,7 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { testGradleVersion << CCUD_COMPATIBLE_VERSIONS } - def "applies CCUD plugin via init script where GE plugin already applied"() { + def "applies CCUD plugin via init script where Develocity plugin already applied"() { assumeTrue testGradleVersion.compatibleWithCurrentJvm given: @@ -90,7 +90,7 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { def result = run(testGradleVersion, testConfig().withCCUDPlugin()) then: - outputMissesGePluginApplicationViaInitScript(result) + outputMissesDevelocityPluginApplicationViaInitScript(result) outputContainsCcudPluginApplicationViaInitScript(result) and: @@ -110,7 +110,7 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { def result = run(testGradleVersion, testConfig().withCCUDPlugin()) then: - outputMissesGePluginApplicationViaInitScript(result) + outputMissesDevelocityPluginApplicationViaInitScript(result) outputMissesCcudPluginApplicationViaInitScript(result) and: @@ -120,18 +120,18 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { testGradleVersion << CCUD_COMPATIBLE_VERSIONS } - def "ignores GE URL and allowUntrustedServer when GE plugin is not applied by the init script"() { + def "ignores Develocity URL and allowUntrustedServer when Develocity plugin is not applied by the init script"() { assumeTrue testGradleVersion.compatibleWithCurrentJvm given: declareGePluginApplication(testGradleVersion.gradleVersion) when: - def config = testConfig().withServer(URI.create('https://ge-server.invalid')) + def config = testConfig().withServer(URI.create('https://develocity-server.invalid')) def result = run(testGradleVersion, config) then: - outputMissesGePluginApplicationViaInitScript(result) + outputMissesDevelocityPluginApplicationViaInitScript(result) outputMissesCcudPluginApplicationViaInitScript(result) and: @@ -141,7 +141,7 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { testGradleVersion << ALL_VERSIONS } - def "configures GE URL and allowUntrustedServer when GE plugin is applied by the init script"() { + def "configures Develocity URL and allowUntrustedServer when Develocity plugin is applied by the init script"() { assumeTrue testGradleVersion.compatibleWithCurrentJvm when: @@ -149,8 +149,8 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { def result = run(testGradleVersion, config) then: - outputContainsGePluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) - outputContainsGeConnectionInfo(result, mockScansServer.address.toString(), true) + outputContainsDevelocityPluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) + outputContainsDevelocityConnectionInfo(result, mockScansServer.address.toString(), true) outputMissesCcudPluginApplicationViaInitScript(result) outputContainsPluginRepositoryInfo(result, 'https://plugins.gradle.org/m2') @@ -161,22 +161,22 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { testGradleVersion << ALL_VERSIONS } - def "enforces GE URL and allowUntrustedServer in project if enforce url parameter is enabled"() { + def "enforces Develocity URL and allowUntrustedServer in project if enforce url parameter is enabled"() { assumeTrue testGradleVersion.compatibleWithCurrentJvm given: - declareGePluginApplication(testGradleVersion.gradleVersion, URI.create('https://ge-server.invalid')) + declareGePluginApplication(testGradleVersion.gradleVersion, URI.create('https://develocity-server.invalid')) when: def config = testConfig().withServer(mockScansServer.address, true) def result = run(testGradleVersion, config) then: - outputMissesGePluginApplicationViaInitScript(result) + outputMissesDevelocityPluginApplicationViaInitScript(result) outputMissesCcudPluginApplicationViaInitScript(result) and: - outputEnforcesGeUrl(result, mockScansServer.address.toString(), true) + outputEnforcesDevelocityUrl(result, mockScansServer.address.toString(), true) and: outputContainsBuildScanUrl(result) @@ -185,7 +185,7 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { testGradleVersion << ALL_VERSIONS } - def "can configure alternative repository for plugins when GE plugin is applied by the init script"() { + def "can configure alternative repository for plugins when Develocity plugin is applied by the init script"() { assumeTrue testGradleVersion.compatibleWithCurrentJvm when: @@ -193,8 +193,8 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { def result = run(testGradleVersion, config) then: - outputContainsGePluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) - outputContainsGeConnectionInfo(result, mockScansServer.address.toString(), true) + outputContainsDevelocityPluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) + outputContainsDevelocityConnectionInfo(result, mockScansServer.address.toString(), true) outputMissesCcudPluginApplicationViaInitScript(result) outputContainsPluginRepositoryInfo(result, 'https://plugins.grdev.net/m2') @@ -213,7 +213,7 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { def result = run(testGradleVersion, config) then: - outputMissesGePluginApplicationViaInitScript(result) + outputMissesDevelocityPluginApplicationViaInitScript(result) outputMissesCcudPluginApplicationViaInitScript(result) result.output.contains('Common Custom User Data Gradle plugin must be at least 1.7. Configured version is 1.6.6.') @@ -221,15 +221,15 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { testGradleVersion << ALL_VERSIONS } - def "can configure GE via CCUD system property overrides when CCUD plugin is inject via init script"() { + def "can configure Develocity via CCUD system property overrides when CCUD plugin is inject via init script"() { assumeTrue testGradleVersion.compatibleWithCurrentJvm when: - def config = testConfig().withCCUDPlugin().withServer(URI.create('https://ge-server.invalid')) + def config = testConfig().withCCUDPlugin().withServer(URI.create('https://develocity-server.invalid')) def result = run(testGradleVersion, config, ["help", "-Dgradle.enterprise.url=${mockScansServer.address}".toString()]) then: - outputContainsGePluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) + outputContainsDevelocityPluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) outputContainsCcudPluginApplicationViaInitScript(result) and: @@ -247,7 +247,7 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { def result = run(testGradleVersion, config, ["help", "--configuration-cache"]) then: - outputContainsGePluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) + outputContainsDevelocityPluginApplicationViaInitScript(result, testGradleVersion.gradleVersion) outputContainsCcudPluginApplicationViaInitScript(result) and: @@ -257,7 +257,7 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { result = run(testGradleVersion, config, ["help", "--configuration-cache"]) then: - outputMissesGePluginApplicationViaInitScript(result) + outputMissesDevelocityPluginApplicationViaInitScript(result) outputMissesCcudPluginApplicationViaInitScript(result) and: @@ -273,7 +273,7 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { assert 1 == result.output.count(message) } - void outputContainsGePluginApplicationViaInitScript(BuildResult result, GradleVersion gradleVersion) { + void outputContainsDevelocityPluginApplicationViaInitScript(BuildResult result, GradleVersion gradleVersion) { def pluginApplicationLogMsgGradle4And5 = "Applying com.gradle.scan.plugin.BuildScanPlugin via init script" def pluginApplicationLogMsgGradle6AndHigher = "Applying com.gradle.enterprise.gradleplugin.GradleEnterprisePlugin via init script" if (gradleVersion < GRADLE_6) { @@ -287,7 +287,7 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { } } - void outputMissesGePluginApplicationViaInitScript(BuildResult result) { + void outputMissesDevelocityPluginApplicationViaInitScript(BuildResult result) { def pluginApplicationLogMsgGradle4And5 = "Applying com.gradle.scan.plugin.BuildScanPlugin via init script" def pluginApplicationLogMsgGradle6AndHigher = "Applying com.gradle.enterprise.gradleplugin.GradleEnterprisePlugin via init script" assert !result.output.contains(pluginApplicationLogMsgGradle4And5) @@ -305,20 +305,20 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { assert !result.output.contains(pluginApplicationLogMsg) } - void outputContainsGeConnectionInfo(BuildResult result, String geUrl, boolean geAllowUntrustedServer) { - def geConnectionInfo = "Connection to Gradle Enterprise: $geUrl, allowUntrustedServer: $geAllowUntrustedServer" + void outputContainsDevelocityConnectionInfo(BuildResult result, String geUrl, boolean geAllowUntrustedServer) { + def geConnectionInfo = "Connection to Develocity: $geUrl, allowUntrustedServer: $geAllowUntrustedServer" assert result.output.contains(geConnectionInfo) assert 1 == result.output.count(geConnectionInfo) } void outputContainsPluginRepositoryInfo(BuildResult result, String gradlePluginRepositoryUrl) { - def repositoryInfo = "Gradle Enterprise plugins resolution: ${gradlePluginRepositoryUrl}" + def repositoryInfo = "Develocity plugins resolution: ${gradlePluginRepositoryUrl}" assert result.output.contains(repositoryInfo) assert 1 == result.output.count(repositoryInfo) } - void outputEnforcesGeUrl(BuildResult result, String geUrl, boolean geAllowUntrustedServer) { - def enforceUrl = "Enforcing Gradle Enterprise: $geUrl, allowUntrustedServer: $geAllowUntrustedServer" + void outputEnforcesDevelocityUrl(BuildResult result, String geUrl, boolean geAllowUntrustedServer) { + def enforceUrl = "Enforcing Develocity: $geUrl, allowUntrustedServer: $geAllowUntrustedServer" assert result.output.contains(enforceUrl) assert 1 == result.output.count(enforceUrl) } @@ -369,31 +369,31 @@ class TestGradleEnterpriseInjection extends BaseInitScriptTest { def getEnvVars() { Map envVars = [ - GRADLE_ENTERPRISE_INJECTION_ENABLED: "true", - GRADLE_ENTERPRISE_URL: serverUrl, - GRADLE_ENTERPRISE_ALLOW_UNTRUSTED_SERVER: "true", - GRADLE_ENTERPRISE_PLUGIN_VERSION: GE_PLUGIN_VERSION, - GRADLE_ENTERPRISE_BUILD_SCAN_UPLOAD_IN_BACKGROUND: "true" // Need to upload in background since our Mock server doesn't cope with foreground upload + DEVELOCITY_INJECTION_ENABLED: "true", + DEVELOCITY_URL: serverUrl, + DEVELOCITY_ALLOW_UNTRUSTED_SERVER: "true", + DEVELOCITY_PLUGIN_VERSION: GE_PLUGIN_VERSION, + DEVELOCITY_BUILD_SCAN_UPLOAD_IN_BACKGROUND: "true" // Need to upload in background since our Mock server doesn't cope with foreground upload ] - if (enforceUrl) envVars.put("GRADLE_ENTERPRISE_ENFORCE_URL", "true") - if (ccudPluginVersion != null) envVars.put("GRADLE_ENTERPRISE_CCUD_PLUGIN_VERSION", ccudPluginVersion) - if (pluginRepositoryUrl != null) envVars.put("GRADLE_ENTERPRISE_PLUGIN_REPOSITORY_URL", pluginRepositoryUrl) + if (enforceUrl) envVars.put("DEVELOCITY_ENFORCE_URL", "true") + if (ccudPluginVersion != null) envVars.put("DEVELOCITY_CCUD_PLUGIN_VERSION", ccudPluginVersion) + if (pluginRepositoryUrl != null) envVars.put("DEVELOCITY_PLUGIN_REPOSITORY_URL", pluginRepositoryUrl) return envVars } def getJvmArgs() { List jvmArgs = [ - "-Dgradle-enterprise.injection-enabled=true", - "-Dgradle-enterprise.url=$serverUrl", - "-Dgradle-enterprise.allow-untrusted-server=true", - "-Dgradle-enterprise.plugin.version=$GE_PLUGIN_VERSION", - "-Dgradle-enterprise.build-scan.upload-in-background=true" + "-Ddevelocity.injection-enabled=true", + "-Ddevelocity.url=$serverUrl", + "-Ddevelocity.allow-untrusted-server=true", + "-Ddevelocity.plugin.version=$GE_PLUGIN_VERSION", + "-Ddevelocity.build-scan.upload-in-background=true" ] - if (enforceUrl) jvmArgs.add("-Dgradle-enterprise.enforce-url=true") - if (ccudPluginVersion != null) jvmArgs.add("-Dgradle-enterprise.ccud-plugin.version=$ccudPluginVersion") - if (pluginRepositoryUrl != null) jvmArgs.add("-Dgradle-enterprise.plugin-repository.url=$pluginRepositoryUrl") + if (enforceUrl) jvmArgs.add("-Ddevelocity.enforce-url=true") + if (ccudPluginVersion != null) jvmArgs.add("-Ddevelocity.ccud-plugin.version=$ccudPluginVersion") + if (pluginRepositoryUrl != null) jvmArgs.add("-Ddevelocity.plugin-repository.url=$pluginRepositoryUrl") return jvmArgs.collect { it.toString() } // Convert from GStrings }