pm-auto 1.0.5 → 1.0.7

package/tests/build_command.test.ts

@@ -1,37 +1,247 @@
 import { describe, it, expect } from "vitest";
-import { buildCommands, buildUninstallCommands } from "../src/build_command.js";
-import type { ConfigType } from "../src/types/index.js";
+import {
+  buildInstallCommands,
+  buildUninstallCommands,
+  cleanCommand,
+} from "../src/build_command.js";
+import type { CommandResult, ConfigType } from "../src/types/index.js";
 
-describe("buildCommand", () => {
-  const mockConfig: ConfigType[] = [
+describe("cleanCommand", () => {
+  it("should return a string of a command stripped of its flags", () => {
+    const commands = [
+      "lodash@latest",
+      "@react-three/fiber",
+      "@three/types -D",
+      "three --force",
+    ];
+    const results = [];
+    for (const command of commands) {
+      results.push(cleanCommand(command));
+    }
+    expect(results).toEqual([
+      "lodash",
+      "@react-three/fiber",
+      "@three/types",
+      "three",
+    ]);
+  });
+});
+
+const mockConfigs: Record<string, ConfigType[]> = {
+  pnpm: [
+    {
+      presetName: "vite",
+      packageManager: "pnpm",
+      packages: [
+        { command: "vite", interactive: true, version: "latest", flags: ["."] },
+        { command: "gsap", interactive: false, version: "latest" },
+        {
+          command: "react-dom",
+          interactive: false,
+          version: "latest",
+          dev: true,
+          flags: ["--legacy-peer-deps"],
+        },
+        {
+          command: "@react-three/fiber",
+          interactive: false,
+          version: "1.0.0",
+          dev: true,
+        },
+        {
+          command: "typescript",
+          interactive: false,
+          version: "latest",
+          dev: true,
+        },
+        { command: "clsx", interactive: false },
+        { command: "shadcn", interactive: true, version: "latest" },
+      ],
+    },
+  ],
+  yarn: [
+    {
+      presetName: "vite",
+      packageManager: "yarn",
+      packages: [
+        { command: "vite", interactive: true, version: "latest", flags: ["."] },
+        { command: "gsap", interactive: false, version: "latest" },
+        {
+          command: "react-dom",
+          interactive: false,
+          version: "latest",
+          dev: true,
+          flags: ["--peer-deps"],
+        },
+        {
+          command: "@react-three/fiber",
+          interactive: false,
+          version: "1.0.0",
+          dev: true,
+        },
+        {
+          command: "typescript",
+          interactive: false,
+          version: "latest",
+          dev: true,
+        },
+        { command: "clsx", interactive: false },
+        { command: "shadcn", interactive: true, version: "latest" },
+      ],
+    },
+  ],
+  npm: [
     {
-      name: "vite",
+      presetName: "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"],
-      },
-    ]);
-  });
+        { command: "vite", interactive: true, version: "latest", flags: ["."] },
+        { command: "gsap", interactive: false, version: "latest" },
+        {
+          command: "react-dom",
+          interactive: false,
+          version: "latest",
+          dev: true,
+          flags: ["--legacy-peer-deps"],
+        },
+        {
+          command: "@react-three/fiber",
+          interactive: false,
+          version: "1.0.0",
+          dev: true,
+        },
+        {
+          command: "typescript",
+          interactive: false,
+          version: "latest",
+          dev: true,
+        },
+        { command: "clsx", interactive: false },
+        { command: "shadcn", interactive: true, version: "latest" },
+      ],
+    },
+  ],
+  bun: [
+    {
+      presetName: "vite",
+      packageManager: "bun",
+      packages: [
+        { command: "vite", interactive: true, version: "latest", flags: ["."] },
+        { command: "gsap", interactive: false, version: "latest" },
+        {
+          command: "react-dom",
+          interactive: false,
+          version: "latest",
+          dev: true,
+          flags: ["--peer-deps"],
+        },
+        {
+          command: "@react-three/fiber",
+          interactive: false,
+          version: "1.0.0",
+          dev: true,
+        },
+        {
+          command: "typescript",
+          interactive: false,
+          version: "latest",
+          dev: true,
+        },
+        { command: "clsx", interactive: false },
+        { command: "shadcn", interactive: true, version: "latest" },
+      ],
+    },
+  ],
+};
 
-  it("builds an uninstallation command", () => {
-    const command = buildUninstallCommands(mockConfig);
-    expect(command).toEqual([
-      {
-        name: "vite",
-        interactive: [],
-        nonInteractive: ["npm uninstall gsap@latest"],
-      },
-    ]);
-  });
+const expectedInstall: Record<string, CommandResult[]> = {
+  pnpm: [
+    {
+      presetName: "vite",
+      interactive: ["pnpm dlx vite@latest .", "pnpm dlx shadcn@latest"],
+      nonInteractive: [
+        "pnpm add gsap@latest react-dom@latest -D --legacy-peer-deps @react-three/fiber@1.0.0 -D typescript@latest -D clsx",
+      ],
+    },
+  ],
+  yarn: [
+    {
+      presetName: "vite",
+      interactive: ["yarn dlx vite@latest .", "yarn dlx shadcn@latest"],
+      nonInteractive: [
+        "yarn add gsap@latest react-dom@latest -D --peer-deps @react-three/fiber@1.0.0 -D typescript@latest -D clsx",
+      ],
+    },
+  ],
+  npm: [
+    {
+      presetName: "vite",
+      interactive: ["npx vite@latest .", "npx shadcn@latest"],
+      nonInteractive: [
+        "npm install gsap@latest react-dom@latest -D --legacy-peer-deps @react-three/fiber@1.0.0 -D typescript@latest -D clsx",
+      ],
+    },
+  ],
+  bun: [
+    {
+      presetName: "vite",
+      interactive: ["bunx vite@latest .", "bunx shadcn@latest"],
+      nonInteractive: [
+        "bun add gsap@latest react-dom@latest -d --peer-deps @react-three/fiber@1.0.0 -d typescript@latest -d clsx",
+      ],
+    },
+  ],
+};
+
+const expectedUninstall: Record<string, CommandResult[]> = {
+  pnpm: [
+    {
+      presetName: "vite",
+      interactive: [],
+      nonInteractive: [
+        "pnpm remove gsap react-dom @react-three/fiber typescript clsx",
+      ],
+    },
+  ],
+  yarn: [
+    {
+      presetName: "vite",
+      interactive: [],
+      nonInteractive: [
+        "yarn remove gsap react-dom @react-three/fiber typescript clsx",
+      ],
+    },
+  ],
+  npm: [
+    {
+      presetName: "vite",
+      interactive: [],
+      nonInteractive: [
+        "npm uninstall gsap react-dom @react-three/fiber typescript clsx",
+      ],
+    },
+  ],
+  bun: [
+    {
+      presetName: "vite",
+      interactive: [],
+      nonInteractive: [
+        "bun remove gsap react-dom @react-three/fiber typescript clsx",
+      ],
+    },
+  ],
+};
+
+describe("buildCommand", () => {
+  for (const pm of Object.keys(mockConfigs)) {
+    it(`builds ${pm} installation command`, () => {
+      const command = buildInstallCommands(mockConfigs[pm]);
+      expect(command).toEqual(expectedInstall[pm]);
+    });
+
+    it(`builds ${pm} uninstallation command`, () => {
+      const command = buildUninstallCommands(mockConfigs[pm]);
+      expect(command).toEqual(expectedUninstall[pm]);
+    });
+  }
 });

package/tests/config_reader.test.ts

@@ -1,11 +1,9 @@
 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 { getConfigObject } from "../src/config_reader.js";
 import { getConfigPath } from "../src/config_path.js";
-import type { CommandResult, ConfigType } from "../src/types/index.js";
+import type { ConfigType } from "../src/types/index.js";
 import * as clack from "@clack/prompts";
 
 vi.mock("fs/promises");
@@ -15,55 +13,25 @@ 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 = {
+  const mockConfig: Record<string, ConfigType> = {
     react: {
-      name: "react",
-      packages: [{ command: "npm install react", interactive: false }],
+      presetName: "react",
+      packageManager: "pnpm",
+      packages: [
+        {
+          command: "npm install react",
+          interactive: false,
+          flags: ["--peers-deps"],
+        },
+      ],
     },
     vue: {
-      name: "vue",
-      packages: [{ command: "npm install vue", interactive: false }],
+      presetName: "vue",
+      packageManager: "npm",
+      packages: [
+        { command: "npm install vue", interactive: false, version: "latest" },
+      ],
     },
   };
 
@@ -79,41 +47,61 @@ describe("get Config Object", () => {
 
     expect(config).toEqual([
       {
-        name: "react",
-        packages: [{ command: "npm install react", interactive: false }],
+        presetName: "react",
+        packageManager: "pnpm",
+        packages: [
+          {
+            command: "npm install react",
+            interactive: false,
+            flags: ["--peers-deps"],
+          },
+        ],
       },
       {
-        name: "vue",
-        packages: [{ command: "npm install vue", interactive: false }],
+        presetName: "vue",
+        packageManager: "npm",
+        packages: [
+          { command: "npm install vue", interactive: false, version: "latest" },
+        ],
       },
-    ]);
+    ] as ConfigType[]);
     expect(display).toHaveBeenCalledWith(
       expect.stringContaining("Package 'next' not found in config"),
       "warning",
     );
   });
 
+  it("should display an error on invalid config file format", async () => {
+    vi.mocked(getConfigPath).mockReturnValue("/mock/config.json");
+    vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({ name: "help" }));
+
+    await getConfigObject(["react"], {});
+    expect(display).toHaveBeenCalledWith(
+      expect.stringContaining("Invalid config file format"),
+      "error",
+    );
+  });
+
   // 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([], {});
+  //   vi.mocked(getConfigPath).mockReturnValue("/");
+  //   vi.mocked(fs.readFile).mockRejectedValue("File not found");
+  //   await getConfigObject(["react"], {});
   //   expect(display).toHaveBeenCalledWith(
-  //     expect.stringContaining("Try updating the config file"),
+  //     expect.stringContaining("Try updating the config file path"),
   //     "error",
   //   );
   // });
-  //
 
-  it("adds command with addCommand option", async () => {
+  it("adds flags with addFlags 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",
+      addFlags: "--force",
     })) as ConfigType[];
 
-    if (result[0]?.packages[0]?.command) {
-      expect(result[0].packages[0].command).toContain("--save-dev");
+    if (result[0]?.packages[0]?.flags) {
+      expect(result[0].packages[0].flags).toContain("--force");
     }
   });
 
@@ -147,33 +135,4 @@ describe("get Config Object", () => {
 
     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

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