Add a chai plugin to check for path equality (#1950)

matthewbastien · web-flow · commit 5e18396f167f · 2025-12-01T14:51:12.000-05:00
diff --git a/.github/workflows/pull_request.yml b/.github/workflows/pull_request.yml
@@ -64,7 +64,7 @@ jobs:
       linux_pre_build_command: . .github/workflows/scripts/setup-linux.sh
       linux_build_command: ./scripts/test.sh
       # Windows
-      windows_exclude_swift_versions: "${{ contains(github.event.pull_request.labels.*.name, 'full-test-run') && '[{\"swift_version\": \"nightly-6.1\"},{\"swift_version\": \"nightly\"}]' || '[{\"swift_version\": \"nightly-6.1\"},{\"swift_version\": \"nightly-6.2\"},{\"swift_version\": \"nightly\"}]' }}"
+      windows_exclude_swift_versions: "${{ contains(github.event.pull_request.labels.*.name, 'full-test-run') && '[{\"swift_version\": \"nightly-6.1\"},{\"swift_version\": \"nightly\", {\"swift_version\": \"6.2\"}}]' || '[{\"swift_version\": \"nightly-6.1\"},{\"swift_version\": \"nightly-6.2\"},{\"swift_version\": \"nightly\"}]' }}"
       windows_env_vars: |
         CI=1
         FAST_TEST_RUN=${{ contains(github.event.pull_request.labels.*.name, 'full-test-run') && '0' || '1'}}
diff --git a/test/chai-path-plugin.ts b/test/chai-path-plugin.ts
@@ -0,0 +1,96 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the VS Code Swift open source project
+//
+// Copyright (c) 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 path from "path";
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    namespace Chai {
+        interface Assertion {
+            /**
+             * Asserts that the object equals the expected path.
+             *
+             * This assertion will convert both paths to the same file separator and then
+             * compare them to ensure consistent behavior on all platforms.
+             *
+             * @param expected The expected path string.
+             */
+            equalPath(expected: string): Assertion;
+
+            /**
+             * Asserts that the object equals the expected path.
+             *
+             * This assertion will convert both paths to the same file separator and then
+             * compare them to ensure consistent behavior on all platforms.
+             *
+             * @param expected The expected path string.
+             */
+            equalsPath(expected: string): Assertion;
+        }
+
+        interface PromisedAssertion {
+            /**
+             * Asserts that the object equals the expected path.
+             *
+             * This assertion will convert both paths to the same file separator and then
+             * compare them to ensure consistent behavior on all platforms.
+             *
+             * @param expected The expected path string.
+             */
+            equalPath(expected: string): PromisedAssertion;
+
+            /**
+             * Asserts that the object equals the expected path.
+             *
+             * This assertion will convert both paths to the same file separator and then
+             * compare them to ensure consistent behavior on all platforms.
+             *
+             * @param expected The expected path string.
+             */
+            equalsPath(expected: string): PromisedAssertion;
+        }
+    }
+}
+
+export function chaiPathPlugin(chai: Chai.ChaiStatic, _utils: Chai.ChaiUtils): void {
+    function assertPath(this: Chai.AssertionStatic, expected: string): void {
+        const obj = this._obj;
+        // First make sure the object is a string.
+        new chai.Assertion(obj).to.be.a.string;
+        // Then check for path equality.
+        const expectedNormalized = normalizePath(expected);
+        const objNormalized = normalizePath(obj);
+        this.assert(
+            objNormalized === expectedNormalized,
+            `expected path "${objNormalized}" to equal "${expectedNormalized}"`,
+            `expected path "${objNormalized}" to not equal "${expectedNormalized}"`,
+            expectedNormalized,
+            objNormalized
+        );
+    }
+
+    chai.Assertion.addMethod("equalPath", assertPath);
+    chai.Assertion.addMethod("equalsPath", assertPath);
+}
+
+function normalizePath(input: string): string {
+    return normalizeWindowsDriveLetter(path.resolve(input));
+}
+
+function normalizeWindowsDriveLetter(input: string): string {
+    if (process.platform !== "win32") {
+        return input;
+    }
+    const root = path.parse(input).root;
+    return root.toLocaleUpperCase() + input.slice(root.length);
+}
diff --git a/test/common.ts b/test/common.ts
@@ -21,6 +21,7 @@ import * as sinonChai from "sinon-chai";
 import * as sourceMapSupport from "source-map-support";
 import * as tsConfigPaths from "tsconfig-paths";
 
+import { chaiPathPlugin } from "./chai-path-plugin";
 import { installTagSupport } from "./tags";
 
 // Use source-map-support to get better stack traces.
@@ -48,8 +49,11 @@ tsConfigPaths.register({
     paths: tsConfig.compilerOptions.paths,
 });
 
+// Install chai plugins
 chai.use(sinonChai);
-chai.use(chaiAsPromised);
 chai.use(chaiSubset);
+chai.use(chaiPathPlugin);
+// chai-as-promised must always be installed last!
+chai.use(chaiAsPromised);
 
 installTagSupport();
diff --git a/test/integration-tests/SwiftSnippet.test.ts b/test/integration-tests/SwiftSnippet.test.ts
@@ -78,7 +78,7 @@ tag("large").suite("SwiftSnippet Test Suite", function () {
 
         expect(succeeded).to.be.true;
         const session = await sessionPromise;
-        expect(vscode.Uri.file(session.configuration.program).fsPath).to.equal(
+        expect(session.configuration.program).to.equalPath(
             realpathSync(
                 testAssetUri(
                     "defaultPackage/.build/debug/hello" +
@@ -118,7 +118,7 @@ tag("large").suite("SwiftSnippet Test Suite", function () {
         expect(succeeded).to.be.true;
 
         const session = await sessionPromise;
-        expect(vscode.Uri.file(session.configuration.program).fsPath).to.equal(
+        expect(session.configuration.program).to.equalPath(
             realpathSync(
                 testAssetUri(
                     "defaultPackage/.build/debug/hello" +
diff --git a/test/integration-tests/ui/ProjectPanelProvider.test.ts b/test/integration-tests/ui/ProjectPanelProvider.test.ts
@@ -313,9 +313,8 @@ tag("medium").suite("ProjectPanelProvider Test Suite", function () {
             const dep = items.find(n => n.name === "swift-markdown") as PackageNode;
             expect(dep, `${JSON.stringify(items, null, 2)}`).to.not.be.undefined;
             expect(dep?.location).to.equal("https://github.com/swiftlang/swift-markdown.git");
-            assertPathsEqual(
-                dep?.path,
-                path.join(testAssetPath("targets"), ".build/checkouts/swift-markdown")
+            expect(dep?.path).to.equalPath(
+                testAssetPath("targets/.build/checkouts/swift-markdown")
             );
         });
 
@@ -326,8 +325,8 @@ tag("medium").suite("ProjectPanelProvider Test Suite", function () {
                 dep,
                 `Expected to find defaultPackage, but instead items were ${items.map(n => n.name)}`
             ).to.not.be.undefined;
-            assertPathsEqual(dep?.location, testAssetPath("defaultPackage"));
-            assertPathsEqual(dep?.path, testAssetPath("defaultPackage"));
+            expect(dep?.location).to.equalPath(testAssetPath("defaultPackage"));
+            expect(dep?.path).to.equalPath(testAssetPath("defaultPackage"));
         });
 
         test("Lists local dependency file structure", async () => {
@@ -343,24 +342,22 @@ tag("medium").suite("ProjectPanelProvider Test Suite", function () {
             const folder = folders.find(n => n.name === "Sources") as FileNode;
             expect(folder).to.not.be.undefined;
 
-            assertPathsEqual(folder?.path, path.join(testAssetPath("defaultPackage"), "Sources"));
+            expect(folder?.path).to.equalPath(testAssetPath("defaultPackage/Sources"));
 
             const childFolders = await treeProvider.getChildren(folder);
             const childFolder = childFolders.find(n => n.name === "PackageExe") as FileNode;
             expect(childFolder).to.not.be.undefined;
 
-            assertPathsEqual(
-                childFolder?.path,
-                path.join(testAssetPath("defaultPackage"), "Sources/PackageExe")
+            expect(childFolder?.path).to.equalPath(
+                testAssetPath("defaultPackage/Sources/PackageExe")
             );
 
             const files = await treeProvider.getChildren(childFolder);
             const file = files.find(n => n.name === "main.swift") as FileNode;
             expect(file).to.not.be.undefined;
 
-            assertPathsEqual(
-                file?.path,
-                path.join(testAssetPath("defaultPackage"), "Sources/PackageExe/main.swift")
+            expect(file?.path).to.equalPath(
+                testAssetPath("defaultPackage/Sources/PackageExe/main.swift")
             );
         });
 
@@ -375,19 +372,19 @@ tag("medium").suite("ProjectPanelProvider Test Suite", function () {
             expect(folder).to.not.be.undefined;
 
             const depPath = path.join(testAssetPath("targets"), ".build/checkouts/swift-markdown");
-            assertPathsEqual(folder?.path, path.join(depPath, "Sources"));
+            expect(folder?.path).to.equalPath(path.join(depPath, "Sources"));
 
             const childFolders = await treeProvider.getChildren(folder);
             const childFolder = childFolders.find(n => n.name === "CAtomic") as FileNode;
             expect(childFolder).to.not.be.undefined;
 
-            assertPathsEqual(childFolder?.path, path.join(depPath, "Sources/CAtomic"));
+            expect(childFolder?.path).to.equalPath(path.join(depPath, "Sources/CAtomic"));
 
             const files = await treeProvider.getChildren(childFolder);
             const file = files.find(n => n.name === "CAtomic.c") as FileNode;
             expect(file).to.not.be.undefined;
 
-            assertPathsEqual(file?.path, path.join(depPath, "Sources/CAtomic/CAtomic.c"));
+            expect(file?.path).to.equalPath(path.join(depPath, "Sources/CAtomic/CAtomic.c"));
         });
 
         test("Shows a flat dependency list", async () => {
@@ -501,11 +498,4 @@ tag("medium").suite("ProjectPanelProvider Test Suite", function () {
             throw error;
         }
     }
-
-    function assertPathsEqual(path1: string | undefined, path2: string | undefined) {
-        expect(path1).to.not.be.undefined;
-        expect(path2).to.not.be.undefined;
-        // Convert to vscode.Uri to normalize paths, including drive letter capitalization on Windows.
-        expect(vscode.Uri.file(path1!).fsPath).to.equal(vscode.Uri.file(path2!).fsPath);
-    }
 });
diff --git a/test/unit-tests/debugger/debugAdapterFactory.test.ts b/test/unit-tests/debugger/debugAdapterFactory.test.ts
@@ -13,7 +13,6 @@
 //===----------------------------------------------------------------------===//
 import { expect } from "chai";
 import * as mockFS from "mock-fs";
-import * as path from "path";
 import * as vscode from "vscode";
 
 import { FolderContext } from "@src/FolderContext";
@@ -173,10 +172,11 @@ suite("LLDBDebugConfigurationProvider Tests", () => {
                 target: "executable",
             }
         );
-        expect(launchConfig).to.have.property(
-            "program",
-            path.normalize("/path/to/swift-executable/.build/arm64-apple-macosx/debug/executable")
-        );
+        expect(launchConfig)
+            .to.have.property("program")
+            .that.equalsPath(
+                "/path/to/swift-executable/.build/arm64-apple-macosx/debug/executable"
+            );
     });
 
     suite("CodeLLDB selected in settings", () => {
diff --git a/test/unit-tests/tasks/SwiftPluginTaskProvider.test.ts b/test/unit-tests/tasks/SwiftPluginTaskProvider.test.ts
@@ -12,8 +12,8 @@
 //
 //===----------------------------------------------------------------------===//
 import * as assert from "assert";
+import { expect } from "chai";
 import * as os from "os";
-import * as path from "path";
 import { match } from "sinon";
 import * as vscode from "vscode";
 
@@ -122,7 +122,7 @@ suite("SwiftPluginTaskProvider Unit Test Suite", () => {
                 new vscode.CancellationTokenSource().token
             );
             const swiftExecution = resolvedTask.execution as SwiftExecution;
-            assert.equal(swiftExecution.options.cwd, `${workspaceFolder.uri.fsPath}/myCWD`);
+            expect(swiftExecution.options.cwd).to.equalPath(`${workspaceFolder.uri.fsPath}/myCWD`);
         });
 
         test("includes scope cwd", async () => {
@@ -141,7 +141,7 @@ suite("SwiftPluginTaskProvider Unit Test Suite", () => {
                 new vscode.CancellationTokenSource().token
             );
             const swiftExecution = resolvedTask.execution as SwiftExecution;
-            assert.equal(swiftExecution.options.cwd, workspaceFolder.uri.fsPath);
+            expect(swiftExecution.options.cwd).to.equalPath(workspaceFolder.uri.fsPath);
         });
 
         test("includes resolved cwd", async () => {
@@ -161,10 +161,7 @@ suite("SwiftPluginTaskProvider Unit Test Suite", () => {
                 new vscode.CancellationTokenSource().token
             );
             const swiftExecution = resolvedTask.execution as SwiftExecution;
-            assert.equal(
-                swiftExecution.options.cwd,
-                path.normalize(`${workspaceFolder.uri.fsPath}/myCWD`)
-            );
+            expect(swiftExecution.options.cwd).to.equalPath(`${workspaceFolder.uri.fsPath}/myCWD`);
         });
 
         test("includes fallback cwd", async () => {
diff --git a/test/unit-tests/tasks/SwiftTaskProvider.test.ts b/test/unit-tests/tasks/SwiftTaskProvider.test.ts
@@ -12,6 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 import * as assert from "assert";
+import { expect } from "chai";
 import * as os from "os";
 import { match } from "sinon";
 import * as vscode from "vscode";
@@ -379,7 +380,9 @@ suite("SwiftTaskProvider Unit Test Suite", () => {
                     new vscode.CancellationTokenSource().token
                 );
                 const swiftExecution = resolvedTask.execution as SwiftExecution;
-                assert.equal(swiftExecution.options.cwd, `${workspaceFolder.uri.fsPath}/macos`);
+                expect(swiftExecution.options.cwd).to.equalPath(
+                    `${workspaceFolder.uri.fsPath}/macos`
+                );
             });
 
             test("includes linux cwd", () => {
@@ -403,7 +406,9 @@ suite("SwiftTaskProvider Unit Test Suite", () => {
                     new vscode.CancellationTokenSource().token
                 );
                 const swiftExecution = resolvedTask.execution as SwiftExecution;
-                assert.equal(swiftExecution.options.cwd, `${workspaceFolder.uri.fsPath}/linux`);
+                expect(swiftExecution.options.cwd).to.equalPath(
+                    `${workspaceFolder.uri.fsPath}/linux`
+                );
             });
 
             test("includes windows cwd", () => {
@@ -427,7 +432,9 @@ suite("SwiftTaskProvider Unit Test Suite", () => {
                     new vscode.CancellationTokenSource().token
                 );
                 const swiftExecution = resolvedTask.execution as SwiftExecution;
-                assert.equal(swiftExecution.options.cwd, `${workspaceFolder.uri.fsPath}/windows`);
+                expect(swiftExecution.options.cwd).to.equalPath(
+                    `${workspaceFolder.uri.fsPath}/windows`
+                );
             });
 
             test("fallback default cwd", () => {
@@ -451,7 +458,7 @@ suite("SwiftTaskProvider Unit Test Suite", () => {
                     new vscode.CancellationTokenSource().token
                 );
                 const swiftExecution = resolvedTask.execution as SwiftExecution;
-                assert.equal(swiftExecution.options.cwd, workspaceFolder.uri.fsPath);
+                expect(swiftExecution.options.cwd).to.equalPath(workspaceFolder.uri.fsPath);
             });
         });
 
diff --git a/test/unit-tests/toolchain/BuildFlags.test.ts b/test/unit-tests/toolchain/BuildFlags.test.ts
diff --git a/test/unit-tests/toolchain/toolchain.test.ts b/test/unit-tests/toolchain/toolchain.test.ts
diff --git a/test/unit-tests/ui/PackageDependencyProvider.test.ts b/test/unit-tests/ui/PackageDependencyProvider.test.ts
diff --git a/test/unit-tests/utilities/filesystem.test.ts b/test/unit-tests/utilities/filesystem.test.ts
