@bash-app/bash-common 30.246.0 → 30.253.0

package/src/utils/__tests__/paymentUtils.test.ts

@@ -16,6 +16,7 @@ import {
   calculateTotalBashPoints,
   calculateStripeDonationFee,
   calculateServiceFeeWithMembershipDiscount,
+  calculatePartnerFeeWithMembershipDiscount,
   calculateBashPlatformFeeCents,
   splitBashPlatformFeeForTicketCheckout,
   computeTicketApplicationFeeAmountCents,
@@ -24,7 +25,9 @@ import {
   getBashPassMonthlyCapRemaining,
   higherBashPassTier,
   membershipGrantsBashPassTier,
+  VENUE_PRICING_PLAN_DATA,
 } from "../paymentUtils.js";
+import { VenuePricingPlan } from "@prisma/client";
 
 describe("PaymentUtils - Core Functions", () => {
   describe("Currency Conversion", () => {
@@ -337,6 +340,62 @@ describe("PaymentUtils - Core Functions", () => {
     });
   });
 
+  describe("Partner fee with membership discount", () => {
+    test("calculatePartnerFeeWithMembershipDiscount scales with amount", () => {
+      const small = calculatePartnerFeeWithMembershipDiscount(1000, MembershipTier.Basic);
+      const large = calculatePartnerFeeWithMembershipDiscount(100000, MembershipTier.Basic);
+      expect(large).toBeGreaterThan(small);
+    });
+
+    test("calculatePartnerFeeWithMembershipDiscount defaults to Basic tier", () => {
+      const withTier = calculatePartnerFeeWithMembershipDiscount(5000, MembershipTier.Pro);
+      const defaulted = calculatePartnerFeeWithMembershipDiscount(5000, null);
+      expect(typeof withTier).toBe("number");
+      expect(typeof defaulted).toBe("number");
+    });
+  });
+
+  describe("VENUE_PRICING_PLAN_DATA", () => {
+    test("Percentage plan uses pay-per-booking copy and fee", () => {
+      const plan = VENUE_PRICING_PLAN_DATA[VenuePricingPlan.Percentage];
+      expect(plan.name).toBe("Pay per booking");
+      expect(plan.percentageFee).toBeGreaterThan(0);
+      expect(plan.monthlyFee).toBe(0);
+    });
+
+    test("Subscription plan is flat monthly with no percentage fee", () => {
+      const plan = VENUE_PRICING_PLAN_DATA[VenuePricingPlan.Subscription];
+      expect(plan.monthlyFee).toBe(100);
+      expect(plan.percentageFee).toBe(0);
+    });
+  });
+
+  describe("splitBashPlatformFeeForTicketCheckout edge cases", () => {
+    test("returns zeros when platform fee disabled", () => {
+      expect(
+        splitBashPlatformFeeForTicketCheckout({
+          grossCents: 10000,
+          platformFeeEnabled: false,
+          platformFeeRate: 0.03,
+          feeHandling: "GuestPays",
+          bashPassWaivesGuestFee: false,
+        })
+      ).toEqual({ totalPlatformCents: 0, guestPlatformLineCents: 0 });
+    });
+
+    test("defaults feeHandling to HostAbsorbs", () => {
+      expect(
+        splitBashPlatformFeeForTicketCheckout({
+          grossCents: 10000,
+          platformFeeEnabled: true,
+          platformFeeRate: 0.03,
+          feeHandling: null,
+          bashPassWaivesGuestFee: false,
+        })
+      ).toEqual({ totalPlatformCents: 300, guestPlatformLineCents: 0 });
+    });
+  });
+
   describe("BashPass tier and monthly cap", () => {
     const future = new Date(Date.now() + 86400000 * 30);
     const past = new Date(Date.now() - 86400000);

package/src/utils/__tests__/qrCodeUtils.test.ts

@@ -18,12 +18,18 @@
  *
  * Bugs in any of these route door-scanners to the wrong page (= entry chaos).
  */
+import QRCode from "qrcode";
+
 import {
   bashEventPrismaCheckoutQrCodeUrl,
   bashEventQrCodeUrl,
   createQrCodeImage,
 } from "../qrCodeUtils.js";
 
+jest.mock("qrcode", () => ({
+  toDataURL: jest.fn(),
+}));
+
 // ============================================================================
 // bashEventPrismaCheckoutQrCodeUrl — checkout-id deep link
 // ============================================================================
@@ -120,22 +126,43 @@ describe("bashEventQrCodeUrl", () => {
 // ============================================================================
 
 describe("createQrCodeImage", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
   it("returns a base64-encoded PNG data URL", async () => {
+    const mockDataUrl =
+      "data:image/png;base64," +
+      "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==".repeat(
+        3
+      );
+    (QRCode.toDataURL as jest.Mock).mockResolvedValue(mockDataUrl);
+
     const dataUrl = await createQrCodeImage(
       "https://bash.app/ticket-details/evt_1/ticket/abc"
     );
     expect(dataUrl).toMatch(/^data:image\/png;base64,/);
-    // Sanity: a real QR image will have *meaningful* base64 length, not a few bytes.
     expect(dataUrl.length).toBeGreaterThan(200);
+    expect(QRCode.toDataURL).toHaveBeenCalledWith(
+      "https://bash.app/ticket-details/evt_1/ticket/abc",
+      { errorCorrectionLevel: "high" }
+    );
   });
 
   it("produces a deterministic PNG for the same input (no nonce / timestamp leakage)", async () => {
+    const mockDataUrl = "data:image/png;base64,same-payload";
+    (QRCode.toDataURL as jest.Mock).mockResolvedValue(mockDataUrl);
+
     const a = await createQrCodeImage("ticket://abc");
     const b = await createQrCodeImage("ticket://abc");
     expect(a).toBe(b);
   });
 
   it("produces DIFFERENT output for different payloads", async () => {
+    (QRCode.toDataURL as jest.Mock)
+      .mockResolvedValueOnce("data:image/png;base64,abc")
+      .mockResolvedValueOnce("data:image/png;base64,xyz");
+
     const a = await createQrCodeImage("ticket://abc");
     const b = await createQrCodeImage("ticket://xyz");
     expect(a).not.toBe(b);

package/src/utils/__tests__/reviewUtils.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  calculateAverageRating,
+  generateReviewStats,
+  formatRatingWithStars,
+  isEligibleToReview,
+} from "../reviewUtils.js";
+import type { Review } from "../../definitions.js";
+
+const reviews: Review[] = [
+  { rating: 5, id: "1" } as Review,
+  { rating: 4, id: "2" } as Review,
+  { rating: 3, id: "3" } as Review,
+];
+
+describe("reviewUtils", () => {
+  describe("calculateAverageRating", () => {
+    test("returns 0 for empty list", () => {
+      expect(calculateAverageRating([])).toBe(0);
+    });
+
+    test("averages ratings to one decimal", () => {
+      expect(calculateAverageRating(reviews)).toBe(4);
+    });
+  });
+
+  describe("generateReviewStats", () => {
+    test("builds distribution and totals", () => {
+      expect(generateReviewStats(reviews)).toEqual({
+        averageRating: 4,
+        totalRatings: 3,
+        ratings: { 1: 0, 2: 0, 3: 1, 4: 1, 5: 1 },
+      });
+    });
+
+    test("ignores out-of-range ratings", () => {
+      const mixed = [{ rating: 6, id: "x" } as Review, { rating: 0, id: "y" } as Review];
+      expect(generateReviewStats(mixed).ratings).toEqual({ 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 });
+    });
+  });
+
+  describe("formatRatingWithStars", () => {
+    test("includes full stars and half star", () => {
+      expect(formatRatingWithStars(4.5)).toBe("4.5 ★★★★½");
+    });
+
+    test("rounds down fractional stars below 0.5", () => {
+      expect(formatRatingWithStars(3.2)).toBe("3.2 ★★★");
+    });
+  });
+
+  describe("isEligibleToReview", () => {
+    test("allows attendee who has not reviewed and is not the host", () => {
+      expect(isEligibleToReview("user-1", "event-1", "host-1", [], ["event-1"])).toBe(true);
+    });
+
+    test("blocks host, non-attendees, and duplicate reviews", () => {
+      expect(isEligibleToReview("host-1", "event-1", "host-1", [], ["event-1"])).toBe(false);
+      expect(isEligibleToReview("user-1", "event-1", "host-1", [], [])).toBe(false);
+      expect(isEligibleToReview("user-1", "event-1", "host-1", ["event-1"], ["event-1"])).toBe(
+        false
+      );
+    });
+  });
+});

package/src/utils/__tests__/slugUtils.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  BASH_DETAIL_URL,
+  BASH_EVENT_WIZARD_HOW_MAJOR_STEP,
+  BASH_EVENT_WIZARD_HOW_SUBSTEP_PAYOUT,
+  BASH_EVENT_WIZARD_PATH_PREFIX,
+} from "../../definitions.js";
+import {
+  generateSlug,
+  generateUniqueSlug,
+  generateBashDetailUrl,
+  getPublicBashDetailPath,
+  getBashEventWizardStepPath,
+  getBashEventWizardPayoutStepPath,
+  parseBashUrlParams,
+  validateSlug,
+} from "../slugUtils.js";
+
+describe("generateSlug", () => {
+  test("lowercases and slugifies a title", () => {
+    expect(generateSlug("Summer Bash 2026!")).toBe("summer-bash-2026");
+  });
+
+  test("removes special characters", () => {
+    expect(generateSlug("Hello *World*")).toBe("hello-world");
+  });
+
+  test("handles empty string", () => {
+    expect(generateSlug("")).toBe("");
+  });
+});
+
+describe("generateUniqueSlug", () => {
+  test("returns base slug when available", async () => {
+    const checkSlugExists = async () => false;
+    await expect(generateUniqueSlug("My Event", checkSlugExists)).resolves.toBe("my-event");
+  });
+
+  test("appends counter when slug exists", async () => {
+    const taken = new Set(["my-event", "my-event-1"]);
+    const checkSlugExists = async (slug: string) => taken.has(slug);
+    await expect(generateUniqueSlug("My Event", checkSlugExists)).resolves.toBe("my-event-2");
+  });
+
+  test("passes excludeId to checkSlugExists", async () => {
+    const calls: Array<{ slug: string; excludeId?: string }> = [];
+    const checkSlugExists = async (slug: string, excludeId?: string) => {
+      calls.push({ slug, excludeId });
+      return false;
+    };
+    await generateUniqueSlug("My Event", checkSlugExists, "event-123");
+    expect(calls).toEqual([{ slug: "my-event", excludeId: "event-123" }]);
+  });
+});
+
+describe("generateBashDetailUrl", () => {
+  test("builds id-slug path", () => {
+    expect(generateBashDetailUrl("abc123", "summer-bash")).toBe("/bash/abc123-summer-bash");
+  });
+});
+
+describe("getPublicBashDetailPath", () => {
+  test("uses slug path when slug is present", () => {
+    expect(getPublicBashDetailPath("abc123", "summer-bash")).toBe(
+      "/bash/abc123-summer-bash"
+    );
+  });
+
+  test("trims slug before use", () => {
+    expect(getPublicBashDetailPath("abc123", "  summer-bash  ")).toBe(
+      "/bash/abc123-summer-bash"
+    );
+  });
+
+  test("falls back to id-only legacy path when slug missing", () => {
+    expect(getPublicBashDetailPath("abc123", null)).toBe(`${BASH_DETAIL_URL}/abc123`);
+    expect(getPublicBashDetailPath("abc123", undefined)).toBe(`${BASH_DETAIL_URL}/abc123`);
+    expect(getPublicBashDetailPath("abc123", "   ")).toBe(`${BASH_DETAIL_URL}/abc123`);
+  });
+});
+
+describe("getBashEventWizardStepPath", () => {
+  test("builds wizard step path", () => {
+    expect(getBashEventWizardStepPath("evt-1", 3, 2)).toBe(
+      `${BASH_EVENT_WIZARD_PATH_PREFIX}/evt-1/3/2`
+    );
+  });
+});
+
+describe("getBashEventWizardPayoutStepPath", () => {
+  test("returns How → Payout step path", () => {
+    expect(getBashEventWizardPayoutStepPath("evt-1")).toBe(
+      `${BASH_EVENT_WIZARD_PATH_PREFIX}/evt-1/${BASH_EVENT_WIZARD_HOW_MAJOR_STEP}/${BASH_EVENT_WIZARD_HOW_SUBSTEP_PAYOUT}`
+    );
+  });
+});
+
+describe("parseBashUrlParams", () => {
+  test("parses id-slug format", () => {
+    expect(parseBashUrlParams("abc123-summer-bash")).toEqual({
+      id: "abc123",
+      slug: "summer-bash",
+    });
+  });
+
+  test("parses id-only legacy format", () => {
+    expect(parseBashUrlParams("abc123")).toEqual({ id: "abc123", slug: null });
+  });
+
+  test("returns null for empty param", () => {
+    expect(parseBashUrlParams("")).toBeNull();
+  });
+
+  test("returns null when id portion is empty", () => {
+    expect(parseBashUrlParams("-slug-only")).toBeNull();
+  });
+
+  test("returns slug null when trailing dash has no slug", () => {
+    expect(parseBashUrlParams("abc123-")).toEqual({ id: "abc123", slug: null });
+  });
+
+  test("uses first dash as separator only", () => {
+    expect(parseBashUrlParams("abc-my-cool-event")).toEqual({
+      id: "abc",
+      slug: "my-cool-event",
+    });
+  });
+});
+
+describe("validateSlug", () => {
+  test.each([
+    ["valid-slug", true],
+    ["abc123", true],
+    ["a-b-c", true],
+    ["UPPERCASE", false],
+    ["has spaces", false],
+    ["has_underscore", false],
+    ["special!", false],
+    ["", false],
+  ])("validateSlug(%s) → %s", (slug, expected) => {
+    expect(validateSlug(slug)).toBe(expected);
+  });
+});

package/src/utils/__tests__/sortUtils.test.ts

@@ -0,0 +1,33 @@
+/**
+ * Tests for tier sort ordering.
+ */
+
+import { describe, expect, test } from "@jest/globals";
+import { sortTiers } from "../sortUtils.js";
+
+describe("sortUtils", () => {
+  describe("sortTiers", () => {
+    test("returns 0 when sortOrder matches", () => {
+      expect(sortTiers({ sortOrder: 2 }, { sortOrder: 2 })).toBe(0);
+    });
+
+    test("sorts by sortOrder ascending", () => {
+      expect(sortTiers({ sortOrder: 1 }, { sortOrder: 3 })).toBeLessThan(0);
+      expect(sortTiers({ sortOrder: 5 }, { sortOrder: 2 })).toBeGreaterThan(0);
+    });
+
+    test("falls back to price when sortOrder absent", () => {
+      expect(sortTiers({ price: 10 }, { price: 20 })).toBeLessThan(0);
+      expect(sortTiers({ price: 20 }, { price: 10 })).toBeGreaterThan(0);
+    });
+
+    test("empty values sort before defined values", () => {
+      expect(sortTiers({}, { sortOrder: 1 })).toBeLessThan(0);
+      expect(sortTiers({ sortOrder: 1 }, {})).toBeGreaterThan(0);
+    });
+
+    test("returns 0 when both tiers lack comparable fields", () => {
+      expect(sortTiers({}, {})).toBe(0);
+    });
+  });
+});

package/src/utils/__tests__/stringUtils.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "@jest/globals";
+import { formatString } from "../stringUtils.js";
+
+describe("formatString", () => {
+  test("replaces placeholders with string values", () => {
+    expect(formatString("Hello ${name}!", { name: "World" })).toBe("Hello World!");
+  });
+
+  test("replaces placeholders with numeric values", () => {
+    expect(formatString("Count: ${count}", { count: 42 })).toBe("Count: 42");
+  });
+
+  test("replaces multiple placeholders", () => {
+    expect(
+      formatString("${greeting}, ${name}!", { greeting: "Hi", name: "Alex" })
+    ).toBe("Hi, Alex!");
+  });
+
+  test("uses empty string for missing keys", () => {
+    expect(formatString("Hello ${name}!", {})).toBe("Hello !");
+  });
+
+  test("leaves text without placeholders unchanged", () => {
+    expect(formatString("No placeholders here", { unused: "x" })).toBe(
+      "No placeholders here"
+    );
+  });
+
+  test("handles empty template", () => {
+    expect(formatString("", { key: "value" })).toBe("");
+  });
+
+  test("only matches word-character keys", () => {
+    expect(formatString("${key_1} ${key2}", { key_1: "a", key2: "b" })).toBe("a b");
+    expect(formatString("${key-name}", {})).toBe("${key-name}");
+  });
+});

package/src/utils/__tests__/ticketListUtils.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "@jest/globals";
+import { DateTime } from "luxon";
+import { ticketListToString, ticketListStrToTicketList } from "../ticketListUtils.js";
+import type { NumberOfTicketsForDate } from "../../definitions.js";
+
+describe("ticketListUtils", () => {
+  const isoDate = "2024-07-04T18:00:00.000Z";
+
+  test("round-trips ticket list through base64 encoding", () => {
+    const ticketList = new Map<string, NumberOfTicketsForDate[]>([
+      [
+        "tier-abc",
+        [
+          { numberOfTickets: 2, ticketDateTime: isoDate },
+          { numberOfTickets: 1, ticketDateTime: isoDate },
+        ],
+      ],
+      ["tier-xyz", [{ numberOfTickets: 3, ticketDateTime: isoDate }]],
+    ]);
+
+    const encoded = ticketListToString(ticketList);
+    expect(encoded).not.toContain("+");
+    expect(encoded).not.toContain("/");
+
+    const decoded = ticketListStrToTicketList(encoded);
+    expect(decoded.size).toBe(2);
+    expect(decoded.get("tier-abc")).toHaveLength(2);
+    expect(decoded.get("tier-abc")![0].numberOfTickets).toBe(2);
+    expect(decoded.get("tier-xyz")![0].numberOfTickets).toBe(3);
+  });
+
+  test("omits tiers with zero tickets", () => {
+    const ticketList = new Map<string, NumberOfTicketsForDate[]>([
+      ["tier-empty", [{ numberOfTickets: 0, ticketDateTime: isoDate }]],
+      ["tier-live", [{ numberOfTickets: 1, ticketDateTime: isoDate }]],
+    ]);
+    const decoded = ticketListStrToTicketList(ticketListToString(ticketList));
+    expect(decoded.has("tier-empty")).toBe(false);
+    expect(decoded.get("tier-live")).toHaveLength(1);
+  });
+
+  test("decodes legacy plain strings for backward compatibility", () => {
+    const plain = `tier1__2;;${DateTime.fromISO(isoDate).toISO()}~~`;
+    const decoded = ticketListStrToTicketList(plain);
+    expect(decoded.get("tier1")![0].numberOfTickets).toBe(2);
+  });
+});

package/src/utils/__tests__/typeUtils.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, test } from "@jest/globals";
+import { createAllTrueObject } from "../typeUtils.js";
+
+describe("createAllTrueObject", () => {
+  test("maps every key to true", () => {
+    expect(createAllTrueObject(["a", "b", "c"])).toEqual({ a: true, b: true, c: true });
+  });
+
+  test("returns empty object for empty key list", () => {
+    expect(createAllTrueObject([])).toEqual({});
+  });
+});

package/src/utils/__tests__/userSubscriptionUtils.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Tests for service subscription tier mappings.
+ */
+
+import { ServiceTypes, MembershipTier } from "@prisma/client";
+import { describe, expect, test } from "@jest/globals";
+import {
+  SERVICE_TIER_TO_SERVICES_LIST,
+  SERVICE_TIER_FROM_SERVICE_TYPE,
+  USER_SUBSCRIPTION_TYPES,
+  ServiceSubscriptionTier,
+} from "../userSubscriptionUtils.js";
+
+describe("userSubscriptionUtils", () => {
+  describe("SERVICE_TIER_TO_SERVICES_LIST", () => {
+    test("Free and Ally tiers include event and entertainment services", () => {
+      expect(SERVICE_TIER_TO_SERVICES_LIST.Free).toEqual([
+        ServiceTypes.EventServices,
+        ServiceTypes.EntertainmentServices,
+      ]);
+      expect(SERVICE_TIER_TO_SERVICES_LIST.Ally).toEqual([
+        ServiceTypes.EventServices,
+        ServiceTypes.EntertainmentServices,
+      ]);
+    });
+
+    test("Partner and Patron tiers map to vendor and venue service groups", () => {
+      expect(SERVICE_TIER_TO_SERVICES_LIST.Partner).toEqual([
+        ServiceTypes.Vendors,
+        ServiceTypes.Exhibitors,
+        ServiceTypes.Sponsors,
+      ]);
+      expect(SERVICE_TIER_TO_SERVICES_LIST.Patron).toEqual([
+        ServiceTypes.Venues,
+        ServiceTypes.Organizations,
+      ]);
+    });
+  });
+
+  describe("SERVICE_TIER_FROM_SERVICE_TYPE", () => {
+    test("maps all service types listed in tier config", () => {
+      const configuredTypes = Object.values(SERVICE_TIER_TO_SERVICES_LIST).flat();
+      for (const serviceType of configuredTypes) {
+        expect(SERVICE_TIER_FROM_SERVICE_TYPE[serviceType]).toBeDefined();
+      }
+    });
+
+    test("defaults EventServices and EntertainmentServices to Free", () => {
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.EventServices]).toBe(
+        ServiceSubscriptionTier.Free
+      );
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.EntertainmentServices]).toBe(
+        ServiceSubscriptionTier.Free
+      );
+    });
+
+    test("maps vendor-related types to Partner", () => {
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.Vendors]).toBe(ServiceSubscriptionTier.Partner);
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.Exhibitors]).toBe(
+        ServiceSubscriptionTier.Partner
+      );
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.Sponsors]).toBe(ServiceSubscriptionTier.Partner);
+    });
+
+    test("maps venue-related types to Patron", () => {
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.Venues]).toBe(ServiceSubscriptionTier.Patron);
+      expect(SERVICE_TIER_FROM_SERVICE_TYPE[ServiceTypes.Organizations]).toBe(
+        ServiceSubscriptionTier.Patron
+      );
+    });
+  });
+
+  describe("USER_SUBSCRIPTION_TYPES", () => {
+    test("Basic tier is free and typed as MembershipTier.Basic", () => {
+      expect(USER_SUBSCRIPTION_TYPES.Basic).toEqual({
+        name: "Basic",
+        description: "Basic",
+        price: 0,
+        type: MembershipTier.Basic,
+      });
+    });
+
+    test("only Basic tier is currently defined", () => {
+      expect(Object.keys(USER_SUBSCRIPTION_TYPES)).toEqual(["Basic"]);
+    });
+  });
+});

package/src/utils/__tests__/userUtils.test.ts

@@ -0,0 +1,41 @@
+import { Gender } from "@prisma/client";
+import { describe, expect, test } from "@jest/globals";
+import { getDisplayGender, type GenderDisplayUser } from "../userUtils.js";
+
+describe("getDisplayGender", () => {
+  test("returns trimmed genderIdentity when present", () => {
+    const user: GenderDisplayUser = {
+      gender: Gender.Male,
+      genderIdentity: "  Non-binary  ",
+    };
+    expect(getDisplayGender(user)).toBe("Non-binary");
+  });
+
+  test("genderIdentity wins over gender enum", () => {
+    const user: GenderDisplayUser = {
+      gender: Gender.Female,
+      genderIdentity: "Genderfluid",
+    };
+    expect(getDisplayGender(user)).toBe("Genderfluid");
+  });
+
+  test("returns gender enum when genderIdentity is absent", () => {
+    expect(getDisplayGender({ gender: Gender.Male })).toBe(Gender.Male);
+    expect(getDisplayGender({ gender: Gender.Female })).toBe(Gender.Female);
+  });
+
+  test("returns null when genderIdentity is blank whitespace", () => {
+    expect(getDisplayGender({ genderIdentity: "   ", gender: Gender.Male })).toBe(
+      Gender.Male
+    );
+  });
+
+  test("returns null when neither field is set", () => {
+    expect(getDisplayGender({})).toBeNull();
+    expect(getDisplayGender({ gender: null, genderIdentity: null })).toBeNull();
+  });
+
+  test("returns null when genderIdentity is empty and gender is null", () => {
+    expect(getDisplayGender({ genderIdentity: "", gender: null })).toBeNull();
+  });
+});

package/src/utils/__tests__/venueTypeFormatter.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "@jest/globals";
+import { formatVenueType, formatVenueTypes } from "../venueTypeFormatter.js";
+
+describe("venueTypeFormatter", () => {
+  describe("formatVenueType", () => {
+    test("inserts spaces before capital letters", () => {
+      expect(formatVenueType("OutdoorSpace")).toBe("Outdoor Space");
+      expect(formatVenueType("WeddingVenue")).toBe("Wedding Venue");
+    });
+
+    test("returns empty string for falsy input", () => {
+      expect(formatVenueType("")).toBe("");
+    });
+  });
+
+  describe("formatVenueTypes", () => {
+    test("formats up to maxDisplay types", () => {
+      expect(formatVenueTypes(["Restaurant", "Bar"], 2)).toBe("Restaurant, Bar");
+    });
+
+    test("appends +N more when truncated", () => {
+      expect(formatVenueTypes(["Restaurant", "Bar", "Nightclub", "Rooftop"], 2)).toBe(
+        "Restaurant, Bar +2 more"
+      );
+    });
+
+    test("returns empty string for empty array", () => {
+      expect(formatVenueTypes([])).toBe("");
+    });
+  });
+});