Prompt for cancellation when starting test run while one is in flight

If a test run is already in progress and another one is started VS Code
will queue it and start the second run once the first has finished.

Implement cancellation logic that prompts the user to cancel the active
test run if one is in flight. If they chose to cancel the dialog, the
second test run is not queued. If they do chose to cancel the active
test run it is stopped and the new one starts immediately.

Issue: #1748

Author: plemarquand

CHANGELOG.md

@@ -8,6 +8,7 @@
 - New `swift.outputChannelLogLevel` setting to control the verbosity of the `Swift` output channel ([#1746](https://github.com/swiftlang/vscode-swift/pull/1746))
 - New `swift.debugTestsMultipleTimes` and `swift.debugTestsUntilFailure` commands for debugging tests over multiple runs ([#1763](https://github.com/swiftlang/vscode-swift/pull/1763))
 - Optionally include LLDB DAP logs in the Swift diagnostics bundle ([#1768](https://github.com/swiftlang/vscode-swift/pull/1758))
+- Prompt to cancel and replace the active test run if one is in flight ([#1774](https://github.com/swiftlang/vscode-swift/pull/1774))
 
 ### Changed
 - Added log levels and improved Swift extension logging so a logfile is produced in addition to logging messages to the existing `Swift` output channel. Deprecated the `swift.diagnostics` setting in favour of the new `swift.outputChannelLogLevel` setting ([#1746](https://github.com/swiftlang/vscode-swift/pull/1746))

src/FolderContext.ts

@@ -18,19 +18,22 @@ import { LinuxMain } from "./LinuxMain";
 import { PackageWatcher } from "./PackageWatcher";
 import { SwiftPackage, Target, TargetType } from "./SwiftPackage";
 import { TestExplorer } from "./TestExplorer/TestExplorer";
+import { TestRunManager } from "./TestExplorer/TestRunManager";
 import { WorkspaceContext, FolderOperation } from "./WorkspaceContext";
 import { BackgroundCompilation } from "./BackgroundCompilation";
 import { TaskQueue } from "./tasks/TaskQueue";
 import { isPathInsidePath } from "./utilities/filesystem";
 import { SwiftToolchain } from "./toolchain/toolchain";
 import { SwiftLogger } from "./logging/SwiftLogger";
+import { TestRunProxy } from "./TestExplorer/TestRunner";
 
 export class FolderContext implements vscode.Disposable {
-    private packageWatcher: PackageWatcher;
     public backgroundCompilation: BackgroundCompilation;
     public hasResolveErrors = false;
     public testExplorer?: TestExplorer;
     public taskQueue: TaskQueue;
+    private packageWatcher: PackageWatcher;
+    private testRunManager: TestRunManager;
 
     /**
      * FolderContext constructor
@@ -49,6 +52,7 @@ export class FolderContext implements vscode.Disposable {
         this.packageWatcher = new PackageWatcher(this, workspaceContext);
         this.backgroundCompilation = new BackgroundCompilation(this);
         this.taskQueue = new TaskQueue(this);
+        this.testRunManager = new TestRunManager();
     }
 
     /** dispose of any thing FolderContext holds */
@@ -212,6 +216,34 @@ export class FolderContext implements vscode.Disposable {
         return target;
     }
 
+    /**
+     * Register a new test run
+     * @param testRun The test run to register
+     * @param folder The folder context
+     * @param testKind The kind of test run
+     * @param tokenSource The cancellation token source
+     */
+    public registerTestRun(testRun: TestRunProxy, tokenSource: vscode.CancellationTokenSource) {
+        this.testRunManager.registerTestRun(testRun, this, tokenSource);
+    }
+
+    /**
+     * Returns true if there is an active test run for the given test kind
+     * @param testKind The kind of test
+     * @returns True if there is an active test run, false otherwise
+     */
+    hasActiveTestRun() {
+        return this.testRunManager.getActiveTestRun(this) !== undefined;
+    }
+
+    /**
+     * Cancels the active test run for the given test kind
+     * @param testKind The kind of test run
+     */
+    cancelTestRun() {
+        this.testRunManager.cancelTestRun(this);
+    }
+
     /**
      * Called whenever we have new document symbols
      */

src/TestExplorer/TestRunManager.ts

@@ -0,0 +1,80 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the VS Code Swift open source project
+//
+// Copyright (c) 2021-2025 the VS Code Swift project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of VS Code Swift project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import * as vscode from "vscode";
+import { TestRunProxy } from "./TestRunner";
+import { FolderContext } from "../FolderContext";
+
+/**
+ * Manages active test runs and provides functionality to check if a test run is in progress
+ * and to cancel test runs.
+ */
+export class TestRunManager {
+    private activeTestRuns = new Map<
+        string,
+        { testRun: TestRunProxy; tokenSource: vscode.CancellationTokenSource }
+    >();
+
+    /**
+     * Register a new test run
+     * @param testRun The test run to register
+     * @param folder The folder context
+     * @param tokenSource The cancellation token source
+     */
+    public registerTestRun(
+        testRun: TestRunProxy,
+        folder: FolderContext,
+        tokenSource: vscode.CancellationTokenSource
+    ) {
+        const key = this.getTestRunKey(folder);
+        this.activeTestRuns.set(key, { testRun, tokenSource });
+
+        // When the test run completes, remove it from active test runs
+        testRun.onTestRunComplete(() => {
+            this.activeTestRuns.delete(key);
+        });
+    }
+
+    /**
+     * Cancel an active test run
+     * @param folder The folder context
+     */
+    public cancelTestRun(folder: FolderContext) {
+        const key = this.getTestRunKey(folder);
+        const activeRun = this.activeTestRuns.get(key);
+        if (activeRun) {
+            activeRun.tokenSource.cancel();
+        }
+    }
+
+    /**
+     * Check if a test run is already in progress for the given folder and test kind
+     * @param folder The folder context
+     * @returns The active test run if one exists, undefined otherwise
+     */
+    public getActiveTestRun(folder: FolderContext) {
+        const key = this.getTestRunKey(folder);
+        const activeRun = this.activeTestRuns.get(key);
+        return activeRun?.testRun;
+    }
+
+    /**
+     * Generate a unique key for a test run based on folder and test kind
+     * @param folder The folder context
+     * @returns A unique key
+     */
+    private getTestRunKey(folder: FolderContext) {
+        return folder.folder.fsPath;
+    }
+}

src/TestExplorer/TestRunner.ts

@@ -48,7 +48,10 @@ import {
 } from "../debugger/buildConfig";
 import { TestKind, isDebugging, isRelease } from "./TestKind";
 import { reduceTestItemChildren } from "./TestUtils";
-import { CompositeCancellationToken } from "../utilities/cancellation";
+import {
+    CompositeCancellationToken,
+    CompositeCancellationTokenSource,
+} from "../utilities/cancellation";
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 import stripAnsi = require("strip-ansi");
 import { packageName, resolveScope } from "../utilities/tasks";
@@ -429,7 +432,7 @@ export class TestRunner {
     private testArgs: TestRunArguments;
     private xcTestOutputParser: IXCTestOutputParser;
     private swiftTestOutputParser: SwiftTestingOutputParser;
-    private static CANCELLATION_ERROR = "Test run cancelled";
+    private static CANCELLATION_ERROR = "Test run cancelled.";
 
     /**
      * Constructor for TestRunner
@@ -517,15 +520,14 @@ export class TestRunner {
                 TestKind.standard,
                 vscode.TestRunProfileKind.Run,
                 async (request, token) => {
-                    const runner = new TestRunner(
+                    await this.handleTestRunRequest(
                         TestKind.standard,
                         request,
                         folderContext,
                         controller,
-                        token
+                        token,
+                        onCreateTestRun
                     );
-                    onCreateTestRun.fire(runner.testRun);
-                    await runner.runHandler();
                 },
                 true,
                 runnableTag
@@ -534,15 +536,14 @@ export class TestRunner {
                 TestKind.parallel,
                 vscode.TestRunProfileKind.Run,
                 async (request, token) => {
-                    const runner = new TestRunner(
+                    await this.handleTestRunRequest(
                         TestKind.parallel,
                         request,
                         folderContext,
                         controller,
-                        token
+                        token,
+                        onCreateTestRun
                     );
-                    onCreateTestRun.fire(runner.testRun);
-                    await runner.runHandler();
                 },
                 false,
                 runnableTag
@@ -551,15 +552,14 @@ export class TestRunner {
                 TestKind.release,
                 vscode.TestRunProfileKind.Run,
                 async (request, token) => {
-                    const runner = new TestRunner(
+                    await this.handleTestRunRequest(
                         TestKind.release,
                         request,
                         folderContext,
                         controller,
-                        token
+                        token,
+                        onCreateTestRun
                     );
-                    onCreateTestRun.fire(runner.testRun);
-                    await runner.runHandler();
                 },
                 false,
                 runnableTag
@@ -569,21 +569,27 @@ export class TestRunner {
                 TestKind.coverage,
                 vscode.TestRunProfileKind.Coverage,
                 async (request, token) => {
-                    const runner = new TestRunner(
+                    await this.handleTestRunRequest(
                         TestKind.coverage,
                         request,
                         folderContext,
                         controller,
-                        token
+                        token,
+                        onCreateTestRun,
+                        async runner => {
+                            if (request.profile) {
+                                request.profile.loadDetailedCoverage = async (
+                                    _testRun,
+                                    fileCoverage
+                                ) => {
+                                    return runner.testRun.coverage.loadDetailedCoverage(
+                                        fileCoverage.uri
+                                    );
+                                };
+                            }
+                            await vscode.commands.executeCommand("testing.openCoverage");
+                        }
                     );
-                    onCreateTestRun.fire(runner.testRun);
-                    if (request.profile) {
-                        request.profile.loadDetailedCoverage = async (_testRun, fileCoverage) => {
-                            return runner.testRun.coverage.loadDetailedCoverage(fileCoverage.uri);
-                        };
-                    }
-                    await runner.runHandler();
-                    await vscode.commands.executeCommand("testing.openCoverage");
                 },
                 false,
                 runnableTag
@@ -593,15 +599,14 @@ export class TestRunner {
                 TestKind.debug,
                 vscode.TestRunProfileKind.Debug,
                 async (request, token) => {
-                    const runner = new TestRunner(
+                    await this.handleTestRunRequest(
                         TestKind.debug,
                         request,
                         folderContext,
                         controller,
-                        token
+                        token,
+                        onCreateTestRun
                     );
-                    onCreateTestRun.fire(runner.testRun);
-                    await runner.runHandler();
                 },
                 false,
                 runnableTag
@@ -610,22 +615,84 @@ export class TestRunner {
                 TestKind.debugRelease,
                 vscode.TestRunProfileKind.Debug,
                 async (request, token) => {
-                    const runner = new TestRunner(
+                    await this.handleTestRunRequest(
                         TestKind.debugRelease,
                         request,
                         folderContext,
                         controller,
-                        token
+                        token,
+                        onCreateTestRun
                     );
-                    onCreateTestRun.fire(runner.testRun);
-                    await runner.runHandler();
                 },
                 false,
                 runnableTag
             ),
         ];
     }
 
+    /**
+     * Handle a test run request, checking if a test run is already in progress
+     * @param testKind The kind of test run
+     * @param request The test run request
+     * @param folderContext The folder context
+     * @param controller The test controller
+     * @param token The cancellation token
+     * @param onCreateTestRun Event emitter for test run creation
+     * @param postRunHandler Optional handler to run after the test run completes
+     */
+    private static async handleTestRunRequest(
+        testKind: TestKind,
+        request: vscode.TestRunRequest,
+        folderContext: FolderContext,
+        controller: vscode.TestController,
+        token: vscode.CancellationToken,
+        onCreateTestRun: vscode.EventEmitter<TestRunProxy>,
+        postRunHandler?: (runner: TestRunner) => Promise<void>
+    ): Promise<void> {
+        // If there's an active test run, prompt the user to cancel
+        if (folderContext.hasActiveTestRun()) {
+            const cancelOption = "Replace Running Test";
+            const result = await vscode.window.showInformationMessage(
+                "A test run is already in progress. Would you like to cancel and replace the active test run?",
+                { modal: true },
+                cancelOption
+            );
+
+            if (result === cancelOption) {
+                // Cancel the active test run
+                folderContext.cancelTestRun();
+            } else {
+                return;
+            }
+        }
+
+        // Create a cancellation token source for this test run
+        const compositeToken = new CompositeCancellationTokenSource(token);
+
+        // Create and run the test runner
+        const runner = new TestRunner(
+            testKind,
+            request,
+            folderContext,
+            controller,
+            compositeToken.token
+        );
+
+        // Register the test run with the manager
+        folderContext.registerTestRun(runner.testRun, compositeToken);
+
+        // Fire the event to notify that a test run was created
+        onCreateTestRun.fire(runner.testRun);
+
+        // Run the tests
+        await runner.runHandler();
+
+        // Run the post-run handler if provided
+        if (postRunHandler) {
+            await postRunHandler(runner);
+        }
+    }
+
     /**
      * Extracts a list of unique test Targets from the list of test items.
      */