Address comments

1. Add abiility for tests to override environment behaviour
2. Fix tests.

Author: rasharab

src/main/kotlin/com/github/gradle/node/NodeExtension.kt

@@ -5,6 +5,7 @@ import com.github.gradle.node.util.Platform
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.mapProperty
 import org.gradle.kotlin.dsl.property
 
 open class NodeExtension(project: Project) {
@@ -181,6 +182,9 @@ open class NodeExtension(project: Project) {
      */
     val resolvedPlatform = project.objects.property<Platform>()
 
+
+    val environment = project.objects.mapProperty<String, String>().convention(System.getenv())
+
     init {
         distBaseUrl.set("https://nodejs.org/dist")
     }

src/main/kotlin/com/github/gradle/node/exec/ExecRunner.kt

@@ -13,9 +13,10 @@ import java.io.File
  *
  * @param execConfiguration configuration to get environment variables from
  */
-fun computeEnvironment(execConfiguration: ExecConfiguration): Map<String, String> {
+fun computeEnvironment(extension: NodeExtension, execConfiguration: ExecConfiguration): Map<String, String> {
     val execEnvironment = mutableMapOf<String, String>()
     execEnvironment += System.getenv()
+    execEnvironment += extension.environment.getOrElse(emptyMap())
     execEnvironment += execConfiguration.environment
     if (execConfiguration.additionalBinPaths.isNotEmpty()) {
         // Take care of Windows environments that may contain "Path" OR "PATH" - both existing
@@ -34,25 +35,6 @@ fun computeWorkingDir(nodeProjectDir: DirectoryProperty, execConfiguration: Exec
     workingDir.mkdirs()
     return workingDir
 }
-
-/**
- * Helper function to find the best matching executable in the system PATH.
- *
- * @param executableName The name of the executable to search for.
- * @return The best matching executable path as a String.
- */
-fun findBestExecutableMatch(executableName: String): String {
-    val pathVariable = System.getenv("PATH") ?: return executableName
-    val paths = pathVariable.split(File.pathSeparator)
-    for (path in paths) {
-        val executableFile = File(path, executableName)
-        if (executableFile.exists() && executableFile.canExecute()) {
-            return executableFile.absolutePath
-        }
-    }
-    return executableName  // Return the original executable if no match is found
-}
-
 /**
  * Basic execution runner that runs a given ExecConfiguration.
  *
@@ -61,11 +43,10 @@ fun findBestExecutableMatch(executableName: String): String {
  */
 class ExecRunner {
     fun execute(projectHelper: ProjectApiHelper, extension: NodeExtension, execConfiguration: ExecConfiguration): ExecResult {
-        val executablePath = findBestExecutableMatch(execConfiguration.executable)
         return projectHelper.exec {
-            executable = executablePath
+            executable = execConfiguration.executable
             args = execConfiguration.args
-            environment = computeEnvironment(execConfiguration)
+            environment = computeEnvironment(extension, execConfiguration)
             isIgnoreExitValue = execConfiguration.ignoreExitValue
             workingDir = computeWorkingDir(extension.nodeProjectDir, execConfiguration)
             execConfiguration.execOverrides?.execute(this)

src/main/kotlin/com/github/gradle/node/variant/VariantComputer.kt

@@ -8,19 +8,47 @@ import org.gradle.api.file.Directory
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
+import java.io.File
+
+/**
+ * Helper function to find the best matching executable in the system PATH.
+ *
+ * @param executableName The name of the executable to search for.
+ * @return The best matching executable path as a String.
+ */
+fun findBestExecutableMatch(
+    executableName: String,
+    environmentProvider: Provider<Map<String, String>>,
+): String {
+    val environment = environmentProvider.orNull ?: return executableName
+    val pathEnvironmentVariableName = if (environment["Path"] != null) "Path" else "PATH"
+    val pathVariable = environment[pathEnvironmentVariableName] ?: return executableName
+    val paths = pathVariable.split(File.pathSeparator)
+    for (path in paths) {
+        val executableFile = File(path, executableName)
+        if (executableFile.exists() && executableFile.canExecute()) {
+            return executableFile.absolutePath
+        }
+    }
+    return executableName  // Return the original executable if no match is found
+}
 
 /**
  * Get the expected node binary name, node.exe on Windows and node everywhere else.
  */
-fun computeNodeExec(nodeExtension: NodeExtension, nodeBinDirProvider: Provider<Directory>): Provider<String> {
+fun computeNodeExec(
+    nodeExtension: NodeExtension,
+    nodeBinDirProvider: Provider<Directory>,
+): Provider<String> {
     return zip(nodeExtension.download, nodeBinDirProvider).map {
         val (download, nodeBinDir) = it
         if (download) {
             val nodeCommand = if (nodeExtension.resolvedPlatform.get().isWindows()) "node.exe" else "node"
             nodeBinDir.dir(nodeCommand).asFile.absolutePath
-        } else "node"
+        } else findBestExecutableMatch("node", nodeExtension.environment)
     }
 }
+
 fun computeNpmScriptFile(nodeDirProvider: Provider<Directory>, command: String, isWindows: Boolean): Provider<String> {
     return nodeDirProvider.map { nodeDir ->
         if (isWindows) nodeDir.dir("node_modules/npm/bin/$command-cli.js").asFile.path
@@ -44,21 +72,27 @@ fun computeNodeDir(nodeExtension: NodeExtension, osName: String, osArch: String)
 /**
  * Compute the path for a given command, from a given binary directory, taking Windows into account
  */
-internal fun computeExec(nodeExtension: NodeExtension, binDirProvider: Provider<Directory>,
-                         configurationCommand: Property<String>, unixCommand: String, windowsCommand: String): Provider<String> {
+internal fun computeExec(
+    nodeExtension: NodeExtension, binDirProvider: Provider<Directory>,
+    configurationCommand: Property<String>, unixCommand: String, windowsCommand: String
+): Provider<String> {
     return zip(nodeExtension.download, configurationCommand, binDirProvider).map {
         val (download, cfgCommand, binDir) = it
         val command = if (nodeExtension.resolvedPlatform.get().isWindows()) {
             cfgCommand.mapIf({ it == unixCommand }) { windowsCommand }
         } else cfgCommand
-        if (download) binDir.dir(command).asFile.absolutePath else command
+        if (download) binDir.dir(command).asFile.absolutePath else findBestExecutableMatch(command, nodeExtension.environment)
     }
 }
 
 /**
  * Compute the path for a given package, taken versions and user-configured working directories into account
  */
-internal fun computePackageDir(packageName: String, packageVersion: Property<String>, packageWorkDir: DirectoryProperty): Provider<Directory> {
+internal fun computePackageDir(
+    packageName: String,
+    packageVersion: Property<String>,
+    packageWorkDir: DirectoryProperty
+): Provider<Directory> {
     return zip(packageVersion, packageWorkDir).map {
         val (version, workDir) = it
         val dirnameSuffix = if (version.isNotBlank()) {
@@ -85,14 +119,17 @@ open class VariantComputer {
     /**
      * Get the expected node binary directory, taking Windows specifics into account.
      */
-    fun computeNodeBinDir(nodeDirProvider: Provider<Directory>, platform: Property<Platform>) = computeProductBinDir(nodeDirProvider, platform)
+    fun computeNodeBinDir(nodeDirProvider: Provider<Directory>, platform: Property<Platform>) =
+        computeProductBinDir(nodeDirProvider, platform)
 
     /**
      * Get the expected node binary name, node.exe on Windows and node everywhere else.
      */
-    @Deprecated(message = "replaced by package-level function",
+    @Deprecated(
+        message = "replaced by package-level function",
         replaceWith =
-        ReplaceWith("com.github.gradle.node.variant.computeNodeExec(nodeExtension, nodeBinDirProvider)"))
+            ReplaceWith("com.github.gradle.node.variant.computeNodeExec(nodeExtension, nodeBinDirProvider)")
+    )
     fun computeNodeExec(nodeExtension: NodeExtension, nodeBinDirProvider: Provider<Directory>): Provider<String> {
         return com.github.gradle.node.variant.computeNodeExec(nodeExtension, nodeBinDirProvider)
     }
@@ -113,16 +150,19 @@ open class VariantComputer {
     /**
      * Get the expected npm binary directory, taking Windows specifics into account.
      */
-    fun computeNpmBinDir(npmDirProvider: Provider<Directory>, platform: Property<Platform>) = computeProductBinDir(npmDirProvider, platform)
+    fun computeNpmBinDir(npmDirProvider: Provider<Directory>, platform: Property<Platform>) =
+        computeProductBinDir(npmDirProvider, platform)
 
     /**
      * Get the expected node binary name, npm.cmd on Windows and npm everywhere else.
      *
      * Can be overridden by setting npmCommand.
      */
     fun computeNpmExec(nodeExtension: NodeExtension, npmBinDirProvider: Provider<Directory>): Provider<String> {
-        return computeExec(nodeExtension, npmBinDirProvider,
-            nodeExtension.npmCommand, "npm", "npm.cmd")
+        return computeExec(
+            nodeExtension, npmBinDirProvider,
+            nodeExtension.npmCommand, "npm", "npm.cmd"
+        )
     }
 
     /**
@@ -131,26 +171,32 @@ open class VariantComputer {
      * Can be overridden by setting npxCommand.
      */
     fun computeNpxExec(nodeExtension: NodeExtension, npmBinDirProvider: Provider<Directory>): Provider<String> {
-        return computeExec(nodeExtension, npmBinDirProvider,
-            nodeExtension.npxCommand, "npx", "npx.cmd")
+        return computeExec(
+            nodeExtension, npmBinDirProvider,
+            nodeExtension.npxCommand, "npx", "npx.cmd"
+        )
     }
 
     fun computePnpmDir(nodeExtension: NodeExtension): Provider<Directory> {
         return computePackageDir("pnpm", nodeExtension.pnpmVersion, nodeExtension.pnpmWorkDir)
     }
 
-    fun computePnpmBinDir(pnpmDirProvider: Provider<Directory>, platform: Property<Platform>) = computeProductBinDir(pnpmDirProvider, platform)
+    fun computePnpmBinDir(pnpmDirProvider: Provider<Directory>, platform: Property<Platform>) =
+        computeProductBinDir(pnpmDirProvider, platform)
 
     fun computePnpmExec(nodeExtension: NodeExtension, pnpmBinDirProvider: Provider<Directory>): Provider<String> {
-        return computeExec(nodeExtension, pnpmBinDirProvider,
-            nodeExtension.pnpmCommand, "pnpm", "pnpm.cmd")
+        return computeExec(
+            nodeExtension, pnpmBinDirProvider,
+            nodeExtension.pnpmCommand, "pnpm", "pnpm.cmd"
+        )
     }
 
     fun computeYarnDir(nodeExtension: NodeExtension): Provider<Directory> {
         return computePackageDir("yarn", nodeExtension.yarnVersion, nodeExtension.yarnWorkDir)
     }
 
-    fun computeYarnBinDir(yarnDirProvider: Provider<Directory>, platform: Property<Platform>) = computeProductBinDir(yarnDirProvider, platform)
+    fun computeYarnBinDir(yarnDirProvider: Provider<Directory>, platform: Property<Platform>) =
+        computeProductBinDir(yarnDirProvider, platform)
 
     fun computeYarnExec(nodeExtension: NodeExtension, yarnBinDirProvider: Provider<Directory>): Provider<String> {
         return zip(nodeExtension.yarnCommand, yarnBinDirProvider).map {
@@ -167,11 +213,14 @@ open class VariantComputer {
         return computePackageDir("bun", nodeExtension.bunVersion, nodeExtension.bunWorkDir)
     }
 
-    fun computeBunBinDir(bunDirProvider: Provider<Directory>, platform: Property<Platform>) = computeProductBinDir(bunDirProvider, platform)
+    fun computeBunBinDir(bunDirProvider: Provider<Directory>, platform: Property<Platform>) =
+        computeProductBinDir(bunDirProvider, platform)
 
     fun computeBunExec(nodeExtension: NodeExtension, bunBinDirProvider: Provider<Directory>): Provider<String> {
-        return computeExec(nodeExtension, bunBinDirProvider,
-            nodeExtension.bunCommand, "bun", "bun.cmd")
+        return computeExec(
+            nodeExtension, bunBinDirProvider,
+            nodeExtension.bunCommand, "bun", "bun.cmd"
+        )
     }
 
     /**
@@ -180,20 +229,24 @@ open class VariantComputer {
      * Can be overridden by setting bunxCommand.
      */
     fun computeBunxExec(nodeExtension: NodeExtension, bunBinDirProvider: Provider<Directory>): Provider<String> {
-        return computeExec(nodeExtension, bunBinDirProvider,
-            nodeExtension.bunxCommand, "bunx", "bunx.cmd")
+        return computeExec(
+            nodeExtension, bunBinDirProvider,
+            nodeExtension.bunxCommand, "bunx", "bunx.cmd"
+        )
     }
 
     private fun computeProductBinDir(productDirProvider: Provider<Directory>, platform: Property<Platform>) =
-            if (platform.get().isWindows()) productDirProvider else productDirProvider.map { it.dir("bin") }
+        if (platform.get().isWindows()) productDirProvider else productDirProvider.map { it.dir("bin") }
 
     /**
      * Get the node archive name in Gradle dependency format, using zip for Windows and tar.gz everywhere else.
      *
      * Essentially: org.nodejs:node:$version:$osName-$osArch@tar.gz
      */
-    @Deprecated(message = "replaced by package-level function",
-        replaceWith = ReplaceWith("com.github.gradle.node.variant.computeNodeArchiveDependency(nodeExtension)"))
+    @Deprecated(
+        message = "replaced by package-level function",
+        replaceWith = ReplaceWith("com.github.gradle.node.variant.computeNodeArchiveDependency(nodeExtension)")
+    )
     fun computeNodeArchiveDependency(nodeExtension: NodeExtension): Provider<String> {
         return com.github.gradle.node.variant.computeNodeArchiveDependency(nodeExtension)
     }

src/test/groovy/com/github/gradle/node/npm/task/NpmInstallTaskTest.groovy

@@ -13,6 +13,7 @@ class NpmInstallTaskTest extends AbstractTaskTest {
     def "exec npm install task with configured proxy"() {
         given:
         nodeExtension.resolvedPlatform.set(PlatformHelperKt.parsePlatform("Linux", "x86_64", {}))
+        nodeExtension.environment.set([:])
         GradleProxyHelper.setHttpsProxyHost("my-super-proxy.net")
         GradleProxyHelper.setHttpsProxyPort(11235)
 
@@ -32,6 +33,7 @@ class NpmInstallTaskTest extends AbstractTaskTest {
     def "exec npm install task with configured proxy but disabled"() {
         given:
         nodeExtension.resolvedPlatform.set(PlatformHelperKt.parsePlatform("Linux", "x86_64", {}))
+        nodeExtension.environment.set([:])
         GradleProxyHelper.setHttpsProxyHost("my-super-proxy.net")
         GradleProxyHelper.setHttpsProxyPort(11235)
         nodeExtension.nodeProxySettings.set(ProxySettings.OFF)