@somewhatabstract/x 0.0.1 → 0.1.0

package/src/__tests__/resolve-bin-path.test.ts

@@ -0,0 +1,344 @@
+import path from "node:path";
+import {describe, expect, it} from "vitest";
+import type {PackageInfo} from "../discover-packages";
+import {resolveBinPath} from "../resolve-bin-path";
+
+describe("resolveBinPath", () => {
+    const mockPackage: PackageInfo = {
+        name: "test-package",
+        path: "/workspace/packages/test-package",
+        version: "1.0.0",
+    };
+
+    describe("basic functionality", () => {
+        it("should resolve string-style bin when binName matches package name", () => {
+            // Arrange
+            const bin = "bin/cli.js";
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBe(
+                path.resolve("/workspace/packages/test-package", "bin/cli.js"),
+            );
+        });
+
+        it("should return null for string-style bin when binName doesn't match package name", () => {
+            // Arrange
+            const bin = "bin/cli.js";
+            const binName = "different-name";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should resolve object-style bin when binName exists in bin object", () => {
+            // Arrange
+            const bin = {
+                cli: "bin/cli.js",
+                server: "bin/server.js",
+            };
+            const binName = "cli";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBe(
+                path.resolve("/workspace/packages/test-package", "bin/cli.js"),
+            );
+        });
+
+        it("should return null for object-style bin when binName doesn't exist", () => {
+            // Arrange
+            const bin = {
+                cli: "bin/cli.js",
+            };
+            const binName = "nonexistent";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should return null when bin is null", () => {
+            // Arrange
+            const bin = null;
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should return null when bin is undefined", () => {
+            // Arrange
+            const bin = undefined;
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+    });
+
+    describe("security - path traversal protection", () => {
+        it("should reject parent directory traversal in string-style bin", () => {
+            // Arrange
+            const bin = "../../../etc/passwd";
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should reject parent directory traversal in object-style bin", () => {
+            // Arrange
+            const bin = {
+                malicious: "../../../usr/bin/malicious",
+            };
+            const binName = "malicious";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should reject absolute paths in string-style bin", () => {
+            // Arrange
+            const bin = "/usr/bin/malicious";
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should reject absolute paths in object-style bin", () => {
+            // Arrange
+            const bin = {
+                malicious: "/usr/bin/malicious",
+            };
+            const binName = "malicious";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should accept valid subdirectory paths", () => {
+            // Arrange
+            const bin = "bin/nested/script.js";
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBe(
+                path.resolve(
+                    "/workspace/packages/test-package",
+                    "bin/nested/script.js",
+                ),
+            );
+        });
+
+        it("should accept valid paths at package root", () => {
+            // Arrange
+            const bin = "index.js";
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBe(
+                path.resolve("/workspace/packages/test-package", "index.js"),
+            );
+        });
+
+        it("should handle edge case where bin path equals package directory", () => {
+            // Arrange
+            const bin = ".";
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBe(
+                path.resolve("/workspace/packages/test-package"),
+            );
+        });
+
+        it("should reject path that tries to escape with multiple parent references", () => {
+            // Arrange
+            const bin = {
+                escape: "../../../../../../etc/shadow",
+            };
+            const binName = "escape";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should handle path with backslashes (valid filename chars on Unix)", () => {
+            // Arrange
+            // On Unix, backslashes are valid filename characters, not path separators
+            // On Windows, Node.js normalizes these to forward slashes before our check
+            const bin = "bin\\script.js";
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            // Should resolve successfully since backslashes are just filename chars on Unix
+            expect(result).toBe(
+                path.resolve(
+                    "/workspace/packages/test-package",
+                    "bin\\script.js",
+                ),
+            );
+        });
+    });
+
+    describe("type handling", () => {
+        it("should return null when bin is a number", () => {
+            // Arrange
+            const bin: any = 123;
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should return null when bin is a boolean", () => {
+            // Arrange
+            const bin: any = true;
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should return null when bin is an empty object", () => {
+            // Arrange
+            const bin = {};
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should return null when bin is an array", () => {
+            // Arrange
+            const bin: any = ["bin/cli.js"];
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+    });
+
+    describe("edge cases", () => {
+        it("should handle package path with trailing slash", () => {
+            // Arrange
+            const packageWithTrailingSlash: PackageInfo = {
+                name: "test-package",
+                path: "/workspace/packages/test-package/",
+                version: "1.0.0",
+            };
+            const bin = "bin/cli.js";
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(
+                packageWithTrailingSlash,
+                bin,
+                binName,
+            );
+
+            // Assert
+            expect(result).toBe(
+                path.resolve("/workspace/packages/test-package/", "bin/cli.js"),
+            );
+        });
+
+        it("should handle bin path with leading slash", () => {
+            // Arrange
+            const bin = "/bin/cli.js";
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should handle bin path with only dots", () => {
+            // Arrange
+            const bin = "..";
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should resolve relative path with current directory reference", () => {
+            // Arrange
+            const bin = "./bin/cli.js";
+            const binName = "test-package";
+
+            // Act
+            const result = resolveBinPath(mockPackage, bin, binName);
+
+            // Assert
+            expect(result).toBe(
+                path.resolve(
+                    "/workspace/packages/test-package",
+                    "./bin/cli.js",
+                ),
+            );
+        });
+    });
+});

package/src/__tests__/x-impl.test.ts

@@ -1,15 +1,314 @@
-import {describe, expect, it, vi} from "vitest";
-import { xImpl } from "../x-impl";
+import {beforeEach, describe, expect, it, vi} from "vitest";
+import * as discoverPackagesModule from "../discover-packages";
+import {HandledError} from "../errors";
+import * as executeScriptModule from "../execute-script";
+import * as findMatchingBinsModule from "../find-matching-bins";
+import * as findWorkspaceRootModule from "../find-workspace-root";
+import {xImpl} from "../x-impl";
+
+// Mock the modules
+vi.mock("../find-workspace-root");
+vi.mock("../discover-packages");
+vi.mock("../find-matching-bins");
+vi.mock("../execute-script");
 
 describe("xImpl", () => {
-    it("should log 'Hello, world!'", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Suppress console output in tests
+        vi.spyOn(console, "error").mockImplementation(() => {});
+        vi.spyOn(console, "log").mockImplementation(() => {});
+    });
+
+    it("should return exit code 1 when script not found", async () => {
+        // Arrange
+        const scriptName = "nonexistent-script";
+
+        vi.mocked(findWorkspaceRootModule.findWorkspaceRoot).mockResolvedValue(
+            "/test/workspace",
+        );
+        vi.mocked(discoverPackagesModule.discoverPackages).mockResolvedValue([
+            {name: "pkg1", path: "/test/pkg1", version: "1.0.0"},
+        ]);
+        vi.mocked(findMatchingBinsModule.findMatchingBins).mockResolvedValue(
+            [],
+        );
+
+        // Act
+        const result = await xImpl(scriptName);
+
+        // Assert
+        expect(result.exitCode).toBe(1);
+    });
+
+    it("should return exit code 1 when no packages found", async () => {
+        // Arrange
+        const scriptName = "test-script";
+
+        vi.mocked(findWorkspaceRootModule.findWorkspaceRoot).mockResolvedValue(
+            "/test/workspace",
+        );
+        vi.mocked(discoverPackagesModule.discoverPackages).mockResolvedValue(
+            [],
+        );
+
+        // Act
+        const result = await xImpl(scriptName);
+
+        // Assert
+        expect(result.exitCode).toBe(1);
+    });
+
+    it("should return exit code 1 when multiple bins match", async () => {
+        // Arrange
+        const scriptName = "test-script";
+
+        vi.mocked(findWorkspaceRootModule.findWorkspaceRoot).mockResolvedValue(
+            "/test/workspace",
+        );
+        vi.mocked(discoverPackagesModule.discoverPackages).mockResolvedValue([
+            {name: "pkg1", path: "/test/pkg1", version: "1.0.0"},
+            {name: "pkg2", path: "/test/pkg2", version: "1.0.0"},
+        ]);
+        vi.mocked(findMatchingBinsModule.findMatchingBins).mockResolvedValue([
+            {
+                packageName: "pkg1",
+                packagePath: "/test/pkg1",
+                binName: "test-script",
+                binPath: "/test/pkg1/bin/test",
+            },
+            {
+                packageName: "pkg2",
+                packagePath: "/test/pkg2",
+                binName: "test-script",
+                binPath: "/test/pkg2/bin/test",
+            },
+        ]);
+
+        // Act
+        const result = await xImpl(scriptName);
+
+        // Assert
+        expect(result.exitCode).toBe(1);
+    });
+
+    it("should execute script in dry-run mode", async () => {
+        // Arrange
+        const scriptName = "test-script";
+        const options = {dryRun: true};
+
+        vi.mocked(findWorkspaceRootModule.findWorkspaceRoot).mockResolvedValue(
+            "/test/workspace",
+        );
+        vi.mocked(discoverPackagesModule.discoverPackages).mockResolvedValue([
+            {name: "pkg1", path: "/test/pkg1", version: "1.0.0"},
+        ]);
+        vi.mocked(findMatchingBinsModule.findMatchingBins).mockResolvedValue([
+            {
+                packageName: "pkg1",
+                packagePath: "/test/pkg1",
+                binName: "test-script",
+                binPath: "/test/pkg1/bin/test",
+            },
+        ]);
+
+        // Act
+        const result = await xImpl(scriptName, [], options);
+
+        // Assert
+        expect(result.exitCode).toBe(0);
+    });
+
+    it("should not execute script when dry-run is true", async () => {
+        // Arrange
+        const scriptName = "test-script";
+        const options = {dryRun: true};
+
+        vi.mocked(findWorkspaceRootModule.findWorkspaceRoot).mockResolvedValue(
+            "/test/workspace",
+        );
+        vi.mocked(discoverPackagesModule.discoverPackages).mockResolvedValue([
+            {name: "pkg1", path: "/test/pkg1", version: "1.0.0"},
+        ]);
+        vi.mocked(findMatchingBinsModule.findMatchingBins).mockResolvedValue([
+            {
+                packageName: "pkg1",
+                packagePath: "/test/pkg1",
+                binName: "test-script",
+                binPath: "/test/pkg1/bin/test",
+            },
+        ]);
+
+        // Act
+        await xImpl(scriptName, [], options);
+
+        // Assert
+        expect(executeScriptModule.executeScript).not.toHaveBeenCalled();
+    });
+
+    it("should execute script and return its exit code", async () => {
+        // Arrange
+        const scriptName = "test-script";
+
+        vi.mocked(findWorkspaceRootModule.findWorkspaceRoot).mockResolvedValue(
+            "/test/workspace",
+        );
+        vi.mocked(discoverPackagesModule.discoverPackages).mockResolvedValue([
+            {name: "pkg1", path: "/test/pkg1", version: "1.0.0"},
+        ]);
+        vi.mocked(findMatchingBinsModule.findMatchingBins).mockResolvedValue([
+            {
+                packageName: "pkg1",
+                packagePath: "/test/pkg1",
+                binName: "test-script",
+                binPath: "/test/pkg1/bin/test",
+            },
+        ]);
+        vi.mocked(executeScriptModule.executeScript).mockResolvedValue(0);
+
+        // Act
+        const result = await xImpl(scriptName);
+
+        // Assert
+        expect(result.exitCode).toBe(0);
+    });
+
+    it("should pass workspace root to executeScript", async () => {
+        // Arrange
+        const scriptName = "test-script";
+        const workspaceRoot = "/test/workspace";
+
+        vi.mocked(findWorkspaceRootModule.findWorkspaceRoot).mockResolvedValue(
+            workspaceRoot,
+        );
+        vi.mocked(discoverPackagesModule.discoverPackages).mockResolvedValue([
+            {name: "pkg1", path: "/test/pkg1", version: "1.0.0"},
+        ]);
+        vi.mocked(findMatchingBinsModule.findMatchingBins).mockResolvedValue([
+            {
+                packageName: "pkg1",
+                packagePath: "/test/pkg1",
+                binName: "test-script",
+                binPath: "/test/pkg1/bin/test",
+            },
+        ]);
+        vi.mocked(executeScriptModule.executeScript).mockResolvedValue(0);
+
+        // Act
+        await xImpl(scriptName);
+
+        // Assert
+        expect(executeScriptModule.executeScript).toHaveBeenCalledWith(
+            expect.any(Object),
+            expect.any(Array),
+            workspaceRoot,
+        );
+    });
+
+    it("should pass args to executeScript", async () => {
+        // Arrange
+        const scriptName = "test-script";
+        const args = ["--flag", "value"];
+
+        vi.mocked(findWorkspaceRootModule.findWorkspaceRoot).mockResolvedValue(
+            "/test/workspace",
+        );
+        vi.mocked(discoverPackagesModule.discoverPackages).mockResolvedValue([
+            {name: "pkg1", path: "/test/pkg1", version: "1.0.0"},
+        ]);
+        vi.mocked(findMatchingBinsModule.findMatchingBins).mockResolvedValue([
+            {
+                packageName: "pkg1",
+                packagePath: "/test/pkg1",
+                binName: "test-script",
+                binPath: "/test/pkg1/bin/test",
+            },
+        ]);
+        vi.mocked(executeScriptModule.executeScript).mockResolvedValue(0);
+
+        // Act
+        await xImpl(scriptName, args);
+
+        // Assert
+        expect(executeScriptModule.executeScript).toHaveBeenCalledWith(
+            expect.any(Object),
+            args,
+            expect.any(String),
+        );
+    });
+
+    it("should return exit code 1 on unhandled error", async () => {
+        // Arrange
+        const scriptName = "test-script";
+
+        vi.mocked(findWorkspaceRootModule.findWorkspaceRoot).mockRejectedValue(
+            new HandledError("Test error"),
+        );
+
+        // Act
+        const result = await xImpl(scriptName);
+
+        // Assert
+        expect(result.exitCode).toBe(1);
+    });
+
+    it("should rethrow non-HandledError errors", async () => {
+        // Arrange
+        const scriptName = "test-script";
+        const unexpectedError = new Error("Unexpected error");
+
+        vi.mocked(findWorkspaceRootModule.findWorkspaceRoot).mockRejectedValue(
+            unexpectedError,
+        );
+
+        // Act
+        const underTest = () => xImpl(scriptName);
+
+        // Assert
+        await expect(underTest).rejects.toThrow("Unexpected error");
+    });
+
+    it("should return exit code 1 when script name is empty", async () => {
+        // Arrange
+        const scriptName = "";
+
+        // Act
+        const result = await xImpl(scriptName);
+
+        // Assert
+        expect(result.exitCode).toBe(1);
+    });
+
+    it("should return exit code 1 when script name is only whitespace", async () => {
+        // Arrange
+        const scriptName = "   ";
+
+        // Act
+        const result = await xImpl(scriptName);
+
+        // Assert
+        expect(result.exitCode).toBe(1);
+    });
+
+    it("should return exit code 1 when script name contains forward slash", async () => {
+        // Arrange
+        const scriptName = "bin/script";
+
+        // Act
+        const result = await xImpl(scriptName);
+
+        // Assert
+        expect(result.exitCode).toBe(1);
+    });
+
+    it("should return exit code 1 when script name contains backslash", async () => {
         // Arrange
-        const consoleSpy = vi.spyOn(console, "log");
+        const scriptName = "bin\\script";
 
         // Act
-        xImpl();
+        const result = await xImpl(scriptName);
 
         // Assert
-        expect(consoleSpy).toHaveBeenCalledWith("Hello, world!");
+        expect(result.exitCode).toBe(1);
     });
-});
+});