@gencow/core 0.1.23 → 0.1.25

package/src/__tests__/scheduler.test.ts

@@ -10,160 +10,178 @@ import { describe, it, expect, mock, beforeEach, afterEach } from "bun:test";
 import { createScheduler, getSchedulerInfo } from "../scheduler";
 
 describe("createScheduler()", () => {
-    let scheduler: ReturnType<typeof createScheduler>;
+  let scheduler: ReturnType<typeof createScheduler>;
 
-    beforeEach(() => {
-        scheduler = 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 });
     });
 
-    // ─── registerAction + executeAction ──────────────────
+    it("미등록 액션 실행 시 console.error만 출력 (throw 안 함)", async () => {
+      const errorSpy = mock(() => {});
+      const orig = console.error;
+      console.error = errorSpy;
 
-    describe("registerAction / executeAction", () => {
-        it("등록된 액션 실행", async () => {
-            const fn = mock(async (args: any) => {});
-            scheduler.registerAction("test.action", fn);
+      await scheduler.executeAction("nonexistent.action");
 
-            await scheduler.executeAction("test.action", { foo: 1 });
+      expect(errorSpy).toHaveBeenCalled();
+      expect(String(errorSpy.mock.calls[0][0])).toContain("nonexistent.action");
 
-            expect(fn).toHaveBeenCalledTimes(1);
-            expect(fn.mock.calls[0][0]).toEqual({ foo: 1 });
-        });
+      console.error = orig;
+    });
+
+    it("액션 핸들러 에러 시 console.error 출력 (throw 안 함)", async () => {
+      scheduler.registerAction("failing.action", async () => {
+        throw new Error("action failed");
+      });
 
-        it("미등록 액션 실행 시 console.error만 출력 (throw 안 함)", async () => {
-            const errorSpy = mock(() => {});
-            const orig = console.error;
-            console.error = errorSpy;
+      const errorSpy = mock((..._args: any[]) => {});
+      const orig = console.error;
+      console.error = errorSpy;
 
-            await scheduler.executeAction("nonexistent.action");
+      await scheduler.executeAction("failing.action");
 
-            expect(errorSpy).toHaveBeenCalled();
-            expect(String(errorSpy.mock.calls[0][0])).toContain("nonexistent.action");
+      expect(errorSpy).toHaveBeenCalled();
 
-            console.error = orig;
-        });
+      console.error = orig;
+    });
 
-        it("액션 핸들러 에러 시 console.error 출력 (throw 안 함)", async () => {
-            scheduler.registerAction("failing.action", async () => {
-                throw new Error("action failed");
-            });
+    it("executeActionStrict는 등록된 액션의 args를 그대로 전달한다", async () => {
+      const fn = mock(async (_args: any) => {});
+      scheduler.registerAction("strict.action", fn);
 
-            const errorSpy = mock((..._args: any[]) => {});
-            const orig = console.error;
-            console.error = errorSpy;
+      await scheduler.executeActionStrict("strict.action", { workflowId: "wf-1" });
 
-            await scheduler.executeAction("failing.action");
+      expect(fn).toHaveBeenCalledTimes(1);
+      expect(fn.mock.calls[0][0]).toEqual({ workflowId: "wf-1" });
+    });
 
-            expect(errorSpy).toHaveBeenCalled();
+    it("executeActionStrict는 액션 에러를 호출자에게 다시 던진다", async () => {
+      scheduler.registerAction("strict.fail", async () => {
+        throw new Error("strict failed");
+      });
 
-            console.error = orig;
-        });
+      await expect(scheduler.executeActionStrict("strict.fail")).rejects.toThrow("strict failed");
     });
+  });
 
-    // ─── runAfter ───────────────────────────────────────
+  // ─── runAfter ───────────────────────────────────────
 
-    describe("runAfter()", () => {
-        it("jobId를 반환한다", () => {
-            const jobId = scheduler.runAfter(10000, "test.action");
-            expect(typeof jobId).toBe("string");
-            expect(jobId).toContain("job_");
+  describe("runAfter()", () => {
+    it("jobId를 반환한다", () => {
+      const jobId = scheduler.runAfter(10000, "test.action");
+      expect(typeof jobId).toBe("string");
+      expect(jobId).toContain("job_");
 
-            // cleanup
-            scheduler.cancel(jobId);
-        });
+      // cleanup
+      scheduler.cancel(jobId);
+    });
 
-        it("지정 시간 후 액션을 실행한다", async () => {
-            const fn = mock(async () => {});
-            scheduler.registerAction("delayed.action", fn);
+    it("지정 시간 후 액션을 실행한다", async () => {
+      const fn = mock(async () => {});
+      scheduler.registerAction("delayed.action", fn);
 
-            scheduler.runAfter(50, "delayed.action", { key: "val" });
+      scheduler.runAfter(50, "delayed.action", { key: "val" });
 
-            // 액션은 아직 실행되지 않아야 함
-            expect(fn).not.toHaveBeenCalled();
+      // 액션은 아직 실행되지 않아야 함
+      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" });
-        });
+      // 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");
+    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);
-        });
+      // cleanup
+      scheduler.cancel(jobId);
     });
+  });
 
-    // ─── cancel ─────────────────────────────────────────
+  // ─── cancel ─────────────────────────────────────────
 
-    describe("cancel()", () => {
-        it("예약된 작업을 취소한다", () => {
-            const fn = mock(async () => {});
-            scheduler.registerAction("cancel.test", fn);
+  describe("cancel()", () => {
+    it("예약된 작업을 취소한다", () => {
+      const fn = mock(async () => {});
+      scheduler.registerAction("cancel.test", fn);
 
-            const jobId = scheduler.runAfter(50, "cancel.test");
-            const cancelled = scheduler.cancel(jobId);
+      const jobId = scheduler.runAfter(50, "cancel.test");
+      const cancelled = scheduler.cancel(jobId);
 
-            expect(cancelled).toBe(true);
-        });
+      expect(cancelled).toBe(true);
+    });
 
-        it("존재하지 않는 jobId → false 반환", () => {
-            expect(scheduler.cancel("nonexistent_id")).toBe(false);
-        });
+    it("존재하지 않는 jobId → false 반환", () => {
+      expect(scheduler.cancel("nonexistent_id")).toBe(false);
+    });
 
-        it("취소된 작업은 실행되지 않는다", async () => {
-            const fn = mock(async () => {});
-            scheduler.registerAction("cancel.verify", fn);
+    it("취소된 작업은 실행되지 않는다", async () => {
+      const fn = mock(async () => {});
+      scheduler.registerAction("cancel.verify", fn);
 
-            const jobId = scheduler.runAfter(30, "cancel.verify");
-            scheduler.cancel(jobId);
+      const jobId = scheduler.runAfter(30, "cancel.verify");
+      scheduler.cancel(jobId);
 
-            await new Promise(r => setTimeout(r, 100));
-            expect(fn).not.toHaveBeenCalled();
-        });
+      await new Promise((r) => setTimeout(r, 100));
+      expect(fn).not.toHaveBeenCalled();
     });
+  });
 
-    // ─── runAt ──────────────────────────────────────────
+  // ─── 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);
-        });
+  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("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);
+    it("과거 시각 → 즉시 실행 (ms=0)", async () => {
+      const fn = mock(async () => {});
+      scheduler.registerAction("past.action", fn);
 
-            scheduler.runAt(Date.now() - 10000, "past.action");
+      scheduler.runAt(Date.now() - 10000, "past.action");
 
-            await new Promise(r => setTimeout(r, 50));
-            expect(fn).toHaveBeenCalledTimes(1);
-        });
+      await new Promise((r) => setTimeout(r, 50));
+      expect(fn).toHaveBeenCalledTimes(1);
     });
+  });
 
-    // ─── getSchedulerInfo ───────────────────────────────
+  // ─── 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);
-        });
+  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);
     });
+  });
 });