@somewhatabstract/x 0.0.1 → 0.1.0

package/src/__tests__/discover-packages.test.ts

@@ -0,0 +1,196 @@
+import * as manypkg from "@manypkg/get-packages";
+import {beforeEach, describe, expect, it, vi} from "vitest";
+import {discoverPackages} from "../discover-packages";
+import {HandledError} from "../errors";
+
+// Mock @manypkg/get-packages
+vi.mock("@manypkg/get-packages", () => ({
+    getPackages: vi.fn(),
+}));
+
+describe("discoverPackages", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("should return packages from @manypkg", async () => {
+        // Arrange
+        const workspaceRoot = "/test/workspace";
+        const mockPackages = {
+            packages: [
+                {
+                    packageJson: {name: "pkg1", version: "1.0.0"},
+                    dir: "/test/workspace/pkg1",
+                },
+                {
+                    packageJson: {name: "pkg2", version: "2.0.0"},
+                    dir: "/test/workspace/pkg2",
+                },
+            ],
+        };
+
+        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
+
+        // Act
+        const result = await discoverPackages(workspaceRoot);
+
+        // Assert
+        expect(result).toHaveLength(2);
+    });
+
+    it("should map package names correctly", async () => {
+        // Arrange
+        const workspaceRoot = "/test/workspace";
+        const mockPackages = {
+            packages: [
+                {
+                    packageJson: {name: "test-package", version: "1.0.0"},
+                    dir: "/test/workspace/pkg",
+                },
+            ],
+        };
+
+        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
+
+        // Act
+        const result = await discoverPackages(workspaceRoot);
+
+        // Assert
+        expect(result[0].name).toBe("test-package");
+    });
+
+    it("should map package paths correctly", async () => {
+        // Arrange
+        const workspaceRoot = "/test/workspace";
+        const mockPackages = {
+            packages: [
+                {
+                    packageJson: {name: "test-package", version: "1.0.0"},
+                    dir: "/test/workspace/packages/test",
+                },
+            ],
+        };
+
+        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
+
+        // Act
+        const result = await discoverPackages(workspaceRoot);
+
+        // Assert
+        expect(result[0].path).toBe("/test/workspace/packages/test");
+    });
+
+    it("should map package versions correctly", async () => {
+        // Arrange
+        const workspaceRoot = "/test/workspace";
+        const mockPackages = {
+            packages: [
+                {
+                    packageJson: {name: "test-package", version: "3.2.1"},
+                    dir: "/test/workspace/pkg",
+                },
+            ],
+        };
+
+        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
+
+        // Act
+        const result = await discoverPackages(workspaceRoot);
+
+        // Assert
+        expect(result[0].version).toBe("3.2.1");
+    });
+
+    it("should use 'unknown' for missing version", async () => {
+        // Arrange
+        const workspaceRoot = "/test/workspace";
+        const mockPackages = {
+            packages: [
+                {
+                    packageJson: {name: "test-package"},
+                    dir: "/test/workspace/pkg",
+                },
+            ],
+        };
+
+        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
+
+        // Act
+        const result = await discoverPackages(workspaceRoot);
+
+        // Assert
+        expect(result[0].version).toBe("unknown");
+    });
+
+    it("should call getPackages with workspace root", async () => {
+        // Arrange
+        const workspaceRoot = "/test/workspace";
+        const mockPackages = {
+            packages: [],
+        };
+
+        vi.mocked(manypkg.getPackages).mockResolvedValue(mockPackages as any);
+
+        // Act
+        await discoverPackages(workspaceRoot);
+
+        // Assert
+        expect(manypkg.getPackages).toHaveBeenCalledWith(workspaceRoot);
+    });
+
+    it("should rethrow HandledError type as is", async () => {
+        // Arrange
+        const workspaceRoot = "/test/workspace";
+        const handledError = new HandledError("Test handled error");
+
+        vi.mocked(manypkg.getPackages).mockRejectedValue(handledError);
+
+        // Act
+        const underTest = () => discoverPackages(workspaceRoot);
+
+        // Assert
+        await expect(underTest).rejects.toThrow(HandledError);
+    });
+
+    it("should rethrow HandledError message as is", async () => {
+        // Arrange
+        const workspaceRoot = "/test/workspace";
+        const handledError = new HandledError("Test handled error");
+
+        vi.mocked(manypkg.getPackages).mockRejectedValue(handledError);
+
+        // Act
+        const underTest = () => discoverPackages(workspaceRoot);
+
+        // Assert
+        await expect(underTest).rejects.toThrow("Test handled error");
+    });
+
+    it("should wrap non-HandledError in HandledError type", async () => {
+        // Arrange
+        const workspaceRoot = "/test/workspace";
+        const error = new Error("Original error");
+
+        vi.mocked(manypkg.getPackages).mockRejectedValue(error);
+
+        // Act
+        const underTest = () => discoverPackages(workspaceRoot);
+
+        // Assert
+        await expect(underTest).rejects.toThrow(HandledError);
+    });
+
+    it("should use expected message when wrapping non-HandledError", async () => {
+        // Arrange
+        const workspaceRoot = "/test/workspace";
+        const error = new Error("Original error");
+
+        vi.mocked(manypkg.getPackages).mockRejectedValue(error);
+
+        // Act
+        const underTest = () => discoverPackages(workspaceRoot);
+
+        // Assert
+        await expect(underTest).rejects.toThrow("Failed to discover packages");
+    });
+});

package/src/__tests__/errors.test.ts

@@ -0,0 +1,59 @@
+import {describe, expect, it} from "vitest";
+import {HandledError} from "../errors";
+
+describe("HandledError", () => {
+    it("should be an instance of Error", () => {
+        // Arrange
+        const error = new HandledError("Test error message");
+
+        // Act
+        const isError = error instanceof Error;
+
+        // Assert
+        expect(isError).toBe(true);
+    });
+
+    it("should have name 'HandledError'", () => {
+        // Arrange
+        const error = new HandledError("Test error message");
+
+        // Act
+        const name = error.name;
+
+        // Assert
+        expect(name).toBe("HandledError");
+    });
+
+    it("should preserve the error message", () => {
+        // Arrange
+        const message = "Test error message";
+
+        // Act
+        const error = new HandledError(message);
+
+        // Assert
+        expect(error.message).toBe(message);
+    });
+
+    it("should be distinguishable from HandledError type", () => {
+        // Arrange
+        const handledError = new HandledError("Handled");
+
+        // Act
+        const isHandledError = handledError instanceof HandledError;
+
+        // Assert
+        expect(isHandledError).toBe(true);
+    });
+
+    it("should distinguish regular errors from HandledError type", () => {
+        // Arrange
+        const regularError = new Error("Regular");
+
+        // Act
+        const isHandledError = regularError instanceof HandledError;
+
+        // Assert
+        expect(isHandledError).toBe(false);
+    });
+});