chunked-cookies.test.ts

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import {
  CookieOptions,
  deleteChunkedCookie,
  getChunkedCookie,
  RequestCookies,
  ResponseCookies,
  setChunkedCookie
} from "./cookies";

// Create mock implementation for RequestCookies and ResponseCookies
const createMocks = () => {
  const cookieStore = new Map();

  const reqCookies = {
    get: vi.fn((...args) => {
      const name = typeof args[0] === "string" ? args[0] : args[0].name;
      if (cookieStore.has(name)) {
        return { name, value: cookieStore.get(name) };
      }
      return undefined;
    }),
    getAll: vi.fn((...args) => {
      if (args.length === 0) {
        return Array.from(cookieStore.entries()).map(([name, value]) => ({
          name,
          value
        }));
      }
      const name = typeof args[0] === "string" ? args[0] : args[0].name;
      return cookieStore.has(name)
        ? [{ name, value: cookieStore.get(name) }]
        : [];
    }),
    has: vi.fn((name) => cookieStore.has(name)),
    set: vi.fn((...args) => {
      const name = typeof args[0] === "string" ? args[0] : args[0].name;
      const value = typeof args[0] === "string" ? args[1] : args[0].value;
      cookieStore.set(name, value);
      return reqCookies;
    }),
    delete: vi.fn((names) => {
      if (Array.isArray(names)) {
        return names.map((name) => cookieStore.delete(name));
      }
      return cookieStore.delete(names);
    }),
    clear: vi.fn(() => {
      cookieStore.clear();
      return reqCookies;
    }),
    get size() {
      return cookieStore.size;
    },
    [Symbol.iterator]: vi.fn(() => cookieStore.entries())
  };

  const resCookies = {
    get: vi.fn((...args) => {
      const name = typeof args[0] === "string" ? args[0] : args[0].name;
      if (cookieStore.has(name)) {
        return { name, value: cookieStore.get(name) };
      }
      return undefined;
    }),
    getAll: vi.fn((...args) => {
      if (args.length === 0) {
        return Array.from(cookieStore.entries()).map(([name, value]) => ({
          name,
          value
        }));
      }
      const name = typeof args[0] === "string" ? args[0] : args[0].name;
      return cookieStore.has(name)
        ? [{ name, value: cookieStore.get(name) }]
        : [];
    }),
    has: vi.fn((name) => cookieStore.has(name)),
    set: vi.fn((...args) => {
      const name = typeof args[0] === "string" ? args[0] : args[0].name;
      const value = typeof args[0] === "string" ? args[1] : args[0].value;
      cookieStore.set(name, value);
      return resCookies;
    }),
    delete: vi.fn((...args) => {
      const name = typeof args[0] === "string" ? args[0] : args[0].name;
      cookieStore.delete(name);
      return resCookies;
    }),
    toString: vi.fn(() => {
      return Array.from(cookieStore.entries())
        .map(([name, value]) => `${name}=${value}`)
        .join("; ");
    })
  };

  return { reqCookies, resCookies, cookieStore };
};

describe("Chunked Cookie Utils", () => {
  let reqCookies: RequestCookies;
  let resCookies: ResponseCookies;
  let cookieStore: Map<any, any>;

  beforeEach(() => {
    const mocks = createMocks();
    reqCookies = mocks.reqCookies;
    resCookies = mocks.resCookies;
    cookieStore = mocks.cookieStore;

    // Spy on console.warn
    vi.spyOn(console, "warn").mockImplementation(() => {});
  });

  afterEach(() => {
    vi.clearAllMocks();
  });

  describe("setChunkedCookie", () => {
    it("should set a single cookie when value is small enough", () => {
      const name = "testCookie";
      const value = "small value";
      const options = { path: "/" } as CookieOptions;

      setChunkedCookie(name, value, options, reqCookies, resCookies);

      expect(resCookies.set).toHaveBeenCalledTimes(1);
      expect(resCookies.set).toHaveBeenCalledWith(name, value, options);
      expect(reqCookies.set).toHaveBeenCalledTimes(1);
      expect(reqCookies.set).toHaveBeenCalledWith(name, value);
    });

    it("should split cookie into chunks when value exceeds max size", () => {
      const name = "largeCookie";
      const options = { path: "/" } as CookieOptions;

      // Create a large string (8000 bytes)
      const largeValue = "a".repeat(8000);

      setChunkedCookie(name, largeValue, options, reqCookies, resCookies);

      // Should create 3 chunks (8000 / 3500 ≈ 2.3, rounded up to 3)
      expect(resCookies.set).toHaveBeenCalledTimes(3);
      expect(reqCookies.set).toHaveBeenCalledTimes(3);

      // Check first chunk
      expect(resCookies.set).toHaveBeenCalledWith(
        `${name}__0`,
        largeValue.slice(0, 3500),
        options
      );

      // Check second chunk
      expect(resCookies.set).toHaveBeenCalledWith(
        `${name}__1`,
        largeValue.slice(3500, 7000),
        options
      );

      // Check third chunk
      expect(resCookies.set).toHaveBeenCalledWith(
        `${name}__2`,
        largeValue.slice(7000),
        options
      );
    });

    it("should log a warning when cookie size exceeds warning threshold", () => {
      const name = "warningCookie";
      const options = { path: "/" } as CookieOptions;

      // Create a value that exceeds the warning threshold (4096 bytes)
      const value = "a".repeat(4097);

      setChunkedCookie(name, value, options, reqCookies, resCookies);

      expect(console.warn).toHaveBeenCalled();
    });

    describe("getChunkedCookie", () => {
      it("should return undefined when cookie does not exist", () => {
        const result = getChunkedCookie("nonexistent", reqCookies);
        expect(result).toBeUndefined();
      });

      it("should return cookie value when it exists as a regular cookie", () => {
        const name = "simpleCookie";
        const value = "simple value";

        // Setup the cookie
        cookieStore.set(name, value);

        const result = getChunkedCookie(name, reqCookies);

        expect(result).toBe(value);
        expect(reqCookies.get).toHaveBeenCalledWith(name);
      });

      it("should reconstruct value from chunks when cookie is chunked", () => {
        const name = "chunkedCookie";
        const chunk0 = "chunk0 value";
        const chunk1 = "chunk1 value";
        const chunk2 = "chunk2 value";

        // Add the chunks to the store (out of order)
        cookieStore.set(`${name}__1`, chunk1);
        cookieStore.set(`${name}__0`, chunk0);
        cookieStore.set(`${name}__2`, chunk2);

        // Also add some unrelated cookies
        cookieStore.set("otherCookie", "other value");

        const result = getChunkedCookie(name, reqCookies);

        // Should combine chunks in proper order
        expect(result).toBe(`${chunk0}${chunk1}${chunk2}`);
      });

      it("should return undefined when chunks are not in a complete sequence", () => {
        const name = "incompleteCookie";

        // Add incomplete chunks (missing chunk1)
        cookieStore.set(`${name}__0`, "chunk0");
        cookieStore.set(`${name}__2`, "chunk2");

        const result = getChunkedCookie(name, reqCookies);

        expect(result).toBeUndefined();
        expect(console.warn).toHaveBeenCalled();
      });
    });

    describe("deleteChunkedCookie", () => {
      it("should delete the regular cookie", () => {
        const name = "regularCookie";
        cookieStore.set(name, "regular value");

        deleteChunkedCookie(name, reqCookies, resCookies);

        expect(resCookies.delete).toHaveBeenCalledWith(name);
      });

      it("should delete all chunks of a cookie", () => {
        const name = "chunkedCookie";

        // Add chunks
        cookieStore.set(`${name}__0`, "chunk0");
        cookieStore.set(`${name}__1`, "chunk1");
        cookieStore.set(`${name}__2`, "chunk2");

        // Add unrelated cookie
        cookieStore.set("otherCookie", "other value");

        deleteChunkedCookie(name, reqCookies, resCookies);

        // Should delete main cookie and 3 chunks
        expect(resCookies.delete).toHaveBeenCalledTimes(4);
        expect(resCookies.delete).toHaveBeenCalledWith(name);
        expect(resCookies.delete).toHaveBeenCalledWith(`${name}__0`);
        expect(resCookies.delete).toHaveBeenCalledWith(`${name}__1`);
        expect(resCookies.delete).toHaveBeenCalledWith(`${name}__2`);
        // Should not delete unrelated cookies
        expect(resCookies.delete).not.toHaveBeenCalledWith("otherCookie");
      });
    });

    describe("Edge Cases", () => {
      it("should handle empty values correctly", () => {
        const name = "emptyCookie";
        const value = "";
        const options = { path: "/" } as CookieOptions;

        setChunkedCookie(name, value, options, reqCookies, resCookies);

        expect(resCookies.set).toHaveBeenCalledTimes(1);
        expect(resCookies.set).toHaveBeenCalledWith(name, value, options);
      });

      it("should handle values at the exact chunk boundary", () => {
        const name = "boundaryValueCookie";
        const value = "a".repeat(3500); // Exactly MAX_CHUNK_SIZE
        const options = { path: "/" } as CookieOptions;

        setChunkedCookie(name, value, options, reqCookies, resCookies);

        // Should still fit in one cookie
        expect(resCookies.set).toHaveBeenCalledTimes(1);
        expect(resCookies.set).toHaveBeenCalledWith(name, value, options);
      });

      it("should handle special characters in cookie values", () => {
        const name = "specialCharCookie";
        const value =
          '{"special":"characters","with":"quotation marks","and":"😀 emoji"}';
        const options = { path: "/" } as CookieOptions;

        setChunkedCookie(name, value, options, reqCookies, resCookies);

        expect(resCookies.set).toHaveBeenCalledWith(name, value, options);

        // Setup for retrieval
        cookieStore.set(name, value);

        const result = getChunkedCookie(name, reqCookies);
        expect(result).toBe(value);
      });

      it("should handle multi-byte characters correctly", () => {
        const name = "multiByteCookie";
        // Create a test string with multi-byte characters (emojis)
        const value = "Hello 😀 world 🌍 with emojis 🎉";
        const options = { path: "/" } as CookieOptions;

        // Store the cookie
        setChunkedCookie(name, value, options, reqCookies, resCookies);

        // For the retrieval test, manually set up the cookies
        // We're testing the retrieval functionality, not the chunking itself
        cookieStore.clear();
        cookieStore.set(name, value);

        // Verify retrieval works correctly with multi-byte characters
        const result = getChunkedCookie(name, reqCookies);
        expect(result).toBe(value);

        // Verify emoji characters were preserved
        expect(result).toContain("😀");
        expect(result).toContain("🌍");
        expect(result).toContain("🎉");
      });

      it("should handle very large cookies properly", () => {
        const name = "veryLargeCookie";
        const value = "a".repeat(10000); // Will create multiple chunks
        const options = { path: "/" } as CookieOptions;

        setChunkedCookie(name, value, options, reqCookies, resCookies);

        // Get chunks count (10000 / 3500 ≈ 2.86, so we need 3 chunks)
        const expectedChunks = Math.ceil(10000 / 3500);

        expect(resCookies.set).toHaveBeenCalledTimes(expectedChunks);

        // Clear and set up cookies for retrieval test
        cookieStore.clear();

        // Setup for getChunkedCookie retrieval
        for (let i = 0; i < expectedChunks; i++) {
          const start = i * 3500;
          const end = Math.min((i + 1) * 3500, 10000);
          cookieStore.set(`${name}__${i}`, value.slice(start, end));
        }

        const result = getChunkedCookie(name, reqCookies);
        expect(result).toBe(value);
        expect(result!.length).toBe(10000);
      });
    });
  });
});