Refactor unit tests to use shared vscode mock and clean up test setup:

sharma1208 · sharma1208 · commit 93196486cd03 · 2026-07-07T10:53:12.000-05:00
- Extracted shared fakeVscode.ts with installFakeVscode()

- Remove TS_NODE_COMPILER_OPTIONS from test-unit script in package.json since tsconfig.json already specifies module: commonjs
- Simplify addUserSelectedPath Test 1 — remove unnecessary existsSyncStub
  and readFileStub wrappers since createLibertyProject is fully replaced
  with a fake and no real file I/O occurs
diff --git a/package.json b/package.json
@@ -254,7 +254,7 @@
 		"test": "npm run test-compile && extest setup-and-run -o .vscode/settings.json 'out/test/*.js' --code_settings src/test/resources/settings.json",
 		"test-maven": "npm run test-compile && extest setup-and-run -o .vscode/settings.json 'out/test/M*.js' --code_settings src/test/resources/settings.json",
 		"test-gradle": "npm run test-compile && extest setup-and-run -o .vscode/settings.json 'out/test/G*.js' --code_settings src/test/resources/settings.json",
-		"test-unit": "TS_NODE_COMPILER_OPTIONS='{\"module\":\"commonjs\"}' node --require ts-node/register node_modules/.bin/mocha --config .mocharc.unit.yml"
+		"test-unit": "node node_modules/.bin/mocha --config .mocharc.unit.yml"
 	},
 	"devDependencies": {
 		"@types/chai": "4.3.4",
diff --git a/src/test/unit/addProjectsToTheDashBoard.test.ts b/src/test/unit/addProjectsToTheDashBoard.test.ts
@@ -4,75 +4,28 @@
  */
 
 // This test runs in plain Node, not inside a real VS Code window.
-// The extension's localization helper expects this env var to exist during import.
-process.env.VSCODE_NLS_CONFIG = JSON.stringify({ locale: "en" });
-
-// Intercept module loading so we can replace VS Code and localization imports
-// with tiny fakes that are easy to reason about in a unit test.
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const Module = require("module");
-const originalLoad = Module._load;
-
-// Fake localization helper.
-// Instead of reading translation files, return a predictable string that includes:
-//   1. the message key the command asked for
-//   2. the selected project path passed into localize()
-// Example result: "add.project.manually.message.0:/my/project"
-const localizeStub = (key: string, selection: string) => `${key}:${selection}`;
-
-// Return a tiny fake module whenever production code imports "vscode" or the i18n helper.
-// devCommands.ts imports libertyProject.ts, and that file defines classes that extend
-// vscode.TreeItem and create vscode.EventEmitter instances. So this fake must include
-// enough of the VS Code API for those imports to load successfully.
-Module._load = function(request: string, ...args: any[]) {
-    if (request === "vscode") {
-        return {
-            EventEmitter: class { event = () => {}; fire() {} },
-            TreeItemCollapsibleState: { None: 0 },
-            TreeItem: class {
-                label: string;
-                collapsibleState: number;
-                tooltip?: string;
-                constructor(label: string, collapsibleState?: number) {
-                    this.label = label;
-                    this.collapsibleState = collapsibleState ?? 0;
-                }
-            },
-            Uri: { file: (p: string) => ({ fsPath: p }) },
-            window: {
-                showInformationMessage: showInformationMessageStub,
-                setStatusBarMessage: () => ({ dispose() {} })
-            }
-        };
-    }
-    if (request.endsWith("/util/i18nUtil") || request === "../util/i18nUtil") {
-        return {
-            localize: localizeStub
-        };
-    }
-    return originalLoad.call(this, request, ...args);
-};
-
-import * as assert from "assert";
+import { installFakeVscode } from "./fakeVscode";
 import * as sinon from "sinon";
 
-// Keep one shared reference to the fake VS Code message API.
-// The fake vscode module below returns this same stub, so each test can inspect
-// whether addProjectsToTheDashBoard() asked VS Code to show the expected message.
+// Keep one shared reference to the fake VS Code message API so each test can
+// inspect whether addProjectsToTheDashBoard() asked VS Code to show the right message.
 const showInformationMessageStub = sinon.stub();
 
+// Install the shared vscode fake, must happen before any extension imports.
+// Pass our sinon stub so the fake window.showInformationMessage is observable.
+installFakeVscode({ showInformationMessage: showInformationMessageStub });
+
+import * as assert from "assert";
 import { addProjectsToTheDashBoard } from "../../liberty/devCommands";
 
 describe("addProjectsToTheDashBoard", () => {
 
     afterEach(() => {
-        // Reset call history on the shared message stub between tests.
         showInformationMessageStub.resetHistory();
-        // Restore console stubs so each test starts clean.
         sinon.restore();
     });
 
-    // Run the same command-wrapper test for all 3 return codes from addUserSelectedPath():
+    // Run the same wrapper test for all 3 return codes from addUserSelectedPath():
     //   0 = added successfully
     //   1 = project already exists
     //   2 = not a Maven or Gradle project
@@ -82,42 +35,23 @@ describe("addProjectsToTheDashBoard", () => {
         { result: 2, expectedMessage: "add.project.manually.message.2:/my/project" }
     ].forEach(({ result, expectedMessage }) => {
         it(`shows the expected message and refreshes the dashboard when addUserSelectedPath returns ${result}`, async () => {
-            // Pretend the lower-level worker method already finished and returned this result.
-            // This keeps the test focused on the command wrapper behavior only.
             const addUserSelectedPathStub = sinon.stub().resolves(result);
-
-            // addProjectsToTheDashBoard() passes projectProvider.getProjects() into addUserSelectedPath().
-            // Return an empty map because the command wrapper does not care about its contents here.
             const getProjectsStub = sinon.stub().returns(new Map());
-
-            // The command should tell the dashboard tree to refresh after it handles the result.
             const fireChangeEventStub = sinon.stub();
-
-            // The command logs success with console.info() and non-success with console.error().
             const consoleInfoStub = sinon.stub(console, "info");
             const consoleErrorStub = sinon.stub(console, "error");
 
-            // Fake ProjectProvider with only the methods addProjectsToTheDashBoard() actually calls.
             const projectProvider = {
                 addUserSelectedPath: addUserSelectedPathStub,
                 getProjects: getProjectsStub,
                 fireChangeEvent: fireChangeEventStub
             } as any;
 
-            // Call the real command wrapper under test.
             await addProjectsToTheDashBoard(projectProvider, "/my/project");
 
-            // ASSERT: the command should pass the selected path and live projects map
-            // into addUserSelectedPath().
             assert.equal(addUserSelectedPathStub.calledOnceWithExactly("/my/project", getProjectsStub.firstCall.returnValue), true);
-
-            // ASSERT: the dashboard should be refreshed after the add attempt.
             assert.equal(fireChangeEventStub.calledOnce, true);
-
-            // ASSERT: the user should see the message built from the result code.
             assert.equal(showInformationMessageStub.calledOnceWithExactly(expectedMessage), true);
-
-            // ASSERT: success logs to console.info(); non-success logs to console.error().
             assert.equal(result === 0 ? consoleInfoStub.calledOnceWithExactly(expectedMessage) : consoleErrorStub.calledOnceWithExactly(expectedMessage), true);
         });
     });
diff --git a/src/test/unit/addUserSelectedPath.test.ts b/src/test/unit/addUserSelectedPath.test.ts
@@ -4,50 +4,26 @@
  */
 
 // This test runs in plain Node, not inside a real VS Code window.
-// Set the minimum localization config early so extension imports do not crash.
-process.env.VSCODE_NLS_CONFIG = JSON.stringify({ locale: "en" });
-
-// When production code imports "vscode", return a tiny fake object instead.
-// We only provide the pieces ProjectProvider touches during this test.
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const Module = require("module");
-const originalLoad = Module._load;
-Module._load = function(request: string, ...args: any[]) {
-    if (request === "vscode") {
-        return {
-            // ProjectProvider creates an EventEmitter in its constructor.
-            EventEmitter: class { event = () => {}; fire() {} },
-            TreeItemCollapsibleState: { None: 0 },
-            TreeItem: class { constructor(label: string) { (this as any).label = label; } },
-            Uri: { file: (p: string) => ({ fsPath: p }) },
-            // refresh() temporarily shows a status bar message and later disposes it.
-            window: {
-                setStatusBarMessage: () => ({ dispose() {} })
-            }
-        };
-    }
-    return originalLoad.call(this, request, ...args);
-};
+import { installFakeVscode } from "./fakeVscode";
+import * as sinon from "sinon";
 
+// Install the shared vscode fake — must happen before any extension imports.
+installFakeVscode();
 
 import * as assert from "assert";
-import * as sinon from "sinon";
-
 import { ProjectProvider } from "../../liberty/libertyProject";
 import { DashboardData } from "../../liberty/dashboard";
 
 // Fake ExtensionContext for ProjectProvider.
-// addUserSelectedPath() reads saved dashboard data from workspaceState and saves updates back to it.
+// addUserSelectedPath() reads saved dashboard data from workspaceState and saves updates back.
 const fakeContext: any = {
     workspaceState: {
-        // Start with empty stored dashboard data.
         get: () => new DashboardData([], []),
-        // Stubbed so each test can check whether a save happened.
         update: sinon.stub()
     },
     globalState: {
         get: () => undefined,
-        update: sinon.stub(),
+        update: sinon.stub()
     }
 };
 
@@ -56,112 +32,59 @@ describe("addUserSelectedPath", () => {
     let provider: ProjectProvider;
 
     before(() => {
-        // Create the real ProjectProvider instance that owns addUserSelectedPath().
         provider = new ProjectProvider(fakeContext);
     });
 
     afterEach(() => {
-        // Reset Sinon-created stubs so one test's fake behavior does not leak into another.
         sinon.restore();
     });
 
     // ─── Test 1 ───────────────────────────────────────────────────────────────
-    // Scenario: the user manually picks a Maven project that is not already in the dashboard.
-    // The add should succeed, update the live project map, and save the change.
+    // Scenario: the user manually picks a Maven project not already in the dashboard.
     it("returns 0 and adds project to map when valid pom.xml exists", async () => {
+        (provider as any).createLibertyProject = async () => ({
+            getPath: () => "/my/project/pom.xml",
+            getLabel: () => "my-app",
+            getContextValue: () => "libertyMavenProject"
+        });
 
-        // These two stubs model the successful Maven path inside createLibertyProject().
-        // existsSyncStub() means "pretend pom.xml exists".
-        const existsSyncStub = sinon.stub().returns(true);
-        // readFileStub() means "pretend reading pom.xml returned this XML".
-        const readFileStub = sinon.stub().resolves(`<project><artifactId>my-app</artifactId></project>`);
-
-        // Replace ProjectProvider's internal createLibertyProject() helper for this test only.
-        // That keeps the test focused on addUserSelectedPath(): when project creation succeeds,
-        // does it add the project, save it, and return the success code?
-        (provider as any).createLibertyProject = async () => {
-            if (existsSyncStub()) {
-                await readFileStub();
-                // Return the smallest fake project object addUserSelectedPath() needs.
-                return {
-                    getPath: () => "/my/project/pom.xml",
-                    getLabel: () => "my-app",
-                    getContextValue: () => "libertyMavenProject"
-                };
-            }
-            // If project creation fails, the real helper would return undefined.
-            return undefined;
-        };
-
-        // This map represents the live set of projects currently shown in the Liberty dashboard.
-        // Start empty to model "project was not already in the dashboard".
         const existingProjects = new Map();
-
-        // Call the real method under test.
         const result = await provider.addUserSelectedPath("/my/project", existingProjects);
 
-        // ASSERT
-        // 0 means the manual add succeeded.
         assert.equal(result, 0);
-        // The project should now appear in the live dashboard map.
         assert.equal(existingProjects.has("/my/project/pom.xml"), true);
-        // The dashboard update should also be persisted to workspace storage.
         assert.equal(fakeContext.workspaceState.update.called, true);
     });
 
     // ─── Test 2 ───────────────────────────────────────────────────────────────
     // Scenario: the user picks a folder that is already in the Liberty dashboard.
-    // addUserSelectedPath() should detect the duplicate and refuse to add it again.
     it("returns 1 and adds nothing when project already exists", async () => {
-
-        // Clear any save calls left over from earlier tests.
         fakeContext.workspaceState.update.resetHistory();
 
-        // provider.getProjects() is the provider's internal "already in the dashboard" map.
-        // Put this path in the map first to simulate a project that Liberty Tools already knows about.
         const dashboardProjects = provider.getProjects();
         dashboardProjects.set("/my/project/pom.xml", {} as any);
 
-        // This separate map is the live map passed into addUserSelectedPath().
-        // It starts empty because this test is checking that nothing new gets added.
         const existingProjects = new Map();
-
-        // Try to manually add the same project again.
         const result = await provider.addUserSelectedPath("/my/project", existingProjects);
 
-        // ASSERT
-        // 1 means "project already exists".
         assert.equal(result, 1);
-
-        // Because the project was a duplicate, addUserSelectedPath() should not add anything new.
         assert.equal(existingProjects.size, 0);
-
-        // Because nothing changed, it should not save anything to workspace storage.
         assert.equal(fakeContext.workspaceState.update.called, false);
 
-        // Clean up the provider's internal dashboard map so other tests stay isolated.
         dashboardProjects.clear();
     });
 
     // ─── Test 3 ───────────────────────────────────────────────────────────────
-    // Scenario: the user picks a folder that is not a Maven or Gradle project.
-    // The add should fail without changing dashboard state.
+    // Scenario: the user picks a folder with no pom.xml or build.gradle.
     it("returns 2 and adds nothing when no build file exists", async () => {
-
-        // Clear any save calls recorded by earlier tests.
         fakeContext.workspaceState.update.resetHistory();
-        // Force project creation to fail to model a folder with no pom.xml or build.gradle.
         (provider as any).createLibertyProject = async () => undefined;
-    
+
         const existingProjects = new Map();
         const result = await provider.addUserSelectedPath("/my/project", existingProjects);
 
-        // ASSERT
-        // 2 means the selected folder is not a Maven or Gradle project.
         assert.equal(result, 2);
-        // Nothing should be added to the live dashboard map.
         assert.equal(existingProjects.size, 0);
-        // Nothing should be saved because the add failed.
         assert.equal(fakeContext.workspaceState.update.called, false);
     });
 
diff --git a/src/test/unit/fakeVscode.ts b/src/test/unit/fakeVscode.ts
@@ -0,0 +1,74 @@
+/*
+ * IBM Confidential
+ * Copyright IBM Corp. 2026
+ */
+
+/**
+ * Shared VS Code API fake for unit tests that run in plain Node (no VS Code window).
+ *
+ * Import this file before any extension code. It sets the NLS config env var,
+ * installs Module._load hooks for "vscode" and the i18n helper, and returns
+ * a mutable fake object tests can inspect and mutate.
+ */
+
+// The extension's localization helper reads this env var on import.
+// Set it before any extension module loads.
+process.env.VSCODE_NLS_CONFIG = JSON.stringify({ locale: "en" });
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const Module = require("module");
+const originalLoad = Module._load;
+
+export interface FakeVscode {
+    EventEmitter: any;
+    TreeItemCollapsibleState: { None: number };
+    TreeItem: any;
+    Uri: { file: (p: string) => { fsPath: string } };
+    window: {
+        showInformationMessage: (...args: any[]) => any;
+        setStatusBarMessage: () => { dispose(): void };
+    };
+    workspace: {
+        workspaceFolders: any;
+        name: any;
+    };
+}
+
+export function installFakeVscode(windowOverrides: Partial<FakeVscode["window"]> = {}): FakeVscode {
+    const fakeVscode: FakeVscode = {
+        EventEmitter: class { event = () => {}; fire() {} },
+        TreeItemCollapsibleState: { None: 0 },
+        TreeItem: class {
+            label: string;
+            collapsibleState: number;
+            constructor(label: string, collapsibleState = 0) {
+                this.label = label;
+                this.collapsibleState = collapsibleState;
+            }
+        },
+        Uri: { file: (p: string) => ({ fsPath: p }) },
+        window: {
+            showInformationMessage: () => {},
+            setStatusBarMessage: () => ({ dispose() {} }),
+            ...windowOverrides
+        },
+        workspace: {
+            workspaceFolders: undefined,
+            name: undefined
+        }
+    };
+
+    Module._load = function(request: string, ...args: any[]) {
+        if (request === "vscode") {
+            return fakeVscode;
+        }
+        // Stub the i18n helper so tests get a predictable "<key>:<arg>" string
+        // instead of crashing when NLS translation files are not available in plain Node.
+        if (request.endsWith("/util/i18nUtil") || request === "../util/i18nUtil") {
+            return { localize: (key: string, ...args2: any[]) => [key, ...args2].join(":") };
+        }
+        return originalLoad.call(this, request, ...args);
+    };
+
+    return fakeVscode;
+}
