[Gradle] Fix passing process environment when launching KotlinKarma tests

Correctly forward environment variables when launching Kotlin/JS tests.

Update ExecAsyncHandle to log exec parameters.

Add test to verify env can be customised.

^KT-73142
^KT-77119

(cherry picked from commit 231d6bc)

Author: adam-enko

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/js/JsBrowserTestsIT.kt

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2010-2025 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.gradle.js
+
+import org.gradle.api.logging.LogLevel
+import org.gradle.testkit.runner.GradleRunner
+import org.gradle.util.GradleVersion
+import org.jetbrains.kotlin.gradle.targets.js.testing.KotlinJsTest
+import org.jetbrains.kotlin.gradle.testbase.*
+import org.jetbrains.kotlin.gradle.uklibs.applyMultiplatform
+import kotlin.test.assertContains
+
+@JsGradlePluginTests
+class JsBrowserTestsIT : KGPBaseTest() {
+
+    @GradleTest
+    fun `verify custom custom KotlinJsTest environment variables are used to launch tests`(gradleVersion: GradleVersion) {
+        project(
+            "buildScriptInjection",
+            gradleVersion = gradleVersion,
+            buildOptions = defaultBuildOptions.copy(
+                logLevel = LogLevel.DEBUG,
+            )
+        ) {
+            addKgpToBuildScriptCompilationClasspath()
+            buildScriptInjection {
+                project.applyMultiplatform {
+                    js().browser()
+                    sourceSets.commonTest.dependencies {
+                        implementation(kotlin("test"))
+                    }
+                }
+
+                project.projectDir.resolve("src/jsTest/kotlin/DummyTest.kt").apply {
+                    parentFile.mkdirs()
+                    writeText(
+                        """
+                        class DummyTest {
+                          @kotlin.test.Test
+                          fun dummy() {
+                            println("dummy test")
+                          }
+                        }
+                        """.trimIndent()
+                    )
+                }
+
+                project.tasks.withType(KotlinJsTest::class.java).configureEach { task ->
+                    task.environment("CUSTOM_ENV", "custom-env-value")
+
+                    // KT-77134 verify doFirst {} workaround,
+                    // which is necessary because KotlinJsTest doesn't use Provider API.
+                    val lazyValue = project.provider { "lazy-custom-env-value" }
+                    task.doFirst { _ ->
+                        task.environment("CUSTOM_ENV_LAZY", lazyValue.get())
+                    }
+                }
+            }
+
+            build(
+                ":jsBrowserTest",
+                // :jsBrowserTest might fail if no browsers are installed (e.g. on CI).
+                // For this test we don't care if the task passes or fails, only if the custom environment variables are set correctly.
+                // So, use `GradleRunner.run()` to ignore the build outcome.
+                gradleRunnerAction = GradleRunner::run,
+            ) {
+                val execAsyncHandleLogs = output.lineSequence()
+                    .mapNotNull {
+                        it
+                            .substringAfter(" [DEBUG] [org.jetbrains.kotlin.gradle.utils.processes.ExecAsyncHandle] ", "")
+                            .ifBlank { null }
+                    }
+
+                val createdExecSpecLog = execAsyncHandleLogs
+                    .singleOrNull { it.startsWith("[ExecAsyncHandle :jsBrowserTest] created ExecSpec.") }
+
+                requireNotNull(createdExecSpecLog) {
+                    "Could not find 'created ExecSpec' log in build output:\n${execAsyncHandleLogs.joinToString("\n").prependIndent()}"
+                }
+
+                val env = createdExecSpecLog.substringAfter("Environment: {").substringBefore("},")
+                assertContains(env, "CUSTOM_ENV=custom-env-value")
+                assertContains(env, "CUSTOM_ENV_LAZY=lazy-custom-env-value")
+            }
+        }
+    }
+}

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/testbase/testDsl.kt

@@ -173,6 +173,7 @@ fun TestProject.build(
     environmentVariables: EnvironmentalVariables = this.environmentVariables,
     inputStream: InputStream? = null,
     forwardBuildOutput: Boolean = enableGradleDebug.toBooleanFlag(overridingEnvironmentVariablesInstantiationBacktrace = environmentVariables.overridingEnvironmentVariablesInstantiationBacktrace),
+    gradleRunnerAction: GradleRunner.() -> BuildResult = GradleRunner::build,
     assertions: BuildResult.() -> Unit = {},
 ) {
     if (enableBuildScan) agreeToBuildScanService()
@@ -205,7 +206,7 @@ fun TestProject.build(
     }
 
     withBuildSummary(allBuildArguments) {
-        val buildResult = gradleRunnerForBuild.build()
+        val buildResult = gradleRunnerForBuild.gradleRunnerAction()
         if (enableBuildScan) buildResult.printBuildScanUrl()
         assertions(buildResult)
         buildResult.additionalAssertions(buildOptions)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/js/testing/karma/KotlinKarma.kt

@@ -467,13 +467,8 @@ class KotlinKarma internal constructor(
                     listOf("start", karmaConfigAbsolutePath)
         }
 
-        val processLaunchOpts = objects.processLaunchOptions {
-            this.workingDir.set(this@KotlinKarma.workingDir)
-            this.executable.set(this@KotlinKarma.executable)
-        }
-
         return object : JSServiceMessagesTestExecutionSpec(
-            processLaunchOpts = processLaunchOpts,
+            processLaunchOpts = launchOpts,
             processArgs = args,
             checkExitCode = true,
             clientSettings = clientSettings

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/utils/processes/ExecAsyncHandle.kt

@@ -68,12 +68,9 @@ internal sealed interface ExecAsyncHandle {
             return ExecAsyncHandleImpl(
                 displayName = displayName,
                 abortTimeout = abortTimeout,
-            ) {
-                exec { exec ->
-                    exec.isIgnoreExitValue = true
-                    configure(exec)
-                }
-            }
+                execOperations = this,
+                configure = configure,
+            )
         }
     }
 }
@@ -82,7 +79,8 @@ internal sealed interface ExecAsyncHandle {
 private class ExecAsyncHandleImpl(
     override val displayName: String,
     private val abortTimeout: Duration,
-    private val run: () -> ExecResult,
+    private val execOperations: ExecOperations,
+    private val configure: (execSpec: ExecSpec) -> Unit,
 ) : ExecAsyncHandle {
     private val logTag: String = "[ExecAsyncHandle $displayName]"
 
@@ -96,14 +94,22 @@ private class ExecAsyncHandleImpl(
     ) {
         logger.info("$logTag started")
         try {
-            result.set(run())
+            result.set(exec())
             logger.info("$logTag finished ${result.get()}")
         } catch (e: Exception) {
             failure.set(e)
             logger.info("$logTag failed $e")
         }
     }
 
+    private fun exec(): ExecResult {
+        return execOperations.exec { exec ->
+            exec.isIgnoreExitValue = true
+            configure(exec)
+            logger.debug("$logTag created ExecSpec. Command: ${exec.commandLine.joinToString()}, Environment: ${exec.environment}, WorkingDir: ${exec.workingDir}")
+        }
+    }
+
     override fun start(): ExecAsyncHandle {
         thread.start()
         return this