@simplysm/sd-cli 13.0.100 → 14.0.1

package/tests/engines/tsc-engine.spec.ts

@@ -0,0 +1,213 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// --- Mock factories (vi.mock is hoisted) ---
+
+vi.mock("consola", () => ({
+  consola: {
+    withTag: vi.fn(() => ({
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    })),
+  },
+}));
+
+const mockWorker = {
+  build: vi.fn(),
+  startWatch: vi.fn(),
+  stopWatch: vi.fn(),
+  terminate: vi.fn(),
+  on: vi.fn(),
+};
+
+vi.mock("@simplysm/core-node", () => ({
+  Worker: {
+    create: vi.fn(() => mockWorker),
+  },
+}));
+
+// --- Dynamic imports after mocking ---
+
+const { TscEngine } = await import("../../src/engines/TscEngine");
+
+import type { BuildPackageInfo } from "../../src/engines/types";
+
+// --- Helpers ---
+
+function createMockPkg(overrides: Partial<BuildPackageInfo> = {}): BuildPackageInfo {
+  return {
+    name: "test-pkg",
+    dir: "/packages/test-pkg",
+    config: { target: "node" } as any,
+    ...overrides,
+  };
+}
+
+function setupDefaultBuildResult(): void {
+  mockWorker.build.mockResolvedValue({
+    js: { success: true, errors: undefined, warnings: undefined },
+    dts: { success: true, errors: undefined, diagnostics: [] },
+  });
+  mockWorker.terminate.mockResolvedValue(undefined);
+  mockWorker.stopWatch.mockResolvedValue(undefined);
+}
+
+// --- Tests ---
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  setupDefaultBuildResult();
+});
+
+describe("TscEngine", () => {
+  // Acceptance: Scenario "run()으로 프로덕션 빌드 실행"
+  describe("run()", () => {
+    it("creates worker, calls build, and returns EngineResult", async () => {
+      const { Worker } = await import("@simplysm/core-node");
+      const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
+
+      const result = await engine.run({ js: true, dts: true });
+
+      expect(Worker.create).toHaveBeenCalledTimes(1);
+      expect(mockWorker.build).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "test-pkg",
+          pkgDir: "/packages/test-pkg",
+          output: { js: true, dts: true },
+        }),
+      );
+      expect(result.success).toBe(true);
+      expect(result.js.success).toBe(true);
+      expect(result.dts.success).toBe(true);
+      await engine.stop();
+    });
+
+    it("maps worker result to EngineResult with js/dts separation", async () => {
+      mockWorker.build.mockResolvedValue({
+        js: { success: true, errors: undefined, warnings: ["warn1"] },
+        dts: { success: true, errors: undefined, diagnostics: [{ code: 1, category: 0 }] },
+      });
+
+      const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
+      const result = await engine.run({ js: true, dts: true });
+
+      expect(result.js.warnings).toEqual(["warn1"]);
+      expect(result.dts.diagnostics).toEqual([{ code: 1, category: 0 }]);
+      await engine.stop();
+    });
+
+    it("reflects failure when tsc reports errors", async () => {
+      mockWorker.build.mockResolvedValue({
+        js: { success: false, errors: ["type error"], warnings: undefined },
+        dts: { success: false, errors: ["type error"], diagnostics: [{ code: 2322, category: 1 }] },
+      });
+
+      const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
+      const result = await engine.run({ js: true, dts: true });
+
+      expect(result.success).toBe(false);
+      expect(result.js.errors).toEqual(["type error"]);
+      expect(result.dts.diagnostics).toHaveLength(1);
+      await engine.stop();
+    });
+
+    it("passes output flags to worker", async () => {
+      const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.run({ js: false, dts: true });
+      expect(mockWorker.build).toHaveBeenCalledWith(
+        expect.objectContaining({ output: { js: false, dts: true } }),
+      );
+      await engine.stop();
+    });
+  });
+
+  // Acceptance: Scenario "startWatch()로 watch 모드 시작"
+  describe("startWatch()", () => {
+    it("resolves when initial build event arrives", async () => {
+      mockWorker.startWatch.mockImplementation(() => {
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({
+          js: { success: true },
+          dts: { success: true },
+        });
+      });
+
+      const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.startWatch({ js: true, dts: true });
+
+      expect(mockWorker.on).toHaveBeenCalledWith("build", expect.any(Function));
+      expect(mockWorker.on).toHaveBeenCalledWith("buildStart", expect.any(Function));
+      expect(mockWorker.on).toHaveBeenCalledWith("error", expect.any(Function));
+
+      await engine.stop();
+    });
+
+    it("reports build and dts results separately to ResultCollector", async () => {
+      const mockResultCollector = { add: vi.fn() };
+
+      mockWorker.startWatch.mockImplementation(() => {
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({
+          js: { success: true, errors: undefined },
+          dts: { success: false, errors: ["type error"] },
+        });
+      });
+
+      const engine = new TscEngine({
+        cwd: "/root",
+        pkg: createMockPkg(),
+        resultCollector: mockResultCollector as any,
+      });
+
+      await engine.startWatch({ js: true, dts: true });
+
+      const addCalls = mockResultCollector.add.mock.calls;
+      const buildResult = addCalls.find((c: any[]) => c[0].type === "build");
+      const dtsResult = addCalls.find((c: any[]) => c[0].type === "dts");
+
+      expect(buildResult).toBeDefined();
+      expect(buildResult![0].status).toBe("success");
+      expect(dtsResult).toBeDefined();
+      expect(dtsResult![0].status).toBe("error");
+
+      await engine.stop();
+    });
+  });
+
+  // Acceptance: Scenario "stop()으로 리소스 정리"
+  describe("stop()", () => {
+    it("calls stopWatch and terminate in watch mode", async () => {
+      mockWorker.startWatch.mockImplementation(() => {
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({ js: { success: true }, dts: { success: true } });
+      });
+
+      const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.startWatch({ js: true, dts: true });
+      await engine.stop();
+
+      expect(mockWorker.stopWatch).toHaveBeenCalled();
+      expect(mockWorker.terminate).toHaveBeenCalled();
+    });
+
+    it("handles stop without prior run/startWatch", async () => {
+      const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
+      await expect(engine.stop()).resolves.toBeUndefined();
+    });
+
+    it("skips stopWatch in run mode", async () => {
+      const engine = new TscEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.run({ js: true, dts: true });
+      await engine.stop();
+
+      expect(mockWorker.stopWatch).not.toHaveBeenCalled();
+      expect(mockWorker.terminate).toHaveBeenCalled();
+    });
+  });
+});

package/tests/engines/vite-engine.spec.ts

@@ -0,0 +1,358 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// --- Mock factories (vi.mock is hoisted) ---
+
+vi.mock("consola", () => ({
+  consola: {
+    withTag: vi.fn(() => ({
+      debug: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    })),
+  },
+}));
+
+const mockWorker = {
+  build: vi.fn(),
+  startWatch: vi.fn(),
+  stopWatch: vi.fn(),
+  terminate: vi.fn(),
+  on: vi.fn(),
+};
+
+vi.mock("@simplysm/core-node", () => ({
+  Worker: {
+    create: vi.fn(() => mockWorker),
+  },
+}));
+
+// --- Dynamic imports after mocking ---
+
+const { ViteEngine } = await import("../../src/engines/ViteEngine");
+
+import type { ClientPackageInfo } from "../../src/engines/types";
+
+// --- Helpers ---
+
+function createMockPkg(overrides: Partial<ClientPackageInfo> = {}): ClientPackageInfo {
+  return {
+    name: "my-client",
+    dir: "/packages/my-client",
+    config: { target: "client", server: "my-server" } as any,
+    ...overrides,
+  };
+}
+
+// --- Tests ---
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockWorker.terminate.mockResolvedValue(undefined);
+  mockWorker.stopWatch.mockResolvedValue(undefined);
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("ViteEngine", () => {
+  describe("run()", () => {
+    // Acceptance: Scenario "프로덕션 빌드 성공"
+    it("creates worker, calls build, and returns EngineResult with js success and dts always-success", async () => {
+      mockWorker.build.mockResolvedValue({
+        js: { success: true, errors: undefined, warnings: undefined },
+        dts: { success: true, errors: undefined, diagnostics: [] },
+      });
+
+      const engine = new ViteEngine({ cwd: "/root", pkg: createMockPkg() });
+      const result = await engine.run({ js: true, dts: false });
+
+      const { Worker } = await import("@simplysm/core-node");
+      expect(Worker.create).toHaveBeenCalledTimes(1);
+      expect(mockWorker.build).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "my-client",
+          pkgDir: "/packages/my-client",
+          output: { js: true, dts: false },
+        }),
+      );
+      expect(result.success).toBe(true);
+      expect(result.js.success).toBe(true);
+      expect(result.js.errors).toEqual([]);
+      expect(result.dts.success).toBe(true);
+      expect(result.dts.diagnostics).toEqual([]);
+      await engine.stop();
+    });
+
+    // Acceptance: Scenario "TypeScript 또는 Angular 에러로 빌드 실패"
+    it("returns failure EngineResult when build fails", async () => {
+      mockWorker.build.mockResolvedValue({
+        js: { success: false, errors: ["TS2345: Argument of type..."], warnings: undefined },
+        dts: { success: true, errors: undefined, diagnostics: [] },
+      });
+
+      const engine = new ViteEngine({ cwd: "/root", pkg: createMockPkg() });
+      const result = await engine.run({ js: true, dts: false });
+
+      expect(result.success).toBe(false);
+      expect(result.js.success).toBe(false);
+      expect(result.js.errors).toContain("TS2345: Argument of type...");
+      await engine.stop();
+    });
+
+    // Unit: warnings are mapped through
+    it("maps worker warnings to EngineResult", async () => {
+      mockWorker.build.mockResolvedValue({
+        js: { success: true, errors: undefined, warnings: ["deprecation warning"] },
+        dts: { success: true, errors: undefined, diagnostics: [] },
+      });
+
+      const engine = new ViteEngine({ cwd: "/root", pkg: createMockPkg() });
+      const result = await engine.run({ js: true, dts: false });
+
+      expect(result.js.warnings).toEqual(["deprecation warning"]);
+      await engine.stop();
+    });
+
+    // Unit: dts is always success for client packages (D2)
+    it("always returns dts success regardless of build outcome", async () => {
+      mockWorker.build.mockResolvedValue({
+        js: { success: false, errors: ["error"], warnings: undefined },
+        dts: { success: true, errors: undefined, diagnostics: [] },
+      });
+
+      const engine = new ViteEngine({ cwd: "/root", pkg: createMockPkg() });
+      const result = await engine.run({ js: true, dts: false });
+
+      expect(result.dts.success).toBe(true);
+      expect(result.dts.diagnostics).toEqual([]);
+      await engine.stop();
+    });
+  });
+
+  describe("stop()", () => {
+    // Acceptance: Scenario "stop()으로 엔진 정리"
+    it("terminates worker on stop", async () => {
+      mockWorker.build.mockResolvedValue({
+        js: { success: true, errors: undefined, warnings: undefined },
+        dts: { success: true, errors: undefined, diagnostics: [] },
+      });
+
+      const engine = new ViteEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.run({ js: true, dts: false });
+      await engine.stop();
+
+      expect(mockWorker.terminate).toHaveBeenCalled();
+    });
+
+    it("handles stop without prior run", async () => {
+      const engine = new ViteEngine({ cwd: "/root", pkg: createMockPkg() });
+      await expect(engine.stop()).resolves.toBeUndefined();
+    });
+
+    // Unit: run mode doesn't call stopWatch
+    it("skips stopWatch in run mode", async () => {
+      mockWorker.build.mockResolvedValue({
+        js: { success: true, errors: undefined, warnings: undefined },
+        dts: { success: true, errors: undefined, diagnostics: [] },
+      });
+
+      const engine = new ViteEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.run({ js: true, dts: false });
+      await engine.stop();
+
+      expect(mockWorker.stopWatch).not.toHaveBeenCalled();
+      expect(mockWorker.terminate).toHaveBeenCalled();
+    });
+
+    // Unit: watch mode calls stopWatch
+    it("calls stopWatch in watch mode before terminate", async () => {
+      mockWorker.startWatch.mockImplementation(() => {
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({
+          js: { success: true },
+          dts: { success: true },
+        });
+      });
+
+      const engine = new ViteEngine({ cwd: "/root", pkg: createMockPkg() });
+      await engine.startWatch({ js: true, dts: false });
+      await engine.stop();
+
+      expect(mockWorker.stopWatch).toHaveBeenCalled();
+      expect(mockWorker.terminate).toHaveBeenCalled();
+    });
+  });
+
+  describe("startWatch()", () => {
+    // Acceptance: Scenario "개발 서버 시작 및 initial build 완료"
+    it("resolves when initial build event arrives", async () => {
+      mockWorker.startWatch.mockImplementation(() => {
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({
+          js: { success: true },
+          dts: { success: true },
+        });
+      });
+
+      const { Worker } = await import("@simplysm/core-node");
+      const engine = new ViteEngine({ cwd: "/root", pkg: createMockPkg() });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      expect(Worker.create).toHaveBeenCalledTimes(1);
+      expect(mockWorker.on).toHaveBeenCalledWith("build", expect.any(Function));
+      expect(mockWorker.on).toHaveBeenCalledWith("buildStart", expect.any(Function));
+      expect(mockWorker.on).toHaveBeenCalledWith("error", expect.any(Function));
+      expect(mockWorker.on).toHaveBeenCalledWith("serverReady", expect.any(Function));
+
+      await engine.stop();
+    });
+
+    // Acceptance: Scenario "파일 변경 시 rebuild 보고"
+    it("reports build and dts results separately to ResultCollector", async () => {
+      const mockResultCollector = { add: vi.fn() };
+
+      mockWorker.startWatch.mockImplementation(() => {
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({
+          js: { success: true, errors: undefined },
+          dts: { success: true, errors: undefined },
+        });
+      });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg(),
+        resultCollector: mockResultCollector as any,
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      const addCalls = mockResultCollector.add.mock.calls;
+      const buildResult = addCalls.find((c: any[]) => c[0].type === "build");
+      const dtsResult = addCalls.find((c: any[]) => c[0].type === "dts");
+
+      expect(buildResult).toBeDefined();
+      expect(buildResult![0].status).toBe("success");
+      expect(dtsResult).toBeDefined();
+      expect(dtsResult![0].status).toBe("success");
+
+      await engine.stop();
+    });
+
+    // Acceptance: Scenario "dev server 포트가 ViteEngine에 보고된다" (D1)
+    it("stores port from serverReady event", async () => {
+      mockWorker.startWatch.mockImplementation(() => {
+        // Emit serverReady before build
+        const serverReadyHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "serverReady",
+        )?.[1];
+        serverReadyHandler?.({ port: 4200 });
+
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({
+          js: { success: true },
+          dts: { success: true },
+        });
+      });
+
+      const engine = new ViteEngine({ cwd: "/root", pkg: createMockPkg() });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      expect(engine.port).toBe(4200);
+
+      await engine.stop();
+    });
+
+    // Acceptance: Scenario "독립 클라이언트의 Vite dev server 시작 (지정 포트)"
+    it("passes port to worker startWatch when config.server is a number", async () => {
+      mockWorker.startWatch.mockImplementation(() => {
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({
+          js: { success: true },
+          dts: { success: true },
+        });
+      });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg({
+          config: { target: "client", server: 3000 } as any,
+        }),
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      expect(mockWorker.startWatch).toHaveBeenCalledWith(
+        expect.objectContaining({ port: 3000 }),
+      );
+
+      await engine.stop();
+    });
+
+    // Unit: server: string does not pass port
+    it("does not pass port when config.server is a string", async () => {
+      mockWorker.startWatch.mockImplementation(() => {
+        const buildHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "build",
+        )?.[1];
+        buildHandler?.({
+          js: { success: true },
+          dts: { success: true },
+        });
+      });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg({
+          config: { target: "client", server: "my-server" } as any,
+        }),
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      const callArgs = mockWorker.startWatch.mock.calls[0][0];
+      expect(callArgs.port).toBeUndefined();
+
+      await engine.stop();
+    });
+
+    // Unit: error event also resolves startWatch
+    it("resolves when error event arrives on initial build", async () => {
+      const mockResultCollector = { add: vi.fn() };
+
+      mockWorker.startWatch.mockImplementation(() => {
+        const errorHandler = mockWorker.on.mock.calls.find(
+          (call: any[]) => call[0] === "error",
+        )?.[1];
+        errorHandler?.({ message: "Build failed" });
+      });
+
+      const engine = new ViteEngine({
+        cwd: "/root",
+        pkg: createMockPkg(),
+        resultCollector: mockResultCollector as any,
+      });
+
+      await engine.startWatch({ js: true, dts: false });
+
+      const addCalls = mockResultCollector.add.mock.calls;
+      const errorResult = addCalls.find((c: any[]) => c[0].status === "error");
+      expect(errorResult).toBeDefined();
+
+      await engine.stop();
+    });
+  });
+});

package/tests/infra/result-collector.spec.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "vitest";
+import { ResultCollector } from "../../src/infra/ResultCollector";
+
+describe("ResultCollector", () => {
+  it("adds and retrieves a build result by key", () => {
+    const collector = new ResultCollector();
+    collector.add({ name: "core", target: "node", type: "build", status: "success" });
+
+    const result = collector.get("core:build");
+    expect(result).toBeDefined();
+    expect(result!.name).toBe("core");
+    expect(result!.status).toBe("success");
+  });
+
+  it("overwrites result with same key on re-add", () => {
+    const collector = new ResultCollector();
+    collector.add({ name: "core", target: "node", type: "build", status: "building" });
+    collector.add({ name: "core", target: "node", type: "build", status: "success" });
+
+    expect(collector.get("core:build")!.status).toBe("success");
+  });
+
+  it("returns all results via toMap", () => {
+    const collector = new ResultCollector();
+    collector.add({ name: "core", target: "node", type: "build", status: "success" });
+    collector.add({ name: "core", target: "node", type: "dts", status: "building" });
+
+    const map = collector.toMap();
+    expect(map.size).toBe(2);
+    expect(map.has("core:build")).toBe(true);
+    expect(map.has("core:dts")).toBe(true);
+  });
+
+  it("returns undefined for non-existent key", () => {
+    const collector = new ResultCollector();
+    expect(collector.get("nonexistent")).toBeUndefined();
+  });
+
+  it("uses name:type as key format", () => {
+    const collector = new ResultCollector();
+    collector.add({ name: "storage", target: "node", type: "server", status: "running", port: 3000 });
+
+    expect(collector.get("storage:server")).toBeDefined();
+    expect(collector.get("storage:build")).toBeUndefined();
+  });
+});

package/tests/infra/signal-handler.spec.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "vitest";
+import { SignalHandler } from "../../src/infra/SignalHandler";
+
+describe("SignalHandler", () => {
+  it("resolves waitForTermination on requestTermination", async () => {
+    const handler = new SignalHandler();
+
+    expect(handler.isTerminated()).toBe(false);
+
+    handler.requestTermination();
+
+    await handler.waitForTermination();
+    expect(handler.isTerminated()).toBe(true);
+  });
+
+  it("is not terminated initially", () => {
+    const handler = new SignalHandler();
+    expect(handler.isTerminated()).toBe(false);
+    // Clean up: prevent dangling signal listeners
+    handler.requestTermination();
+  });
+
+  it("handles double requestTermination gracefully", async () => {
+    const handler = new SignalHandler();
+
+    handler.requestTermination();
+    handler.requestTermination();
+
+    await handler.waitForTermination();
+    expect(handler.isTerminated()).toBe(true);
+  });
+});