tests(ssh): expand coverage for edge cases

Signed-off-by: Trae Yelovich <trae.yelovich@broadcom.com>

Author: traeok

packages/zowex-for-zowe-explorer/tests/NativeSshHelper.test.ts

@@ -184,5 +184,85 @@ describe("NativeSshHelper", () => {
             expect(fetchMock).toHaveBeenCalledTimes(1);
             expect(String(fetchMock.mock.calls[0][0])).toContain("linux-arm-gnueabihf");
         });
+
+        it.each([
+            ["win32", "arm64", "win32-arm64-msvc"],
+            ["darwin", "x64", "darwin-x64"],
+            ["linux", "x64", "linux-x64-gnu"],
+            ["linux", "arm64", "linux-arm64-gnu"],
+        ])("should resolve the %s-%s triple (%s) when downloading", async (platform, arch, triple) => {
+            setPlatform(platform, arch);
+            vi.spyOn(fs, "existsSync").mockReturnValue(false);
+            vi.spyOn(fs, "writeFileSync").mockImplementation(() => undefined as never);
+            vi.spyOn(fs, "mkdirSync").mockImplementation(() => undefined as never);
+
+            handleNativeSshSettings(fakeContext);
+            await flush();
+
+            expect(fetchMock).toHaveBeenCalledTimes(1);
+            expect(String(fetchMock.mock.calls[0][0])).toContain(triple);
+        });
+
+        it("should warn when the platform is supported but the architecture is not (arch lookup misses)", async () => {
+            // Exercises the `NATIVE_TRIPLES[platform]?.[arch]` arch-miss branch (distinct from an
+            // entirely unknown platform): win32 is known, but "mips" has no entry.
+            setPlatform("win32", "mips");
+            const warnSpy = vi.spyOn(vscode.window, "showWarningMessage").mockReturnValue(undefined);
+            vi.spyOn(fs, "existsSync").mockReturnValue(false);
+
+            handleNativeSshSettings(fakeContext);
+            await flush();
+
+            expect(warnSpy).toHaveBeenCalledTimes(1);
+            expect(String(warnSpy.mock.calls[0][0])).toContain("No native SSH binary available for win32-mips");
+            expect(fetchMock).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("ensureNativeBinary timeout handling", () => {
+        beforeEach(() => {
+            mockFlag(true);
+            vi.spyOn(imperative.Logger, "getAppLogger").mockReturnValue({ info: vi.fn(), error: vi.fn() } as any);
+            setPlatform("darwin", "arm64");
+            vi.spyOn(fs, "existsSync").mockReturnValue(false);
+            vi.spyOn(fs, "writeFileSync").mockImplementation(() => undefined as never);
+            vi.spyOn(fs, "mkdirSync").mockImplementation(() => undefined as never);
+        });
+
+        it("should clear the abort timeout after a successful fetch", async () => {
+            fetchMock.mockResolvedValue({ ok: true, status: 200, arrayBuffer: () => Promise.resolve(new ArrayBuffer(4)) });
+            const clearTimeoutSpy = vi.spyOn(globalThis, "clearTimeout");
+
+            handleNativeSshSettings(fakeContext);
+            await flush();
+
+            // The `finally { clearTimeout(timeoutId) }` arm must run on the success path.
+            expect(clearTimeoutSpy).toHaveBeenCalled();
+        });
+
+        it("should abort the request and surface an error when the timeout elapses", async () => {
+            vi.useFakeTimers();
+            try {
+                const abortSpy = vi.spyOn(AbortController.prototype, "abort");
+                // fetch only settles when its AbortSignal fires, so advancing the timer triggers the reject.
+                fetchMock.mockImplementation(
+                    (_url: string, opts: { signal: AbortSignal }) =>
+                        new Promise((_resolve, reject) => {
+                            opts.signal.addEventListener("abort", () => reject(new Error("The operation was aborted")));
+                        })
+                );
+                const errorSpy = vi.spyOn(vscode.window, "showErrorMessage").mockReturnValue(undefined);
+
+                handleNativeSshSettings(fakeContext);
+                // SSH_TIMEOUT is 60_000ms; advancing past it fires the controller.abort() callback.
+                await vi.advanceTimersByTimeAsync(60_000);
+
+                expect(abortSpy).toHaveBeenCalled();
+                expect(errorSpy).toHaveBeenCalledTimes(1);
+                expect(String(errorSpy.mock.calls[0][0])).toContain("Failed to download native SSH binary");
+            } finally {
+                vi.useRealTimers();
+            }
+        });
     });
 });

packages/zowex-for-zowe-explorer/tests/SSHClientCache.test.ts

@@ -18,8 +18,15 @@ import { deployWithProgress } from "../src/ServerDeployment";
 
 vi.mock("@zowe/zowe-explorer-api", () => {
     class MockDeferredPromise {
-        promise = Promise.resolve();
-        resolve = vi.fn();
+        public promise: Promise<unknown>;
+        public resolve!: (value?: unknown) => void;
+        public reject!: (reason?: unknown) => void;
+        constructor() {
+            this.promise = new Promise((resolve, reject) => {
+                this.resolve = resolve;
+                this.reject = reject;
+            });
+        }
     }
     return {
         Gui: {},
@@ -290,6 +297,45 @@ describe("SshClientCache", () => {
             expect(endSpy).toHaveBeenCalledWith(clientId, { restart: true, retryRequests: true });
             expect(ZSshClient.create).toHaveBeenCalledTimes(2);
         });
+
+        it("should reuse the cached client on a second connect without restart (cache hit)", async () => {
+            const first = await cache.connect(mockProfile);
+            vi.mocked(ZSshClient.create).mockClear();
+
+            const second = await cache.connect(mockProfile);
+
+            // The second connect must short-circuit on the existing session-map entry, not rebuild.
+            expect(second).toBe(first);
+            expect(ZSshClient.create).not.toHaveBeenCalled();
+        });
+
+        it("should serialize overlapping connect() calls so exactly one client is built", async () => {
+            let releaseCreate!: (client: unknown) => void;
+            const createGate = new Promise((resolve) => {
+                releaseCreate = resolve;
+            });
+            const builtClient = { dispose: vi.fn(), collectAllRequests: vi.fn(), serverChecksums: {} };
+            vi.mocked(ZSshClient.create).mockReset();
+            vi.mocked(ZSshClient.create).mockReturnValueOnce(createGate as any);
+            vi.mocked(ZSshClient.create).mockResolvedValue(builtClient as any);
+
+            const firstConnect = cache.connect(mockProfile);
+            await Promise.resolve();
+            await Promise.resolve();
+            expect((cache as any).mMutexMap.has(clientId)).toBe(true);
+
+            const secondConnect = cache.connect(mockProfile);
+
+            releaseCreate(builtClient);
+            const [c1, c2] = await Promise.all([firstConnect, secondConnect]);
+
+            // Only the first build runs; the second observes the populated session map and reuses it.
+            expect(ZSshClient.create).toHaveBeenCalledTimes(1);
+            expect(c1).toBe(builtClient);
+            expect(c2).toBe(builtClient);
+            // The lock is released once the build completes.
+            expect((cache as any).mMutexMap.has(clientId)).toBe(false);
+        });
     });
 
     describe("end()", () => {

packages/zowex-for-zowe-explorer/tests/ServerDeployment.test.ts

@@ -82,5 +82,11 @@ describe("ServerDeployment", () => {
 
             expect(result).toEqual(false);
         });
+
+        it("should propagate a rejection from ZSshUtils.installServer", async () => {
+            vi.mocked(ZSshUtils.installServer).mockRejectedValue(new Error("install failed"));
+
+            await expect(deployWithProgress(fakeSession, "/server/path")).rejects.toThrow("install failed");
+        });
     });
 });

packages/zowex-for-zowe-explorer/tests/SshErrorCorrelations.test.ts

@@ -11,6 +11,7 @@
 
 import { ErrorCorrelator, ZoweExplorerApiType } from "@zowe/zowe-explorer-api";
 import { afterEach, beforeEach, describe, expect, it, type MockedFunction, vi } from "vitest";
+import { SshErrors } from "@zowe/zowex-for-zowe-sdk";
 import { registerSshErrorCorrelations } from "../src/SshErrorCorrelations";
 
 // Mock Zowe Explorer API
@@ -49,8 +50,8 @@ describe("SshErrorCorrelations", () => {
 
             expect(mockGetInstance).toHaveBeenCalled();
 
-            // Should register multiple correlations (connection failures, memory failures, filesystem errors, expired password)
-            expect(mockErrorCorrelator.addCorrelation).toHaveBeenCalledTimes(17); // 1 request timeout + 6 connection (incl. FOTS1668) + 4 memory + 6 filesystem
+            // One correlation per entry in the SDK's SshErrors map
+            expect(mockErrorCorrelator.addCorrelation).toHaveBeenCalledTimes(Object.keys(SshErrors).length);
         });
 
         it("should handle missing ErrorCorrelator gracefully", () => {
@@ -242,6 +243,50 @@ describe("SshErrorCorrelations", () => {
         });
     });
 
+    describe("request timeout & disk/password correlations", () => {
+        beforeEach(() => {
+            registerSshErrorCorrelations();
+        });
+
+        const findCorrelation = (code: string): any =>
+            (mockErrorCorrelator.addCorrelation as any).mock.calls.find((call: any) => call[2].errorCode === code)?.[2];
+
+        it("should register the REQUEST_TIMEOUT correlation with both string and RegExp matchers", () => {
+            const correlation = findCorrelation("REQUEST_TIMEOUT");
+
+            expect(correlation).toBeDefined();
+            expect(correlation.summary).toContain("exceeded the timeout limit");
+            expect(correlation.matches).toContain("Request timed out");
+            expect(correlation.matches).toEqual(expect.arrayContaining([expect.any(RegExp)]));
+            expect(correlation.tips.length).toBeGreaterThan(0);
+            // The timeout correlation intentionally ships without resource links.
+            expect(correlation.resources).toBeUndefined();
+        });
+
+        it("should register the FOTS1668 expired-password correlation", () => {
+            const correlation = findCorrelation("FOTS1668");
+
+            expect(correlation).toBeDefined();
+            expect(correlation.summary).toContain("password has expired");
+            expect(correlation.matches).toEqual(
+                expect.arrayContaining(["FOTS1668", "FOTS1669", "Your password has expired", "Password change required but no TTY available"])
+            );
+            expect(correlation.resources).toHaveLength(1);
+            expect(new URL(correlation.resources[0].href).host).toBe("www.ibm.com");
+        });
+
+        it("should register the EDC5133I out-of-space correlation", () => {
+            const correlation = findCorrelation("EDC5133I");
+
+            expect(correlation).toBeDefined();
+            expect(correlation.summary).toContain("no space left on the device");
+            expect(correlation.matches).toEqual(["EDC5133I"]);
+            expect(correlation.tips).toEqual(expect.arrayContaining([expect.stringContaining("free space")]));
+            // EDC5133I has no resource links.
+            expect(correlation.resources).toBeUndefined();
+        });
+    });
+
     describe("correlation structure validation", () => {
         beforeEach(() => {
             registerSshErrorCorrelations();
@@ -320,8 +365,11 @@ describe("SshErrorCorrelations", () => {
             const errorCodes = allCalls.map((call) => call[2].errorCode);
 
             const expectedCodes = [
+                // Request timeout
+                "REQUEST_TIMEOUT",
                 // Connection failures
                 "FOTS4241",
+                "FOTS1668",
                 "FOTS4134",
                 "FOTS4231",
                 "FOTS4203",
@@ -333,12 +381,16 @@ describe("SshErrorCorrelations", () => {
                 "FOTS4311",
                 // Filesystem errors
                 "FSUM6260",
+                "EDC5133I",
                 "FOTS4152",
                 "FOTS4154",
                 "FOTS4150",
                 "FOTS4312",
             ];
 
+            // Sanity check: the curated list should match the SDK's full set of registered codes.
+            expect(expectedCodes.sort()).toEqual(Object.keys(SshErrors).sort());
+
             expectedCodes.forEach((expectedCode) => {
                 expect(errorCodes).toContain(expectedCode);
             });

packages/zowex-for-zowe-explorer/tests/SshErrorHandler.test.ts

@@ -184,6 +184,16 @@ describe("SshErrorHandler", () => {
             expect(errorHandler.isFatalError("Prefix FOTS4241 Authentication failed suffix")).toBe(true);
             expect(errorHandler.isFatalError("Some message with FSUM6260 in the middle")).toBe(true);
         });
+
+        it("should classify any literal SshErrors key substring as fatal (e.g. FOTS1668, EDC5133I)", () => {
+            expect(errorHandler.isFatalError("FOTS1668 Your password has expired")).toBe(true);
+            expect(errorHandler.isFatalError("EDC5133I no space left on device")).toBe(true);
+            expect(errorHandler.isFatalError(new Error("EDC5133I no space left on device"))).toBe(true);
+        });
+
+        it("should not treat the REQUEST_TIMEOUT key as fatal when the message is an actual timeout", () => {
+            expect(errorHandler.isFatalError("Request timed out after 5000 ms")).toBe(false);
+        });
     });
 
     describe("extractErrorCode", () => {
@@ -307,5 +317,16 @@ describe("SshErrorHandler", () => {
 
             expect(errorHandler.isTimeoutError(imperativeError)).toBe(true);
         });
+
+        it("should recognize the fully-formed 'after N ms' timeout message", () => {
+            expect(errorHandler.isTimeoutError("Request timed out after 12345 ms")).toBe(true);
+            expect(errorHandler.isTimeoutError(new Error("Request timed out after 1 ms"))).toBe(true);
+        });
+
+        it("should exercise the RegExp matcher branch and return false for a non-timeout message", () => {
+            const imperativeError = new ImperativeError({ msg: "Some failure", errorCode: "EOTHER" });
+            expect(errorHandler.isTimeoutError(imperativeError)).toBe(false);
+            expect(errorHandler.isTimeoutError("Connection reset by peer")).toBe(false);
+        });
     });
 });

packages/zowex-for-zowe-explorer/tests/Utilities.test.ts

@@ -414,5 +414,21 @@ describe("Utilities", () => {
 
             expect(showMessageSpy).toHaveBeenCalledWith("Uninstalled Zowe Remote SSH server from myProf");
         });
+
+        it("should propagate a rejection from ZSshUtils.uninstallServer", async () => {
+            const mockedExplorer = await vi.importMock("@zowe/zowe-explorer-api");
+            const mockedConfig = await vi.importMock("../src/ConfigUtils");
+            const { VscePromptApi } = await vi.importMock("../src/VscePromptApi");
+            const profile = { name: "myProf", profile: { host: "myHost" } };
+            VscePromptApi.mockImplementation(() => ({ promptForProfile: vi.fn().mockResolvedValue(profile) }));
+
+            vi.spyOn(mockedConfig.ConfigUtils, "getServerPath").mockReturnValue("/server/path");
+            vi.spyOn(mockedConfig.ConfigUtils, "showSessionInTree").mockResolvedValue(undefined);
+            vi.spyOn(ZSshUtils, "buildSession").mockReturnValue({ ISshSession: {} });
+            vi.spyOn(ZSshUtils, "uninstallServer").mockRejectedValue(new Error("uninstall failed"));
+
+            const api = mockedExplorer.ZoweVsCodeExtension.getZoweExplorerApi().getExplorerExtenderApi();
+            await expect((Utilities as any).uninstallCallback(api, "myProf")).rejects.toThrow("uninstall failed");
+        });
     });
 });

packages/zowex-for-zowe-explorer/tests/api/SshJesApi.test.ts

@@ -210,6 +210,14 @@ describe("SshJesApi", () => {
             expect(readSpoolSpy).toHaveBeenCalledWith({ spoolId: 1, jobId: "FAKEID", encoding: "1047" });
             expect(response).toEqual("fakedata");
         });
+
+        it("should propagate a rejection from readSpool", async () => {
+            const jesApi = new SshJesApi();
+            vi.spyOn(SshJesApi.prototype, "client", "get").mockResolvedValue({
+                jobs: { readSpool: vi.fn().mockRejectedValue(new Error("readSpool failed")) },
+            });
+            await expect(jesApi.getSpoolContentById("fakejob", "fakeid", 1)).rejects.toThrow("readSpool failed");
+        });
     });
 
     describe("getJclForJob", () => {
@@ -236,9 +244,19 @@ describe("SshJesApi", () => {
                 jobs: { getJcl: vi.fn().mockRejectedValue(new Error("getJcl failed")) },
             });
             const fakeJob: IJob = {
-                jobid: "fakejob", jobname: "FAKEJOB", subsystem: "JES2", owner: "USER",
-                status: "OUTPUT", type: "JOB", class: "A", retcode: "CC 0000",
-                url: "", "files-url": "", "job-correlator": "", phase: 20, "phase-name": "Job is on the hard copy queue",
+                jobid: "fakejob",
+                jobname: "FAKEJOB",
+                subsystem: "JES2",
+                owner: "USER",
+                status: "OUTPUT",
+                type: "JOB",
+                class: "A",
+                retcode: "CC 0000",
+                url: "",
+                "files-url": "",
+                "job-correlator": "",
+                phase: 20,
+                "phase-name": "Job is on the hard copy queue",
             };
             await expect(jesApi.getJclForJob(fakeJob)).rejects.toThrow("getJcl failed");
         });
@@ -261,6 +279,14 @@ describe("SshJesApi", () => {
             expect(cancelJobSpy).toHaveBeenCalledWith({ jobId: "FAKEJOB" });
             expect(response).toEqual(true);
         });
+
+        it("should propagate a rejection from cancelJob", async () => {
+            const jesApi = new SshJesApi();
+            vi.spyOn(SshJesApi.prototype, "client", "get").mockResolvedValue({
+                jobs: { cancelJob: vi.fn().mockRejectedValue(new Error("cancelJob failed")) },
+            });
+            await expect(jesApi.cancelJob({ jobid: "fakejob" } as any)).rejects.toThrow("cancelJob failed");
+        });
     });
 
     describe("submitJcl", () => {