Code coverage for linux

Refactor common debug config creation

Author: plemarquand

src/FolderContext.ts

@@ -21,7 +21,6 @@ import { TestExplorer } from "./TestExplorer/TestExplorer";
 import { WorkspaceContext, FolderEvent } from "./WorkspaceContext";
 import { BackgroundCompilation } from "./BackgroundCompilation";
 import { TaskQueue } from "./tasks/TaskQueue";
-import { LcovResults } from "./coverage/LcovResults";
 import { isPathInsidePath } from "./utilities/utilities";
 
 export class FolderContext implements vscode.Disposable {
@@ -30,7 +29,6 @@ export class FolderContext implements vscode.Disposable {
     public hasResolveErrors = false;
     public testExplorer?: TestExplorer;
     public taskQueue: TaskQueue;
-    public lcovResults: LcovResults;
 
     /**
      * FolderContext constructor
@@ -49,15 +47,13 @@ export class FolderContext implements vscode.Disposable {
         this.packageWatcher.install();
         this.backgroundCompilation = new BackgroundCompilation(this);
         this.taskQueue = new TaskQueue(this);
-        this.lcovResults = new LcovResults(this);
     }
 
     /** dispose of any thing FolderContext holds */
     dispose() {
         this.linuxMain?.dispose();
         this.packageWatcher.dispose();
         this.testExplorer?.dispose();
-        this.lcovResults.dispose();
     }
 
     /**

src/TestExplorer/TestRunner.ts

@@ -17,14 +17,9 @@ import * as path from "path";
 import * as stream from "stream";
 import * as os from "os";
 import * as asyncfs from "fs/promises";
-import {
-    createXCTestConfiguration,
-    createSwiftTestConfiguration,
-    createDarwinTestConfiguration,
-} from "../debugger/launch";
 import { FolderContext } from "../FolderContext";
+import { execFile, getErrorDescription } from "../utilities/utilities";
 import { getBuildAllTask } from "../tasks/SwiftTaskProvider";
-import { execFile, getErrorDescription, regexEscapedString } from "../utilities/utilities";
 import configuration from "../configuration";
 import { WorkspaceContext } from "../WorkspaceContext";
 import { XCTestOutputParser } from "./TestParsers/XCTestOutputParser";
@@ -37,8 +32,9 @@ import { ITestRunState } from "./TestParsers/TestRunState";
 import { TestRunArguments } from "./TestRunArguments";
 import { TemporaryFolder } from "../utilities/tempFolder";
 import { TestClass, runnableTag, upsertTestItem } from "./TestDiscovery";
-import { SwiftProcess } from "../tasks/SwiftProcess";
-import { TestCoverage } from "../coverage/TestCoverage";
+import { TestCoverage } from "../coverage/LcovResults";
+import { DebugConfigurationFactory } from "../debugger/buildConfig";
+import { SwiftPtyProcess } from "../tasks/SwiftProcess";
 
 /** Workspace Folder events */
 export enum TestKind {
@@ -50,6 +46,11 @@ export enum TestKind {
     coverage = "coverage",
 }
 
+export enum TestLibrary {
+    xctest = "XCTest",
+    swiftTesting = "swift-testing",
+}
+
 class TestRunProxy {
     private testRun?: vscode.TestRun;
     private addedTestItems: { testClass: TestClass; parentIndex: number }[] = [];
@@ -363,13 +364,13 @@ export class TestRunner {
                     await execFile("mkfifo", [fifoPipePath], undefined, this.folderContext);
                 }
 
-                const testBuildConfig =
-                    await LaunchConfigurations.createLaunchConfigurationForSwiftTesting(
-                        this.testArgs.swiftTestArgs,
-                        this.folderContext,
-                        fifoPipePath,
-                        testKind === TestKind.coverage
-                    );
+                const testBuildConfig = DebugConfigurationFactory.swiftTestingConfig(
+                    this.folderContext,
+                    fifoPipePath,
+                    testKind,
+                    this.testArgs.swiftTestArgs,
+                    true
+                );
 
                 if (testBuildConfig === null) {
                     return;
@@ -397,18 +398,18 @@ export class TestRunner {
                     testKind === TestKind.parallel ? TestKind.standard : testKind,
                     token,
                     outputStream,
-                    testBuildConfig
+                    testBuildConfig,
+                    TestLibrary.swiftTesting
                 );
             });
         }
 
         if (this.testArgs.hasXCTests) {
-            const testBuildConfig = LaunchConfigurations.createLaunchConfigurationForXCTestTesting(
-                this.testArgs.xcTestArgs,
-                this.workspaceContext,
+            const testBuildConfig = DebugConfigurationFactory.xcTestConfig(
                 this.folderContext,
-                false,
-                testKind === TestKind.coverage
+                testKind,
+                this.testArgs.xcTestArgs,
+                true
             );
             if (testBuildConfig === null) {
                 return;
@@ -431,21 +432,33 @@ export class TestRunner {
             // XCTestRuns are started immediately
             this.testRun.testRunStarted();
 
-            await this.launchTests(testKind, token, parsedOutputStream, testBuildConfig);
+            await this.launchTests(
+                testKind,
+                token,
+                parsedOutputStream,
+                testBuildConfig,
+                TestLibrary.xctest
+            );
         }
     }
 
     private async launchTests(
         testKind: TestKind,
         token: vscode.CancellationToken,
         outputStream: stream.Writable,
-        testBuildConfig: vscode.DebugConfiguration
+        testBuildConfig: vscode.DebugConfiguration,
+        testLibrary: TestLibrary
     ) {
         this.testRun.appendOutput(`> Test run started at ${new Date().toLocaleString()} <\r\n\r\n`);
         try {
             switch (testKind) {
                 case TestKind.coverage:
-                    await this.runCoverageSession(token, outputStream, testBuildConfig);
+                    await this.runCoverageSession(
+                        token,
+                        outputStream,
+                        testBuildConfig,
+                        testLibrary
+                    );
                     break;
                 case TestKind.parallel:
                     await this.runParallelSession(token, outputStream, testBuildConfig);
@@ -475,7 +488,7 @@ export class TestRunner {
             let didError = false;
             let cancellation: vscode.Disposable;
 
-            const exec = new SwiftProcess(testBuildConfig.program, args, {
+            const exec = new SwiftPtyProcess(testBuildConfig.program, args, {
                 cwd: testBuildConfig.cwd,
                 env: { ...process.env, ...testBuildConfig.env },
             });
@@ -527,7 +540,8 @@ export class TestRunner {
     async runCoverageSession(
         token: vscode.CancellationToken,
         outputStream: stream.Writable,
-        testBuildConfig: vscode.DebugConfiguration
+        testBuildConfig: vscode.DebugConfiguration,
+        testLibrary: TestLibrary
     ) {
         try {
             await this.runStandardSession(token, outputStream, testBuildConfig);
@@ -538,7 +552,7 @@ export class TestRunner {
             }
         }
 
-        await this.testRun.coverage.captureCoverage();
+        await this.testRun.coverage.captureCoverage(testLibrary);
     }
 
     /** Run tests in parallel outside of debugger */
@@ -605,13 +619,13 @@ export class TestRunner {
             }
 
             if (this.testArgs.hasSwiftTestingTests) {
-                const swiftTestBuildConfig =
-                    await LaunchConfigurations.createLaunchConfigurationForSwiftTesting(
-                        this.testArgs.swiftTestArgs,
-                        this.folderContext,
-                        fifoPipePath,
-                        false
-                    );
+                const swiftTestBuildConfig = DebugConfigurationFactory.swiftTestingConfig(
+                    this.folderContext,
+                    fifoPipePath,
+                    TestKind.standard,
+                    this.testArgs.swiftTestArgs,
+                    true
+                );
 
                 if (swiftTestBuildConfig !== null) {
                     // given we have already run a build task there is no need to have a pre launch task
@@ -650,14 +664,12 @@ export class TestRunner {
 
                 // create launch config for testing
                 if (this.testArgs.hasXCTests) {
-                    const xcTestBuildConfig =
-                        await LaunchConfigurations.createLaunchConfigurationForXCTestTesting(
-                            this.testArgs.xcTestArgs,
-                            this.workspaceContext,
-                            this.folderContext,
-                            true,
-                            false
-                        );
+                    const xcTestBuildConfig = DebugConfigurationFactory.xcTestConfig(
+                        this.folderContext,
+                        TestKind.standard,
+                        this.testArgs.xcTestArgs,
+                        true
+                    );
 
                     if (xcTestBuildConfig !== null) {
                         // given we have already run a build task there is no need to have a pre launch task
@@ -772,111 +784,6 @@ export class TestRunner {
     }
 }
 
-class LaunchConfigurations {
-    /**
-     * Edit launch configuration to run tests
-     * @param debugging Do we need this configuration for debugging
-     * @param outputFile Debug output file
-     * @returns
-     */
-    static createLaunchConfigurationForXCTestTesting(
-        args: string[],
-        workspaceContext: WorkspaceContext,
-        folderContext: FolderContext,
-        debugging: boolean,
-        coverage: boolean
-    ): vscode.DebugConfiguration | null {
-        const testList = args.join(",");
-
-        if (process.platform === "darwin") {
-            // if debugging on macOS with Swift 5.6 we need to create a custom launch
-            // configuration so we can set the system architecture
-            const swiftVersion = workspaceContext.toolchain.swiftVersion;
-            if (
-                debugging &&
-                swiftVersion.isLessThan(new Version(5, 7, 0)) &&
-                swiftVersion.isGreaterThanOrEqual(new Version(5, 6, 0))
-            ) {
-                let testFilterArg: string;
-                if (testList.length > 0) {
-                    testFilterArg = `-XCTest ${testList}`;
-                } else {
-                    testFilterArg = "";
-                }
-                const testBuildConfig = createDarwinTestConfiguration(folderContext, testFilterArg);
-                if (testBuildConfig === null) {
-                    return null;
-                }
-                return testBuildConfig;
-            } else {
-                const testBuildConfig = createXCTestConfiguration(folderContext, true);
-                if (testBuildConfig === null) {
-                    return null;
-                }
-
-                let additionalArgs: string[] = [];
-                if (testList.length > 0) {
-                    additionalArgs = args.flatMap(arg => ["--filter", regexEscapedString(arg)]);
-                }
-
-                if (coverage) {
-                    additionalArgs = [...additionalArgs, "--enable-code-coverage"];
-                }
-
-                testBuildConfig.args = [...testBuildConfig.args, ...additionalArgs];
-                testBuildConfig.terminal = "console";
-
-                return testBuildConfig;
-            }
-        } else {
-            const testBuildConfig = createXCTestConfiguration(folderContext, true);
-            if (testBuildConfig === null) {
-                return null;
-            }
-
-            let testFilterArg: string[] = [];
-            if (testList.length > 0) {
-                testFilterArg = args.flatMap(arg => ["--filter", regexEscapedString(arg)]);
-            }
-            if (coverage) {
-                testFilterArg = [...testFilterArg, "--enable-code-coverage"];
-            }
-            testBuildConfig.args = [...testBuildConfig.args, ...testFilterArg];
-
-            // output test logging to debug console so we can catch it with a tracker
-            testBuildConfig.terminal = "console";
-            return testBuildConfig;
-        }
-    }
-
-    static async createLaunchConfigurationForSwiftTesting(
-        args: string[],
-        folderContext: FolderContext,
-        fifoPipePath: string,
-        coverage: boolean
-    ): Promise<vscode.DebugConfiguration | null> {
-        const testList = args.join(",");
-
-        const testBuildConfig = createSwiftTestConfiguration(folderContext, fifoPipePath, true);
-        if (testBuildConfig === null) {
-            return null;
-        }
-
-        let additionalArgs: string[] = [];
-        if (testList.length > 0) {
-            additionalArgs = args.flatMap(arg => ["--filter", regexEscapedString(arg)]);
-        }
-
-        if (coverage) {
-            additionalArgs = [...additionalArgs, "--enable-code-coverage"];
-        }
-
-        testBuildConfig.args = [...testBuildConfig.args, ...additionalArgs];
-        testBuildConfig.terminal = "console";
-        return testBuildConfig;
-    }
-}
-
 /** Interface defining how to find test items given a test id from XCTest output */
 interface TestItemFinder {
     getIndex(id: string, filename?: string): number;