Set MSRV in rust-toolchain.toml using the gradle.property (#3841)

The `rust-toolchain.toml` file for tests now uses the `rust.msrv` value
from the `gradle.properties` file.

This PR also fixes an issue where the `rust-toolchain.toml` file was not
created in the overridden test directory when `overrideTestDir` was set.
This caused the installed compiler version to be used, resulting in
errors with the latest compiler and preventing the use of
`overrideTestDir`.

Closes: #2048

---------

Co-authored-by: Fahad Zubair <[email protected]>

Author: drganjoo

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/testutil/Rust.kt

@@ -40,9 +40,11 @@ import software.amazon.smithy.rust.codegen.core.util.letIf
 import software.amazon.smithy.rust.codegen.core.util.orNullIfEmpty
 import software.amazon.smithy.rust.codegen.core.util.runCommand
 import java.io.File
+import java.io.FileInputStream
 import java.nio.file.Files
 import java.nio.file.Files.createTempDirectory
 import java.nio.file.Path
+import java.util.Properties
 import kotlin.io.path.absolutePathString
 import kotlin.io.path.writeText
 
@@ -54,6 +56,8 @@ val TestModuleDocProvider =
             }
     }
 
+val projectRootDir by lazy { File("git rev-parse --show-toplevel".runCommand().replace("\n", "")) }
+
 /**
  * Waiting for Kotlin to stabilize their temp directory functionality
  */
@@ -65,6 +69,38 @@ private fun tempDir(directory: File? = null): File {
     }
 }
 
+/**
+ * This function returns the minimum supported Rust version, as specified in the `gradle.properties` file
+ * located at the root of the project.
+ */
+fun msrv(): String {
+    val properties = Properties()
+    val propertiesFilePath = projectRootDir.resolve("gradle.properties")
+
+    FileInputStream(propertiesFilePath).use { inputStream ->
+        properties.load(inputStream)
+    }
+
+    return properties.getProperty("rust.msrv")
+}
+
+/**
+ * Generates the `rust-toolchain.toml` file in the specified directory.
+ *
+ * The compiler version is set in `gradle.properties` under the `rust.msrv` property.
+ * The Gradle task `GenerateMsrvTask` generates the Kotlin class
+ * `software.amazon.smithy.rust.codegen.core.Msrv` and writes the value of `rust.msrv` into it.
+ */
+private fun File.generateRustToolchainToml() {
+    resolve("rust-toolchain.toml").writeText(
+        // Help rust select the right version when we run cargo test.
+        """
+        [toolchain]
+        channel = "${msrv()}"
+        """.trimIndent(),
+    )
+}
+
 /**
  * Creates a Cargo workspace shared among all tests
  *
@@ -87,8 +123,7 @@ object TestWorkspace {
     private val subprojects = mutableListOf<String>()
 
     private val cargoLock: File by lazy {
-        val projectDir = "git rev-parse --show-toplevel".runCommand().replace("\n", "")
-        File(projectDir).resolve("aws/sdk/Cargo.lock")
+        projectRootDir.resolve("aws/sdk/Cargo.lock")
     }
 
     init {
@@ -121,12 +156,7 @@ object TestWorkspace {
                 version = "0.0.1"
                 """.trimIndent(),
             )
-            newProject.resolve("rust-toolchain.toml").writeText(
-                // help rust select the right version when we run cargo test
-                // TODO(https://github.com/smithy-lang/smithy-rs/issues/2048): load this from the msrv property using a
-                //  method as we do for runtime crate versions
-                "[toolchain]\nchannel = \"1.78.0\"\n",
-            )
+            newProject.generateRustToolchainToml()
             // ensure there at least an empty lib.rs file to avoid broken crates
             newProject.resolve("src").mkdirs()
             newProject.resolve("src/lib.rs").writeText("")
@@ -181,7 +211,11 @@ fun generatePluginContext(
     runtimeConfig: RuntimeConfig? = null,
     overrideTestDir: File? = null,
 ): Pair<PluginContext, Path> {
-    val testDir = overrideTestDir ?: TestWorkspace.subproject()
+    val testDir =
+        overrideTestDir?.apply {
+            mkdirs()
+            generateRustToolchainToml()
+        } ?: TestWorkspace.subproject()
     val moduleName = "test_${testDir.nameWithoutExtension}"
     val testPath = testDir.toPath()
     val manifest = FileManifest.create(testPath)

codegen-core/src/test/kotlin/software/amazon/smithy/rust/codegen/core/util/RustToolChainTomlTest.kt

@@ -0,0 +1,88 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.rust.codegen.core.util
+
+import io.kotest.matchers.booleans.shouldBeTrue
+import io.kotest.matchers.paths.shouldExist
+import io.kotest.matchers.shouldNotBe
+import org.junit.jupiter.api.Test
+import software.amazon.smithy.rust.codegen.core.testutil.asSmithyModel
+import software.amazon.smithy.rust.codegen.core.testutil.generatePluginContext
+import software.amazon.smithy.rust.codegen.core.testutil.projectRootDir
+import java.nio.file.Files.createTempDirectory
+import java.util.regex.Pattern
+
+internal class RustToolChainTomlTest {
+    val model =
+        """
+        namespace test
+
+        service TestService {
+            version: "123",
+            operations: [TestOperation]
+        }
+
+        operation TestOperation {
+            input:= {}
+            output:= {}
+        }
+        """.asSmithyModel(smithyVersion = "2")
+
+    @Test
+    fun `override test directory in integration test has a rust-toolchain toml file`() {
+        val dir = createTempDirectory("smithy-test").toFile()
+        val (_, path) = generatePluginContext(model, overrideTestDir = dir)
+        path.shouldExist()
+        val rustToolchainTomlPath = path.resolve("rust-toolchain.toml")
+        rustToolchainTomlPath.shouldExist()
+    }
+
+    @Test
+    fun `rust-toolchain toml file has correct value from gradle properties for rust-msrv`() {
+        val (_, path) = generatePluginContext(model)
+        val rustToolchainTomlPath = path.resolve("rust-toolchain.toml")
+        rustToolchainTomlPath.shouldExist()
+
+        // Read the MSRV written in `gradle.properties` file.
+        val msrvPattern = Pattern.compile("rust\\.msrv=(.+)")
+        val gradlePropertiesPath = projectRootDir.resolve("gradle.properties")
+        val msrv =
+            gradlePropertiesPath.useLines { lines ->
+                lines.firstNotNullOfOrNull { line ->
+                    msrvPattern.matcher(line).let { matcher ->
+                        if (matcher.find()) matcher.group(1) else null
+                    }
+                }
+            }
+        msrv shouldNotBe null
+
+        // Read `channel = (\d+)` from `rust-toolchain.toml` file, and
+        // ensure it matches the one in `gradle.properties`.
+        val toolchainPattern = Pattern.compile("\\[toolchain]")
+        val channelPattern = Pattern.compile("channel\\s*=\\s*\"(.+)\"")
+
+        val channelMatches =
+            rustToolchainTomlPath.toFile().useLines { lines ->
+                // Skip lines until the [toolchain] table is found, then take all lines until the next table.
+                val toolchainSection =
+                    lines
+                        .dropWhile { !toolchainPattern.matcher(it).find() }
+                        .drop(1)
+                        .takeWhile { !it.trim().startsWith("[") }
+
+                // There should be a [toolchain] table, and it must have a key called 'channel' whose value must
+                // match the `rust.msrv` specified in gradle.properties.
+                toolchainSection != null &&
+                    toolchainSection.any { line ->
+                        channelPattern.matcher(line).let { matcher ->
+                            matcher.find() && matcher.group(1) == msrv
+                        }
+                    }
+            }
+
+        channelMatches.shouldBeTrue()
+    }
+}