@simplysm/sd-cli 14.0.30 → 14.0.33

package/tests/utils/engine-watch-events.acc.spec.ts

@@ -0,0 +1,217 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { EventEmitter } from "node:events";
+import { ResultCollector } from "../../src/runtime/ResultCollector";
+import type { NormalizedBuildInfo } from "../../src/runtime/engine-watch-events";
+
+// --- Test helpers ---
+
+/**
+ * 실제 EventEmitter 기반 mock worker.
+ * setupWatchEvents가 on()으로 등록한 핸들러가 emit()시 실제로 호출된다.
+ */
+class MockWorker extends EventEmitter {}
+
+function createMockRebuildManager() {
+  const mockResolver = vi.fn();
+  return {
+    manager: { registerBuild: vi.fn(() => mockResolver) },
+    resolver: mockResolver,
+  };
+}
+
+// --- Dynamic import ---
+
+const { setupWatchEvents } = await import("../../src/runtime/engine-watch-events");
+
+// --- Tests ---
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("setupWatchEvents (Acceptance)", () => {
+  it("buildStart 이벤트 발생 시 RebuildManager에 빌드를 등록한다", () => {
+    const worker = new MockWorker();
+    const { manager } = createMockRebuildManager();
+
+    setupWatchEvents(worker, {
+      name: "test-pkg",
+      target: "node",
+      rebuildManager: manager as any,
+      normalizeBuild: (d) => d as NormalizedBuildInfo,
+    });
+
+    worker.emit("buildStart", {});
+
+    expect(manager.registerBuild).toHaveBeenCalledWith("test-pkg:build", "test-pkg (node)");
+  });
+
+  it("build 이벤트 발생 시 ResultCollector에 성공 결과를 보고하고 resolver를 호출한다", () => {
+    const worker = new MockWorker();
+    const resultCollector = new ResultCollector();
+    const { manager, resolver } = createMockRebuildManager();
+
+    setupWatchEvents(worker, {
+      name: "test-pkg",
+      target: "node",
+      resultCollector,
+      rebuildManager: manager as any,
+      normalizeBuild: (d) => d as NormalizedBuildInfo,
+    });
+
+    // buildStart → build 시퀀스
+    worker.emit("buildStart", {});
+    worker.emit("build", { success: true });
+
+    const result = resultCollector.get("test-pkg:build");
+    expect(result).toMatchObject({
+      name: "test-pkg",
+      target: "node",
+      type: "build",
+      status: "success",
+    });
+    expect(resolver).toHaveBeenCalled();
+  });
+
+  it("build 실패 시 에러 메시지가 포함된다", () => {
+    const worker = new MockWorker();
+    const resultCollector = new ResultCollector();
+
+    setupWatchEvents(worker, {
+      name: "test-pkg",
+      target: "node",
+      resultCollector,
+      normalizeBuild: (d) => d as NormalizedBuildInfo,
+    });
+
+    worker.emit("build", { success: false, errors: ["type error", "syntax error"] });
+
+    const result = resultCollector.get("test-pkg:build");
+    expect(result).toMatchObject({
+      status: "error",
+      message: "type error\nsyntax error",
+    });
+  });
+
+  it("error 이벤트 발생 시 ResultCollector에 에러를 보고하고 resolver를 호출한다", () => {
+    const worker = new MockWorker();
+    const resultCollector = new ResultCollector();
+    const { manager, resolver } = createMockRebuildManager();
+
+    setupWatchEvents(worker, {
+      name: "test-pkg",
+      target: "node",
+      resultCollector,
+      rebuildManager: manager as any,
+      normalizeBuild: (d) => d as NormalizedBuildInfo,
+    });
+
+    worker.emit("buildStart", {});
+    worker.emit("error", { message: "Worker crashed" });
+
+    const result = resultCollector.get("test-pkg:build");
+    expect(result).toMatchObject({
+      status: "error",
+      type: "build",
+      message: "Worker crashed",
+    });
+    expect(resolver).toHaveBeenCalled();
+  });
+
+  it("RebuildManager 없이도 buildStart/build가 에러 없이 동작한다", () => {
+    const worker = new MockWorker();
+    const resultCollector = new ResultCollector();
+
+    setupWatchEvents(worker, {
+      name: "test-pkg",
+      target: "node",
+      resultCollector,
+      normalizeBuild: (d) => d as NormalizedBuildInfo,
+    });
+
+    // rebuildManager가 없으므로 buildStart는 무시, build는 ResultCollector에만 보고
+    expect(() => {
+      worker.emit("buildStart", {});
+      worker.emit("build", { success: true });
+    }).not.toThrow();
+
+    expect(resultCollector.get("test-pkg:build")).toBeDefined();
+  });
+
+  it("ResultCollector 없이도 build/error가 에러 없이 동작한다", () => {
+    const worker = new MockWorker();
+    const { manager, resolver } = createMockRebuildManager();
+
+    setupWatchEvents(worker, {
+      name: "test-pkg",
+      target: "node",
+      rebuildManager: manager as any,
+      normalizeBuild: (d) => d as NormalizedBuildInfo,
+    });
+
+    expect(() => {
+      worker.emit("buildStart", {});
+      worker.emit("build", { success: true });
+    }).not.toThrow();
+
+    expect(resolver).toHaveBeenCalled();
+  });
+
+  it("waitForInitialBuild()가 첫 번째 build 이벤트에서 resolve된다", async () => {
+    const worker = new MockWorker();
+
+    const { waitForInitialBuild } = setupWatchEvents(worker, {
+      name: "test-pkg",
+      target: "node",
+      normalizeBuild: (d) => d as NormalizedBuildInfo,
+    });
+
+    const promise = waitForInitialBuild();
+
+    // build 이벤트 발행
+    worker.emit("build", { success: true });
+
+    await expect(promise).resolves.toBeUndefined();
+  });
+
+  it("waitForInitialBuild()가 첫 번째 error 이벤트에서도 resolve된다", async () => {
+    const worker = new MockWorker();
+
+    const { waitForInitialBuild } = setupWatchEvents(worker, {
+      name: "test-pkg",
+      target: "node",
+      normalizeBuild: (d) => d as NormalizedBuildInfo,
+    });
+
+    const promise = waitForInitialBuild();
+
+    // error 이벤트 발행
+    worker.emit("error", { message: "Fatal error" });
+
+    // reject하지 않고 resolve
+    await expect(promise).resolves.toBeUndefined();
+  });
+
+  it("두 번째 build 이벤트에서는 waitForInitialBuild가 다시 resolve되지 않는다", async () => {
+    const worker = new MockWorker();
+    const resultCollector = new ResultCollector();
+
+    const { waitForInitialBuild } = setupWatchEvents(worker, {
+      name: "test-pkg",
+      target: "node",
+      resultCollector,
+      normalizeBuild: (d) => d as NormalizedBuildInfo,
+    });
+
+    const promise = waitForInitialBuild();
+
+    worker.emit("build", { success: true });
+    await promise;
+
+    // 두 번째 build — ResultCollector에는 보고되지만 Promise는 이미 settled
+    worker.emit("build", { success: false, errors: ["second error"] });
+
+    const result = resultCollector.get("test-pkg:build");
+    expect(result?.status).toBe("error"); // 두 번째 결과로 갱신됨
+  });
+});

package/tests/utils/engine-watch-events.spec.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { EventEmitter } from "node:events";
+import { ResultCollector } from "../../src/runtime/ResultCollector";
+
+// --- Test helpers ---
+
+class MockWorker extends EventEmitter {}
+
+function createMockRebuildManager() {
+  const mockResolver = vi.fn();
+  return {
+    manager: { registerBuild: vi.fn(() => mockResolver) },
+    resolver: mockResolver,
+  };
+}
+
+// --- Dynamic import ---
+
+const { setupWatchEvents } = await import("../../src/runtime/engine-watch-events");
+
+// --- Tests ---
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("setupWatchEvents", () => {
+  describe("normalizeBuild 콜백", () => {
+    it("build 이벤트 데이터를 normalizeBuild로 변환하여 처리한다", () => {
+      const worker = new MockWorker();
+      const resultCollector = new ResultCollector();
+
+      // BaseEngine 스타일: 중첩 구조에서 build 필드 추출
+      setupWatchEvents(worker, {
+        name: "test-pkg",
+        target: "node",
+        resultCollector,
+        normalizeBuild: (d) => (d as { build: { success: boolean } }).build,
+      });
+
+      worker.emit("build", { build: { success: true }, lint: { success: true } });
+
+      const result = resultCollector.get("test-pkg:build");
+      expect(result?.status).toBe("success");
+    });
+
+    it("EsbuildClientEngine 스타일: 평탄 구조를 그대로 사용한다", () => {
+      const worker = new MockWorker();
+      const resultCollector = new ResultCollector();
+
+      setupWatchEvents(worker, {
+        name: "client-app",
+        target: "client",
+        resultCollector,
+        normalizeBuild: (d) => d as { success: boolean },
+      });
+
+      worker.emit("build", { success: false, errors: ["esbuild error"] });
+
+      const result = resultCollector.get("client-app:build");
+      expect(result?.status).toBe("error");
+      expect(result?.message).toBe("esbuild error");
+    });
+  });
+
+  describe("resolver 생명주기", () => {
+    it("build 후 resolver가 초기화되어 중복 호출되지 않는다", () => {
+      const worker = new MockWorker();
+      const { manager, resolver } = createMockRebuildManager();
+
+      setupWatchEvents(worker, {
+        name: "test-pkg",
+        target: "node",
+        rebuildManager: manager as any,
+        normalizeBuild: (d) => d as any,
+      });
+
+      worker.emit("buildStart", {});
+      worker.emit("build", { success: true });
+      // resolver 한번만 호출됨
+      expect(resolver).toHaveBeenCalledOnce();
+
+      // buildStart 없이 build만 다시 발생 — resolver 없으므로 추가 호출 없음
+      worker.emit("build", { success: true });
+      expect(resolver).toHaveBeenCalledOnce();
+    });
+
+    it("error 후 resolver가 초기화되어 중복 호출되지 않는다", () => {
+      const worker = new MockWorker();
+      const { manager, resolver } = createMockRebuildManager();
+
+      setupWatchEvents(worker, {
+        name: "test-pkg",
+        target: "node",
+        rebuildManager: manager as any,
+        normalizeBuild: (d) => d as any,
+      });
+
+      worker.emit("buildStart", {});
+      worker.emit("error", { message: "crash" });
+      expect(resolver).toHaveBeenCalledOnce();
+
+      worker.emit("error", { message: "crash again" });
+      expect(resolver).toHaveBeenCalledOnce();
+    });
+  });
+
+  describe("resolveInitialBuild", () => {
+    it("수동으로 초기 빌드를 resolve할 수 있다", async () => {
+      const worker = new MockWorker();
+
+      const { waitForInitialBuild, resolveInitialBuild } = setupWatchEvents(worker, {
+        name: "test-pkg",
+        target: "node",
+        normalizeBuild: (d) => d as any,
+      });
+
+      const promise = waitForInitialBuild();
+      resolveInitialBuild();
+
+      await expect(promise).resolves.toBeUndefined();
+    });
+
+    it("이미 resolve된 후 다시 호출해도 안전하다", async () => {
+      const worker = new MockWorker();
+
+      const { waitForInitialBuild, resolveInitialBuild } = setupWatchEvents(worker, {
+        name: "test-pkg",
+        target: "node",
+        normalizeBuild: (d) => d as any,
+      });
+
+      const promise = waitForInitialBuild();
+      worker.emit("build", { success: true });
+      await promise;
+
+      // 이미 resolve된 후 수동 호출 — 에러 없음
+      expect(() => resolveInitialBuild()).not.toThrow();
+    });
+  });
+});

package/tests/utils/engine-watch-events.verify.md

@@ -0,0 +1,17 @@
+# setupWatchEvents + BaseEngine/EsbuildClientEngine 적용 — LLM 검증
+
+## 검증 항목
+
+### Slice 1: BaseEngine 적용
+
+- [x] BaseEngine lint 결과 보고 유지: `BaseEngine.ts:148-157` — build 이벤트에서 `event.lint`가 있으면 lint BuildResult를 ResultCollector에 추가. 기존 로직 그대로 유지됨.
+- [x] BaseEngine 경고 로깅 유지: `BaseEngine.ts:144-146` — `event.build.warnings`가 있으면 `logger.warn` 호출. 기존 로직 그대로 유지됨.
+- [x] setupWatchEvents가 index.ts의 public export에 포함되지 않음: 내부 유틸리티이므로 패키지 외부 API 불변. `engines/index.ts`의 export 목록에 engine-watch-events 없음 확인.
+- [x] resolveInitialBuild가 _callStartWatch catch에서 호출됨: `BaseEngine.ts:162-164` — `this._callStartWatch(output).catch(() => { resolveInitialBuild(); })`. 기존의 `isInitialBuild` 가드와 동등한 동작.
+
+### Slice 2: EsbuildClientEngine 적용
+
+- [x] EsbuildClientEngine이 waitForInitialBuild() 미사용: `EsbuildClientEngine.ts:103-111` — setupWatchEvents 호출 후 반환값 사용 안 함. 111행에 "waitForInitialBuild 미사용" 주석 확인.
+- [x] serverReady 이벤트 처리 유지: `EsbuildClientEngine.ts:97-101` — serverReady 핸들러가 setupWatchEvents 전에 등록됨. `this.port = event.port` 로직 그대로.
+- [x] error 로깅 유지: `EsbuildClientEngine.ts:113-117` — setupWatchEvents 이후 별도 error 핸들러에서 `logger.error` 호출. 기존 동작 보존.
+- [x] worker.startWatch() await 패턴 유지: `EsbuildClientEngine.ts:119-130` — 기존과 동일하게 `await this._worker!.startWatch(...)` 로 완료 감지.