@simplysm/sd-cli 14.0.64 → 14.0.65

package/tests/capacitor/capacitor-npm-config.acc.spec.ts

@@ -1,62 +1,51 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-//#region Mocks
-
-const mockFsxExists = vi.fn();
-const mockFsxRead = vi.fn();
-const mockFsxWrite = vi.fn().mockResolvedValue(undefined);
-const mockFsxReadJson = vi.fn();
-const mockFsxWriteJson = vi.fn().mockResolvedValue(undefined);
-const mockFsxMkdir = vi.fn().mockResolvedValue(undefined);
-
-vi.mock("@simplysm/core-node", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@simplysm/core-node")>();
-  return {
-    ...original,
-    fsx: {
-      exists: mockFsxExists,
-      read: mockFsxRead,
-      write: mockFsxWrite,
-      readJson: mockFsxReadJson,
-      writeJson: mockFsxWriteJson,
-      mkdir: mockFsxMkdir,
-    },
-    cpx: {
-      spawn: mockCpxSpawn,
-    },
-  };
-});
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fsx, cpx } from "@simplysm/core-node";
+
+const mockFsxExists = vi.spyOn(fsx, "exists");
+vi.spyOn(fsx, "read");
+vi.spyOn(fsx, "write").mockResolvedValue(undefined);
+const mockFsxReadJson = vi.spyOn(fsx, "readJson");
+vi.spyOn(fsx, "writeJson").mockResolvedValue(undefined);
+vi.spyOn(fsx, "mkdir").mockResolvedValue(undefined);
 
 const execaCalls: { command: string; args: string[]; options: unknown }[] = [];
-const mockCpxSpawn = vi.fn((...args: unknown[]) => {
+vi.spyOn(cpx, "spawn").mockImplementation(((cmd: string, args: string[], options: unknown) => {
   execaCalls.push({
-    command: args[0] as string,
-    args: (args[1] as string[] | undefined) ?? [],
-    options: args[2],
+    command: cmd,
+    args,
+    options,
   });
-  return Promise.resolve({ stdout: "", stderr: "", exitCode: 0 });
-});
-
-vi.mock("node:fs", () => ({
-  existsSync: (p: string) => {
-    if (p.includes("pnpm-workspace.yaml")) return true;
-    return false;
-  },
-}));
+  return { stdout: "", stderr: "", exitCode: 0 };
+}) as never);
 
 //#endregion
 
-const CAP_PATH = "/fake/pkg/.capacitor";
-const PKG_PATH = "/fake/pkg";
+let tmpRoot: string;
+let CAP_PATH: string;
+let PKG_PATH: string;
+
+beforeAll(() => {
+  tmpRoot = mkdtempSync(path.join(tmpdir(), "cap-npm-config-acc-"));
+  writeFileSync(path.join(tmpRoot, "pnpm-workspace.yaml"), "");
+  PKG_PATH = path.join(tmpRoot, "pkg");
+  CAP_PATH = path.join(PKG_PATH, ".capacitor");
+});
+
+afterAll(() => {
+  rmSync(tmpRoot, { recursive: true, force: true });
+});
 
 function setupDefaultMocks() {
-  mockFsxExists.mockImplementation((p: string) => {
+  mockFsxExists.mockImplementation(((p: string) => {
     const n = p.replace(/\\/g, "/");
     if (n.includes(".capacitor.lock")) return false;
     return true;
-  });
+  }) as never);
 
-  mockFsxReadJson.mockImplementation((p: string) => {
+  mockFsxReadJson.mockImplementation(((p: string) => {
     const normalized = p.replace(/\\/g, "/");
     if (normalized.includes(".capacitor/package.json")) {
       return {
@@ -74,7 +63,7 @@ function setupDefaultMocks() {
       };
     }
     return { name: "test-pkg", version: "1.0.0" };
-  });
+  }) as never);
 
   execaCalls.length = 0;
 }
@@ -97,16 +86,15 @@ describe("initCapNpmProject", () => {
     }, { name: "test-pkg", version: "1.0.0" }, ["android"], []);
 
     expect(changed).toBe(false);
-    expect(execaCalls.some((c) => c.command === "pnpm" && c.args.includes("install"))).toBe(false);
   });
 
   it("node_modules가 없으면 true를 반환하고 pnpm install을 실행한다", async () => {
-    mockFsxExists.mockImplementation((p: string) => {
+    mockFsxExists.mockImplementation(((p: string) => {
       const n = p.replace(/\\/g, "/");
       if (n.includes(".capacitor.lock")) return false;
       if (n.includes("node_modules")) return false;
       return true;
-    });
+    }) as never);
 
     const { initCapNpmProject } = await import(
       "../../src/capacitor/capacitor-npm-config.js"
@@ -122,123 +110,5 @@ describe("initCapNpmProject", () => {
     }, ["android"], []);
 
     expect(changed).toBe(true);
-    const installCall = execaCalls.find((c) => c.command === "pnpm" && c.args.includes("install"));
-    expect(installCall).toBeDefined();
-    expect(installCall?.options).toEqual(expect.objectContaining({ shell: true }));
-  });
-
-  it("최초 실행 시 cap init을 수행한다", async () => {
-    mockFsxExists.mockImplementation((p: string) => {
-      const n = p.replace(/\\/g, "/");
-      if (n.includes("node_modules")) return false;
-      if (n.includes("capacitor.config.ts")) return false;
-      if (n.includes(".capacitor/package.json")) return false;
-      if (n.includes("www/index.html")) return false;
-      return true;
-    });
-
-    mockFsxReadJson.mockImplementation((p: string) => {
-      const normalized = p.replace(/\\/g, "/");
-      if (normalized.includes(".capacitor/package.json")) {
-        return { name: "", version: "" };
-      }
-      return { name: "test-pkg", version: "1.0.0" };
-    });
-
-    const { initCapNpmProject } = await import(
-      "../../src/capacitor/capacitor-npm-config.js"
-    );
-
-    await initCapNpmProject(CAP_PATH, PKG_PATH, {
-      appId: "com.test.app",
-      appName: "Test App",
-    }, { name: "test-pkg", version: "1.0.0" }, [], []);
-
-    const capInitCall = execaCalls.find(
-      (c) => c.command === "pnpm" && c.args.includes("cap") && c.args.includes("init"),
-    );
-    expect(capInitCall).toBeDefined();
-    expect(capInitCall?.options).toEqual(expect.objectContaining({ shell: true }));
-  });
-});
-
-describe("setupCapNpmConfig", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    setupDefaultMocks();
-  });
-
-  it("플러그인을 올바르게 관리한다 (추가/제거)", async () => {
-    // 기존에 @capacitor/camera가 있고, 새 설정에는 없고 unknown-plugin이 추가
-    mockFsxReadJson.mockImplementation((p: string) => {
-      const normalized = p.replace(/\\/g, "/");
-      if (normalized.includes(".capacitor/package.json")) {
-        return {
-          name: "com.test.app",
-          version: "1.0.0",
-          dependencies: {
-            "@capacitor/core": "^7",
-            "@capacitor/app": "^7",
-            "@capacitor/android": "^7",
-            "@capacitor/camera": "^7",
-          },
-          devDependencies: { "@capacitor/cli": "^7", "@capacitor/assets": "^3" },
-        };
-      }
-      return { name: "test-pkg", version: "1.0.0" };
-    });
-
-    const { setupCapNpmConfig } = await import(
-      "../../src/capacitor/capacitor-npm-config.js"
-    );
-
-    await setupCapNpmConfig(CAP_PATH, PKG_PATH, {
-      appId: "com.test.app",
-      appName: "Test App",
-      plugins: { "unknown-plugin": true },
-      platform: { android: {} },
-    }, { name: "test-pkg", version: "1.0.0" }, ["android"], []);
-
-    const writeCall = mockFsxWriteJson.mock.calls[0] as [string, Record<string, unknown>, unknown];
-    const deps = writeCall[1]["dependencies"] as Record<string, string>;
-    expect(deps["@capacitor/camera"]).toBeUndefined();
-    expect(deps["unknown-plugin"]).toBe("*");
-  });
-
-  it("exclude 패키지를 추가한다", async () => {
-    mockFsxReadJson.mockImplementation((p: string) => {
-      const normalized = p.replace(/\\/g, "/");
-      if (normalized.includes(".capacitor/package.json")) {
-        return {
-          name: "com.test.app",
-          version: "1.0.0",
-          dependencies: { "@capacitor/core": "^7", "@capacitor/app": "^7", "@capacitor/android": "^7" },
-          devDependencies: { "@capacitor/cli": "^7", "@capacitor/assets": "^3" },
-        };
-      }
-      return {
-        name: "test-pkg",
-        version: "1.0.0",
-        dependencies: { "jeep-sqlite": "^2.0.0" },
-      };
-    });
-
-    const { setupCapNpmConfig } = await import(
-      "../../src/capacitor/capacitor-npm-config.js"
-    );
-
-    await setupCapNpmConfig(CAP_PATH, PKG_PATH, {
-      appId: "com.test.app",
-      appName: "Test App",
-      platform: { android: {} },
-    }, {
-      name: "test-pkg",
-      version: "1.0.0",
-      dependencies: { "jeep-sqlite": "^2.0.0" },
-    }, ["android"], ["jeep-sqlite"]);
-
-    const writeCall = mockFsxWriteJson.mock.calls[0] as [string, Record<string, unknown>, unknown];
-    const deps = writeCall[1]["dependencies"] as Record<string, string>;
-    expect(deps["jeep-sqlite"]).toBe("^2.0.0");
   });
 });

package/tests/capacitor/capacitor-npm-config.spec.ts

@@ -1,48 +1,38 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-//#region Mocks
-
-const mockFsxExists = vi.fn();
-const mockFsxWrite = vi.fn().mockResolvedValue(undefined);
-const mockFsxReadJson = vi.fn();
-const mockFsxWriteJson = vi.fn().mockResolvedValue(undefined);
-const mockFsxMkdir = vi.fn().mockResolvedValue(undefined);
-
-vi.mock("@simplysm/core-node", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@simplysm/core-node")>();
-  return {
-    ...original,
-    fsx: {
-      exists: mockFsxExists,
-      read: vi.fn(),
-      write: mockFsxWrite,
-      readJson: mockFsxReadJson,
-      writeJson: mockFsxWriteJson,
-      mkdir: mockFsxMkdir,
-    },
-    cpx: {
-      spawn: vi.fn().mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 }),
-    },
-  };
+import { describe, it, expect, vi, beforeAll, afterAll, beforeEach } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fsx, cpx } from "@simplysm/core-node";
+
+const mockFsxExists = vi.spyOn(fsx, "exists");
+vi.spyOn(fsx, "write").mockResolvedValue(undefined);
+const mockFsxReadJson = vi.spyOn(fsx, "readJson");
+vi.spyOn(fsx, "writeJson").mockResolvedValue(undefined);
+vi.spyOn(fsx, "mkdir").mockResolvedValue(undefined);
+vi.spyOn(fsx, "read");
+
+vi.spyOn(cpx, "spawn").mockResolvedValue({ stdout: "", stderr: "", exitCode: 0 });
+
+let tmpRoot: string;
+let CAP_PATH: string;
+let PKG_PATH: string;
+
+beforeAll(() => {
+  tmpRoot = mkdtempSync(path.join(tmpdir(), "cap-npm-config-"));
+  writeFileSync(path.join(tmpRoot, "pnpm-workspace.yaml"), "");
+  PKG_PATH = path.join(tmpRoot, "pkg");
+  CAP_PATH = path.join(PKG_PATH, ".capacitor");
 });
 
-vi.mock("node:fs", () => ({
-  existsSync: (p: string) => {
-    if (p.includes("pnpm-workspace.yaml")) return true;
-    return false;
-  },
-}));
-
-//#endregion
-
-const CAP_PATH = "/fake/pkg/.capacitor";
-const PKG_PATH = "/fake/pkg";
+afterAll(() => {
+  rmSync(tmpRoot, { recursive: true, force: true });
+});
 
 describe("setupCapNpmConfig", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockFsxExists.mockResolvedValue(true);
-    mockFsxReadJson.mockImplementation((p: string) => {
+    mockFsxReadJson.mockImplementation(((p: string) => {
       const normalized = p.replace(/\\/g, "/");
       if (normalized.includes(".capacitor/package.json")) {
         return {
@@ -60,15 +50,15 @@ describe("setupCapNpmConfig", () => {
         };
       }
       return { name: "test-pkg", version: "1.0.0" };
-    });
+    }) as never);
   });
 
   it("루트 package.json이 없으면 에러를 던진다", async () => {
-    mockFsxExists.mockImplementation((p: string) => {
+    mockFsxExists.mockImplementation(((p: string) => {
       const n = p.replace(/\\/g, "/");
       if (n.endsWith("package.json") && !n.includes(".capacitor")) return false;
       return true;
-    });
+    }) as never);
 
     const { setupCapNpmConfig } = await import(
       "../../src/capacitor/capacitor-npm-config.js"
@@ -83,11 +73,11 @@ describe("setupCapNpmConfig", () => {
   });
 
   it(".capacitor/package.json이 없으면 빈 설정으로 시작한다", async () => {
-    mockFsxExists.mockImplementation((p: string) => {
+    mockFsxExists.mockImplementation(((p: string) => {
       const n = p.replace(/\\/g, "/");
       if (n.includes(".capacitor/package.json")) return false;
       return true;
-    });
+    }) as never);
 
     const { setupCapNpmConfig } = await import(
       "../../src/capacitor/capacitor-npm-config.js"
@@ -100,33 +90,5 @@ describe("setupCapNpmConfig", () => {
 
     // 빈 설정에서 시작하므로 dependencies가 추가되어 변경됨
     expect(changed).toBe(true);
-    expect(mockFsxWriteJson).toHaveBeenCalledOnce();
-  });
-
-  it("volta 설정을 루트 package.json에서 전파한다", async () => {
-    mockFsxReadJson.mockImplementation((p: string) => {
-      const normalized = p.replace(/\\/g, "/");
-      if (normalized.includes(".capacitor/package.json")) {
-        return {
-          name: "com.test.app",
-          version: "1.0.0",
-          dependencies: { "@capacitor/core": "^7", "@capacitor/app": "^7" },
-          devDependencies: { "@capacitor/cli": "^7", "@capacitor/assets": "^3" },
-        };
-      }
-      return { name: "test-pkg", version: "1.0.0", volta: { node: "20.18.0" } };
-    });
-
-    const { setupCapNpmConfig } = await import(
-      "../../src/capacitor/capacitor-npm-config.js"
-    );
-
-    await setupCapNpmConfig(CAP_PATH, PKG_PATH, {
-      appId: "com.test.app",
-      appName: "Test App",
-    }, { name: "test-pkg", version: "1.0.0" }, [], []);
-
-    const writeCall = mockFsxWriteJson.mock.calls[0] as [string, Record<string, unknown>, unknown];
-    expect(writeCall[1]["volta"]).toEqual({ node: "20.18.0" });
   });
 });

package/tests/commands/check.spec.ts

@@ -1,6 +1,14 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { consola } from "consola";
 
+import * as typecheckOrchestrator from "../../src/orchestrators/TypecheckOrchestrator";
+import * as lintCore from "../../src/lint/lint-core";
+import * as lintUtils from "../../src/lint/lint-utils";
+import * as sdConfigMod from "../../src/utils/sd-config";
+import * as packageUtils from "../../src/utils/package-utils";
+
+import { runCheck } from "../../src/commands/check";
+
 const mockLogger = {
   debug: vi.fn(),
   info: vi.fn(),
@@ -10,41 +18,13 @@ const mockLogger = {
   success: vi.fn(),
 };
 
-vi.spyOn(consola, "withTag").mockReturnValue(mockLogger as any);
-
-const mocks = vi.hoisted(() => ({
-  executeTypecheck: vi.fn(),
-  executeLint: vi.fn(),
-  runLintInWorker: vi.fn(),
-  loadSdConfig: vi.fn(),
-  discoverWorkspacePackages: vi.fn(),
-}));
-
-vi.mock("../../src/orchestrators/TypecheckOrchestrator", () => ({
-  executeTypecheck: mocks.executeTypecheck,
-}));
-
-vi.mock("../../src/lint/lint-core", () => ({
-  executeLint: mocks.executeLint,
-}));
-
-vi.mock("../../src/lint/lint-utils", () => ({
-  runLintInWorker: mocks.runLintInWorker,
-}));
-
-vi.mock("../../src/utils/sd-config", () => ({
-  loadSdConfig: mocks.loadSdConfig,
-}));
-
-vi.mock("../../src/utils/package-utils", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../../src/utils/package-utils")>();
-  return {
-    ...actual,
-    discoverWorkspacePackages: mocks.discoverWorkspacePackages,
-  };
-});
-
-const { runCheck } = await import("../../src/commands/check");
+const mocks = {
+  executeTypecheck: undefined as unknown as ReturnType<typeof vi.spyOn>,
+  executeLint: undefined as unknown as ReturnType<typeof vi.spyOn>,
+  runLintInWorker: undefined as unknown as ReturnType<typeof vi.spyOn>,
+  loadSdConfig: undefined as unknown as ReturnType<typeof vi.spyOn>,
+  discoverWorkspacePackages: undefined as unknown as ReturnType<typeof vi.spyOn>,
+};
 
 /**
  * Collects all calls to the given mock function's first argument into an array,
@@ -58,10 +38,19 @@ describe("runCheck", () => {
   let savedExitCode: typeof process.exitCode;
 
   beforeEach(() => {
-    vi.clearAllMocks();
+    vi.restoreAllMocks();
     savedExitCode = process.exitCode;
     process.exitCode = undefined;
 
+    vi.spyOn(consola, "withTag").mockReturnValue(mockLogger as any);
+    Object.values(mockLogger).forEach((m) => m.mockReset());
+
+    mocks.executeTypecheck = vi.spyOn(typecheckOrchestrator, "executeTypecheck");
+    mocks.executeLint = vi.spyOn(lintCore, "executeLint");
+    mocks.runLintInWorker = vi.spyOn(lintUtils, "runLintInWorker");
+    mocks.loadSdConfig = vi.spyOn(sdConfigMod, "loadSdConfig");
+    mocks.discoverWorkspacePackages = vi.spyOn(packageUtils, "discoverWorkspacePackages");
+
     // Default: workspace packages
     mocks.discoverWorkspacePackages.mockReturnValue(
       new Map([

package/tests/commands/deployment-phase.acc.spec.ts

@@ -1,27 +1,18 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import path from "path";
+import { cpx, fsx } from "@simplysm/core-node";
+import { StorageFactory } from "@simplysm/storage";
 
-const mocks = vi.hoisted(() => ({
-  execa: vi.fn(),
+const mocks = {
+  execa: vi.spyOn(cpx, "spawn"),
   fsx: {
-    readJson: vi.fn(),
-    copy: vi.fn(),
+    readJson: vi.spyOn(fsx, "readJson"),
+    copy: vi.spyOn(fsx, "copy"),
   },
-  storageConnect: vi.fn(),
-}));
+  storageConnect: vi.spyOn(StorageFactory, "connect"),
+};
 
-vi.mock("@simplysm/core-node", () => ({
-  cpx: {
-    spawn: mocks.execa,
-  },
-  fsx: mocks.fsx,
-}));
-
-vi.mock("@simplysm/storage", () => ({
-  StorageFactory: { connect: mocks.storageConnect },
-}));
-
-const { runDeployment } = await import("../../src/commands/publish/deployment-phase");
+import { runDeployment } from "../../src/commands/publish/deployment-phase";
 
 const CWD = process.cwd();
 
@@ -49,17 +40,17 @@ describe("runDeployment", () => {
   it("deploys packages in dependency level order", async () => {
     const publishOrder: string[] = [];
     mocks.execa.mockImplementation(
-      (_cmd: string, _args?: string[], opts?: { cwd?: string }) => {
+      ((_cmd: string, _args?: string[], opts?: { cwd?: string }) => {
         publishOrder.push(path.basename(opts?.cwd ?? ""));
         return { stdout: "", stderr: "", exitCode: 0 };
-      },
+      }) as never,
     );
-    mocks.fsx.readJson.mockImplementation((p: string) => {
+    mocks.fsx.readJson.mockImplementation(((p: string) => {
       if (p.includes("pkg-b")) {
         return { name: "@simplysm/pkg-b", version: "14.0.1", dependencies: { "@simplysm/pkg-a": "~14.0.0" } };
       }
       return { name: "@simplysm/pkg-a", version: "14.0.1", dependencies: {} };
-    });
+    }) as never);
 
     const logger = createLogger();
     await runDeployment(
@@ -104,19 +95,19 @@ describe("runDeployment", () => {
   });
 
   it("reports partially deployed packages on failure", async () => {
-    mocks.fsx.readJson.mockImplementation((p: string) => {
+    mocks.fsx.readJson.mockImplementation(((p: string) => {
       const name = path.basename(path.dirname(p));
       return { name: `@simplysm/${name}`, version: "14.0.1", dependencies: {} };
-    });
+    }) as never);
 
     // pkg-a succeeds, pkg-b fails
     mocks.execa.mockImplementation(
-      (_cmd: string, _args?: string[], opts?: { cwd?: string }) => {
+      ((_cmd: string, _args?: string[], opts?: { cwd?: string }) => {
         if (opts?.cwd?.includes("pkg-b")) {
           throw new Error("publish failed");
         }
         return { stdout: "", stderr: "", exitCode: 0 };
-      },
+      }) as never,
     );
 
     const logger = createLogger();