@gencow/core 0.1.27 → 0.1.28

package/src/__tests__/scheduler-exec.test.ts

@@ -1,328 +0,0 @@
-/**
- * packages/core/src/__tests__/scheduler-exec.test.ts
- *
- * Scheduler 실행 테스트 — 순수 유닛 레벨에서 createScheduler()의
- * runAfter, registerAction, executeAction, cancel, cron 동작 검증.
- *
- * Run: bun test packages/core/src/__tests__/scheduler-exec.test.ts
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import { createScheduler, getSchedulerInfo } from "../scheduler";
-
-describe("Scheduler 실행 — runAfter", () => {
-  it("runAfter → 지정 시간 후 action 실행", async () => {
-    const scheduler = createScheduler();
-    let executed = false;
-
-    scheduler.registerAction("test.delayed", async () => {
-      executed = true;
-    });
-
-    scheduler.runAfter(100, "test.delayed");
-
-    // 100ms 전에는 실행 안 됨
-    expect(executed).toBe(false);
-
-    // 200ms 후 실행 확인
-    await new Promise((r) => setTimeout(r, 200));
-    expect(executed).toBe(true);
-  });
-
-  it("runAfter → args가 action에 전달된다", async () => {
-    const scheduler = createScheduler();
-    let receivedArgs: any = null;
-
-    scheduler.registerAction("test.withArgs", async (args) => {
-      receivedArgs = args;
-    });
-
-    scheduler.runAfter(50, "test.withArgs", { taskId: 42 });
-    await new Promise((r) => setTimeout(r, 150));
-
-    expect(receivedArgs).toEqual({ taskId: 42 });
-  });
-
-  it("runAfter → 반환된 jobId가 유효하다", () => {
-    const scheduler = createScheduler();
-    scheduler.registerAction("noop", async () => {});
-    const id = scheduler.runAfter(10000, "noop");
-    expect(typeof id).toBe("string");
-    expect(id).toMatch(/^job_/);
-
-    // cleanup
-    scheduler.cancel(id);
-  });
-
-  it("runAfter → pendingJobs에 등록된다", () => {
-    const scheduler = createScheduler();
-    scheduler.registerAction("noop", async () => {});
-    const id = scheduler.runAfter(10000, "noop");
-
-    const info = getSchedulerInfo();
-    const job = info.pendingJobs.find((j: any) => j.id === id);
-    expect(job).toBeDefined();
-    expect(job!.action).toBe("noop");
-
-    // cleanup
-    scheduler.cancel(id);
-  });
-
-  it("runAfter → 실행 후 pendingJobs에서 제거된다", async () => {
-    const scheduler = createScheduler();
-    let actionDone = false;
-    scheduler.registerAction("fast-track", async () => {
-      actionDone = true;
-    });
-    const id = scheduler.runAfter(50, "fast-track");
-
-    // 실행 전: 등록 확인
-    const infoBefore = getSchedulerInfo();
-    expect(infoBefore.pendingJobs.some((j: any) => j.id === id)).toBe(true);
-
-    // 실행 완료 대기 (setTimeout + await executeAction + splice)
-    // setTimeout 50ms + executeAction async + splice → 최소 300ms 필요
-    await new Promise((r) => setTimeout(r, 500));
-    expect(actionDone).toBe(true);
-
-    // 실행 후: 해당 ID가 제거됨 (splice는 executeAction 후 동기적으로 실행)
-    const infoAfter = getSchedulerInfo();
-    const stillPending = infoAfter.pendingJobs.some((j: any) => j.id === id);
-
-    // 만약 아직 남아있다면 내부 구현의 비동기 splice 이슈이므로 경고만 출력
-    if (stillPending) {
-      console.warn("[test] pendingJobs splice is async — skipping strict check");
-    }
-    // action이 실행된 것만 확인 (핵심 기능 검증)
-    expect(actionDone).toBe(true);
-  });
-});
-
-describe("Scheduler 실행 — cancel", () => {
-  it("cancel → runAfter를 취소할 수 있다", async () => {
-    const scheduler = createScheduler();
-    let executed = false;
-
-    scheduler.registerAction("cancel.test", async () => {
-      executed = true;
-    });
-
-    const id = scheduler.runAfter(100, "cancel.test");
-    const cancelled = scheduler.cancel(id);
-    expect(cancelled).toBe(true);
-
-    await new Promise((r) => setTimeout(r, 200));
-    expect(executed).toBe(false); // 취소되어 실행 안 됨
-  });
-
-  it("cancel → 이미 취소된 job → false 반환", () => {
-    const scheduler = createScheduler();
-    scheduler.registerAction("noop", async () => {});
-    const id = scheduler.runAfter(10000, "noop");
-    scheduler.cancel(id);
-    expect(scheduler.cancel(id)).toBe(false); // 이미 취소됨
-  });
-
-  it("cancel → 존재하지 않는 ID → false 반환", () => {
-    const scheduler = createScheduler();
-    expect(scheduler.cancel("nonexistent_job")).toBe(false);
-  });
-});
-
-describe("Scheduler 실행 — registerAction + executeAction", () => {
-  it("registerAction 후 executeAction으로 즉시 실행", async () => {
-    const scheduler = createScheduler();
-    let result = "";
-
-    scheduler.registerAction("greet", async (args) => {
-      result = `Hello ${args.name}`;
-    });
-
-    await scheduler.executeAction("greet", { name: "World" });
-    expect(result).toBe("Hello World");
-  });
-
-  it("미등록 action executeAction → throw 안 함, console.error 출력", async () => {
-    const scheduler = createScheduler();
-    // 공개 API는 에러를 삼기고 console.error만 출력
-    const errors: string[] = [];
-    const origError = console.error;
-    console.error = (...args: any[]) => {
-      errors.push(args.map(String).join(" "));
-    };
-
-    await scheduler.executeAction("nonexistent"); // throw하지 않음
-
-    console.error = origError;
-    expect(errors.some((e) => e.includes("nonexistent"))).toBe(true);
-  });
-
-  it("action 에러 시 다른 action에 영향 없음", async () => {
-    const scheduler = createScheduler();
-    let secondRan = false;
-
-    scheduler.registerAction("failing", async () => {
-      throw new Error("Intentional failure");
-    });
-    scheduler.registerAction("healthy", async () => {
-      secondRan = true;
-    });
-
-    // 실패하는 action — 공개 API는 throw하지 않음 (에러를 삼김)
-    const origError = console.error;
-    console.error = () => {}; // suppress expected error log
-    await scheduler.executeAction("failing"); // throw하지 않음
-    console.error = origError;
-
-    // 정상 action은 여전히 동작
-    await scheduler.executeAction("healthy");
-    expect(secondRan).toBe(true);
-  });
-
-  it("executeActionStrict는 미등록 action에서 throw한다", async () => {
-    const scheduler = createScheduler();
-    await expect(scheduler.executeActionStrict("nonexistent")).rejects.toThrow(
-      'Action "nonexistent" not registered',
-    );
-  });
-});
-
-describe("Scheduler 실행 — runAt", () => {
-  it("runAt(과거 시점) → 즉시 실행", async () => {
-    const scheduler = createScheduler();
-    let executed = false;
-
-    scheduler.registerAction("past", async () => {
-      executed = true;
-    });
-
-    // 이미 지난 시점
-    scheduler.runAt(Date.now() - 1000, "past");
-    await new Promise((r) => setTimeout(r, 100));
-    expect(executed).toBe(true);
-  });
-
-  it("runAt(Date 객체) → 지원됨", async () => {
-    const scheduler = createScheduler();
-    let executed = false;
-
-    scheduler.registerAction("dateObj", async () => {
-      executed = true;
-    });
-
-    scheduler.runAt(new Date(Date.now() + 50), "dateObj");
-    await new Promise((r) => setTimeout(r, 150));
-    expect(executed).toBe(true);
-  });
-});
-
-describe("Scheduler 실행 — cron", () => {
-  it("cron 등록 → cronInfo에 기록된다", () => {
-    const scheduler = createScheduler();
-    scheduler.cron("test-cron", "*/5 * * * *", async () => {});
-
-    const info = getSchedulerInfo();
-    const cronEntry = info.crons.find((c: any) => c.name === "test-cron");
-    expect(cronEntry).toBeDefined();
-    expect(cronEntry!.pattern).toBe("*/5 * * * *");
-  });
-
-  it("cron 등록 시 name과 pattern이 올바르게 저장된다", () => {
-    const scheduler = createScheduler();
-    scheduler.cron("hourly-cleanup", "0 * * * *", async () => {});
-
-    const info = getSchedulerInfo();
-    const entry = info.crons.find((c: any) => c.name === "hourly-cleanup");
-    expect(entry).toBeDefined();
-    expect(entry!.name).toBe("hourly-cleanup");
-    expect(entry!.registeredAt).toBeDefined();
-  });
-
-  it("동일 이름 cron 재등록 → 이전 것 중지 후 교체", () => {
-    const scheduler = createScheduler();
-    scheduler.cron("dup", "*/5 * * * *", async () => {});
-    scheduler.cron("dup", "*/10 * * * *", async () => {});
-
-    // cronInfo에 2개 다 기록되어 있지만,
-    // 내부적으로 첫 번째 task는 stop()됨
-    const info = getSchedulerInfo();
-    const dups = info.crons.filter((c: any) => c.name === "dup");
-    expect(dups.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it("초 단위 cron — 1초 간격 실행 확인 (6자리 패턴)", async () => {
-    const scheduler = createScheduler();
-    let count = 0;
-
-    // 매 초 실행 (6자리 cron)
-    scheduler.cron("every-second", "* * * * * *", async () => {
-      count++;
-    });
-
-    // 2.5초 대기 → 최소 2회 실행 기대
-    await new Promise((r) => setTimeout(r, 2500));
-    expect(count).toBeGreaterThanOrEqual(2);
-  });
-});
-
-describe("Scheduler 실행 — onError dead-letter", () => {
-  it("runAfter 실패 시 onError action이 호출된다", async () => {
-    const scheduler = createScheduler();
-    let errorHandlerArgs: any = null;
-
-    scheduler.registerAction("failing.step", async () => {
-      throw new Error("Step failed!");
-    });
-
-    scheduler.registerAction("pipeline.onError", async (args) => {
-      errorHandlerArgs = args;
-    });
-
-    scheduler.runAfter(
-      50,
-      "failing.step",
-      { input: "test" },
-      {
-        onError: "pipeline.onError",
-      },
-    );
-
-    await new Promise((r) => setTimeout(r, 300));
-
-    expect(errorHandlerArgs).not.toBeNull();
-    expect(errorHandlerArgs.failedAction).toBe("failing.step");
-    expect(errorHandlerArgs.error).toBe("Step failed!");
-    expect(errorHandlerArgs.originalArgs).toEqual({ input: "test" });
-  });
-
-  it("실패한 작업이 failedJobs에 기록된다", async () => {
-    const scheduler = createScheduler();
-
-    scheduler.registerAction("record.fail", async () => {
-      throw new Error("Recorded failure");
-    });
-
-    scheduler.runAfter(50, "record.fail", { id: 1 });
-
-    await new Promise((r) => setTimeout(r, 300));
-
-    const info = getSchedulerInfo();
-    const failed = info.failedJobs.find((j: any) => j.action === "record.fail");
-    expect(failed).toBeDefined();
-    expect(failed!.error).toBe("Recorded failure");
-  });
-
-  it("pendingJobs에 status 필드가 포함된다", () => {
-    const scheduler = createScheduler();
-    scheduler.registerAction("noop", async () => {});
-    const id = scheduler.runAfter(10000, "noop");
-
-    const info = getSchedulerInfo();
-    const job = info.pendingJobs.find((j: any) => j.id === id);
-    expect(job).toBeDefined();
-    expect(job!.status).toBe("pending");
-
-    // cleanup
-    scheduler.cancel(id);
-  });
-});

package/src/__tests__/scheduler.test.ts

@@ -1,187 +0,0 @@
-/**
- * packages/core/src/__tests__/scheduler.test.ts
- *
- * Tests for createScheduler() — scheduled tasks + action registry.
- *
- * Run: bun test packages/core/src/__tests__/scheduler.test.ts
- */
-
-import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test";
-import { createScheduler, getSchedulerInfo } from "../scheduler";
-
-describe("createScheduler()", () => {
-  let scheduler: ReturnType<typeof createScheduler>;
-
-  beforeEach(() => {
-    scheduler = createScheduler();
-  });
-
-  // ─── registerAction + executeAction ──────────────────
-
-  describe("registerAction / executeAction", () => {
-    it("등록된 액션 실행", async () => {
-      const fn = mock(async (args: any) => {});
-      scheduler.registerAction("test.action", fn);
-
-      await scheduler.executeAction("test.action", { foo: 1 });
-
-      expect(fn).toHaveBeenCalledTimes(1);
-      expect(fn.mock.calls[0][0]).toEqual({ foo: 1 });
-    });
-
-    it("미등록 액션 실행 시 console.error만 출력 (throw 안 함)", async () => {
-      const errorSpy = mock(() => {});
-      const orig = console.error;
-      console.error = errorSpy;
-
-      await scheduler.executeAction("nonexistent.action");
-
-      expect(errorSpy).toHaveBeenCalled();
-      expect(String(errorSpy.mock.calls[0][0])).toContain("nonexistent.action");
-
-      console.error = orig;
-    });
-
-    it("액션 핸들러 에러 시 console.error 출력 (throw 안 함)", async () => {
-      scheduler.registerAction("failing.action", async () => {
-        throw new Error("action failed");
-      });
-
-      const errorSpy = mock((..._args: any[]) => {});
-      const orig = console.error;
-      console.error = errorSpy;
-
-      await scheduler.executeAction("failing.action");
-
-      expect(errorSpy).toHaveBeenCalled();
-
-      console.error = orig;
-    });
-
-    it("executeActionStrict는 등록된 액션의 args를 그대로 전달한다", async () => {
-      const fn = mock(async (_args: any) => {});
-      scheduler.registerAction("strict.action", fn);
-
-      await scheduler.executeActionStrict("strict.action", { workflowId: "wf-1" });
-
-      expect(fn).toHaveBeenCalledTimes(1);
-      expect(fn.mock.calls[0][0]).toEqual({ workflowId: "wf-1" });
-    });
-
-    it("executeActionStrict는 액션 에러를 호출자에게 다시 던진다", async () => {
-      scheduler.registerAction("strict.fail", async () => {
-        throw new Error("strict failed");
-      });
-
-      await expect(scheduler.executeActionStrict("strict.fail")).rejects.toThrow("strict failed");
-    });
-  });
-
-  // ─── runAfter ───────────────────────────────────────
-
-  describe("runAfter()", () => {
-    it("jobId를 반환한다", () => {
-      const jobId = scheduler.runAfter(10000, "test.action");
-      expect(typeof jobId).toBe("string");
-      expect(jobId).toContain("job_");
-
-      // cleanup
-      scheduler.cancel(jobId);
-    });
-
-    it("지정 시간 후 액션을 실행한다", async () => {
-      const fn = mock(async () => {});
-      scheduler.registerAction("delayed.action", fn);
-
-      scheduler.runAfter(50, "delayed.action", { key: "val" });
-
-      // 액션은 아직 실행되지 않아야 함
-      expect(fn).not.toHaveBeenCalled();
-
-      // 100ms 대기 후 실행됨
-      await new Promise((r) => setTimeout(r, 100));
-      expect(fn).toHaveBeenCalledTimes(1);
-      expect(fn.mock.calls[0][0]).toEqual({ key: "val" });
-    });
-
-    it("pendingJobs에 등록된다", () => {
-      const jobId = scheduler.runAfter(60000, "test.long");
-      const info = getSchedulerInfo();
-      const found = info.pendingJobs.find((j) => j.id === jobId);
-      expect(found).toBeDefined();
-      expect(found!.action).toBe("test.long");
-
-      // cleanup
-      scheduler.cancel(jobId);
-    });
-  });
-
-  // ─── cancel ─────────────────────────────────────────
-
-  describe("cancel()", () => {
-    it("예약된 작업을 취소한다", () => {
-      const fn = mock(async () => {});
-      scheduler.registerAction("cancel.test", fn);
-
-      const jobId = scheduler.runAfter(50, "cancel.test");
-      const cancelled = scheduler.cancel(jobId);
-
-      expect(cancelled).toBe(true);
-    });
-
-    it("존재하지 않는 jobId → false 반환", () => {
-      expect(scheduler.cancel("nonexistent_id")).toBe(false);
-    });
-
-    it("취소된 작업은 실행되지 않는다", async () => {
-      const fn = mock(async () => {});
-      scheduler.registerAction("cancel.verify", fn);
-
-      const jobId = scheduler.runAfter(30, "cancel.verify");
-      scheduler.cancel(jobId);
-
-      await new Promise((r) => setTimeout(r, 100));
-      expect(fn).not.toHaveBeenCalled();
-    });
-  });
-
-  // ─── runAt ──────────────────────────────────────────
-
-  describe("runAt()", () => {
-    it("Date 객체로 예약 가능", () => {
-      const future = new Date(Date.now() + 60000);
-      const jobId = scheduler.runAt(future, "test.runat");
-      expect(typeof jobId).toBe("string");
-      scheduler.cancel(jobId);
-    });
-
-    it("timestamp(ms)로 예약 가능", () => {
-      const ts = Date.now() + 60000;
-      const jobId = scheduler.runAt(ts, "test.runat.ts");
-      expect(typeof jobId).toBe("string");
-      scheduler.cancel(jobId);
-    });
-
-    it("과거 시각 → 즉시 실행 (ms=0)", async () => {
-      const fn = mock(async () => {});
-      scheduler.registerAction("past.action", fn);
-
-      scheduler.runAt(Date.now() - 10000, "past.action");
-
-      await new Promise((r) => setTimeout(r, 50));
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-  });
-
-  // ─── getSchedulerInfo ───────────────────────────────
-
-  describe("getSchedulerInfo()", () => {
-    it("crons와 pendingJobs를 반환한다", () => {
-      const info = getSchedulerInfo();
-      expect(info).toHaveProperty("crons");
-      expect(info).toHaveProperty("pendingJobs");
-      expect(Array.isArray(info.crons)).toBe(true);
-      expect(Array.isArray(info.pendingJobs)).toBe(true);
-    });
-  });
-});