@tribe-nest/forge 3.53.0 → 3.54.0

package/src/server/platformEvents.generated.ts

@@ -220,6 +220,94 @@ export type PlatformEventMap = {
       unitPrice: number | null;
     }>;
   };
+  /**
+   * Event ticket request approved: The organiser approved a ticket request; the sale settled and the tickets were issued.
+   *
+   * Requires the `events.read` grant.
+   */
+  "event_ticket_request.approved": {
+    orderId: string;
+    eventId: string | null;
+    status: string | null;
+    total: number | null;
+    currency: string | null;
+    buyer: {
+      contactId: string | null;
+      email: string | null;
+      name: string | null;
+    };
+    tickets: Array<{
+      ticketId: string | null;
+      quantity: number;
+      unitPrice: number | null;
+    }>;
+  };
+  /**
+   * Event ticket request declined: The organiser declined a ticket request; the hold was released.
+   *
+   * Requires the `events.read` grant.
+   */
+  "event_ticket_request.declined": {
+    orderId: string;
+    eventId: string | null;
+    status: string | null;
+    total: number | null;
+    currency: string | null;
+    buyer: {
+      contactId: string | null;
+      email: string | null;
+      name: string | null;
+    };
+    tickets: Array<{
+      ticketId: string | null;
+      quantity: number;
+      unitPrice: number | null;
+    }>;
+  };
+  /**
+   * Event ticket request expired: A ticket request lapsed undecided; the hold and the seats were released.
+   *
+   * Requires the `events.read` grant.
+   */
+  "event_ticket_request.expired": {
+    orderId: string;
+    eventId: string | null;
+    status: string | null;
+    total: number | null;
+    currency: string | null;
+    buyer: {
+      contactId: string | null;
+      email: string | null;
+      name: string | null;
+    };
+    tickets: Array<{
+      ticketId: string | null;
+      quantity: number;
+      unitPrice: number | null;
+    }>;
+  };
+  /**
+   * Event ticket requested: Someone requested tickets to an event that needs the organiser's approval. Their card is held, not charged.
+   *
+   * Requires the `events.read` grant.
+   */
+  "event_ticket_request.submitted": {
+    orderId: string;
+    eventId: string | null;
+    status: string | null;
+    total: number | null;
+    currency: string | null;
+    buyer: {
+      contactId: string | null;
+      email: string | null;
+      name: string | null;
+    };
+    tickets: Array<{
+      ticketId: string | null;
+      quantity: number;
+      unitPrice: number | null;
+    }>;
+  };
   /**
    * Membership tier archived: A membership tier was archived and can no longer be joined.
    *
@@ -403,6 +491,10 @@ export const PLATFORM_EVENT_PERMISSIONS: Record<PlatformEventName, string> = {
   "email.clicked": "emails.read",
   "email.opened": "emails.read",
   "event_ticket_order.paid": "events.read",
+  "event_ticket_request.approved": "events.read",
+  "event_ticket_request.declined": "events.read",
+  "event_ticket_request.expired": "events.read",
+  "event_ticket_request.submitted": "events.read",
   "membership_tier.archived": "membership.tier_archived",
   "membership_tier.created": "membership.tier_created",
   "message.received": "contacts.read",

package/src/types/models.ts

@@ -66,6 +66,12 @@ export type PublicTaxQuote = {
  * Stripe always populates `paymentSecret` and never the Paystack pair; Paystack
  * always populates `accessCode` + `checkoutUrl` and never `paymentSecret`.
  */
+/** Whether a started charge is taken now or only once the organiser approves. */
+export type PaymentSettlement = "immediate" | "deferred";
+
+/** How a provider holds a deferred charge until the decision. */
+export type DeferredChargeStrategy = "authorization" | "saved_instrument";
+
 export type PaymentStartResponse = {
   /**
    * STRIPE ONLY: the PaymentIntent client secret fed to Stripe Elements.
@@ -101,6 +107,19 @@ export type PaymentStartResponse = {
   shippingCosts?: { deliveryGroupId: string; amount: number; currency: string }[];
   /** Authoritative sales-tax quote for this charge (all wired pillars). */
   taxQuote?: PublicTaxQuote;
+  /**
+   * EVENT TICKET REQUESTS: `"deferred"` when this charge is committed now and
+   * settled only if the organiser approves. Absent (or `"immediate"`) on every
+   * ordinary sale. Drives the "Authorize" wording on the pay button.
+   */
+  settlement?: PaymentSettlement;
+  /**
+   * How the provider defers the charge. `"authorization"` places a temporary
+   * hold the fan can see on their statement; `"saved_instrument"` stores the
+   * card and takes nothing until approval. Only meaningful with
+   * `settlement: "deferred"`.
+   */
+  deferredStrategy?: DeferredChargeStrategy | null;
   /**
    * COHORT ENROLMENT ONLY: what THIS charge takes, when the plan is paid in
    * instalments. `totalAmount` above stays the whole plan, so a checkout that
@@ -1145,6 +1164,12 @@ export interface IEvent {
   createdAt: string;
   updatedAt: string;
   tickets: ITicket[];
+  /**
+   * At least one tier on this event needs the organiser's approval. Optional
+   * on the wire; derive it from `tickets` with `eventHasApprovalTiers` rather
+   * than trusting its absence.
+   */
+  hasApprovalTiers?: boolean;
   media: IMedia[];
   slug: string;
   /**
@@ -1339,6 +1364,17 @@ export type ITicket = {
    * {@link PublicMembershipGate}.
    */
   membershipGate?: PublicMembershipGate | null;
+  /**
+   * The organiser decides who gets this tier (curated access, feature 3).
+   *
+   * A request is lodged instead of a sale: the card is authorised, not charged,
+   * the seat is held, and the organiser has a window to approve or decline.
+   * Sent to every client. A site on an older Forge shows such a tier with its
+   * ordinary buy button; that is accepted until the site takes the update.
+   */
+  requiresApproval?: boolean;
+  /** How long the organiser has to decide, in hours. `null` means the platform default. */
+  approvalWindowHours?: number | null;
 };
 
 // ---- Invoices ----------------------------------------------------------------
@@ -1506,6 +1542,12 @@ export enum OrderStatus {
   Delivered = "delivered",
   Cancelled = "cancelled",
   Processed = "processed",
+  /** Ticket request lodged: charge committed (authorised), seat held, nothing captured, no passes. */
+  PendingApproval = "pending_approval",
+  /** Transient: the organiser approved and settlement is in flight. */
+  Approved = "approved",
+  /** The organiser declined the request; the authorisation was released. */
+  Declined = "declined",
 }
 
 export type IPublicOrderItem = {
@@ -1620,6 +1662,22 @@ export type ITicketOrder = {
   refundedAmountCents?: number | string | null;
   refundState?: "none" | "partial" | "full" | string | null;
   lastRefundedAt?: string | null;
+  /**
+   * Ticket-request columns (curated access, feature 3). All absent on an
+   * ordinary sale and on an older API build.
+   *
+   * `approvalRequestExpiresAt` is the "decide by" instant a fan is shown while
+   * the request is `pending_approval`. `approvalFailureReason` is set when a
+   * request ended without a sale: `"expired"` on a `cancelled` row whose window
+   * lapsed undecided, and the provider's reason on a `payment_failed` row the
+   * organiser approved but could not settle. See `getTicketOrderOutcome` and
+   * `ticketRequestFailureKind`.
+   */
+  approvalRequestedAt?: string | null;
+  approvalRequestExpiresAt?: string | null;
+  approvalDecidedAt?: string | null;
+  approvalDecisionNote?: string | null;
+  approvalFailureReason?: string | null;
   customerName: string;
   customerEmail: string;
   createdAt: string;

package/src/ui/headless/event/_tests/ticketApproval.spec.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from "vitest";
+import {
+  eventHasApprovalTiers,
+  nextStepAfterTicketOrder,
+  selectionMode,
+  selectionRequiresApproval,
+  tierBlockedByApprovalMix,
+  tierRequiresApproval,
+} from "../ticketApproval";
+import type { IEvent, ITicket } from "../../../../types/models";
+
+/**
+ * Ticket requests (curated access, feature 3): the pure decisions the picker
+ * and the checkout make. Two rules are load-bearing and both are here:
+ *
+ *  1. ONE ORDER IS A REQUEST OR A PURCHASE, NEVER BOTH. The API refuses a
+ *     mixed cart; the picker must stop one being built.
+ *  2. A FREE REQUEST HAS NO PAYMENT STEP. It comes back `pending_approval`
+ *     with `isFreeCheckout: false`, so the old "free means isFreeCheckout"
+ *     test alone would send it to a card form for a charge of nothing.
+ */
+const tier = (overrides: Partial<ITicket> = {}): ITicket =>
+  ({
+    id: "t-ga",
+    title: "General admission",
+    description: "",
+    price: 25,
+    quantity: 100,
+    order: 0,
+    sold: 0,
+    maxPerPerson: 4,
+    ...overrides,
+  }) as ITicket;
+
+const ga = tier();
+const vip = tier({ id: "t-vip", title: "Front row", requiresApproval: true });
+const backstage = tier({ id: "t-back", title: "Backstage", requiresApproval: true, price: 0 });
+const tiers = [ga, vip, backstage];
+
+describe("tierRequiresApproval / eventHasApprovalTiers", () => {
+  it("reads the flag, and treats its absence (an older API) as an ordinary tier", () => {
+    expect(tierRequiresApproval(vip)).toBe(true);
+    expect(tierRequiresApproval(ga)).toBe(false);
+    expect(tierRequiresApproval(undefined)).toBe(false);
+  });
+
+  it("finds an approval tier on the event even when the event-level flag did not come", () => {
+    expect(eventHasApprovalTiers({ tickets: [ga, vip] } as IEvent)).toBe(true);
+    expect(eventHasApprovalTiers({ tickets: [ga] } as IEvent)).toBe(false);
+    expect(eventHasApprovalTiers({ tickets: [], hasApprovalTiers: true } as unknown as IEvent)).toBe(true);
+    expect(eventHasApprovalTiers(undefined)).toBe(false);
+  });
+});
+
+describe("selectionMode / selectionRequiresApproval", () => {
+  it("is null while nothing is selected, so either kind is still addable", () => {
+    expect(selectionMode(tiers, {})).toBeNull();
+    expect(selectionMode(tiers, { "t-ga": 0 })).toBeNull();
+    expect(selectionRequiresApproval(tiers, {})).toBe(false);
+  });
+
+  it("is a request once an approval tier is in", () => {
+    expect(selectionMode(tiers, { "t-vip": 1 })).toBe("request");
+    expect(selectionRequiresApproval(tiers, { "t-vip": 2 })).toBe(true);
+  });
+
+  it("is a purchase once an ordinary tier is in", () => {
+    expect(selectionMode(tiers, { "t-ga": 1 })).toBe("purchase");
+    expect(selectionRequiresApproval(tiers, { "t-ga": 1 })).toBe(false);
+  });
+
+  it("reads a mixed selection as a request, the kind the server will refuse rather than silently sell", () => {
+    expect(selectionMode(tiers, { "t-ga": 1, "t-vip": 1 })).toBe("request");
+  });
+
+  it("ignores quantities for tiers the event no longer lists", () => {
+    expect(selectionMode(tiers, { "t-gone": 3 })).toBeNull();
+  });
+});
+
+describe("tierBlockedByApprovalMix: one order is a request or a purchase", () => {
+  it("blocks nothing on an empty selection", () => {
+    expect(tierBlockedByApprovalMix(ga, tiers, {})).toBe(false);
+    expect(tierBlockedByApprovalMix(vip, tiers, {})).toBe(false);
+  });
+
+  it("blocks an ordinary tier once an approval tier is selected, and the reverse", () => {
+    expect(tierBlockedByApprovalMix(ga, tiers, { "t-vip": 1 })).toBe(true);
+    expect(tierBlockedByApprovalMix(vip, tiers, { "t-ga": 1 })).toBe(true);
+  });
+
+  it("lets two approval tiers share a request, and two ordinary tiers share a purchase", () => {
+    expect(tierBlockedByApprovalMix(backstage, tiers, { "t-vip": 1 })).toBe(false);
+    expect(tierBlockedByApprovalMix(ga, tiers, { "t-ga": 1 })).toBe(false);
+  });
+
+  it("never blocks a tier that is already in the selection, so its own stepper keeps working", () => {
+    // If it were blocked, a fan holding one seat could not add a second, and
+    // the `+` would go dark on the very tier that set the mode.
+    expect(tierBlockedByApprovalMix(vip, tiers, { "t-vip": 1 })).toBe(false);
+    expect(tierBlockedByApprovalMix(ga, tiers, { "t-ga": 2 })).toBe(false);
+  });
+});
+
+describe("nextStepAfterTicketOrder: where the checkout goes once the order exists", () => {
+  it("completes a free purchase, exactly as before", () => {
+    expect(nextStepAfterTicketOrder({ isFreeCheckout: true, totalAmount: 0 })).toBe("complete");
+  });
+
+  it("REGRESSION: completes a FREE REQUEST, which is not a free checkout", () => {
+    // The server has already put it in `pending_approval` and minted nothing,
+    // so `isFreeCheckout` is false. There is no card to show.
+    expect(nextStepAfterTicketOrder({ isFreeCheckout: false, awaitingApproval: true, totalAmount: 0 })).toBe(
+      "complete",
+    );
+    // A bigint-ish string total, which is what some responses carry.
+    expect(nextStepAfterTicketOrder({ awaitingApproval: true, totalAmount: "0" })).toBe("complete");
+    expect(nextStepAfterTicketOrder({ awaitingApproval: true, totalAmount: null })).toBe("complete");
+  });
+
+  it("sends a PRICED request to payment, like any sale", () => {
+    // The card is authorised rather than charged, but the fan still has to
+    // present it; only start-payment's wording differs.
+    expect(nextStepAfterTicketOrder({ isFreeCheckout: false, awaitingApproval: true, totalAmount: 40 })).toBe(
+      "payment",
+    );
+    expect(nextStepAfterTicketOrder({ awaitingApproval: true, totalAmount: "12.50" })).toBe("payment");
+  });
+
+  it("sends an ordinary priced sale to payment, and never completes on a zero total alone", () => {
+    expect(nextStepAfterTicketOrder({ isFreeCheckout: false, totalAmount: 40 })).toBe("payment");
+    // A zero total without `isFreeCheckout` and without `awaitingApproval` is
+    // the old behaviour: the server did not say it was free, so start payment.
+    expect(nextStepAfterTicketOrder({ isFreeCheckout: false, totalAmount: 0 })).toBe("payment");
+    expect(nextStepAfterTicketOrder({})).toBe("payment");
+  });
+});

package/src/ui/headless/event/_tests/useEventCheckoutApproval.spec.tsx

@@ -0,0 +1,250 @@
+// @vitest-environment jsdom
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import axios, { type AxiosAdapter, type InternalAxiosRequestConfig } from "axios";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { ReactNode } from "react";
+import { ForgeClientProvider } from "../../../../provider/ForgeProvider";
+import { PublicAuthProvider } from "../../../../contexts/PublicAuthContext";
+import { CartProvider } from "../../../../contexts/CartContext";
+import { useEventCheckout } from "../useEventCheckout";
+
+/**
+ * Ticket requests (curated access, feature 3), end to end through the REAL
+ * hook with only the network faked.
+ *
+ * The case that matters most is the free request. The server answers it with
+ * `isFreeCheckout: false` (no passes were minted: the order is
+ * `pending_approval`) and `awaitingApproval: true`, so the branch that used to
+ * decide "free means done" would have sent the fan to a card form for a charge
+ * of nothing. The hook has to hand the order id to `onComplete` exactly as it
+ * does for a free purchase, and never call start-payment.
+ *
+ * Providers are real and the axios adapter is swapped, so the assertion is on
+ * what actually went over the wire.
+ */
+
+const PROFILE_ID = "profile-1";
+const SLUG = "summer-show";
+
+const event = {
+  id: "ev-1",
+  slug: SLUG,
+  title: "Summer show",
+  dateTime: "2026-12-01T19:00:00.000Z",
+  type: "in_person",
+  status: "published",
+  tickets: [
+    { id: "t-ga", title: "General admission", description: "", price: 25, quantity: 100, order: 0, sold: 0, maxPerPerson: 4 },
+    {
+      id: "t-vip",
+      title: "Front row",
+      description: "",
+      price: 0,
+      quantity: 10,
+      order: 1,
+      sold: 0,
+      maxPerPerson: 2,
+      requiresApproval: true,
+      approvalWindowHours: 72,
+    },
+    {
+      id: "t-priced",
+      title: "Backstage",
+      description: "",
+      price: 40,
+      quantity: 10,
+      order: 2,
+      sold: 0,
+      maxPerPerson: 2,
+      requiresApproval: true,
+      approvalWindowHours: null,
+    },
+  ],
+  media: [],
+  questionnaire: [],
+  bookingFee: null,
+};
+
+type Sent = { method: string; url: string; body: Record<string, unknown> };
+let sent: Sent[] = [];
+let realAdapter: AxiosAdapter | undefined;
+let orderResponse: Record<string, unknown> = {};
+
+function installAdapter() {
+  sent = [];
+  const adapter: AxiosAdapter = async (config: InternalAxiosRequestConfig) => {
+    const url = config.url ?? "";
+    const body = typeof config.data === "string" ? (JSON.parse(config.data) as Record<string, unknown>) : {};
+    sent.push({ method: (config.method ?? "get").toLowerCase(), url, body });
+    const ok = (data: unknown) => ({ data, status: 200, statusText: "OK", headers: {}, config }) as never;
+
+    if (url.includes(`/public/events/${SLUG}`)) return ok(event);
+    if (url.includes(`/public/events/${event.id}/orders`)) return ok(orderResponse);
+    if (url.includes(`/public/events/${event.id}/start-payment`)) {
+      return ok({
+        paymentSecret: "pi_secret",
+        paymentId: "pi_1",
+        paymentProvider: "stripe",
+        totalAmount: 40,
+        settlement: "deferred",
+        deferredStrategy: "authorization",
+      });
+    }
+    if (url.includes("/public/currencies")) {
+      return ok({ supportedCurrencies: ["USD"], userCurrency: "USD", exchangeRates: {} });
+    }
+    return ok({});
+  };
+  realAdapter = axios.defaults.adapter as AxiosAdapter | undefined;
+  axios.defaults.adapter = adapter;
+}
+
+const wrapper = ({ children }: { children: ReactNode }) => (
+  <QueryClientProvider client={new QueryClient({ defaultOptions: { queries: { retry: false }, mutations: { retry: false } } })}>
+    <ForgeClientProvider apiUrl="http://api.test" profileId={PROFILE_ID}>
+      <PublicAuthProvider>
+        <CartProvider>{children}</CartProvider>
+      </PublicAuthProvider>
+    </ForgeClientProvider>
+  </QueryClientProvider>
+);
+
+const mount = (onComplete?: (info: { slug: string; orderId: string }) => void) =>
+  renderHook(() => useEventCheckout(SLUG, { onComplete }), { wrapper });
+
+const fillDetails = (result: { current: ReturnType<typeof useEventCheckout> }) =>
+  act(() => {
+    result.current.setFirstName("Fan");
+    result.current.setLastName("Person");
+    result.current.setEmail("fan@example.com");
+  });
+
+beforeEach(() => {
+  localStorage.clear();
+  installAdapter();
+});
+
+afterEach(() => {
+  if (realAdapter) axios.defaults.adapter = realAdapter;
+  localStorage.clear();
+});
+
+describe("useEventCheckout: a ticket request", () => {
+  it("REGRESSION: a FREE request completes with the order id and never starts a payment", async () => {
+    orderResponse = {
+      orderId: "order-free-request",
+      isFreeCheckout: false,
+      awaitingApproval: true,
+      totalAmount: 0,
+      subTotal: 0,
+      discountAmount: 0,
+      feeAmount: 0,
+      requestExpiresAt: "2026-09-19T12:00:00.000Z",
+      holdExpiresAt: null,
+    };
+    const onComplete = vi.fn();
+    const { result } = mount(onComplete);
+    await waitFor(() => expect(result.current.event?.id).toBe("ev-1"));
+
+    act(() => result.current.setTicketQty("t-vip", 1));
+    expect(result.current.awaitingApproval).toBe(true);
+    expect(result.current.hasApprovalTiers).toBe(true);
+    await fillDetails(result);
+
+    await act(async () => {
+      await result.current.continueToPayment();
+    });
+
+    expect(onComplete).toHaveBeenCalledTimes(1);
+    expect(onComplete).toHaveBeenCalledWith({ slug: SLUG, orderId: "order-free-request" });
+    // The order was posted, the charge was not.
+    expect(sent.some((r) => r.method === "post" && r.url.includes("/orders"))).toBe(true);
+    expect(sent.some((r) => r.url.includes("/start-payment"))).toBe(false);
+    // Still on details: no payment step was entered for a charge of nothing.
+    expect(result.current.step).not.toBe("payment");
+    expect(result.current.requestExpiresAt).toBe("2026-09-19T12:00:00.000Z");
+  });
+
+  it("a PRICED request still goes to payment, and carries the deferred settlement through", async () => {
+    orderResponse = {
+      orderId: "order-priced-request",
+      isFreeCheckout: false,
+      awaitingApproval: true,
+      totalAmount: 40,
+      subTotal: 40,
+      discountAmount: 0,
+      feeAmount: 0,
+      requestExpiresAt: "2026-09-19T12:00:00.000Z",
+      holdExpiresAt: "2026-09-16T12:15:00.000Z",
+    };
+    const onComplete = vi.fn();
+    const { result } = mount(onComplete);
+    await waitFor(() => expect(result.current.event?.id).toBe("ev-1"));
+
+    act(() => result.current.setTicketQty("t-priced", 1));
+    await fillDetails(result);
+    await act(async () => {
+      await result.current.continueToPayment();
+    });
+
+    expect(onComplete).not.toHaveBeenCalled();
+    const start = sent.find((r) => r.url.includes("/start-payment"));
+    expect(start).toBeDefined();
+    expect(start?.body).toMatchObject({ orderId: "order-priced-request", profileId: PROFILE_ID });
+    await waitFor(() => expect(result.current.step).toBe("payment"));
+    expect(result.current.clientSecret).toBe("pi_secret");
+    // What the payment renderer reads to say "Authorize" and "a hold will show".
+    expect(result.current.settlement).toBe("deferred");
+    expect(result.current.deferredStrategy).toBe("authorization");
+  });
+
+  it("an ordinary free purchase completes exactly as it always did", async () => {
+    orderResponse = { orderId: "order-free", isFreeCheckout: true, totalAmount: 0, feeAmount: 0, holdExpiresAt: null };
+    const onComplete = vi.fn();
+    const { result } = mount(onComplete);
+    await waitFor(() => expect(result.current.event?.id).toBe("ev-1"));
+
+    act(() => result.current.setTicketQty("t-ga", 1));
+    expect(result.current.awaitingApproval).toBe(false);
+    await fillDetails(result);
+    await act(async () => {
+      await result.current.continueToPayment();
+    });
+
+    expect(onComplete).toHaveBeenCalledWith({ slug: SLUG, orderId: "order-free" });
+    expect(sent.some((r) => r.url.includes("/start-payment"))).toBe(false);
+  });
+
+  it("refuses to mix a request and a purchase in one selection", async () => {
+    const { result } = mount();
+    await waitFor(() => expect(result.current.event?.id).toBe("ev-1"));
+
+    act(() => result.current.setTicketQty("t-vip", 1));
+    expect(result.current.isTierBlockedByApprovalMix("t-ga")).toBe(true);
+    expect(result.current.isTierBlockedByApprovalMix("t-priced")).toBe(false);
+    // A host driving the hook from its own UI cannot build the cart either.
+    act(() => result.current.setTicketQty("t-ga", 1));
+    expect(result.current.selectedTickets).toEqual({ "t-vip": 1 });
+
+    // Clearing the request frees the ordinary tier again.
+    act(() => result.current.setTicketQty("t-vip", 0));
+    expect(result.current.isTierBlockedByApprovalMix("t-ga")).toBe(false);
+    act(() => result.current.setTicketQty("t-ga", 2));
+    expect(result.current.selectedTickets).toEqual({ "t-ga": 2 });
+    expect(result.current.isTierBlockedByApprovalMix("t-vip")).toBe(true);
+  });
+
+  it("does not send a request to the cart", async () => {
+    const { result } = mount();
+    await waitFor(() => expect(result.current.event?.id).toBe("ev-1"));
+
+    act(() => result.current.setTicketQty("t-vip", 1));
+    let added: boolean | undefined;
+    act(() => {
+      added = result.current.addTicketsToCart();
+    });
+    expect(added).toBe(false);
+    expect(result.current.ticketsInCart).toBe(false);
+  });
+});