@gencow/core 0.1.23 → 0.1.25

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

@@ -9,165 +9,165 @@
  */
 
 import { describe, it, expect } from "bun:test";
-import { createScheduler } from "../scheduler";
-import type { ScheduledJobRecord } from "../scheduler";
+import { createScheduler } from "../scheduler.js";
+import type { ScheduledJobRecord } from "../scheduler.js";
 
 describe("Scheduler Durable Mode — persistJob/removeJob", () => {
-    it("durable mode에서 runAfter → persistJob 콜백 호출", async () => {
-        const persisted: ScheduledJobRecord[] = [];
-
-        const scheduler = createScheduler({
-            persistJob: async (job) => {
-                persisted.push(job);
-            },
-            removeJob: async () => true,
-        });
-
-        scheduler.registerAction("test.durable", async () => {});
-        const id = scheduler.runAfter(5000, "test.durable", { key: "value" });
-
-        // persistJob은 비동기이므로 약간 대기
-        await new Promise((r) => setTimeout(r, 50));
-
-        expect(persisted.length).toBe(1);
-        expect(persisted[0].id).toBe(id);
-        expect(persisted[0].action).toBe("test.durable");
-        expect(persisted[0].args).toEqual({ key: "value" });
-        expect(persisted[0].runAt).toBeInstanceOf(Date);
-        expect(persisted[0].runAt.getTime()).toBeGreaterThan(Date.now() + 4000); // ~5초 후
+  it("durable mode에서 runAfter → persistJob 콜백 호출", async () => {
+    const persisted: ScheduledJobRecord[] = [];
+
+    const scheduler = createScheduler({
+      persistJob: async (job) => {
+        persisted.push(job);
+      },
+      removeJob: async () => true,
     });
 
-    it("durable mode에서 runAfter → setTimeout 실행 안 함 (외부 폴러에 위임)", async () => {
-        let actionExecuted = false;
+    scheduler.registerAction("test.durable", async () => {});
+    const id = scheduler.runAfter(5000, "test.durable", { key: "value" });
 
-        const scheduler = createScheduler({
-            persistJob: async () => {},
-            removeJob: async () => true,
-        });
+    // persistJob은 비동기이므로 약간 대기
+    await new Promise((r) => setTimeout(r, 50));
 
-        scheduler.registerAction("no.exec", async () => {
-            actionExecuted = true;
-        });
+    expect(persisted.length).toBe(1);
+    expect(persisted[0].id).toBe(id);
+    expect(persisted[0].action).toBe("test.durable");
+    expect(persisted[0].args).toEqual({ key: "value" });
+    expect(persisted[0].runAt).toBeInstanceOf(Date);
+    expect(persisted[0].runAt.getTime()).toBeGreaterThan(Date.now() + 4000); // ~5초 후
+  });
 
-        scheduler.runAfter(50, "no.exec");
+  it("durable mode에서 runAfter → setTimeout 실행 안 함 (외부 폴러에 위임)", async () => {
+    let actionExecuted = false;
 
-        // 100ms 대기 — durable mode에서는 action이 실행되지 않아야 함
-        await new Promise((r) => setTimeout(r, 150));
-
-        expect(actionExecuted).toBe(false);
+    const scheduler = createScheduler({
+      persistJob: async () => {},
+      removeJob: async () => true,
     });
 
-    it("durable mode에서 cancel → removeJob 콜백 호출", async () => {
-        const removed: string[] = [];
-
-        const scheduler = createScheduler({
-            persistJob: async () => {},
-            removeJob: async (jobId) => {
-                removed.push(jobId);
-                return true;
-            },
-        });
+    scheduler.registerAction("no.exec", async () => {
+      actionExecuted = true;
+    });
 
-        scheduler.registerAction("noop", async () => {});
-        const id = scheduler.runAfter(10000, "noop");
+    scheduler.runAfter(50, "no.exec");
 
-        // persistJob 완료 대기
-        await new Promise((r) => setTimeout(r, 50));
+    // 100ms 대기 — durable mode에서는 action이 실행되지 않아야 함
+    await new Promise((r) => setTimeout(r, 150));
 
-        scheduler.cancel(id);
+    expect(actionExecuted).toBe(false);
+  });
 
-        // removeJob은 비동기이므로 대기
-        await new Promise((r) => setTimeout(r, 50));
+  it("durable mode에서 cancel → removeJob 콜백 호출", async () => {
+    const removed: string[] = [];
 
-        expect(removed.length).toBeGreaterThanOrEqual(1);
-        expect(removed).toContain(id);
+    const scheduler = createScheduler({
+      persistJob: async () => {},
+      removeJob: async (jobId) => {
+        removed.push(jobId);
+        return true;
+      },
     });
 
-    it("durable mode에서 onError action 이름이 persistJob에 전달", async () => {
-        const persisted: ScheduledJobRecord[] = [];
+    scheduler.registerAction("noop", async () => {});
+    const id = scheduler.runAfter(10000, "noop");
 
-        const scheduler = createScheduler({
-            persistJob: async (job) => {
-                persisted.push(job);
-            },
-            removeJob: async () => true,
-        });
+    // persistJob 완료 대기
+    await new Promise((r) => setTimeout(r, 50));
 
-        scheduler.registerAction("step1", async () => {});
-        scheduler.registerAction("onFail", async () => {});
+    scheduler.cancel(id);
 
-        scheduler.runAfter(1000, "step1", {}, { onError: "onFail" });
+    // removeJob은 비동기이므로 대기
+    await new Promise((r) => setTimeout(r, 50));
 
-        await new Promise((r) => setTimeout(r, 50));
+    expect(removed.length).toBeGreaterThanOrEqual(1);
+    expect(removed).toContain(id);
+  });
 
-        expect(persisted.length).toBe(1);
-        expect(persisted[0].onErrorAction).toBe("onFail");
-    });
+  it("durable mode에서 onError action 이름이 persistJob에 전달", async () => {
+    const persisted: ScheduledJobRecord[] = [];
 
-    it("persistJob 실패 시 인메모리 fallback으로 실행", async () => {
-        let actionExecuted = false;
+    const scheduler = createScheduler({
+      persistJob: async (job) => {
+        persisted.push(job);
+      },
+      removeJob: async () => true,
+    });
 
-        const scheduler = createScheduler({
-            persistJob: async () => {
-                throw new Error("DB connection failed");
-            },
-            removeJob: async () => true,
-        });
+    scheduler.registerAction("step1", async () => {});
+    scheduler.registerAction("onFail", async () => {});
 
-        scheduler.registerAction("fallback.test", async () => {
-            actionExecuted = true;
-        });
+    scheduler.runAfter(1000, "step1", {}, { onError: "onFail" });
 
-        // suppress expected error log
-        const origError = console.error;
-        console.error = () => {};
+    await new Promise((r) => setTimeout(r, 50));
 
-        scheduler.runAfter(50, "fallback.test");
+    expect(persisted.length).toBe(1);
+    expect(persisted[0].onErrorAction).toBe("onFail");
+  });
 
-        // persistJob 실패 → fallback → setTimeout(50ms) → 실행
-        await new Promise((r) => setTimeout(r, 300));
+  it("persistJob 실패 시 인메모리 fallback으로 실행", async () => {
+    let actionExecuted = false;
 
-        console.error = origError;
+    const scheduler = createScheduler({
+      persistJob: async () => {
+        throw new Error("DB connection failed");
+      },
+      removeJob: async () => true,
+    });
 
-        expect(actionExecuted).toBe(true);
+    scheduler.registerAction("fallback.test", async () => {
+      actionExecuted = true;
     });
 
-    it("콜백 미설정 시 기존 인메모리 mode 유지", async () => {
-        let executed = false;
+    // suppress expected error log
+    const origError = console.error;
+    console.error = () => {};
 
-        const scheduler = createScheduler(); // no options
+    scheduler.runAfter(50, "fallback.test");
 
-        scheduler.registerAction("mem.test", async () => {
-            executed = true;
-        });
+    // persistJob 실패 → fallback → setTimeout(50ms) → 실행
+    await new Promise((r) => setTimeout(r, 300));
 
-        scheduler.runAfter(50, "mem.test");
+    console.error = origError;
 
-        await new Promise((r) => setTimeout(r, 150));
+    expect(actionExecuted).toBe(true);
+  });
 
-        expect(executed).toBe(true);
-    });
+  it("콜백 미설정 시 기존 인메모리 mode 유지", async () => {
+    let executed = false;
 
-    it("runAt도 durable mode에서 persistJob 호출", async () => {
-        const persisted: ScheduledJobRecord[] = [];
+    const scheduler = createScheduler(); // no options
 
-        const scheduler = createScheduler({
-            persistJob: async (job) => {
-                persisted.push(job);
-            },
-            removeJob: async () => true,
-        });
+    scheduler.registerAction("mem.test", async () => {
+      executed = true;
+    });
+
+    scheduler.runAfter(50, "mem.test");
 
-        scheduler.registerAction("future.task", async () => {});
+    await new Promise((r) => setTimeout(r, 150));
 
-        const futureTime = new Date(Date.now() + 60_000); // 1분 후
-        scheduler.runAt(futureTime, "future.task", { x: 1 });
+    expect(executed).toBe(true);
+  });
 
-        await new Promise((r) => setTimeout(r, 50));
+  it("runAt도 durable mode에서 persistJob 호출", async () => {
+    const persisted: ScheduledJobRecord[] = [];
 
-        expect(persisted.length).toBe(1);
-        expect(persisted[0].action).toBe("future.task");
-        // runAt → runAfter 변환이므로 runAt 시간과 근사해야 함
-        expect(Math.abs(persisted[0].runAt.getTime() - futureTime.getTime())).toBeLessThan(1000);
+    const scheduler = createScheduler({
+      persistJob: async (job) => {
+        persisted.push(job);
+      },
+      removeJob: async () => true,
     });
+
+    scheduler.registerAction("future.task", async () => {});
+
+    const futureTime = new Date(Date.now() + 60_000); // 1분 후
+    scheduler.runAt(futureTime, "future.task", { x: 1 });
+
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(persisted.length).toBe(1);
+    expect(persisted[0].action).toBe("future.task");
+    // runAt → runAfter 변환이므로 runAt 시간과 근사해야 함
+    expect(Math.abs(persisted[0].runAt.getTime() - futureTime.getTime())).toBeLessThan(1000);
+  });
 });