@gencow/core 0.1.23 → 0.1.25

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

@@ -15,256 +15,274 @@
  */
 
 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 v2 — Platform DB 중앙화", () => {
-    // ── args 전달 정확성 ──
+  // ── args 전달 정확성 ──
 
-    it("persistJob에 args가 정확히 전달된다 (중첩 객체)", async () => {
-        const persisted: ScheduledJobRecord[] = [];
+  it("persistJob에 args가 정확히 전달된다 (중첩 객체)", async () => {
+    const persisted: ScheduledJobRecord[] = [];
 
-        const scheduler = createScheduler({
-            persistJob: async (job) => { persisted.push(job); },
-            removeJob: async () => true,
-        });
-
-        scheduler.registerAction("deep.args", async () => {});
-
-        const complexArgs = {
-            nested: { deeply: { value: 42 } },
-            array: [1, 2, { x: "y" }],
-            unicode: "한글테스트 🎯",
-            nullValue: null,
-            boolValue: false,
-            zero: 0,
-            emptyString: "",
-        };
-
-        scheduler.runAfter(1000, "deep.args", complexArgs);
-        await new Promise((r) => setTimeout(r, 50));
+    const scheduler = createScheduler({
+      persistJob: async (job) => {
+        persisted.push(job);
+      },
+      removeJob: async () => true,
+    });
 
-        expect(persisted.length).toBe(1);
-        expect(persisted[0].args).toEqual(complexArgs);
+    scheduler.registerAction("deep.args", async () => {});
+
+    const complexArgs = {
+      nested: { deeply: { value: 42 } },
+      array: [1, 2, { x: "y" }],
+      unicode: "한글테스트 🎯",
+      nullValue: null,
+      boolValue: false,
+      zero: 0,
+      emptyString: "",
+    };
+
+    scheduler.runAfter(1000, "deep.args", complexArgs);
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(persisted.length).toBe(1);
+    expect(persisted[0].args).toEqual(complexArgs);
+  });
+
+  it("persistJob에 args 미전달 시 undefined로 전달", async () => {
+    const persisted: ScheduledJobRecord[] = [];
+
+    const scheduler = createScheduler({
+      persistJob: async (job) => {
+        persisted.push(job);
+      },
+      removeJob: async () => true,
     });
 
-    it("persistJob에 args 미전달 시 undefined로 전달", async () => {
-        const persisted: ScheduledJobRecord[] = [];
+    scheduler.registerAction("no.args", async () => {});
+    scheduler.runAfter(1000, "no.args"); // args 생략
+
+    await new Promise((r) => setTimeout(r, 50));
 
-        const scheduler = createScheduler({
-            persistJob: async (job) => { persisted.push(job); },
-            removeJob: async () => true,
-        });
+    expect(persisted.length).toBe(1);
+    // args는 undefined 또는 빈 값이어야 함 (Platform에서 {} default 처리)
+    expect(
+      persisted[0].args === undefined ||
+        persisted[0].args === null ||
+        JSON.stringify(persisted[0].args) === "{}",
+    ).toBe(true);
+  });
 
-        scheduler.registerAction("no.args", async () => {});
-        scheduler.runAfter(1000, "no.args"); // args 생략
+  // ── 동시 등록 id 고유성 ──
 
-        await new Promise((r) => setTimeout(r, 50));
+  it("10개 job 동시 등록 시 모든 id가 고유하다", async () => {
+    const persisted: ScheduledJobRecord[] = [];
 
-        expect(persisted.length).toBe(1);
-        // args는 undefined 또는 빈 값이어야 함 (Platform에서 {} default 처리)
-        expect(persisted[0].args === undefined || persisted[0].args === null || JSON.stringify(persisted[0].args) === "{}").toBe(true);
+    const scheduler = createScheduler({
+      persistJob: async (job) => {
+        persisted.push(job);
+      },
+      removeJob: async () => true,
     });
 
-    // ── 동시 등록 id 고유성 ──
+    for (let i = 0; i < 10; i++) {
+      scheduler.registerAction(`batch.${i}`, async () => {});
+    }
 
-    it("10개 job 동시 등록 시 모든 id가 고유하다", async () => {
-        const persisted: ScheduledJobRecord[] = [];
+    const ids: string[] = [];
+    for (let i = 0; i < 10; i++) {
+      ids.push(scheduler.runAfter(1000, `batch.${i}`, { idx: i }));
+    }
 
-        const scheduler = createScheduler({
-            persistJob: async (job) => { persisted.push(job); },
-            removeJob: async () => true,
-        });
+    await new Promise((r) => setTimeout(r, 100));
 
-        for (let i = 0; i < 10; i++) {
-            scheduler.registerAction(`batch.${i}`, async () => {});
-        }
+    // 모든 id 고유
+    const uniqueIds = new Set(ids);
+    expect(uniqueIds.size).toBe(10);
 
-        const ids: string[] = [];
-        for (let i = 0; i < 10; i++) {
-            ids.push(scheduler.runAfter(1000, `batch.${i}`, { idx: i }));
-        }
+    // 모든 persistJob 호출됨
+    expect(persisted.length).toBe(10);
+  });
 
-        await new Promise((r) => setTimeout(r, 100));
+  // ── runAfter(0) — 즉시 실행 ──
 
-        // 모든 id 고유
-        const uniqueIds = new Set(ids);
-        expect(uniqueIds.size).toBe(10);
+  it("runAfter(0) — durable mode에서도 즉시 persistJob 호출", async () => {
+    const persisted: ScheduledJobRecord[] = [];
 
-        // 모든 persistJob 호출됨
-        expect(persisted.length).toBe(10);
+    const scheduler = createScheduler({
+      persistJob: async (job) => {
+        persisted.push(job);
+      },
+      removeJob: async () => true,
     });
 
-    // ── runAfter(0) — 즉시 실행 ──
-
-    it("runAfter(0) — durable mode에서도 즉시 persistJob 호출", async () => {
-        const persisted: ScheduledJobRecord[] = [];
+    scheduler.registerAction("instant", async () => {});
 
-        const scheduler = createScheduler({
-            persistJob: async (job) => { persisted.push(job); },
-            removeJob: async () => true,
-        });
+    const beforeTime = Date.now();
+    scheduler.runAfter(0, "instant", { immediate: true });
 
-        scheduler.registerAction("instant", async () => {});
+    await new Promise((r) => setTimeout(r, 50));
 
-        const beforeTime = Date.now();
-        scheduler.runAfter(0, "instant", { immediate: true });
+    expect(persisted.length).toBe(1);
+    expect(persisted[0].args).toEqual({ immediate: true });
+    // runAt은 현재 시간과 거의 동일해야 함 (±2초 오차 허용)
+    expect(Math.abs(persisted[0].runAt.getTime() - beforeTime)).toBeLessThan(2000);
+  });
 
-        await new Promise((r) => setTimeout(r, 50));
+  // ── removeJob 실패 시 graceful 처리 ──
 
-        expect(persisted.length).toBe(1);
-        expect(persisted[0].args).toEqual({ immediate: true });
-        // runAt은 현재 시간과 거의 동일해야 함 (±2초 오차 허용)
-        expect(Math.abs(persisted[0].runAt.getTime() - beforeTime)).toBeLessThan(2000);
+  it("removeJob 실패 시 cancel()이 false 반환 (throw 안 함)", async () => {
+    const scheduler = createScheduler({
+      persistJob: async () => {},
+      removeJob: async () => {
+        throw new Error("DB connection lost");
+      },
     });
 
-    // ── removeJob 실패 시 graceful 처리 ──
+    scheduler.registerAction("fail.cancel", async () => {});
+    const id = scheduler.runAfter(10000, "fail.cancel");
 
-    it("removeJob 실패 시 cancel()이 false 반환 (throw 안 함)", async () => {
-        const scheduler = createScheduler({
-            persistJob: async () => {},
-            removeJob: async () => {
-                throw new Error("DB connection lost");
-            },
-        });
+    await new Promise((r) => setTimeout(r, 50));
 
-        scheduler.registerAction("fail.cancel", async () => {});
-        const id = scheduler.runAfter(10000, "fail.cancel");
+    // suppress expected error
+    const orig = console.error;
+    console.error = () => {};
+    const result = scheduler.cancel(id);
+    console.error = orig;
 
-        await new Promise((r) => setTimeout(r, 50));
+    // removeJob 실패 시 return false, throw 안 함
+    expect(typeof result).toBe("boolean");
+  });
 
-        // suppress expected error
-        const orig = console.error;
-        console.error = () => {};
-        const result = scheduler.cancel(id);
-        console.error = orig;
+  // ── 대형 args 안정성 ──
 
-        // removeJob 실패 시 return false, throw 안 함
-        expect(typeof result).toBe("boolean");
+  it("대형 args (10KB) 직렬화 안정성", async () => {
+    const persisted: ScheduledJobRecord[] = [];
+
+    const scheduler = createScheduler({
+      persistJob: async (job) => {
+        persisted.push(job);
+      },
+      removeJob: async () => true,
     });
 
-    // ── 대형 args 안정성 ──
+    scheduler.registerAction("large.payload", async () => {});
 
-    it("대형 args (10KB) 직렬화 안정성", async () => {
-        const persisted: ScheduledJobRecord[] = [];
+    // ~10KB args
+    const largeArgs = {
+      data: "x".repeat(10_000),
+      items: Array.from({ length: 100 }, (_, i) => ({ id: i, name: `item-${i}` })),
+    };
 
-        const scheduler = createScheduler({
-            persistJob: async (job) => { persisted.push(job); },
-            removeJob: async () => true,
-        });
+    scheduler.runAfter(1000, "large.payload", largeArgs);
+    await new Promise((r) => setTimeout(r, 50));
 
-        scheduler.registerAction("large.payload", async () => {});
+    expect(persisted.length).toBe(1);
+    expect((persisted[0].args as any).data.length).toBe(10_000);
+    expect((persisted[0].args as any).items.length).toBe(100);
+  });
 
-        // ~10KB args
-        const largeArgs = {
-            data: "x".repeat(10_000),
-            items: Array.from({ length: 100 }, (_, i) => ({ id: i, name: `item-${i}` })),
-        };
+  // ── onError + args 조합 ──
 
-        scheduler.runAfter(1000, "large.payload", largeArgs);
-        await new Promise((r) => setTimeout(r, 50));
+  it("onError와 args가 함께 persistJob에 전달된다", async () => {
+    const persisted: ScheduledJobRecord[] = [];
 
-        expect(persisted.length).toBe(1);
-        expect((persisted[0].args as any).data.length).toBe(10_000);
-        expect((persisted[0].args as any).items.length).toBe(100);
+    const scheduler = createScheduler({
+      persistJob: async (job) => {
+        persisted.push(job);
+      },
+      removeJob: async () => true,
     });
 
-    // ── onError + args 조합 ──
+    scheduler.registerAction("pipeline.step1", async () => {});
+    scheduler.registerAction("pipeline.onError", async () => {});
 
-    it("onError와 args가 함께 persistJob에 전달된다", async () => {
-        const persisted: ScheduledJobRecord[] = [];
+    scheduler.runAfter(5000, "pipeline.step1", { step: 1, data: "test" }, { onError: "pipeline.onError" });
 
-        const scheduler = createScheduler({
-            persistJob: async (job) => { persisted.push(job); },
-            removeJob: async () => true,
-        });
+    await new Promise((r) => setTimeout(r, 50));
 
-        scheduler.registerAction("pipeline.step1", async () => {});
-        scheduler.registerAction("pipeline.onError", async () => {});
+    expect(persisted.length).toBe(1);
+    expect(persisted[0].action).toBe("pipeline.step1");
+    expect(persisted[0].args).toEqual({ step: 1, data: "test" });
+    expect(persisted[0].onErrorAction).toBe("pipeline.onError");
+  });
 
-        scheduler.runAfter(5000, "pipeline.step1", { step: 1, data: "test" }, { onError: "pipeline.onError" });
+  // ── runAt + durable 조합 ──
 
-        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("pipeline.step1");
-        expect(persisted[0].args).toEqual({ step: 1, data: "test" });
-        expect(persisted[0].onErrorAction).toBe("pipeline.onError");
+    const scheduler = createScheduler({
+      persistJob: async (job) => {
+        persisted.push(job);
+      },
+      removeJob: async () => true,
     });
 
-    // ── runAt + durable 조합 ──
+    scheduler.registerAction("past.task", async () => {});
 
-    it("runAt(과거 시점) — durable mode에서도 persistJob 호출 (즉시 실행 대상)", async () => {
-        const persisted: ScheduledJobRecord[] = [];
+    const pastTime = new Date(Date.now() - 60_000); // 1분 전
+    scheduler.runAt(pastTime, "past.task", { expired: true });
 
-        const scheduler = createScheduler({
-            persistJob: async (job) => { persisted.push(job); },
-            removeJob: async () => true,
-        });
+    await new Promise((r) => setTimeout(r, 50));
 
-        scheduler.registerAction("past.task", async () => {});
+    expect(persisted.length).toBe(1);
+    expect(persisted[0].args).toEqual({ expired: true });
+    // runAt이 과거여도 persistJob은 호출되어야 함 (폴러가 즉시 픽업)
+  });
 
-        const pastTime = new Date(Date.now() - 60_000); // 1분 전
-        scheduler.runAt(pastTime, "past.task", { expired: true });
+  // ── 다중 cancel ──
 
-        await new Promise((r) => setTimeout(r, 50));
+  it("같은 job을 2번 cancel — 첫 번째만 removeJob 성공", async () => {
+    let removeCount = 0;
 
-        expect(persisted.length).toBe(1);
-        expect(persisted[0].args).toEqual({ expired: true });
-        // runAt이 과거여도 persistJob은 호출되어야 함 (폴러가 즉시 픽업)
+    const scheduler = createScheduler({
+      persistJob: async () => {},
+      removeJob: async () => {
+        removeCount++;
+        return removeCount === 1; // 첫 번째만 true
+      },
     });
 
-    // ── 다중 cancel ──
+    scheduler.registerAction("double.cancel", async () => {});
+    const id = scheduler.runAfter(10000, "double.cancel");
 
-    it("같은 job을 2번 cancel — 첫 번째만 removeJob 성공", async () => {
-        let removeCount = 0;
+    await new Promise((r) => setTimeout(r, 50));
 
-        const scheduler = createScheduler({
-            persistJob: async () => {},
-            removeJob: async () => {
-                removeCount++;
-                return removeCount === 1; // 첫 번째만 true
-            },
-        });
+    const r1 = scheduler.cancel(id);
+    await new Promise((r) => setTimeout(r, 20));
+    const r2 = scheduler.cancel(id);
 
-        scheduler.registerAction("double.cancel", async () => {});
-        const id = scheduler.runAfter(10000, "double.cancel");
+    // 첫 번째 cancel은 성공 (pendingJobs에서 제거)
+    expect(r1).toBe(true);
+    // 두 번째 cancel은 이미 제거되었으므로 false
+    expect(r2).toBe(false);
+  });
 
-        await new Promise((r) => setTimeout(r, 50));
+  // ── persistJob 순서 보장 ──
 
-        const r1 = scheduler.cancel(id);
-        await new Promise((r) => setTimeout(r, 20));
-        const r2 = scheduler.cancel(id);
+  it("연속 runAfter 호출 시 persistJob 순서 보장", async () => {
+    const order: string[] = [];
 
-        // 첫 번째 cancel은 성공 (pendingJobs에서 제거)
-        expect(r1).toBe(true);
-        // 두 번째 cancel은 이미 제거되었으므로 false
-        expect(r2).toBe(false);
+    const scheduler = createScheduler({
+      persistJob: async (job) => {
+        order.push(job.action);
+      },
+      removeJob: async () => true,
     });
 
-    // ── persistJob 순서 보장 ──
-
-    it("연속 runAfter 호출 시 persistJob 순서 보장", async () => {
-        const order: string[] = [];
-
-        const scheduler = createScheduler({
-            persistJob: async (job) => {
-                order.push(job.action);
-            },
-            removeJob: async () => true,
-        });
+    scheduler.registerAction("a", async () => {});
+    scheduler.registerAction("b", async () => {});
+    scheduler.registerAction("c", async () => {});
 
-        scheduler.registerAction("a", async () => {});
-        scheduler.registerAction("b", async () => {});
-        scheduler.registerAction("c", async () => {});
+    scheduler.runAfter(1000, "a");
+    scheduler.runAfter(2000, "b");
+    scheduler.runAfter(3000, "c");
 
-        scheduler.runAfter(1000, "a");
-        scheduler.runAfter(2000, "b");
-        scheduler.runAfter(3000, "c");
+    await new Promise((r) => setTimeout(r, 100));
 
-        await new Promise((r) => setTimeout(r, 100));
-
-        // persistJob은 호출 순서대로 실행되어야 함
-        expect(order).toEqual(["a", "b", "c"]);
-    });
+    // persistJob은 호출 순서대로 실행되어야 함
+    expect(order).toEqual(["a", "b", "c"]);
+  });
 });