Throw an exception when building with a Gradle version lower than the minimum supported

Author: priettt

embrace-gradle-plugin-integration-tests/src/test/java/io/embrace/android/gradle/integration/framework/PluginIntegrationTestRule.kt

@@ -6,6 +6,7 @@ import org.gradle.testkit.runner.BuildResult
 import org.gradle.testkit.runner.GradleRunner
 import org.gradle.testkit.runner.TaskOutcome
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
 import org.junit.rules.ExternalResource
 import java.io.File
 import java.nio.file.Files
@@ -90,6 +91,11 @@ class PluginIntegrationTestRule : ExternalResource() {
          */
         expectedOutcome: TaskOutcome = TaskOutcome.SUCCESS,
 
+        /**
+         * The expected exception message if the task fails.
+         */
+        expectedExceptionMessage: String? = null,
+
         /**
          * Whether a debugger should be attached to the TestKit build. This stops the build
          * proceeding until a remote debugger is attached.
@@ -123,10 +129,10 @@ class PluginIntegrationTestRule : ExternalResource() {
 
         // run any preconditions before the build
         setupInterface.setup(dir)
-        val result = executeGradleBuild(args, testMatrix.gradle)
+        val result = executeGradleBuild(args, testMatrix.gradle, expectedExceptionMessage != null)
 
         // run assertions on the build outcome
-        assertTaskOutcome(result, task, expectedOutcome)
+        assertTaskOutcome(result, task, expectedOutcome, expectedExceptionMessage)
         assertionInterface.assertions(dir)
     }
 
@@ -137,7 +143,7 @@ class PluginIntegrationTestRule : ExternalResource() {
     private fun prepareTempDirectory(
         fixture: String,
         projectType: ProjectType,
-        androidProjectRoot: String?
+        androidProjectRoot: String?,
     ): File {
         val srcDir = File("fixtures/$fixture")
         if (!srcDir.exists()) {
@@ -185,14 +191,22 @@ class PluginIntegrationTestRule : ExternalResource() {
      */
     private fun executeGradleBuild(
         args: List<String>,
-        gradleVersion: String
-    ): BuildResult = GradleRunner.create()
-        .withProjectDir(tmpDir)
-        .withArguments(args)
-        .withGradleVersion(gradleVersion)
-        .forwardStdOutput(System.out.writer())
-        .forwardStdError(System.err.writer())
-        .build()
+        gradleVersion: String,
+        fail: Boolean,
+    ): BuildResult {
+        val runner = GradleRunner.create()
+            .withProjectDir(tmpDir)
+            .withArguments(args)
+            .withGradleVersion(gradleVersion)
+            .forwardStdOutput(System.out.writer())
+            .forwardStdError(System.err.writer())
+
+        return if (fail) {
+            runner.buildAndFail()
+        } else {
+            runner.build()
+        }
+    }
 
     /**
      * Adds some additional arguments to the gradle build for better performance of the test suite.
@@ -257,8 +271,13 @@ class PluginIntegrationTestRule : ExternalResource() {
     private fun assertTaskOutcome(
         result: BuildResult,
         task: String,
-        expectedOutcome: TaskOutcome
+        expectedOutcome: TaskOutcome,
+        exceptionExpected: String?,
     ) {
+        if (exceptionExpected != null) {
+            assertTrue(result.output.contains(exceptionExpected))
+            return
+        }
         val buildTask = result.tasks.singleOrNull { it.path == ":$task" || it.path == ":app:$task" }
             ?: error("Task '$task' not found in result.")
         val outcome = buildTask.outcome

embrace-gradle-plugin-integration-tests/src/test/java/io/embrace/android/gradle/integration/testcases/AgpSupportTest.kt

@@ -8,6 +8,7 @@ import io.embrace.android.gradle.config.TestMatrix.NewerVersion
 import io.embrace.android.gradle.config.TestMatrix.OlderVersion
 import io.embrace.android.gradle.integration.framework.PluginIntegrationTestRule
 import io.embrace.android.gradle.integration.framework.ProjectType
+import io.embrace.android.gradle.plugin.gradle.GradleVersion
 import org.junit.Rule
 import org.junit.Test
 
@@ -32,6 +33,20 @@ class AgpSupportTest {
     @Test
     fun `maximum supported version`() = runTest(MaxVersion)
 
+    @Test
+    fun `unsupported old version`() {
+        rule.runTest(
+            fixture = "android-version-support",
+            task = "assembleRelease",
+            testMatrix = TestMatrix.UnsupportedOldGradleVersion,
+            projectType = ProjectType.ANDROID,
+            expectedExceptionMessage = "Embrace Gradle Plugin requires Gradle version ${GradleVersion.MIN_VERSION} or newer",
+            assertions = {
+                verifyNoUploads()
+            }
+        )
+    }
+
     private fun runTest(testMatrix: TestMatrix) {
         rule.runTest(
             fixture = "android-version-support",

embrace-gradle-plugin/src/main/java/io/embrace/android/gradle/plugin/EmbraceGradlePlugin.kt

@@ -1,5 +1,7 @@
 package io.embrace.android.gradle.plugin
 
+import io.embrace.android.gradle.plugin.gradle.GradleVersion
+import io.embrace.android.gradle.plugin.gradle.GradleVersion.Companion.isAtLeast
 import io.embrace.android.gradle.plugin.instrumentation.config.model.VariantConfig
 import io.embrace.android.gradle.swazzler.plugin.extension.SwazzlerExtension
 import org.gradle.api.Plugin
@@ -18,6 +20,8 @@ class EmbraceGradlePlugin : Plugin<Project> {
     }
 
     override fun apply(project: Project) {
+        validateMinGradleVersion()
+
         val extension = project.extensions.create(
             EXTENSION_NAME,
             SwazzlerExtension::class.java,
@@ -39,4 +43,10 @@ class EmbraceGradlePlugin : Plugin<Project> {
             )
         }
     }
+
+    private fun validateMinGradleVersion() {
+        if (!isAtLeast(GradleVersion.MIN_VERSION)) {
+            error("Embrace Gradle Plugin requires Gradle version ${GradleVersion.MIN_VERSION} or newer")
+        }
+    }
 }

embrace-gradle-plugin/src/main/java/io/embrace/android/gradle/plugin/gradle/GradleVersion.kt

@@ -5,6 +5,7 @@ import org.gradle.util.GradleVersion.version
 sealed class GradleVersion(private val version: org.gradle.util.GradleVersion) :
     Comparable<GradleVersion> {
 
+    object MIN_VERSION : GradleVersion(version("7.5.1"))
     object CURRENT : GradleVersion(org.gradle.util.GradleVersion.current())
     object GRADLE_7_6 : GradleVersion(version("7.6"))
     object GRADLE_8_0 : GradleVersion(version("8.0"))

embrace-test-common/src/main/kotlin/io/embrace/android/gradle/config/TestMatrix.kt

@@ -19,6 +19,8 @@ sealed class TestMatrix(
     val jdk: JdkEnv,
 ) {
 
+    object UnsupportedOldGradleVersion : TestMatrix("7.4.2", "7.5", "1.8.22", JdkEnv.JAVA_11)
+
     /**
      * The minimum version we support & run tests against.
      */