Refactor binary path detection with new shell utility function

Author: roulpriya

src/toolchain/swiftly.ts

@@ -20,6 +20,7 @@ import * as vscode from "vscode";
 import { Version } from "../utilities/version";
 import { z } from "zod/v4/mini";
 import { SwiftLogger } from "../logging/SwiftLogger";
+import { findBinaryPath } from "../utilities/shell";
 
 const ListResult = z.object({
     toolchains: z.array(
@@ -241,8 +242,8 @@ export class Swiftly {
             return false;
         }
         try {
-            const { stdout } = await execFile("which", ["swiftly"]);
-            return stdout.trim().length > 0;
+            await findBinaryPath("swiftly");
+            return true;
         } catch (error) {
             return false;
         }

src/toolchain/toolchain.ts

@@ -26,6 +26,7 @@ import { Sanitizer } from "./Sanitizer";
 import { lineBreakRegex } from "../utilities/tasks";
 import { Swiftly } from "./swiftly";
 import { SwiftLogger } from "../logging/SwiftLogger";
+import { findBinaryPath } from "../utilities/shell";
 /**
  * Contents of **Info.plist** on Windows.
  */
@@ -550,18 +551,7 @@ export class SwiftToolchain {
                         // use `type swift` to find `swift`. Run inside /bin/sh to ensure
                         // we get consistent output as different shells output a different
                         // format. Tried running with `-p` but that is not available in /bin/sh
-                        const { stdout, stderr } = await execFile("/bin/sh", [
-                            "-c",
-                            "LC_MESSAGES=C type swift",
-                        ]);
-                        const swiftMatch = /^swift is (.*)$/.exec(stdout.trimEnd());
-                        if (swiftMatch) {
-                            swift = swiftMatch[1];
-                        } else {
-                            throw Error(
-                                `/bin/sh -c LC_MESSAGES=C type swift: stdout: ${stdout}, stderr: ${stderr}`
-                            );
-                        }
+                        swift = await findBinaryPath("swift");
                         break;
                     }
                 }

src/utilities/shell.ts

@@ -0,0 +1,16 @@
+import { execFile } from "./utilities";
+
+export async function findBinaryPath(binaryName: string): Promise<string> {
+    const { stdout, stderr } = await execFile("/bin/sh", [
+        "-c",
+        `LC_MESSAGES=C type ${binaryName}`,
+    ]);
+    const binaryNameMatch = new RegExp(`^${binaryName} is (.*)$`).exec(stdout.trimEnd());
+    if (binaryNameMatch) {
+        return binaryNameMatch[1];
+    } else {
+        throw Error(
+            `/bin/sh -c LC_MESSAGES=C type ${binaryName}: stdout: ${stdout}, stderr: ${stderr}`
+        );
+    }
+}

test/unit-tests/toolchain/swiftly.test.ts

@@ -15,10 +15,12 @@
 import { expect } from "chai";
 import { Swiftly } from "../../../src/toolchain/swiftly";
 import * as utilities from "../../../src/utilities/utilities";
+import * as shell from "../../../src/utilities/shell";
 import { mockGlobalModule, mockGlobalValue } from "../../MockUtils";
 
 suite("Swiftly Unit Tests", () => {
     const mockUtilities = mockGlobalModule(utilities);
+    const mockShell = mockGlobalModule(shell);
     const mockedPlatform = mockGlobalValue(process, "platform");
 
     setup(() => {
@@ -105,36 +107,21 @@ suite("Swiftly Unit Tests", () => {
 
     suite("isInstalled", () => {
         test("should return true when swiftly is found", async () => {
-            mockUtilities.execFile.withArgs("which", ["swiftly"]).resolves({
-                stdout: "/usr/local/bin/swiftly\n",
-                stderr: "",
-            });
+            mockShell.findBinaryPath.withArgs("swiftly").resolves("/usr/local/bin/swiftly");
 
             const result = await Swiftly.isInstalled();
 
             expect(result).to.be.true;
-            expect(mockUtilities.execFile).to.have.been.calledWith("which", ["swiftly"]);
+            expect(mockShell.findBinaryPath).to.have.been.calledWith("swiftly");
         });
 
         test("should return false when swiftly is not found", async () => {
-            mockUtilities.execFile.withArgs("which", ["swiftly"]).rejects(new Error("not found"));
-
-            const result = await Swiftly.isInstalled();
-
-            expect(result).to.be.false;
-            expect(mockUtilities.execFile).to.have.been.calledWith("which", ["swiftly"]);
-        });
-
-        test("should return false when which returns empty output", async () => {
-            mockUtilities.execFile.withArgs("which", ["swiftly"]).resolves({
-                stdout: "",
-                stderr: "",
-            });
+            mockShell.findBinaryPath.withArgs("swiftly").rejects(new Error("not found"));
 
             const result = await Swiftly.isInstalled();
 
             expect(result).to.be.false;
-            expect(mockUtilities.execFile).to.have.been.calledWith("which", ["swiftly"]);
+            expect(mockShell.findBinaryPath).to.have.been.calledWith("swiftly");
         });
 
         test("should return false when platform is not supported", async () => {
@@ -143,7 +130,7 @@ suite("Swiftly Unit Tests", () => {
             const result = await Swiftly.isInstalled();
 
             expect(result).to.be.false;
-            expect(mockUtilities.execFile).not.to.have.been.called;
+            expect(mockShell.findBinaryPath).not.to.have.been.called;
         });
     });
 });

test/unit-tests/utilities/shell.test.ts

@@ -0,0 +1,21 @@
+import { expect } from "chai";
+import { findBinaryPath } from "../../../src/utilities/shell";
+
+suite("Shell Unit Test Suite", () => {
+    suite("findBinaryPath", () => {
+        test("returns the path to a binary in the PATH", async () => {
+            const binaryPath = await findBinaryPath("node");
+            expect(binaryPath).to.be.a("string");
+            expect(binaryPath).to.include("node");
+        });
+
+        test("throws for a non-existent binary", async () => {
+            try {
+                await findBinaryPath("nonexistentbinary");
+                expect.fail("Expected an error to be thrown for a non-existent binary");
+            } catch (error) {
+                expect(error).to.be.an("error");
+            }
+        });
+    });
+});