create-acmekit-app 2.13.1

package/src/utils/__tests__/package-manager.test.ts

@@ -0,0 +1,637 @@
+import PackageManager from "../package-manager"
+import ProcessManager from "../process-manager"
+import execute from "../execute"
+import { existsSync, rmSync } from "fs"
+import logMessage from "../log-message"
+
+// Mock dependencies
+jest.mock("../execute")
+jest.mock("fs")
+jest.mock("../log-message")
+
+const mockExecute = execute as jest.MockedFunction<typeof execute>
+const mockExistsSync = existsSync as jest.MockedFunction<typeof existsSync>
+const mockRmSync = rmSync as jest.MockedFunction<typeof rmSync>
+const mockLogMessage = logMessage as jest.MockedFunction<typeof logMessage>
+
+describe("PackageManager", () => {
+  let processManager: ProcessManager
+  let originalEnv: NodeJS.ProcessEnv
+
+  beforeEach(() => {
+    processManager = new ProcessManager()
+    originalEnv = { ...process.env }
+    jest.clearAllMocks()
+  })
+
+  afterEach(() => {
+    process.env = originalEnv
+  })
+
+  describe("constructor", () => {
+    it("should initialize with default options", () => {
+      const pm = new PackageManager(processManager)
+      expect(pm.getPackageManager()).toBeUndefined()
+    })
+
+    it("should set npm as chosen package manager when useNpm is true", () => {
+      const pm = new PackageManager(processManager, { useNpm: true })
+      expect(pm["chosenPackageManager"]).toBe("npm")
+    })
+
+    it("should set yarn as chosen package manager when useYarn is true", () => {
+      const pm = new PackageManager(processManager, { useYarn: true })
+      expect(pm["chosenPackageManager"]).toBe("yarn")
+    })
+
+    it("should set pnpm as chosen package manager when usePnpm is true", () => {
+      const pm = new PackageManager(processManager, { usePnpm: true })
+      expect(pm["chosenPackageManager"]).toBe("pnpm")
+    })
+
+    it("should respect verbose option", () => {
+      const pm = new PackageManager(processManager, { verbose: true })
+      expect(pm["verbose"]).toBe(true)
+    })
+
+    it("should prioritize npm over other options", () => {
+      const pm = new PackageManager(processManager, {
+        useNpm: true,
+        useYarn: true,
+        usePnpm: true,
+      })
+      expect(pm["chosenPackageManager"]).toBe("npm")
+    })
+  })
+
+  describe("detectFromUserAgent", () => {
+    it("should detect pnpm from user agent with version", () => {
+      process.env.npm_config_user_agent = "pnpm/8.0.0"
+      const pm = new PackageManager(processManager)
+      const result = pm["detectFromUserAgent"]()
+      expect(result.manager).toBe("pnpm")
+      expect(result.version).toBe("8.0.0")
+    })
+
+    it("should detect pnpm from pnpx with version", () => {
+      process.env.npm_config_user_agent = "pnpx/8.0.0"
+      const pm = new PackageManager(processManager)
+      const result = pm["detectFromUserAgent"]()
+      expect(result.manager).toBe("pnpm")
+      expect(result.version).toBe("8.0.0")
+    })
+
+    it("should detect yarn from user agent with version", () => {
+      process.env.npm_config_user_agent = "yarn/1.22.0"
+      const pm = new PackageManager(processManager)
+      const result = pm["detectFromUserAgent"]()
+      expect(result.manager).toBe("yarn")
+      expect(result.version).toBe("1.22.0")
+    })
+
+    it("should default to npm for unknown user agent", () => {
+      process.env.npm_config_user_agent = "some-unknown-manager/1.0.0"
+      const pm = new PackageManager(processManager)
+      const result = pm["detectFromUserAgent"]()
+      expect(result.manager).toBe("npm")
+      expect(result.version).toBeUndefined()
+    })
+
+    it("should default to npm when user agent is undefined", () => {
+      delete process.env.npm_config_user_agent
+      const pm = new PackageManager(processManager)
+      const result = pm["detectFromUserAgent"]()
+      expect(result.manager).toBe("npm")
+      expect(result.version).toBeUndefined()
+    })
+  })
+
+  describe("setPackageManager", () => {
+    it("should not run if package manager is already set", async () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "yarn"
+
+      await pm.setPackageManager({})
+
+      expect(mockExecute).not.toHaveBeenCalled()
+    })
+
+    it("should set chosen package manager if available", async () => {
+      mockExecute.mockResolvedValue({ stdout: "8.0.0", stderr: "" })
+      const pm = new PackageManager(processManager, { usePnpm: true })
+
+      await pm.setPackageManager({})
+
+      expect(pm.getPackageManager()).toBe("pnpm")
+      expect(await pm.getPackageManagerString()).toBe("pnpm@8.0.0")
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["pnpm -v", {}],
+        { verbose: false }
+      )
+    })
+
+    it("should throw error when chosen package manager is not available", async () => {
+      mockExecute.mockRejectedValueOnce(new Error("Command not found"))
+
+      const pm = new PackageManager(processManager, { usePnpm: true })
+
+      await pm.setPackageManager({})
+
+      expect(mockLogMessage).toHaveBeenCalledWith({
+        type: "error",
+        message: expect.stringContaining('"pnpm" is not available'),
+      })
+    })
+
+    it("should detect from user agent when no package manager chosen", async () => {
+      process.env.npm_config_user_agent = "yarn/1.22.0"
+
+      const pm = new PackageManager(processManager)
+      await pm.setPackageManager({})
+
+      expect(pm.getPackageManager()).toBe("yarn")
+      expect(await pm.getPackageManagerString()).toBe("yarn@1.22.0")
+      // Detection message should not be logged in non-verbose mode
+      expect(mockLogMessage).not.toHaveBeenCalledWith({
+        type: "info",
+        message: expect.stringContaining('Using detected package manager "yarn"'),
+      })
+      // Should not call getVersion since version is in user agent
+      expect(mockExecute).not.toHaveBeenCalled()
+    })
+
+    it("should use detected package manager even without version in user agent", async () => {
+      mockExecute.mockResolvedValue({ stdout: "1.22.0", stderr: "" })
+      process.env.npm_config_user_agent = "yarn"
+
+      const pm = new PackageManager(processManager)
+      await pm.setPackageManager({})
+
+      expect(pm.getPackageManager()).toBe("yarn")
+      expect(await pm.getPackageManagerString()).toBe("yarn@1.22.0")
+      // Should call getVersion since version is not in user agent
+      expect(mockExecute).toHaveBeenCalledWith(["yarn -v", {}], {
+        verbose: false,
+      })
+      // Fallback message should not be logged in non-verbose mode
+      expect(mockLogMessage).not.toHaveBeenCalledWith({
+        type: "info",
+        message: expect.stringContaining("Falling back to"),
+      })
+    })
+
+    it("should log detection messages in verbose mode", async () => {
+      process.env.npm_config_user_agent = "yarn/1.22.0"
+
+      const pm = new PackageManager(processManager, { verbose: true })
+      await pm.setPackageManager({})
+
+      expect(pm.getPackageManager()).toBe("yarn")
+      expect(mockLogMessage).toHaveBeenCalledWith({
+        type: "info",
+        message: expect.stringContaining('Using detected package manager "yarn"'),
+      })
+      // Should not call getVersion since version is in user agent
+      expect(mockExecute).not.toHaveBeenCalled()
+    })
+
+    it("should log fallback messages in verbose mode when no version in user agent", async () => {
+      mockExecute.mockResolvedValue({ stdout: "1.22.0", stderr: "" })
+      process.env.npm_config_user_agent = "yarn"
+
+      const pm = new PackageManager(processManager, { verbose: true })
+      await pm.setPackageManager({})
+
+      expect(pm.getPackageManager()).toBe("yarn")
+      expect(mockLogMessage).toHaveBeenCalledWith({
+        type: "info",
+        message: expect.stringContaining("Falling back to yarn"),
+      })
+      // Should call getVersion to get the version
+      expect(mockExecute).toHaveBeenCalledWith(["yarn -v", {}], {
+        verbose: false,
+      })
+    })
+  })
+
+  describe("removeLockFiles", () => {
+    it("should not remove files if package manager is not set", async () => {
+      const pm = new PackageManager(processManager)
+
+      await pm.removeLockFiles("/test/path")
+
+      expect(mockExistsSync).not.toHaveBeenCalled()
+      expect(mockRmSync).not.toHaveBeenCalled()
+    })
+
+    it("should remove yarn.lock, pnpm-lock.yaml, and .yarn when using npm", async () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "npm"
+      mockExistsSync.mockReturnValue(true)
+
+      await pm.removeLockFiles("/test/path")
+
+      expect(mockExistsSync).toHaveBeenCalledWith("/test/path/yarn.lock")
+      expect(mockExistsSync).toHaveBeenCalledWith("/test/path/pnpm-lock.yaml")
+      expect(mockExistsSync).toHaveBeenCalledWith("/test/path/.yarn")
+      expect(mockRmSync).toHaveBeenCalledWith("/test/path/yarn.lock", {
+        force: true,
+        recursive: true,
+      })
+      expect(mockRmSync).toHaveBeenCalledWith("/test/path/pnpm-lock.yaml", {
+        force: true,
+        recursive: true,
+      })
+      expect(mockRmSync).toHaveBeenCalledWith("/test/path/.yarn", {
+        force: true,
+        recursive: true,
+      })
+    })
+
+    it("should remove package-lock.json and pnpm-lock.yaml when using yarn", async () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "yarn"
+      mockExistsSync.mockReturnValue(true)
+
+      await pm.removeLockFiles("/test/path")
+
+      expect(mockExistsSync).toHaveBeenCalledWith("/test/path/package-lock.json")
+      expect(mockExistsSync).toHaveBeenCalledWith("/test/path/pnpm-lock.yaml")
+      expect(mockRmSync).toHaveBeenCalledWith("/test/path/package-lock.json", {
+        force: true,
+        recursive: true,
+      })
+      expect(mockRmSync).toHaveBeenCalledWith("/test/path/pnpm-lock.yaml", {
+        force: true,
+        recursive: true,
+      })
+    })
+
+    it("should remove yarn.lock, package-lock.json, and .yarn when using pnpm", async () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "pnpm"
+      mockExistsSync.mockReturnValue(true)
+
+      await pm.removeLockFiles("/test/path")
+
+      expect(mockExistsSync).toHaveBeenCalledWith("/test/path/yarn.lock")
+      expect(mockExistsSync).toHaveBeenCalledWith("/test/path/package-lock.json")
+      expect(mockExistsSync).toHaveBeenCalledWith("/test/path/.yarn")
+      expect(mockRmSync).toHaveBeenCalledWith("/test/path/yarn.lock", {
+        force: true,
+        recursive: true,
+      })
+      expect(mockRmSync).toHaveBeenCalledWith("/test/path/package-lock.json", {
+        force: true,
+        recursive: true,
+      })
+      expect(mockRmSync).toHaveBeenCalledWith("/test/path/.yarn", {
+        force: true,
+        recursive: true,
+      })
+    })
+
+    it("should not remove files that don't exist", async () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "npm"
+      mockExistsSync.mockReturnValue(false)
+
+      await pm.removeLockFiles("/test/path")
+
+      expect(mockExistsSync).toHaveBeenCalled()
+      expect(mockRmSync).not.toHaveBeenCalled()
+    })
+  })
+
+  describe("installDependencies", () => {
+    it("should set package manager before installing if not set", async () => {
+      process.env.npm_config_user_agent = "yarn/1.22.0"
+
+      const pm = new PackageManager(processManager)
+      await pm.installDependencies({ cwd: "/test/path" })
+
+      expect(pm.getPackageManager()).toBe("yarn")
+    })
+
+    it("should remove lock files before installing", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+      mockExistsSync.mockReturnValue(true)
+
+      const pm = new PackageManager(processManager, { useNpm: true })
+      pm["packageManager"] = "npm"
+
+      await pm.installDependencies({ cwd: "/test/path" })
+
+      expect(mockRmSync).toHaveBeenCalled()
+    })
+
+    it("should execute yarn command when using yarn", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "yarn"
+
+      await pm.installDependencies({ cwd: "/test/path" })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["yarn", { cwd: "/test/path" }],
+        { verbose: false }
+      )
+    })
+
+    it("should execute pnpm install when using pnpm", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "pnpm"
+
+      await pm.installDependencies({ cwd: "/test/path" })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["pnpm install", { cwd: "/test/path" }],
+        { verbose: false }
+      )
+    })
+
+    it("should execute npm install then npm ci when using npm", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "npm"
+
+      await pm.installDependencies({ cwd: "/test/path" })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["npm install", { cwd: "/test/path" }],
+        { verbose: false }
+      )
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["npm ci", { cwd: "/test/path" }],
+        { verbose: false }
+      )
+      expect(mockExecute).toHaveBeenCalledTimes(2)
+    })
+
+    it("should re-run npm install if npm ci fails", async () => {
+      mockExecute
+        .mockResolvedValueOnce({ stdout: "", stderr: "" }) // npm install succeeds
+        .mockRejectedValueOnce(new Error("npm ci failed")) // npm ci fails
+        .mockResolvedValueOnce({ stdout: "", stderr: "" }) // npm install retry succeeds
+
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "npm"
+
+      await pm.installDependencies({ cwd: "/test/path" })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["npm install", { cwd: "/test/path" }],
+        { verbose: false }
+      )
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["npm ci", { cwd: "/test/path" }],
+        { verbose: false }
+      )
+      // Second npm install call
+      expect(mockExecute).toHaveBeenCalledTimes(3)
+    })
+
+    it("should respect verbose option", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+
+      const pm = new PackageManager(processManager, { verbose: true })
+      pm["packageManager"] = "yarn"
+
+      await pm.installDependencies({ cwd: "/test/path" })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.anything(),
+        { verbose: true }
+      )
+    })
+  })
+
+  describe("getCommandStr", () => {
+    it("should throw error if package manager is not set", () => {
+      const pm = new PackageManager(processManager)
+
+      expect(() => pm.getCommandStr("dev")).toThrow("Package manager not set")
+    })
+
+    it("should return yarn command format", () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "yarn"
+
+      expect(pm.getCommandStr("dev")).toBe("yarn dev")
+    })
+
+    it("should return pnpm command format", () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "pnpm"
+
+      expect(pm.getCommandStr("build")).toBe("pnpm build")
+    })
+
+    it("should return npm command format with 'run'", () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "npm"
+
+      expect(pm.getCommandStr("test")).toBe("npm run test")
+    })
+  })
+
+  describe("runCommand", () => {
+    it("should set package manager before running if not set", async () => {
+      process.env.npm_config_user_agent = "yarn/1.22.0"
+
+      const pm = new PackageManager(processManager)
+      await pm.runCommand("dev", { cwd: "/test/path" })
+
+      expect(pm.getPackageManager()).toBe("yarn")
+    })
+
+    it("should execute command with correct format for yarn", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "yarn"
+
+      await pm.runCommand("dev", { cwd: "/test/path" })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["yarn dev", { cwd: "/test/path" }],
+        { verbose: false }
+      )
+    })
+
+    it("should execute command with correct format for npm", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "npm"
+
+      await pm.runCommand("build", { cwd: "/test/path" })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["npm run build", { cwd: "/test/path" }],
+        { verbose: false }
+      )
+    })
+
+    it("should pass through verbose options", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+
+      const pm = new PackageManager(processManager, { verbose: true })
+      pm["packageManager"] = "yarn"
+
+      await pm.runCommand("dev", { cwd: "/test/path" }, { needOutput: true })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.anything(),
+        { verbose: true, needOutput: true }
+      )
+    })
+
+    it("should return execution result", async () => {
+      const result = { stdout: "success", stderr: "" }
+      mockExecute.mockResolvedValue(result)
+
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "yarn"
+
+      const output = await pm.runCommand("dev", {})
+
+      expect(output).toEqual(result)
+    })
+  })
+
+  describe("runAcmeKitCommand", () => {
+    it("should set package manager before running if not set", async () => {
+      process.env.npm_config_user_agent = "yarn/1.22.0"
+
+      const pm = new PackageManager(processManager)
+      await pm.runAcmeKitCommand("migrate", { cwd: "/test/path" })
+
+      expect(pm.getPackageManager()).toBe("yarn")
+    })
+
+    it("should execute yarn acmekit command for yarn", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "yarn"
+
+      await pm.runAcmeKitCommand("migrate", { cwd: "/test/path" })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["yarn acmekit migrate", { cwd: "/test/path" }],
+        { verbose: false }
+      )
+    })
+
+    it("should execute pnpm acmekit command for pnpm", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "pnpm"
+
+      await pm.runAcmeKitCommand("seed", { cwd: "/test/path" })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["pnpm acmekit seed", { cwd: "/test/path" }],
+        { verbose: false }
+      )
+    })
+
+    it("should execute npx acmekit command for npm", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "npm"
+
+      await pm.runAcmeKitCommand("start", { cwd: "/test/path" })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        ["npx acmekit start", { cwd: "/test/path" }],
+        { verbose: false }
+      )
+    })
+
+    it("should pass through verbose options", async () => {
+      mockExecute.mockResolvedValue({ stdout: "", stderr: "" })
+
+      const pm = new PackageManager(processManager, { verbose: true })
+      pm["packageManager"] = "yarn"
+
+      await pm.runAcmeKitCommand("migrate", { cwd: "/test/path" }, { needOutput: true })
+
+      expect(mockExecute).toHaveBeenCalledWith(
+        expect.anything(),
+        { verbose: true, needOutput: true }
+      )
+    })
+
+    it("should return execution result", async () => {
+      const result = { stdout: "migration complete", stderr: "" }
+      mockExecute.mockResolvedValue(result)
+
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "yarn"
+
+      const output = await pm.runAcmeKitCommand("migrate", {})
+
+      expect(output).toEqual(result)
+    })
+  })
+
+  describe("getPackageManager", () => {
+    it("should return undefined when not set", () => {
+      const pm = new PackageManager(processManager)
+      expect(pm.getPackageManager()).toBeUndefined()
+    })
+
+    it("should return the current package manager", () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "yarn"
+      expect(pm.getPackageManager()).toBe("yarn")
+    })
+  })
+
+  describe("getPackageManagerString", () => {
+    it("should return undefined when version is not set", async () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "yarn"
+      expect(await pm.getPackageManagerString()).toBeUndefined()
+    })
+
+    it("should return packageManager@version format", async () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "yarn"
+      pm["packageManagerVersion"] = "4.9.0"
+      expect(await pm.getPackageManagerString()).toBe("yarn@4.9.0")
+    })
+
+    it("should work with pnpm", async () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "pnpm"
+      pm["packageManagerVersion"] = "8.15.0"
+      expect(await pm.getPackageManagerString()).toBe("pnpm@8.15.0")
+    })
+
+    it("should work with npm", async () => {
+      const pm = new PackageManager(processManager)
+      pm["packageManager"] = "npm"
+      pm["packageManagerVersion"] = "10.0.0"
+      expect(await pm.getPackageManagerString()).toBe("npm@10.0.0")
+    })
+
+    it("should call setPackageManager if package manager is not set", async () => {
+      process.env.npm_config_user_agent = "yarn/1.22.0"
+
+      const pm = new PackageManager(processManager)
+      const result = await pm.getPackageManagerString()
+
+      expect(pm.getPackageManager()).toBe("yarn")
+      expect(result).toBe("yarn@1.22.0")
+    })
+  })
+})