test: 新增 router 和 eventRoutes 的單元測試

Author: c-c-epr

test/_index.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  router: vi.fn(),
+}));
+
+vi.mock("../src/router", () => ({
+  router: mocks.router,
+}));
+
+import worker from "../src/_index";
+
+describe("worker fetch entry", () => {
+  it("delegates request handling to router", async () => {
+    const request = new Request("https://example.com", { method: "POST" });
+    const env = { SOME_ENV: "value" } as any;
+    const ctx = { waitUntil: vi.fn() } as any;
+    const expectedResponse = new Response("delegated", { status: 200 });
+
+    mocks.router.mockResolvedValueOnce(expectedResponse);
+
+    const response = await worker.fetch(request, env, ctx);
+
+    expect(mocks.router).toHaveBeenCalledWith(request, env, ctx);
+    expect(response).toBe(expectedResponse);
+  });
+});

test/router.extra.test.ts

@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { hmacSHA256Base64 } from "../src/utils/hmacSHA256Base64";
+
+const mocks = vi.hoisted(() => ({
+  eventRouter: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("../src/eventRouter", () => ({
+  eventRouter: mocks.eventRouter,
+}));
+
+import { router } from "../src/router";
+
+const mockEnv = {
+  LINE_CHANNEL_SECRET: { get: vi.fn() },
+  LINE_CHANNEL_ACCESS_TOKEN: { get: vi.fn() },
+};
+
+describe("router extra branches", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockEnv.LINE_CHANNEL_SECRET.get.mockResolvedValue("secret");
+    mockEnv.LINE_CHANNEL_ACCESS_TOKEN.get.mockResolvedValue("accessToken");
+  });
+
+  it("returns 400 when body is not valid JSON", async () => {
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+    const request = new Request("https://example.com", {
+      method: "POST",
+      headers: { "x-line-signature": "sig" },
+      body: "{",
+    });
+
+    const response = await router(request, mockEnv as any, {} as any);
+
+    expect(response.status).toBe(400);
+    expect(await response.text()).toBe("Invalid JSON");
+    errorSpy.mockRestore();
+  });
+
+  it("dispatches each event to eventRouter", async () => {
+    const eventA = { type: "message", message: { type: "text", text: "Hi" } };
+    const eventB = { type: "message", message: { type: "text", text: "hello" } };
+    const rawBody = JSON.stringify({ destination: "", events: [eventA, eventB] });
+    const signature = await hmacSHA256Base64("secret", rawBody);
+
+    const request = new Request("https://example.com", {
+      method: "POST",
+      headers: { "x-line-signature": signature },
+      body: rawBody,
+    });
+    const ctx = { waitUntil: vi.fn() } as any;
+
+    const response = await router(request, mockEnv as any, ctx);
+
+    expect(response.status).toBe(200);
+    expect(mocks.eventRouter).toHaveBeenCalledTimes(2);
+    expect(mocks.eventRouter).toHaveBeenNthCalledWith(1, eventA, "accessToken", ctx);
+    expect(mocks.eventRouter).toHaveBeenNthCalledWith(2, eventB, "accessToken", ctx);
+  });
+
+  it("returns 200 when events field is missing", async () => {
+    const rawBody = JSON.stringify({ destination: "" });
+    const signature = await hmacSHA256Base64("secret", rawBody);
+
+    const request = new Request("https://example.com", {
+      method: "POST",
+      headers: { "x-line-signature": signature },
+      body: rawBody,
+    });
+    const ctx = { waitUntil: vi.fn() } as any;
+
+    const response = await router(request, mockEnv as any, ctx);
+
+    expect(response.status).toBe(200);
+    expect(mocks.eventRouter).not.toHaveBeenCalled();
+  });
+});

test/utils/eventRoutes.test.ts

@@ -0,0 +1,85 @@
+import { afterAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { loadStart, markAsRead, sendMessage } from "../../src/utils/eventRoutes";
+
+describe("eventRoutes", () => {
+  const fetchMock = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.stubGlobal("fetch", fetchMock);
+  });
+
+  afterAll(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("sendMessage calls LINE reply API with expected payload", async () => {
+    fetchMock.mockResolvedValueOnce({
+      json: vi.fn().mockResolvedValueOnce({ ok: true }),
+    });
+
+    const result = await sendMessage("token-123", "reply-123", [{ type: "text", text: "Hello" }]);
+
+    expect(fetchMock).toHaveBeenCalledWith("https://api.line.me/v2/bot/message/reply", {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer token-123",
+      },
+      method: "POST",
+      body: JSON.stringify({
+        replyToken: "reply-123",
+        messages: [{ type: "text", text: "Hello" }],
+      }),
+    });
+    expect(result).toEqual({ ok: true });
+  });
+
+  it("markAsRead calls LINE markAsRead API with expected payload", async () => {
+    fetchMock.mockResolvedValueOnce({
+      json: vi.fn().mockResolvedValueOnce({ ok: true }),
+    });
+
+    const result = await markAsRead("token-123", "mark-123");
+
+    expect(fetchMock).toHaveBeenCalledWith("https://api.line.me/v2/bot/chat/markAsRead", {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer token-123",
+      },
+      method: "POST",
+      body: JSON.stringify({
+        markAsReadToken: "mark-123",
+      }),
+    });
+    expect(result).toEqual({ ok: true });
+  });
+
+  it("loadStart calls LINE loading API with expected payload", async () => {
+    fetchMock.mockResolvedValueOnce({
+      json: vi.fn().mockResolvedValueOnce({ ok: true }),
+    });
+
+    const result = await loadStart("token-123", "U123", 5);
+
+    expect(fetchMock).toHaveBeenCalledWith("https://api.line.me/v2/bot/chat/loading/start", {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer token-123",
+      },
+      method: "POST",
+      body: JSON.stringify({
+        chatId: "U123",
+        loadingSeconds: 5,
+      }),
+    });
+    expect(result).toEqual({ ok: true });
+  });
+
+  it("barrel index re-exports all event route helpers", async () => {
+    const barrel = await import("../../src/utils/eventRoutes/index");
+
+    expect(typeof barrel.sendMessage).toBe("function");
+    expect(typeof barrel.markAsRead).toBe("function");
+    expect(typeof barrel.loadStart).toBe("function");
+  });
+});