feat(dm-dashboard): Wave 4 — rate limiting, translation API, AI tab navigation

tests/rate-limit.test.ts

@@ -0,0 +1,247 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+let mockSelectTotal = 0;
+let mockInsertedValues: unknown[] = [];
+
+const mockDb = {
+  reset() {
+    mockSelectTotal = 0;
+    mockInsertedValues = [];
+  },
+  setTotal(n: number) {
+    mockSelectTotal = n;
+  },
+  getInsertedValues() {
+    return mockInsertedValues;
+  },
+  select: vi.fn(() => ({
+    from: vi.fn(() => ({
+      where: vi.fn(() => Promise.resolve([{ total: mockSelectTotal }])),
+    })),
+  })),
+  insert: vi.fn(() => ({
+    values: vi.fn((vals: unknown) => ({
+      onConflictDoUpdate: vi.fn(() => {
+        mockInsertedValues.push(vals);
+        return Promise.resolve();
+      }),
+    })),
+  })),
+};
+
+vi.mock("drizzle-orm", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("drizzle-orm")>();
+  return {
+    ...actual,
+    eq: (column: { name: string }, value: unknown) => ({
+      type: "eq",
+      column: column.name,
+      value,
+    }),
+    and: (...conditions: unknown[]) => ({
+      type: "and",
+      conditions,
+    }),
+    sql: (strings: TemplateStringsArray, ...values: unknown[]) => {
+      return {
+        type: "sql",
+        raw: strings,
+        values,
+      } as unknown as ReturnType<typeof actual.sql>;
+    },
+    getTableColumns: actual.getTableColumns,
+  };
+});
+
+vi.mock("@/db/client", () => ({
+  db: mockDb,
+}));
+
+describe("Rate Limit Service", () => {
+  beforeEach(() => {
+    mockDb.reset();
+    vi.clearAllMocks();
+  });
+
+  async function importRateLimit() {
+    const mod = await import("@/lib/rate-limit");
+    return mod;
+  }
+
+  describe("checkRateLimit", () => {
+    it("allows request when under limit (free tier)", async () => {
+      const { checkRateLimit } = await importRateLimit();
+      mockDb.setTotal(3);
+
+      const result = await checkRateLimit(1, "free");
+
+      expect(result.allowed).toBe(true);
+      expect(result.remaining).toBe(4);
+    });
+
+    it("blocks request when at limit (free tier)", async () => {
+      const { checkRateLimit } = await importRateLimit();
+      mockDb.setTotal(7);
+
+      const result = await checkRateLimit(1, "free");
+
+      expect(result.allowed).toBe(false);
+      expect(result.remaining).toBe(0);
+    });
+
+    it("blocks request when over limit (free tier)", async () => {
+      const { checkRateLimit } = await importRateLimit();
+      mockDb.setTotal(10);
+
+      const result = await checkRateLimit(1, "free");
+
+      expect(result.allowed).toBe(false);
+      expect(result.remaining).toBe(-3);
+    });
+
+    it("allows request for pro tier even when over 100", async () => {
+      const { checkRateLimit } = await importRateLimit();
+      mockDb.setTotal(150);
+
+      const result = await checkRateLimit(1, "pro");
+
+      expect(result.allowed).toBe(true);
+      expect(result.remaining).toBe(-50);
+    });
+
+    it("resetAt is top of next hour", async () => {
+      const { checkRateLimit } = await importRateLimit();
+      mockDb.setTotal(0);
+
+      const result = await checkRateLimit(1, "free");
+      const now = new Date();
+      const expectedReset = new Date(
+        now.getFullYear(),
+        now.getMonth(),
+        now.getDate(),
+        now.getHours() + 1,
+        0,
+        0,
+        0
+      );
+
+      expect(result.resetAt.getTime()).toBe(expectedReset.getTime());
+    });
+  });
+
+  describe("getRemainingQuota", () => {
+    it("returns remaining quota for free tier", async () => {
+      const { getRemainingQuota } = await importRateLimit();
+      mockDb.setTotal(2);
+
+      const result = await getRemainingQuota(1, "free");
+
+      expect(result.remaining).toBe(5);
+    });
+
+    it("returns remaining quota for pro tier", async () => {
+      const { getRemainingQuota } = await importRateLimit();
+      mockDb.setTotal(50);
+
+      const result = await getRemainingQuota(1, "pro");
+
+      expect(result.remaining).toBe(50);
+    });
+
+    it("resetAt is top of next hour", async () => {
+      const { getRemainingQuota } = await importRateLimit();
+      mockDb.setTotal(0);
+
+      const result = await getRemainingQuota(1, "free");
+      const now = new Date();
+      const expectedReset = new Date(
+        now.getFullYear(),
+        now.getMonth(),
+        now.getDate(),
+        now.getHours() + 1,
+        0,
+        0,
+        0
+      );
+
+      expect(result.resetAt.getTime()).toBe(expectedReset.getTime());
+    });
+  });
+
+  describe("incrementGenerationCounter", () => {
+    it("inserts counter values with model", async () => {
+      const { incrementGenerationCounter } = await importRateLimit();
+      await incrementGenerationCounter(1, "moonshot-v1-8k");
+
+      expect(mockDb.insert).toHaveBeenCalledTimes(1);
+      const valuesCall = (mockDb.insert.mock.results[0].value as ReturnType<typeof mockDb.insert>).values;
+      expect(valuesCall).toHaveBeenCalledTimes(1);
+      const inserted = valuesCall.mock.calls[0][0] as {
+        userId: number;
+        model: string;
+        count: number;
+      };
+      expect(inserted.userId).toBe(1);
+      expect(inserted.model).toBe("moonshot-v1-8k");
+      expect(inserted.count).toBe(1);
+    });
+
+    it("calls onConflictDoUpdate for upsert", async () => {
+      const { incrementGenerationCounter } = await importRateLimit();
+      await incrementGenerationCounter(2, "llama-3.3-70b:free");
+
+      const valuesResult = (mockDb.insert.mock.results[0].value as ReturnType<typeof mockDb.insert>).values;
+      const onConflictCall = (valuesResult.mock.results[0].value as { onConflictDoUpdate: ReturnType<typeof vi.fn> }).onConflictDoUpdate;
+      expect(onConflictCall).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("getRetryAfterSeconds", () => {
+    it("returns positive seconds until next hour", async () => {
+      const { getRetryAfterSeconds } = await importRateLimit();
+      const seconds = getRetryAfterSeconds();
+      expect(seconds).toBeGreaterThan(0);
+      expect(seconds).toBeLessThanOrEqual(3600);
+    });
+
+    it("returns 3600 at exact hour boundary", async () => {
+      const { getRetryAfterSeconds } = await importRateLimit();
+      const now = new Date();
+      const msToNextHour =
+        new Date(
+          now.getFullYear(),
+          now.getMonth(),
+          now.getDate(),
+          now.getHours() + 1,
+          0,
+          0,
+          0
+        ).getTime() - now.getTime();
+
+      vi.useFakeTimers();
+      vi.setSystemTime(new Date(Date.now() + msToNextHour));
+      expect(getRetryAfterSeconds()).toBe(3600);
+      vi.useRealTimers();
+    });
+  });
+
+  describe("tier differentiation", () => {
+    it("free limit is 7", async () => {
+      const { checkRateLimit, TIER_LIMITS } = await importRateLimit();
+      expect(TIER_LIMITS.free).toBe(7);
+      mockDb.setTotal(6);
+      const result = await checkRateLimit(1, "free");
+      expect(result.allowed).toBe(true);
+      expect(result.remaining).toBe(1);
+    });
+
+    it("pro limit is 100", async () => {
+      const { checkRateLimit, TIER_LIMITS } = await importRateLimit();
+      expect(TIER_LIMITS.pro).toBe(100);
+      mockDb.setTotal(99);
+      const result = await checkRateLimit(1, "pro");
+      expect(result.allowed).toBe(true);
+      expect(result.remaining).toBe(1);
+    });
+  });
+});