@gencow/core 0.1.23 → 0.1.25

package/src/__tests__/retry.test.ts

@@ -1,98 +1,113 @@
 import { describe, test, expect, mock } from "bun:test";
-import { withRetry } from "../retry";
+import { withRetry } from "../retry.js";
 
 describe("withRetry", () => {
-    test("성공 시 즉시 반환", async () => {
-        const result = await withRetry(async () => "success");
-        expect(result).toBe("success");
-    });
+  test("성공 시 즉시 반환", async () => {
+    const result = await withRetry(async () => "success");
+    expect(result).toBe("success");
+  });
 
-    test("첫 시도 실패 후 재시도 성공", async () => {
-        let attempt = 0;
-        const result = await withRetry(async () => {
-            attempt++;
-            if (attempt < 2) throw new Error("fail");
-            return "recovered";
-        }, { initialBackoffMs: 10 });
+  test("첫 시도 실패 후 재시도 성공", async () => {
+    let attempt = 0;
+    const result = await withRetry(
+      async () => {
+        attempt++;
+        if (attempt < 2) throw new Error("fail");
+        return "recovered";
+      },
+      { initialBackoffMs: 10 },
+    );
 
-        expect(result).toBe("recovered");
-        expect(attempt).toBe(2);
-    });
+    expect(result).toBe("recovered");
+    expect(attempt).toBe(2);
+  });
 
-    test("maxAttempts 초과 시 마지막 에러 throw", async () => {
-        let attempt = 0;
-        try {
-            await withRetry(async () => {
-                attempt++;
-                throw new Error(`fail-${attempt}`);
-            }, { maxAttempts: 3, initialBackoffMs: 10 });
-            expect(true).toBe(false); // 여기에 도달하면 안됨
-        } catch (err: unknown) {
-            expect((err as Error).message).toBe("fail-3");
-            expect(attempt).toBe(3);
-        }
-    });
+  test("maxAttempts 초과 시 마지막 에러 throw", async () => {
+    let attempt = 0;
+    try {
+      await withRetry(
+        async () => {
+          attempt++;
+          throw new Error(`fail-${attempt}`);
+        },
+        { maxAttempts: 3, initialBackoffMs: 10 },
+      );
+      expect(true).toBe(false); // 여기에 도달하면 안됨
+    } catch (err: unknown) {
+      expect((err as Error).message).toBe("fail-3");
+      expect(attempt).toBe(3);
+    }
+  });
 
-    test("shouldRetry가 false 반환 시 즉시 throw", async () => {
-        let attempt = 0;
-        try {
-            await withRetry(async () => {
-                attempt++;
-                throw new Error("non-retryable");
-            }, {
-                maxAttempts: 5,
-                initialBackoffMs: 10,
-                shouldRetry: (err) => (err as Error).message !== "non-retryable",
-            });
-        } catch (err: unknown) {
-            expect((err as Error).message).toBe("non-retryable");
-            expect(attempt).toBe(1); // 재시도 없이 즉시 실패
-        }
-    });
+  test("shouldRetry가 false 반환 시 즉시 throw", async () => {
+    let attempt = 0;
+    try {
+      await withRetry(
+        async () => {
+          attempt++;
+          throw new Error("non-retryable");
+        },
+        {
+          maxAttempts: 5,
+          initialBackoffMs: 10,
+          shouldRetry: (err) => (err as Error).message !== "non-retryable",
+        },
+      );
+    } catch (err: unknown) {
+      expect((err as Error).message).toBe("non-retryable");
+      expect(attempt).toBe(1); // 재시도 없이 즉시 실패
+    }
+  });
 
-    test("onRetry 콜백 호출", async () => {
-        let attempt = 0;
-        const retries: number[] = [];
+  test("onRetry 콜백 호출", async () => {
+    let attempt = 0;
+    const retries: number[] = [];
 
-        await withRetry(async () => {
-            attempt++;
-            if (attempt < 3) throw new Error("fail");
-            return "ok";
-        }, {
-            initialBackoffMs: 10,
-            onRetry: (_err, attemptNum, _delay) => {
-                retries.push(attemptNum);
-            },
-        });
+    await withRetry(
+      async () => {
+        attempt++;
+        if (attempt < 3) throw new Error("fail");
+        return "ok";
+      },
+      {
+        initialBackoffMs: 10,
+        onRetry: (_err, attemptNum, _delay) => {
+          retries.push(attemptNum);
+        },
+      },
+    );
 
-        expect(retries).toEqual([1, 2]);
-    });
+    expect(retries).toEqual([1, 2]);
+  });
 
-    test("maxAttempts < 1이면 에러", async () => {
-        try {
-            await withRetry(async () => "ok", { maxAttempts: 0 });
-            expect(true).toBe(false);
-        } catch (err: unknown) {
-            expect((err as Error).message).toContain("maxAttempts must be >= 1");
-        }
-    });
+  test("maxAttempts < 1이면 에러", async () => {
+    try {
+      await withRetry(async () => "ok", { maxAttempts: 0 });
+      expect(true).toBe(false);
+    } catch (err: unknown) {
+      expect((err as Error).message).toContain("maxAttempts must be >= 1");
+    }
+  });
 
-    test("maxAttempts = 1이면 재시도 없이 즉시 throw", async () => {
-        let attempt = 0;
-        try {
-            await withRetry(async () => {
-                attempt++;
-                throw new Error("once");
-            }, { maxAttempts: 1 });
-        } catch (err: unknown) {
-            expect((err as Error).message).toBe("once");
-            expect(attempt).toBe(1);
-        }
-    });
+  test("maxAttempts = 1이면 재시도 없이 즉시 throw", async () => {
+    let attempt = 0;
+    try {
+      await withRetry(
+        async () => {
+          attempt++;
+          throw new Error("once");
+        },
+        { maxAttempts: 1 },
+      );
+    } catch (err: unknown) {
+      expect((err as Error).message).toBe("once");
+      expect(attempt).toBe(1);
+    }
+  });
 
-    test("비동기 함수 결과 타입 보존", async () => {
-        const result = await withRetry(async () => ({ id: 1, name: "test" }));
-        expect(result.id).toBe(1);
-        expect(result.name).toBe("test");
-    });
+  test("비동기 함수 결과 타입 보존", async () => {
+    const result = await withRetry(async () => ({ id: 1, name: "test" }));
+    expect(result.id).toBe(1);
+    expect(result.name).toBe("test");
+  });
 });