@getmicdrop/svelte-components 5.19.0 → 5.20.0

package/dist/utils/utils.spec.js

@@ -1,643 +1,643 @@
-import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
-import {
-  parseCookies,
-  getCookie,
-  setCookie,
-  getPerformerToken,
-  getUserDetails,
-  getSuppressedAlerts,
-  saveSuppressedAlerts,
-  parseLocation,
-  cn,
-  classNames,
-  truncateTitle,
-  getDays,
-  getDaysNumberOptions,
-  convertToCustomDateFormat,
-  ROLE_PERMISSION_LIST,
-  fetchData,
-  postData,
-  setAuthCookies,
-  clearAuthCookies,
-  microphonePlaceholder,
-} from "./utils";
-
-// Mock document.cookie
-let mockCookies = "";
-
-beforeEach(() => {
-  mockCookies = "";
-  Object.defineProperty(document, "cookie", {
-    get: () => mockCookies,
-    set: (value) => {
-      // Parse the new cookie and add/update in mockCookies
-      const [cookiePart] = value.split(";");
-      const [name, val] = cookiePart.split("=");
-      const existingCookies = mockCookies
-        .split("; ")
-        .filter((c) => c && !c.startsWith(`${name}=`));
-      if (val) {
-        existingCookies.push(`${name}=${val}`);
-      }
-      mockCookies = existingCookies.join("; ");
-    },
-    configurable: true,
-  });
-});
-
-describe("Cookie Utilities", () => {
-  test("parseCookies returns empty object for no cookies", () => {
-    mockCookies = "";
-    expect(parseCookies()).toEqual({});
-  });
-
-  test("parseCookies parses single cookie", () => {
-    mockCookies = "name=value";
-    expect(parseCookies()).toEqual({ name: "value" });
-  });
-
-  test("parseCookies parses multiple cookies", () => {
-    mockCookies = "name=value; other=test";
-    expect(parseCookies()).toEqual({ name: "value", other: "test" });
-  });
-
-  test("parseCookies decodes URI encoded values", () => {
-    mockCookies = "data=%7B%22key%22%3A%22value%22%7D";
-    expect(parseCookies()).toEqual({ data: '{"key":"value"}' });
-  });
-
-  test("getCookie returns specific cookie value", () => {
-    mockCookies = "name=value; other=test";
-    expect(getCookie("name")).toBe("value");
-    expect(getCookie("other")).toBe("test");
-  });
-
-  test("getCookie returns null for missing cookie", () => {
-    mockCookies = "name=value";
-    expect(getCookie("missing")).toBeNull();
-  });
-
-  test("getPerformerToken returns token from cookies", () => {
-    mockCookies = "performer_token=abc123";
-    expect(getPerformerToken()).toBe("abc123");
-  });
-
-  test("getPerformerToken returns null when no token", () => {
-    mockCookies = "";
-    expect(getPerformerToken()).toBeNull();
-  });
-
-  test("getUserDetails parses JSON user details", () => {
-    const details = { id: 1, name: "Test" };
-    mockCookies = `userDetails=${encodeURIComponent(JSON.stringify(details))}`;
-    expect(getUserDetails()).toEqual(details);
-  });
-
-  test("getUserDetails returns null for invalid JSON", () => {
-    mockCookies = "userDetails=invalid-json";
-    expect(getUserDetails()).toBeNull();
-  });
-
-  test("getUserDetails returns null when no details", () => {
-    mockCookies = "";
-    expect(getUserDetails()).toBeNull();
-  });
-
-  test("getSuppressedAlerts returns array of alert IDs", () => {
-    const alerts = ["alert-1", "alert-2"];
-    mockCookies = `suppressedAlerts=${encodeURIComponent(JSON.stringify(alerts))}`;
-    expect(getSuppressedAlerts()).toEqual(alerts);
-  });
-
-  test("getSuppressedAlerts returns empty array when no alerts", () => {
-    mockCookies = "";
-    expect(getSuppressedAlerts()).toEqual([]);
-  });
-
-  test("getSuppressedAlerts returns empty array for invalid JSON", () => {
-    mockCookies = "suppressedAlerts=invalid";
-    expect(getSuppressedAlerts()).toEqual([]);
-  });
-});
-
-describe("parseLocation", () => {
-  test("parses full address with street and city/state/zip", () => {
-    const result = parseLocation("3400 Warner Blvd, Burbank, CA 91505");
-    expect(result.street).toBe("3400 Warner Blvd");
-    expect(result.cityStateZip).toBe("Burbank, CA 91505");
-  });
-
-  test("parses two-part address", () => {
-    const result = parseLocation("123 Main St, New York NY 10001");
-    expect(result.street).toBe("123 Main St");
-    expect(result.cityStateZip).toBe("New York NY 10001");
-  });
-
-  test("handles single part address", () => {
-    const result = parseLocation("123 Main Street");
-    expect(result.street).toBe("123 Main Street");
-    expect(result.cityStateZip).toBe("");
-  });
-
-  test("returns empty strings for null input", () => {
-    const result = parseLocation(null);
-    expect(result.street).toBe("");
-    expect(result.cityStateZip).toBe("");
-  });
-
-  test("returns empty strings for empty string input", () => {
-    const result = parseLocation("");
-    expect(result.street).toBe("");
-    expect(result.cityStateZip).toBe("");
-  });
-});
-
-describe("classNames utility", () => {
-  test("joins class names", () => {
-    expect(classNames("a", "b", "c")).toBe("a b c");
-  });
-
-  test("filters out falsy values", () => {
-    expect(classNames("a", false, "b", null, "c", undefined)).toBe("a b c");
-  });
-
-  test("returns empty string for no classes", () => {
-    expect(classNames()).toBe("");
-  });
-});
-
-describe("truncateTitle utility", () => {
-  test("truncates long titles", () => {
-    expect(truncateTitle("This is a very long title", 10)).toBe("This is a ...");
-  });
-
-  test("does not truncate short titles", () => {
-    expect(truncateTitle("Short", 10)).toBe("Short");
-  });
-
-  test("handles exact length", () => {
-    expect(truncateTitle("Exact", 5)).toBe("Exact");
-  });
-});
-
-describe("cn utility (tailwind-merge)", () => {
-  test("merges class names", () => {
-    const result = cn("px-2", "px-4");
-    expect(result).toBe("px-4");
-  });
-
-  test("handles conditional classes", () => {
-    const isActive = true;
-    const result = cn("base", isActive && "active");
-    expect(result).toContain("base");
-    expect(result).toContain("active");
-  });
-});
-
-describe("getDays", () => {
-  test('returns weekdays when params is "weeks"', () => {
-    const days = getDays("weeks");
-    expect(days).toHaveLength(5);
-    expect(days[0]).toEqual({ value: "monday", label: "Monday" });
-    expect(days[4]).toEqual({ value: "friday", label: "Friday" });
-  });
-
-  test("returns 31 days with suffixes for other params", () => {
-    const days = getDays("months");
-    expect(days).toHaveLength(31);
-  });
-
-  test("has correct suffix for 1st", () => {
-    const days = getDays("months");
-    expect(days[0]).toEqual({ value: "1", label: "1st" });
-  });
-
-  test("has correct suffix for 2nd", () => {
-    const days = getDays("months");
-    expect(days[1]).toEqual({ value: "2", label: "2nd" });
-  });
-
-  test("has correct suffix for 3rd", () => {
-    const days = getDays("months");
-    expect(days[2]).toEqual({ value: "3", label: "3rd" });
-  });
-
-  test("has correct suffix for 4th", () => {
-    const days = getDays("months");
-    expect(days[3]).toEqual({ value: "4", label: "4th" });
-  });
-
-  test("has correct suffix for 11th (exception)", () => {
-    const days = getDays("months");
-    expect(days[10]).toEqual({ value: "11", label: "11th" });
-  });
-
-  test("has correct suffix for 12th (exception)", () => {
-    const days = getDays("months");
-    expect(days[11]).toEqual({ value: "12", label: "12th" });
-  });
-
-  test("has correct suffix for 13th (exception)", () => {
-    const days = getDays("months");
-    expect(days[12]).toEqual({ value: "13", label: "13th" });
-  });
-
-  test("has correct suffix for 21st", () => {
-    const days = getDays("months");
-    expect(days[20]).toEqual({ value: "21", label: "21st" });
-  });
-
-  test("has correct suffix for 22nd", () => {
-    const days = getDays("months");
-    expect(days[21]).toEqual({ value: "22", label: "22nd" });
-  });
-
-  test("has correct suffix for 23rd", () => {
-    const days = getDays("months");
-    expect(days[22]).toEqual({ value: "23", label: "23rd" });
-  });
-
-  test("has correct suffix for 31st", () => {
-    const days = getDays("months");
-    expect(days[30]).toEqual({ value: "31", label: "31st" });
-  });
-});
-
-describe("getDaysNumberOptions", () => {
-  test("returns 12 options for months", () => {
-    const options = getDaysNumberOptions("months");
-    expect(options).toHaveLength(12);
-    expect(options[0]).toEqual({ value: "1", label: "1" });
-    expect(options[11]).toEqual({ value: "12", label: "12" });
-  });
-
-  test("returns 10 options for weeks", () => {
-    const options = getDaysNumberOptions("weeks");
-    expect(options).toHaveLength(10);
-    expect(options[0]).toEqual({ value: "1", label: "1" });
-    expect(options[9]).toEqual({ value: "10", label: "10" });
-  });
-
-  test("returns 31 options for days (default)", () => {
-    const options = getDaysNumberOptions("days");
-    expect(options).toHaveLength(31);
-    expect(options[0]).toEqual({ value: "1", label: "1" });
-    expect(options[30]).toEqual({ value: "31", label: "31" });
-  });
-
-  test("returns 31 options for unknown timeUnit", () => {
-    const options = getDaysNumberOptions("unknown");
-    expect(options).toHaveLength(31);
-  });
-});
-
-describe("convertToCustomDateFormat", () => {
-  test("converts ISO string to custom date format", () => {
-    const result = convertToCustomDateFormat("2025-06-15T12:00:00Z");
-    expect(result).toBeInstanceOf(Date);
-    expect(result.getFullYear()).toBe(2025);
-    expect(result.getMonth()).toBe(5); // June is month 5
-    expect(result.getDate()).toBe(15);
-  });
-
-  test("handles date without time", () => {
-    const result = convertToCustomDateFormat("2025-01-01T12:00:00Z");
-    expect(result).toBeInstanceOf(Date);
-    expect(result.getFullYear()).toBe(2025);
-    expect(result.getMonth()).toBe(0);
-    expect(result.getDate()).toBe(1);
-  });
-});
-
-describe("ROLE_PERMISSION_LIST", () => {
-  test("is an array", () => {
-    expect(Array.isArray(ROLE_PERMISSION_LIST)).toBe(true);
-  });
-
-  test("has 9 permission groups", () => {
-    expect(ROLE_PERMISSION_LIST).toHaveLength(9);
-  });
-
-  test("each item has icon, title, description, and checkbox", () => {
-    ROLE_PERMISSION_LIST.forEach((item) => {
-      expect(item).toHaveProperty("icon");
-      expect(item).toHaveProperty("title");
-      expect(item).toHaveProperty("description");
-      expect(item).toHaveProperty("checkbox");
-      expect(Array.isArray(item.checkbox)).toBe(true);
-    });
-  });
-
-  test("includes Event creation permission", () => {
-    const eventPermission = ROLE_PERMISSION_LIST.find(
-      (p) => p.title === "Event creation"
-    );
-    expect(eventPermission).toBeDefined();
-    expect(eventPermission.checkbox).toContain("Create Events");
-  });
-
-  test("includes Booking permission", () => {
-    const bookingPermission = ROLE_PERMISSION_LIST.find(
-      (p) => p.title === "Booking"
-    );
-    expect(bookingPermission).toBeDefined();
-  });
-
-  test("includes Venue creation permission", () => {
-    const venuePermission = ROLE_PERMISSION_LIST.find(
-      (p) => p.title === "Venue creation"
-    );
-    expect(venuePermission).toBeDefined();
-  });
-
-  test("includes Marketing permission", () => {
-    const marketingPermission = ROLE_PERMISSION_LIST.find(
-      (p) => p.title === "Marketing"
-    );
-    expect(marketingPermission).toBeDefined();
-  });
-
-  test("includes Orders & attendees permission", () => {
-    const ordersPermission = ROLE_PERMISSION_LIST.find(
-      (p) => p.title === "Orders & attendees"
-    );
-    expect(ordersPermission).toBeDefined();
-  });
-
-  test("includes Organization permission", () => {
-    const orgPermission = ROLE_PERMISSION_LIST.find(
-      (p) => p.title === "Organization"
-    );
-    expect(orgPermission).toBeDefined();
-  });
-
-  test("includes Contacts permission", () => {
-    const contactsPermission = ROLE_PERMISSION_LIST.find(
-      (p) => p.title === "Contacts"
-    );
-    expect(contactsPermission).toBeDefined();
-  });
-
-  test("includes Reporting permission", () => {
-    const reportingPermission = ROLE_PERMISSION_LIST.find(
-      (p) => p.title === "Reporting"
-    );
-    expect(reportingPermission).toBeDefined();
-  });
-
-  test("includes Payouts & billing permission", () => {
-    const payoutsPermission = ROLE_PERMISSION_LIST.find(
-      (p) => p.title === "Payouts & billing"
-    );
-    expect(payoutsPermission).toBeDefined();
-  });
-});
-
-describe("fetchData", () => {
-  beforeEach(() => {
-    global.fetch = vi.fn();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("returns data on successful fetch", async () => {
-    global.fetch.mockResolvedValue({
-      ok: true,
-      json: () => Promise.resolve({ success: true, data: "test" }),
-    });
-
-    const result = await fetchData("/api/test");
-    expect(result.data).toEqual({ success: true, data: "test" });
-    expect(result.error).toBe(null);
-  });
-
-  test("returns error on failed fetch", async () => {
-    global.fetch.mockResolvedValue({
-      ok: false,
-      status: 500,
-      text: () => Promise.resolve("Server Error"),
-    });
-
-    const result = await fetchData("/api/test");
-    expect(result.data).toBe(null);
-    expect(result.error).toContain("Server Error");
-  });
-
-  test("returns error on network failure", async () => {
-    global.fetch.mockRejectedValue(new Error("Network error"));
-
-    const result = await fetchData("/api/test");
-    expect(result.data).toBe(null);
-    expect(result.error).toBe("Network error");
-  });
-
-  test("passes headers to fetch", async () => {
-    global.fetch.mockResolvedValue({
-      ok: true,
-      json: () => Promise.resolve({}),
-    });
-
-    await fetchData("/api/test", {
-      headers: { Authorization: "Bearer token" },
-    });
-
-    // Check that fetch was called with the custom Authorization header
-    const callArgs = global.fetch.mock.calls[0];
-    expect(callArgs[0]).toBe("/api/test");
-    expect(callArgs[1].headers.Authorization).toBe("Bearer token");
-  });
-
-  test("handles text() error gracefully", async () => {
-    global.fetch.mockResolvedValue({
-      ok: false,
-      status: 500,
-      text: () => Promise.reject(new Error("Cannot read body")),
-    });
-
-    const result = await fetchData("/api/test");
-    expect(result.data).toBe(null);
-    expect(result.error).toBe("Unknown error");
-  });
-});
-
-describe("postData", () => {
-  beforeEach(() => {
-    global.fetch = vi.fn();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("returns data and ok:true on success", async () => {
-    global.fetch.mockResolvedValue({
-      ok: true,
-      json: () => Promise.resolve({ id: 1 }),
-    });
-
-    const result = await postData("/api/test", { name: "Test" });
-    expect(result.data).toEqual({ id: 1 });
-    expect(result.error).toBe(null);
-    expect(result.ok).toBe(true);
-  });
-
-  test("returns error on failed request", async () => {
-    global.fetch.mockResolvedValue({
-      ok: false,
-      json: () => Promise.resolve({ message: "Validation failed" }),
-    });
-
-    const result = await postData("/api/test", { name: "" });
-    expect(result.error).toBe("Validation failed");
-    expect(result.ok).toBe(false);
-  });
-
-  test("handles json parse error", async () => {
-    global.fetch.mockResolvedValue({
-      ok: false,
-      json: () => Promise.reject(new Error("Invalid JSON")),
-    });
-
-    const result = await postData("/api/test", {});
-    expect(result.data).toEqual({});
-    expect(result.error).toBe("Request failed");
-    expect(result.ok).toBe(false);
-  });
-
-  test("handles network error", async () => {
-    global.fetch.mockRejectedValue(new Error("Network error"));
-
-    const result = await postData("/api/test", {});
-    expect(result.data).toBe(null);
-    expect(result.error).toBe("Network error");
-    expect(result.ok).toBe(false);
-  });
-
-  test("sends POST request with JSON body", async () => {
-    global.fetch.mockResolvedValue({
-      ok: true,
-      json: () => Promise.resolve({}),
-    });
-
-    await postData("/api/test", { foo: "bar" });
-
-    expect(global.fetch).toHaveBeenCalledWith("/api/test", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ foo: "bar" }),
-    });
-  });
-});
-
-describe("setAuthCookies", () => {
-  test("sets performer_token and userDetails cookies", () => {
-    setAuthCookies("mytoken123", { id: 1, name: "Test User" });
-    expect(getCookie("performer_token")).toBe("mytoken123");
-    const details = getCookie("userDetails");
-    expect(details).toBeTruthy();
-    expect(JSON.parse(decodeURIComponent(details))).toEqual({ id: 1, name: "Test User" });
-  });
-
-  test("handles rememberMe = false", () => {
-    setAuthCookies("token", { id: 1 }, false);
-    expect(getCookie("performer_token")).toBe("token");
-  });
-});
-
-describe("clearAuthCookies", () => {
-  test("clears auth cookies", () => {
-    mockCookies = "performer_token=test; userDetails=test";
-    clearAuthCookies();
-    // After clearing, the cookies should be empty or expired
-    expect(getCookie("performer_token")).toBeFalsy();
-  });
-});
-
-describe("microphonePlaceholder", () => {
-  test("is defined", () => {
-    expect(microphonePlaceholder).toBeDefined();
-  });
-
-  test("is a string (asset path)", () => {
-    expect(typeof microphonePlaceholder).toBe("string");
-  });
-});
-
-describe("setCookie", () => {
-  test("sets a cookie with default options", () => {
-    setCookie("test_cookie", "test_value");
-    expect(getCookie("test_cookie")).toBe("test_value");
-  });
-
-  test("sets a cookie with maxAge option", () => {
-    setCookie("expiring_cookie", "value", { maxAge: 3600 });
-    expect(getCookie("expiring_cookie")).toBe("value");
-  });
-
-  test("sets a cookie with custom path", () => {
-    setCookie("path_cookie", "value", { path: "/custom" });
-    // Cookie is set, though path may not be reflected in our mock
-    expect(getCookie("path_cookie")).toBeDefined();
-  });
-
-  test("encodes special characters in value", () => {
-    setCookie("encoded_cookie", "value with spaces & special=chars");
-    const decoded = getCookie("encoded_cookie");
-    expect(decoded).toContain("value");
-  });
-});
-
-describe("saveSuppressedAlerts", () => {
-  test("saves array of alert IDs", () => {
-    saveSuppressedAlerts(["alert-1", "alert-2", "alert-3"]);
-    expect(getSuppressedAlerts()).toEqual(["alert-1", "alert-2", "alert-3"]);
-  });
-
-  test("overwrites previous alerts", () => {
-    saveSuppressedAlerts(["old-alert"]);
-    saveSuppressedAlerts(["new-alert"]);
-    expect(getSuppressedAlerts()).toEqual(["new-alert"]);
-  });
-
-  test("handles empty array", () => {
-    saveSuppressedAlerts([]);
-    expect(getSuppressedAlerts()).toEqual([]);
-  });
-});
-
-describe("parseCookies edge cases", () => {
-  test("handles cookies with = in value", () => {
-    mockCookies = "data=key=value";
-    const result = parseCookies();
-    expect(result.data).toBe("key=value");
-  });
-
-  test("handles empty cookie string", () => {
-    mockCookies = "";
-    const result = parseCookies();
-    expect(result).toEqual({});
-  });
-});
-
-describe("fetchData edge cases", () => {
-  beforeEach(() => {
-    global.fetch = vi.fn();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("handles empty response body", async () => {
-    global.fetch.mockResolvedValue({
-      ok: false,
-      status: 204,
-      text: () => Promise.resolve(""),
-    });
-
-    const result = await fetchData("/api/test");
-    expect(result.error).toContain("204");
-  });
-});
+import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  parseCookies,
+  getCookie,
+  setCookie,
+  getPerformerToken,
+  getUserDetails,
+  getSuppressedAlerts,
+  saveSuppressedAlerts,
+  parseLocation,
+  cn,
+  classNames,
+  truncateTitle,
+  getDays,
+  getDaysNumberOptions,
+  convertToCustomDateFormat,
+  ROLE_PERMISSION_LIST,
+  fetchData,
+  postData,
+  setAuthCookies,
+  clearAuthCookies,
+  microphonePlaceholder,
+} from "./utils";
+
+// Mock document.cookie
+let mockCookies = "";
+
+beforeEach(() => {
+  mockCookies = "";
+  Object.defineProperty(document, "cookie", {
+    get: () => mockCookies,
+    set: (value) => {
+      // Parse the new cookie and add/update in mockCookies
+      const [cookiePart] = value.split(";");
+      const [name, val] = cookiePart.split("=");
+      const existingCookies = mockCookies
+        .split("; ")
+        .filter((c) => c && !c.startsWith(`${name}=`));
+      if (val) {
+        existingCookies.push(`${name}=${val}`);
+      }
+      mockCookies = existingCookies.join("; ");
+    },
+    configurable: true,
+  });
+});
+
+describe("Cookie Utilities", () => {
+  test("parseCookies returns empty object for no cookies", () => {
+    mockCookies = "";
+    expect(parseCookies()).toEqual({});
+  });
+
+  test("parseCookies parses single cookie", () => {
+    mockCookies = "name=value";
+    expect(parseCookies()).toEqual({ name: "value" });
+  });
+
+  test("parseCookies parses multiple cookies", () => {
+    mockCookies = "name=value; other=test";
+    expect(parseCookies()).toEqual({ name: "value", other: "test" });
+  });
+
+  test("parseCookies decodes URI encoded values", () => {
+    mockCookies = "data=%7B%22key%22%3A%22value%22%7D";
+    expect(parseCookies()).toEqual({ data: '{"key":"value"}' });
+  });
+
+  test("getCookie returns specific cookie value", () => {
+    mockCookies = "name=value; other=test";
+    expect(getCookie("name")).toBe("value");
+    expect(getCookie("other")).toBe("test");
+  });
+
+  test("getCookie returns null for missing cookie", () => {
+    mockCookies = "name=value";
+    expect(getCookie("missing")).toBeNull();
+  });
+
+  test("getPerformerToken returns token from cookies", () => {
+    mockCookies = "performer_token=abc123";
+    expect(getPerformerToken()).toBe("abc123");
+  });
+
+  test("getPerformerToken returns null when no token", () => {
+    mockCookies = "";
+    expect(getPerformerToken()).toBeNull();
+  });
+
+  test("getUserDetails parses JSON user details", () => {
+    const details = { id: 1, name: "Test" };
+    mockCookies = `userDetails=${encodeURIComponent(JSON.stringify(details))}`;
+    expect(getUserDetails()).toEqual(details);
+  });
+
+  test("getUserDetails returns null for invalid JSON", () => {
+    mockCookies = "userDetails=invalid-json";
+    expect(getUserDetails()).toBeNull();
+  });
+
+  test("getUserDetails returns null when no details", () => {
+    mockCookies = "";
+    expect(getUserDetails()).toBeNull();
+  });
+
+  test("getSuppressedAlerts returns array of alert IDs", () => {
+    const alerts = ["alert-1", "alert-2"];
+    mockCookies = `suppressedAlerts=${encodeURIComponent(JSON.stringify(alerts))}`;
+    expect(getSuppressedAlerts()).toEqual(alerts);
+  });
+
+  test("getSuppressedAlerts returns empty array when no alerts", () => {
+    mockCookies = "";
+    expect(getSuppressedAlerts()).toEqual([]);
+  });
+
+  test("getSuppressedAlerts returns empty array for invalid JSON", () => {
+    mockCookies = "suppressedAlerts=invalid";
+    expect(getSuppressedAlerts()).toEqual([]);
+  });
+});
+
+describe("parseLocation", () => {
+  test("parses full address with street and city/state/zip", () => {
+    const result = parseLocation("3400 Warner Blvd, Burbank, CA 91505");
+    expect(result.street).toBe("3400 Warner Blvd");
+    expect(result.cityStateZip).toBe("Burbank, CA 91505");
+  });
+
+  test("parses two-part address", () => {
+    const result = parseLocation("123 Main St, New York NY 10001");
+    expect(result.street).toBe("123 Main St");
+    expect(result.cityStateZip).toBe("New York NY 10001");
+  });
+
+  test("handles single part address", () => {
+    const result = parseLocation("123 Main Street");
+    expect(result.street).toBe("123 Main Street");
+    expect(result.cityStateZip).toBe("");
+  });
+
+  test("returns empty strings for null input", () => {
+    const result = parseLocation(null);
+    expect(result.street).toBe("");
+    expect(result.cityStateZip).toBe("");
+  });
+
+  test("returns empty strings for empty string input", () => {
+    const result = parseLocation("");
+    expect(result.street).toBe("");
+    expect(result.cityStateZip).toBe("");
+  });
+});
+
+describe("classNames utility", () => {
+  test("joins class names", () => {
+    expect(classNames("a", "b", "c")).toBe("a b c");
+  });
+
+  test("filters out falsy values", () => {
+    expect(classNames("a", false, "b", null, "c", undefined)).toBe("a b c");
+  });
+
+  test("returns empty string for no classes", () => {
+    expect(classNames()).toBe("");
+  });
+});
+
+describe("truncateTitle utility", () => {
+  test("truncates long titles", () => {
+    expect(truncateTitle("This is a very long title", 10)).toBe("This is a ...");
+  });
+
+  test("does not truncate short titles", () => {
+    expect(truncateTitle("Short", 10)).toBe("Short");
+  });
+
+  test("handles exact length", () => {
+    expect(truncateTitle("Exact", 5)).toBe("Exact");
+  });
+});
+
+describe("cn utility (tailwind-merge)", () => {
+  test("merges class names", () => {
+    const result = cn("px-2", "px-4");
+    expect(result).toBe("px-4");
+  });
+
+  test("handles conditional classes", () => {
+    const isActive = true;
+    const result = cn("base", isActive && "active");
+    expect(result).toContain("base");
+    expect(result).toContain("active");
+  });
+});
+
+describe("getDays", () => {
+  test('returns weekdays when params is "weeks"', () => {
+    const days = getDays("weeks");
+    expect(days).toHaveLength(5);
+    expect(days[0]).toEqual({ value: "monday", label: "Monday" });
+    expect(days[4]).toEqual({ value: "friday", label: "Friday" });
+  });
+
+  test("returns 31 days with suffixes for other params", () => {
+    const days = getDays("months");
+    expect(days).toHaveLength(31);
+  });
+
+  test("has correct suffix for 1st", () => {
+    const days = getDays("months");
+    expect(days[0]).toEqual({ value: "1", label: "1st" });
+  });
+
+  test("has correct suffix for 2nd", () => {
+    const days = getDays("months");
+    expect(days[1]).toEqual({ value: "2", label: "2nd" });
+  });
+
+  test("has correct suffix for 3rd", () => {
+    const days = getDays("months");
+    expect(days[2]).toEqual({ value: "3", label: "3rd" });
+  });
+
+  test("has correct suffix for 4th", () => {
+    const days = getDays("months");
+    expect(days[3]).toEqual({ value: "4", label: "4th" });
+  });
+
+  test("has correct suffix for 11th (exception)", () => {
+    const days = getDays("months");
+    expect(days[10]).toEqual({ value: "11", label: "11th" });
+  });
+
+  test("has correct suffix for 12th (exception)", () => {
+    const days = getDays("months");
+    expect(days[11]).toEqual({ value: "12", label: "12th" });
+  });
+
+  test("has correct suffix for 13th (exception)", () => {
+    const days = getDays("months");
+    expect(days[12]).toEqual({ value: "13", label: "13th" });
+  });
+
+  test("has correct suffix for 21st", () => {
+    const days = getDays("months");
+    expect(days[20]).toEqual({ value: "21", label: "21st" });
+  });
+
+  test("has correct suffix for 22nd", () => {
+    const days = getDays("months");
+    expect(days[21]).toEqual({ value: "22", label: "22nd" });
+  });
+
+  test("has correct suffix for 23rd", () => {
+    const days = getDays("months");
+    expect(days[22]).toEqual({ value: "23", label: "23rd" });
+  });
+
+  test("has correct suffix for 31st", () => {
+    const days = getDays("months");
+    expect(days[30]).toEqual({ value: "31", label: "31st" });
+  });
+});
+
+describe("getDaysNumberOptions", () => {
+  test("returns 12 options for months", () => {
+    const options = getDaysNumberOptions("months");
+    expect(options).toHaveLength(12);
+    expect(options[0]).toEqual({ value: "1", label: "1" });
+    expect(options[11]).toEqual({ value: "12", label: "12" });
+  });
+
+  test("returns 10 options for weeks", () => {
+    const options = getDaysNumberOptions("weeks");
+    expect(options).toHaveLength(10);
+    expect(options[0]).toEqual({ value: "1", label: "1" });
+    expect(options[9]).toEqual({ value: "10", label: "10" });
+  });
+
+  test("returns 31 options for days (default)", () => {
+    const options = getDaysNumberOptions("days");
+    expect(options).toHaveLength(31);
+    expect(options[0]).toEqual({ value: "1", label: "1" });
+    expect(options[30]).toEqual({ value: "31", label: "31" });
+  });
+
+  test("returns 31 options for unknown timeUnit", () => {
+    const options = getDaysNumberOptions("unknown");
+    expect(options).toHaveLength(31);
+  });
+});
+
+describe("convertToCustomDateFormat", () => {
+  test("converts ISO string to custom date format", () => {
+    const result = convertToCustomDateFormat("2025-06-15T12:00:00Z");
+    expect(result).toBeInstanceOf(Date);
+    expect(result.getFullYear()).toBe(2025);
+    expect(result.getMonth()).toBe(5); // June is month 5
+    expect(result.getDate()).toBe(15);
+  });
+
+  test("handles date without time", () => {
+    const result = convertToCustomDateFormat("2025-01-01T12:00:00Z");
+    expect(result).toBeInstanceOf(Date);
+    expect(result.getFullYear()).toBe(2025);
+    expect(result.getMonth()).toBe(0);
+    expect(result.getDate()).toBe(1);
+  });
+});
+
+describe("ROLE_PERMISSION_LIST", () => {
+  test("is an array", () => {
+    expect(Array.isArray(ROLE_PERMISSION_LIST)).toBe(true);
+  });
+
+  test("has 9 permission groups", () => {
+    expect(ROLE_PERMISSION_LIST).toHaveLength(9);
+  });
+
+  test("each item has icon, title, description, and checkbox", () => {
+    ROLE_PERMISSION_LIST.forEach((item) => {
+      expect(item).toHaveProperty("icon");
+      expect(item).toHaveProperty("title");
+      expect(item).toHaveProperty("description");
+      expect(item).toHaveProperty("checkbox");
+      expect(Array.isArray(item.checkbox)).toBe(true);
+    });
+  });
+
+  test("includes Event creation permission", () => {
+    const eventPermission = ROLE_PERMISSION_LIST.find(
+      (p) => p.title === "Event creation"
+    );
+    expect(eventPermission).toBeDefined();
+    expect(eventPermission.checkbox).toContain("Create Events");
+  });
+
+  test("includes Booking permission", () => {
+    const bookingPermission = ROLE_PERMISSION_LIST.find(
+      (p) => p.title === "Booking"
+    );
+    expect(bookingPermission).toBeDefined();
+  });
+
+  test("includes Venue creation permission", () => {
+    const venuePermission = ROLE_PERMISSION_LIST.find(
+      (p) => p.title === "Venue creation"
+    );
+    expect(venuePermission).toBeDefined();
+  });
+
+  test("includes Marketing permission", () => {
+    const marketingPermission = ROLE_PERMISSION_LIST.find(
+      (p) => p.title === "Marketing"
+    );
+    expect(marketingPermission).toBeDefined();
+  });
+
+  test("includes Orders & attendees permission", () => {
+    const ordersPermission = ROLE_PERMISSION_LIST.find(
+      (p) => p.title === "Orders & attendees"
+    );
+    expect(ordersPermission).toBeDefined();
+  });
+
+  test("includes Organization permission", () => {
+    const orgPermission = ROLE_PERMISSION_LIST.find(
+      (p) => p.title === "Organization"
+    );
+    expect(orgPermission).toBeDefined();
+  });
+
+  test("includes Contacts permission", () => {
+    const contactsPermission = ROLE_PERMISSION_LIST.find(
+      (p) => p.title === "Contacts"
+    );
+    expect(contactsPermission).toBeDefined();
+  });
+
+  test("includes Reporting permission", () => {
+    const reportingPermission = ROLE_PERMISSION_LIST.find(
+      (p) => p.title === "Reporting"
+    );
+    expect(reportingPermission).toBeDefined();
+  });
+
+  test("includes Payouts & billing permission", () => {
+    const payoutsPermission = ROLE_PERMISSION_LIST.find(
+      (p) => p.title === "Payouts & billing"
+    );
+    expect(payoutsPermission).toBeDefined();
+  });
+});
+
+describe("fetchData", () => {
+  beforeEach(() => {
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("returns data on successful fetch", async () => {
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ success: true, data: "test" }),
+    });
+
+    const result = await fetchData("/api/test");
+    expect(result.data).toEqual({ success: true, data: "test" });
+    expect(result.error).toBe(null);
+  });
+
+  test("returns error on failed fetch", async () => {
+    global.fetch.mockResolvedValue({
+      ok: false,
+      status: 500,
+      text: () => Promise.resolve("Server Error"),
+    });
+
+    const result = await fetchData("/api/test");
+    expect(result.data).toBe(null);
+    expect(result.error).toContain("Server Error");
+  });
+
+  test("returns error on network failure", async () => {
+    global.fetch.mockRejectedValue(new Error("Network error"));
+
+    const result = await fetchData("/api/test");
+    expect(result.data).toBe(null);
+    expect(result.error).toBe("Network error");
+  });
+
+  test("passes headers to fetch", async () => {
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({}),
+    });
+
+    await fetchData("/api/test", {
+      headers: { Authorization: "Bearer token" },
+    });
+
+    // Check that fetch was called with the custom Authorization header
+    const callArgs = global.fetch.mock.calls[0];
+    expect(callArgs[0]).toBe("/api/test");
+    expect(callArgs[1].headers.Authorization).toBe("Bearer token");
+  });
+
+  test("handles text() error gracefully", async () => {
+    global.fetch.mockResolvedValue({
+      ok: false,
+      status: 500,
+      text: () => Promise.reject(new Error("Cannot read body")),
+    });
+
+    const result = await fetchData("/api/test");
+    expect(result.data).toBe(null);
+    expect(result.error).toBe("Unknown error");
+  });
+});
+
+describe("postData", () => {
+  beforeEach(() => {
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("returns data and ok:true on success", async () => {
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ id: 1 }),
+    });
+
+    const result = await postData("/api/test", { name: "Test" });
+    expect(result.data).toEqual({ id: 1 });
+    expect(result.error).toBe(null);
+    expect(result.ok).toBe(true);
+  });
+
+  test("returns error on failed request", async () => {
+    global.fetch.mockResolvedValue({
+      ok: false,
+      json: () => Promise.resolve({ message: "Validation failed" }),
+    });
+
+    const result = await postData("/api/test", { name: "" });
+    expect(result.error).toBe("Validation failed");
+    expect(result.ok).toBe(false);
+  });
+
+  test("handles json parse error", async () => {
+    global.fetch.mockResolvedValue({
+      ok: false,
+      json: () => Promise.reject(new Error("Invalid JSON")),
+    });
+
+    const result = await postData("/api/test", {});
+    expect(result.data).toEqual({});
+    expect(result.error).toBe("Request failed");
+    expect(result.ok).toBe(false);
+  });
+
+  test("handles network error", async () => {
+    global.fetch.mockRejectedValue(new Error("Network error"));
+
+    const result = await postData("/api/test", {});
+    expect(result.data).toBe(null);
+    expect(result.error).toBe("Network error");
+    expect(result.ok).toBe(false);
+  });
+
+  test("sends POST request with JSON body", async () => {
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({}),
+    });
+
+    await postData("/api/test", { foo: "bar" });
+
+    expect(global.fetch).toHaveBeenCalledWith("/api/test", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ foo: "bar" }),
+    });
+  });
+});
+
+describe("setAuthCookies", () => {
+  test("sets performer_token and userDetails cookies", () => {
+    setAuthCookies("mytoken123", { id: 1, name: "Test User" });
+    expect(getCookie("performer_token")).toBe("mytoken123");
+    const details = getCookie("userDetails");
+    expect(details).toBeTruthy();
+    expect(JSON.parse(decodeURIComponent(details))).toEqual({ id: 1, name: "Test User" });
+  });
+
+  test("handles rememberMe = false", () => {
+    setAuthCookies("token", { id: 1 }, false);
+    expect(getCookie("performer_token")).toBe("token");
+  });
+});
+
+describe("clearAuthCookies", () => {
+  test("clears auth cookies", () => {
+    mockCookies = "performer_token=test; userDetails=test";
+    clearAuthCookies();
+    // After clearing, the cookies should be empty or expired
+    expect(getCookie("performer_token")).toBeFalsy();
+  });
+});
+
+describe("microphonePlaceholder", () => {
+  test("is defined", () => {
+    expect(microphonePlaceholder).toBeDefined();
+  });
+
+  test("is a string (asset path)", () => {
+    expect(typeof microphonePlaceholder).toBe("string");
+  });
+});
+
+describe("setCookie", () => {
+  test("sets a cookie with default options", () => {
+    setCookie("test_cookie", "test_value");
+    expect(getCookie("test_cookie")).toBe("test_value");
+  });
+
+  test("sets a cookie with maxAge option", () => {
+    setCookie("expiring_cookie", "value", { maxAge: 3600 });
+    expect(getCookie("expiring_cookie")).toBe("value");
+  });
+
+  test("sets a cookie with custom path", () => {
+    setCookie("path_cookie", "value", { path: "/custom" });
+    // Cookie is set, though path may not be reflected in our mock
+    expect(getCookie("path_cookie")).toBeDefined();
+  });
+
+  test("encodes special characters in value", () => {
+    setCookie("encoded_cookie", "value with spaces & special=chars");
+    const decoded = getCookie("encoded_cookie");
+    expect(decoded).toContain("value");
+  });
+});
+
+describe("saveSuppressedAlerts", () => {
+  test("saves array of alert IDs", () => {
+    saveSuppressedAlerts(["alert-1", "alert-2", "alert-3"]);
+    expect(getSuppressedAlerts()).toEqual(["alert-1", "alert-2", "alert-3"]);
+  });
+
+  test("overwrites previous alerts", () => {
+    saveSuppressedAlerts(["old-alert"]);
+    saveSuppressedAlerts(["new-alert"]);
+    expect(getSuppressedAlerts()).toEqual(["new-alert"]);
+  });
+
+  test("handles empty array", () => {
+    saveSuppressedAlerts([]);
+    expect(getSuppressedAlerts()).toEqual([]);
+  });
+});
+
+describe("parseCookies edge cases", () => {
+  test("handles cookies with = in value", () => {
+    mockCookies = "data=key=value";
+    const result = parseCookies();
+    expect(result.data).toBe("key=value");
+  });
+
+  test("handles empty cookie string", () => {
+    mockCookies = "";
+    const result = parseCookies();
+    expect(result).toEqual({});
+  });
+});
+
+describe("fetchData edge cases", () => {
+  beforeEach(() => {
+    global.fetch = vi.fn();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("handles empty response body", async () => {
+    global.fetch.mockResolvedValue({
+      ok: false,
+      status: 204,
+      text: () => Promise.resolve(""),
+    });
+
+    const result = await fetchData("/api/test");
+    expect(result.error).toContain("204");
+  });
+});