pm-auto 1.0.3 → 1.0.5

package/test.json

@@ -1,94 +1,87 @@
-{
-  "sample": {
-    "name": "sample",
-    "packageManager": "npm",
-    "packages": [
-      {
-        "command": "gsap",
-        "interactive": false
-      }
-    ]
-  },
-
-  "vite": {
-    "name": "vite",
-    "packageManager": "npm",
-    "packages": [
-      {
-        "command": "@types/three --save-dev",
-        "interactive": false
-      },
-      {
-        "command": "@react-three/fiber",
-        "interactive": false
-      },
-      {
-        "command": "gsap",
-        "interactive": false
-      },
-      {
-        "command": "create-vite@latest my-app",
-        "interactive": true
-      }
-    ]
-  },
-
-  "next": {
-    "name": "next",
-    "packageManager": "pnpm",
-    "packages": [
-      {
-        "command": "three --save-dev",
-        "interactive": false
-      },
-      {
-        "command": "@react-three/drei",
-        "interactive": false
-      },
-      {
-        "command": "framer-motion",
-        "interactive": false
-      },
-      {
-        "command": "create-next-app@latest my-app",
-        "interactive": true
-      }
-    ]
-  },
-  "test": {
-    "name": "test",
-    "packageManager": "npm",
-    "packages": [
-      {
-        "command": "three",
-        "interactive": false
-      },
-      {
-        "command": "gsap",
-        "interactive": false
-      },
-      {
-        "command": "@react-three/fiber",
-        "interactive": false
-      }
-    ]
-  },
-  "test2": {
-    "name": "test2",
-    "packageManager": "npm",
-    "packages": [
-      {
-        "command": "@react-three/drei",
-        "interactive": false
-      },
-      {
-        "command": "framer-motion",
-        "interactive": false
-      },
-      {
-        "command": "@react-three/postprocessing",
-        "interactive": false
-      }
-    ]
-  }
-}
+{
+  "sample": {
+    "name": "sample",
+    "description": "",
+    "packageManager": "npm",
+    "packages": [
+      {
+        "command": "gsap",
+        "interactive": false
+      }
+    ]
+  },
+
+  "vite": {
+    "name": "vite",
+    "description": "Vite configuration",
+    "packageManager": "npm",
+    "packages": [
+      {
+        "command": "create-vite@latest my-app",
+        "interactive": true
+      }
+    ]
+  },
+
+  "next": {
+    "name": "next",
+    "description": "Next.js configuration",
+    "packageManager": "pnpm",
+    "packages": [
+      {
+        "command": "three --save-dev",
+        "interactive": false
+      },
+      {
+        "command": "@react-three/drei",
+        "interactive": false
+      },
+      {
+        "command": "framer-motion",
+        "interactive": false
+      },
+      {
+        "command": "create-next-app@latest my-app",
+        "interactive": true
+      }
+    ]
+  },
+  "test": {
+    "name": "test",
+    "description": "Test configuration",
+    "packageManager": "npm",
+    "packages": [
+      {
+        "command": "three",
+        "interactive": false
+      },
+      {
+        "command": "gsap",
+        "interactive": false
+      },
+      {
+        "command": "@react-three/fiber",
+        "interactive": false
+      }
+    ]
+  },
+  "test2": {
+    "name": "test2",
+    "description": "Test2 configuration",
+    "packageManager": "npm",
+    "packages": [
+      {
+        "command": "@react-three/drei",
+        "interactive": false
+      },
+      {
+        "command": "framer-motion",
+        "interactive": false
+      },
+      {
+        "command": "@react-three/postprocessing",
+        "interactive": false
+      }
+    ]
+  }
+}

package/tests/build_command.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { buildCommands, buildUninstallCommands } from "../src/build_command.js";
+import type { ConfigType } from "../src/types/index.js";
+
+describe("buildCommand", () => {
+  const mockConfig: ConfigType[] = [
+    {
+      name: "vite",
+      packageManager: "npm",
+      packages: [
+        { command: "vite@latest", interactive: true },
+        { command: "gsap@latest", interactive: false },
+      ],
+    },
+  ];
+  it("builds an installation command", () => {
+    const command = buildCommands(mockConfig);
+    expect(command).toEqual([
+      {
+        name: "vite",
+        interactive: ["npx vite@latest"],
+        nonInteractive: ["npm install gsap@latest"],
+      },
+    ]);
+  });
+
+  it("builds an uninstallation command", () => {
+    const command = buildUninstallCommands(mockConfig);
+    expect(command).toEqual([
+      {
+        name: "vite",
+        interactive: [],
+        nonInteractive: ["npm uninstall gsap@latest"],
+      },
+    ]);
+  });
+});

package/tests/config_path.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as fs from "fs";
+import * as os from "os";
+import { saveConfigPath, getConfigPath } from "../src/config_path.js";
+import * as display from "../src/display.js";
+
+const mocks = vi.hoisted(() => {
+  return {
+    homedir: vi.fn(() => "/mock/home"),
+  };
+});
+
+// Mock modules FIRST
+vi.mock("fs");
+vi.mock("os", () => ({
+  homedir: mocks.homedir,
+}));
+vi.mock("../src/display.js");
+
+// NOW import the module under test AFTER mocks are configured
+
+describe("Config Path Management", () => {
+  const mockHomeDir = "/mock/home";
+  const mockSettingsDir = "\\mock\\home\\.pm-auto";
+  const mockSettingsFile = "\\mock\\home\\.pm-auto\\settings.json";
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mocked(os.homedir).mockReturnValue(mockHomeDir);
+  });
+
+  describe("saveConfigPath", () => {
+    it("creates directory and saves config path", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+      vi.mocked(fs.realpathSync).mockReturnValue("\\real\\path\\config.json");
+
+      saveConfigPath("./config.json");
+
+      expect(fs.mkdirSync).toHaveBeenCalledWith(mockSettingsDir, {
+        recursive: true,
+      });
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        mockSettingsFile,
+        expect.stringContaining('"configPath"'),
+      );
+      expect(display.display).toHaveBeenCalledWith(
+        expect.any(String),
+        "success",
+      );
+    });
+
+    it("skips directory creation if exists", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.realpathSync).mockReturnValue("/real/path");
+
+      saveConfigPath("/path");
+
+      expect(fs.mkdirSync).not.toHaveBeenCalled();
+    });
+
+    it("handles errors gracefully", () => {
+      vi.mocked(fs.realpathSync).mockImplementation(() => {
+        throw new Error("File not found");
+      });
+
+      saveConfigPath("/invalid/path");
+
+      expect(display.display).toHaveBeenCalledWith(
+        expect.stringContaining("File not found"),
+        "error",
+      );
+    });
+  });
+
+  describe("getConfigPath", () => {
+    it("returns config path when file exists", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify({ configPath: "/saved/path" }),
+      );
+
+      const result = getConfigPath();
+
+      expect(result).toBe("/saved/path");
+    });
+
+    it("shows error when settings file does not exist", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      const result = getConfigPath();
+
+      expect(display.display).toHaveBeenCalledWith(
+        expect.stringContaining("Config file path not set"),
+        "error",
+      );
+      expect(result).toBeUndefined();
+    });
+
+    it("handles JSON parse errors", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue("invalid json");
+
+      getConfigPath();
+
+      expect(display.display).toHaveBeenCalledWith(
+        expect.stringContaining("Error reading"),
+        "error",
+      );
+    });
+
+    it("returns empty string if configPath is missing", () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({}));
+
+      const result = getConfigPath();
+
+      expect(result).toBe("");
+    });
+  });
+});

package/tests/config_reader.test.ts

@@ -0,0 +1,179 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import fs from "fs/promises";
+import * as fsd from "fs";
+import * as path from "path";
+import { display } from "../src/display.js";
+import { detectPackageManager, getConfigObject } from "../src/config_reader.js";
+import { getConfigPath } from "../src/config_path.js";
+import type { CommandResult, ConfigType } from "../src/types/index.js";
+import * as clack from "@clack/prompts";
+
+vi.mock("fs/promises");
+vi.mock("fs");
+vi.mock("../src/config_path.js");
+vi.mock("../src/display.js");
+vi.mock("@clack/prompts");
+vi.mock("../src/config_path.js");
+
+describe("detect package manager", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+  it("should detects pnpm from lock file", () => {
+    vi.mocked(fsd.existsSync).mockImplementation((filePath) =>
+      filePath.toString().includes("pnpm-lock.yaml"),
+    );
+    const result = detectPackageManager("/test/path");
+
+    expect(result).toBe("pnpm");
+  });
+  it("should detects yarn from lock file", () => {
+    vi.mocked(fsd.existsSync).mockImplementation((filePath) =>
+      filePath.toString().includes("yarn.lock"),
+    );
+    const result = detectPackageManager("/test/path");
+
+    expect(result).toBe("yarn");
+  });
+  it("should detects npm from lock file", () => {
+    vi.mocked(fsd.existsSync).mockImplementation((filePath) =>
+      filePath.toString().includes("package-lock.json"),
+    );
+    const result = detectPackageManager("/test/path");
+
+    expect(result).toBe("npm");
+  });
+  it("should display error message when no lock file found", () => {
+    vi.mocked(fsd.existsSync).mockImplementation(() => false);
+    const result = detectPackageManager("/test/path");
+
+    expect(display).toHaveBeenCalledWith(
+      expect.stringContaining("No Lock File Found"),
+      "error",
+    );
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("get Config Object", () => {
+  const mockConfig = {
+    react: {
+      name: "react",
+      packages: [{ command: "npm install react", interactive: false }],
+    },
+    vue: {
+      name: "vue",
+      packages: [{ command: "npm install vue", interactive: false }],
+    },
+  };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("should get config object the user wants and display warning when package does not exist", async () => {
+    vi.mocked(getConfigPath).mockResolvedValue("/path/to/test");
+    vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockConfig));
+
+    const config = await getConfigObject(["next", "react", "vue"], {});
+
+    expect(config).toEqual([
+      {
+        name: "react",
+        packages: [{ command: "npm install react", interactive: false }],
+      },
+      {
+        name: "vue",
+        packages: [{ command: "npm install vue", interactive: false }],
+      },
+    ]);
+    expect(display).toHaveBeenCalledWith(
+      expect.stringContaining("Package 'next' not found in config"),
+      "warning",
+    );
+  });
+
+  // it("should display an error on readFile error", async () => {
+  //   vi.mocked(getConfigPath).mockReturnValue("/path/to/test");
+  //   vi.mocked(fs.readFile).mockRejectedValue(new Error("File not found"));
+  //   await getConfigObject([], {});
+  //   expect(display).toHaveBeenCalledWith(
+  //     expect.stringContaining("Try updating the config file"),
+  //     "error",
+  //   );
+  // });
+  //
+
+  it("adds command with addCommand option", async () => {
+    vi.mocked(getConfigPath).mockReturnValue("/mock/config.json");
+    vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockConfig));
+
+    const result = (await getConfigObject(["react"], {
+      addCommand: "--save-dev",
+    })) as ConfigType[];
+
+    if (result[0]?.packages[0]?.command) {
+      expect(result[0].packages[0].command).toContain("--save-dev");
+    }
+  });
+
+  it("shows dry run preview and continues on confirm", async () => {
+    vi.mocked(getConfigPath).mockReturnValue("/mock/config.json");
+    vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockConfig));
+    vi.mocked(clack.confirm).mockResolvedValue(true);
+    vi.mocked(clack.isCancel).mockReturnValue(false);
+
+    const result = await getConfigObject(["react"], { dryRun: true });
+
+    expect(display).toHaveBeenCalledWith("Dry Run:", "info");
+    expect(clack.confirm).toHaveBeenCalled();
+    expect(result).toHaveLength(1);
+  });
+
+  it("cancels on dry run cancel", async () => {
+    vi.mocked(getConfigPath).mockReturnValue("/mock/config.json");
+    vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockConfig));
+    vi.mocked(clack.confirm).mockResolvedValue(false);
+    vi.mocked(clack.isCancel).mockReturnValue(true);
+
+    const mockExit = vi
+      .spyOn(process, "exit")
+      .mockImplementation(() => undefined as never);
+
+    await getConfigObject(["react"], { dryRun: true });
+
+    expect(clack.cancel).toHaveBeenCalledWith("Operation cancelled.");
+    expect(mockExit).toHaveBeenCalledWith(0);
+
+    mockExit.mockRestore();
+  });
+
+  it("generates command for package.json install", async () => {
+    vi.mocked(fsd.existsSync).mockImplementation((filePath) =>
+      filePath.toString().includes("package-lock.json"),
+    );
+
+    const result = await getConfigObject([], { pkgJson: true });
+
+    expect(result).toEqual([
+      {
+        name: "package.json",
+        interactive: [],
+        nonInteractive: ["npm install"],
+      },
+    ]);
+  });
+
+  it("uses correct package manager for package.json", async () => {
+    vi.mocked(fsd.existsSync).mockImplementation((filePath) =>
+      filePath.toString().includes("pnpm-lock.yaml"),
+    );
+
+    const result = (await getConfigObject([], {
+      pkgJson: true,
+    })) as CommandResult[];
+    if (result[0]) {
+      expect(result[0].nonInteractive[0]).toBe("pnpm install");
+    }
+  });
+});

package/tests/display.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { display } from "../src/display.js";
+import { log, spinner } from "@clack/prompts";
+
+// Mock the dependencies
+vi.mock("@clack/prompts", () => ({
+  log: {
+    error: vi.fn(),
+    success: vi.fn(),
+    warn: vi.fn(),
+    info: vi.fn(),
+    message: vi.fn(),
+  },
+  spinner: vi.fn(),
+}));
+
+vi.mock("chalk", () => ({
+  default: {
+    red: vi.fn((text) => `red:${text}`),
+    green: vi.fn((text) => `green:${text}`),
+    yellow: vi.fn((text) => `yellow:${text}`),
+    blue: vi.fn((text) => `blue:${text}`),
+  },
+}));
+
+describe("display", () => {
+  let mockSpinner: any;
+  let exitSpy: any;
+
+  beforeEach(() => {
+    mockSpinner = {
+      stop: vi.fn(),
+      start: vi.fn(),
+    };
+    vi.mocked(spinner).mockReturnValue(mockSpinner);
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(() => undefined as never);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    exitSpy.mockRestore();
+  });
+
+  it("should display error message and exit process", () => {
+    display("Error text", "error");
+    expect(log.error).toHaveBeenCalledWith("red:Error text");
+    expect(exitSpy).toHaveBeenCalledWith(0);
+  });
+
+  it("should display success message", () => {
+    display("Success text", "success");
+    expect(log.success).toHaveBeenCalledWith("green:Success text");
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it("should display warning message", () => {
+    display("Warning text", "warning");
+    expect(log.warn).toHaveBeenCalledWith("yellow:Warning text");
+  });
+
+  it("should display info message", () => {
+    display("Info text", "info");
+    expect(log.info).toHaveBeenCalledWith("blue:Info text");
+  });
+
+  it("should start spinner for loading type", () => {
+    const result = display("Loading text", "loading");
+    expect(mockSpinner.start).toHaveBeenCalledWith("Loading text");
+    expect(result).toBe(mockSpinner);
+  });
+
+  it("should display plain message for default/empty type", () => {
+    display("Plain text", "");
+    expect(log.message).toHaveBeenCalledWith("Plain text");
+  });
+
+  it("should display plain message when type is not recognized", () => {
+    display("Unknown text", "unknown" as any);
+    expect(log.message).toHaveBeenCalledWith("Unknown text");
+  });
+});