@gencow/core 0.1.23 → 0.1.25

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

@@ -11,306 +11,318 @@ 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;
+  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);
+    scheduler.registerAction("test.delayed", async () => {
+      executed = 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));
+    scheduler.runAfter(100, "test.delayed");
 
-        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);
-    });
+    // 100ms 전에는 실행 안 됨
+    expect(executed).toBe(false);
 
-    it("runAfter → pendingJobs에 등록된다", () => {
-        const scheduler = createScheduler();
-        scheduler.registerAction("noop", async () => {});
-        const id = scheduler.runAfter(10000, "noop");
+    // 200ms 후 실행 확인
+    await new Promise((r) => setTimeout(r, 200));
+    expect(executed).toBe(true);
+  });
 
-        const info = getSchedulerInfo();
-        const job = info.pendingJobs.find((j: any) => j.id === id);
-        expect(job).toBeDefined();
-        expect(job!.action).toBe("noop");
+  it("runAfter → args가 action에 전달된다", async () => {
+    const scheduler = createScheduler();
+    let receivedArgs: any = null;
 
-        // cleanup
-        scheduler.cancel(id);
+    scheduler.registerAction("test.withArgs", async (args) => {
+      receivedArgs = args;
     });
 
-    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);
+    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;
+  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); // 취소되어 실행 안 됨
+    scheduler.registerAction("cancel.test", async () => {
+      executed = true;
     });
 
-    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);
-    });
+    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 = "";
+  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");
+    scheduler.registerAction("greet", async (args) => {
+      result = `Hello ${args.name}`;
     });
 
-    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("greet", { name: "World" });
+    expect(result).toBe("Hello World");
+  });
 
-        await scheduler.executeAction("nonexistent"); // throw하지 않음
+  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(" "));
+    };
 
-        console.error = origError;
-        expect(errors.some(e => e.includes("nonexistent"))).toBe(true);
-    });
+    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;
 
-    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);
+    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(과거 시점) → 즉시 실행", async () => {
+    const scheduler = createScheduler();
+    let executed = false;
+
+    scheduler.registerAction("past", async () => {
+      executed = true;
     });
 
-    it("runAt(Date 객체) → 지원됨", async () => {
-        const scheduler = createScheduler();
-        let executed = false;
+    // 이미 지난 시점
+    scheduler.runAt(Date.now() - 1000, "past");
+    await new Promise((r) => setTimeout(r, 100));
+    expect(executed).toBe(true);
+  });
 
-        scheduler.registerAction("dateObj", async () => {
-            executed = true;
-        });
+  it("runAt(Date 객체) → 지원됨", async () => {
+    const scheduler = createScheduler();
+    let executed = false;
 
-        scheduler.runAt(new Date(Date.now() + 50), "dateObj");
-        await new Promise((r) => setTimeout(r, 150));
-        expect(executed).toBe(true);
+    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 등록 → 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++;
     });
 
-    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();
-    });
+    // 2.5초 대기 → 최소 2회 실행 기대
+    await new Promise((r) => setTimeout(r, 2500));
+    expect(count).toBeGreaterThanOrEqual(2);
+  });
+});
 
-    it("동일 이름 cron 재등록 → 이전 것 중지 후 교체", () => {
-        const scheduler = createScheduler();
-        scheduler.cron("dup", "*/5 * * * *", async () => {});
-        scheduler.cron("dup", "*/10 * * * *", async () => {});
+describe("Scheduler 실행 — onError dead-letter", () => {
+  it("runAfter 실패 시 onError action이 호출된다", async () => {
+    const scheduler = createScheduler();
+    let errorHandlerArgs: any = null;
 
-        // cronInfo에 2개 다 기록되어 있지만,
-        // 내부적으로 첫 번째 task는 stop()됨
-        const info = getSchedulerInfo();
-        const dups = info.crons.filter((c: any) => c.name === "dup");
-        expect(dups.length).toBeGreaterThanOrEqual(1);
+    scheduler.registerAction("failing.step", async () => {
+      throw new Error("Step failed!");
     });
 
-    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);
+    scheduler.registerAction("pipeline.onError", async (args) => {
+      errorHandlerArgs = args;
     });
-});
-
-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.runAfter(
+      50,
+      "failing.step",
+      { input: "test" },
+      {
+        onError: "pipeline.onError",
+      },
+    );
 
-        scheduler.registerAction("pipeline.onError", async (args) => {
-            errorHandlerArgs = args;
-        });
+    await new Promise((r) => setTimeout(r, 300));
 
-        scheduler.runAfter(50, "failing.step", { input: "test" }, {
-            onError: "pipeline.onError",
-        });
+    expect(errorHandlerArgs).not.toBeNull();
+    expect(errorHandlerArgs.failedAction).toBe("failing.step");
+    expect(errorHandlerArgs.error).toBe("Step failed!");
+    expect(errorHandlerArgs.originalArgs).toEqual({ input: "test" });
+  });
 
-        await new Promise((r) => setTimeout(r, 300));
+  it("실패한 작업이 failedJobs에 기록된다", async () => {
+    const scheduler = createScheduler();
 
-        expect(errorHandlerArgs).not.toBeNull();
-        expect(errorHandlerArgs.failedAction).toBe("failing.step");
-        expect(errorHandlerArgs.error).toBe("Step failed!");
-        expect(errorHandlerArgs.originalArgs).toEqual({ input: "test" });
+    scheduler.registerAction("record.fail", async () => {
+      throw new Error("Recorded failure");
     });
 
-    it("실패한 작업이 failedJobs에 기록된다", async () => {
-        const scheduler = createScheduler();
+    scheduler.runAfter(50, "record.fail", { id: 1 });
 
-        scheduler.registerAction("record.fail", async () => {
-            throw new Error("Recorded failure");
-        });
+    await new Promise((r) => setTimeout(r, 300));
 
-        scheduler.runAfter(50, "record.fail", { id: 1 });
+    const info = getSchedulerInfo();
+    const failed = info.failedJobs.find((j: any) => j.action === "record.fail");
+    expect(failed).toBeDefined();
+    expect(failed!.error).toBe("Recorded failure");
+  });
 
-        await new Promise((r) => setTimeout(r, 300));
+  it("pendingJobs에 status 필드가 포함된다", () => {
+    const scheduler = createScheduler();
+    scheduler.registerAction("noop", async () => {});
+    const id = scheduler.runAfter(10000, "noop");
 
-        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");
 
-        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);
-    });
+    // cleanup
+    scheduler.cancel(id);
+  });
 });