@session-services/web-elements 0.1.28 → 0.1.31

package/dist/collection/components/session-services-ticketing/session-services-ticketing.test.js

@@ -1,6 +1,18 @@
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { SessionsTicketing } from "./session-services-ticketing";
 import { getTicketingState, selectionKey, } from "./session-services-ticketing.logic";
+const botDetection = vi.hoisted(() => ({
+    detectBot: vi.fn(() => ({ bot: false, signals: [] })),
+    isProductionApi: vi.fn((apiUrl) => apiUrl === "https://api.session.services"),
+}));
+const createClient = vi.hoisted(() => vi.fn(() => ({})));
+const createAnalytics = vi.hoisted(() => vi.fn(() => ({ page: vi.fn(), track: vi.fn() })));
+vi.mock("./bot-detection", () => botDetection);
+vi.mock("@session-services/sdk", () => ({ createClient }));
+vi.mock("@session-services/sdk/analytics", async (importOriginal) => ({
+    ...(await importOriginal()),
+    createAnalytics,
+}));
 vi.mock("@stencil/core", () => ({
     Component: () => () => undefined,
     Element: () => () => undefined,
@@ -129,6 +141,15 @@ function rendered(value, predicate) {
     const matches = predicate(value) ? [value] : [];
     return matches.concat(value.children.flatMap((item) => rendered(item, predicate)));
 }
+function textContent(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(textContent).join(" ");
+    if (!isRenderNode(value))
+        return "";
+    return textContent(value.children);
+}
 function hasClass(node, name) {
     return String(node.props.class ?? "")
         .split(/\s+/)
@@ -136,6 +157,7 @@ function hasClass(node, name) {
 }
 function widget() {
     const item = new SessionsTicketing();
+    item.apiUrl = "https://api.session.services";
     item.eventId = "evt_1";
     item.event = event();
     item.enableAnalytics = true;
@@ -146,20 +168,30 @@ function widget() {
     item.quote = null;
     item.previewQuote = null;
     item.quoteError = null;
+    item.checkoutError = null;
     item.couponError = null;
     item.appliedCouponCode = "";
     item.couponInput = "";
     item.couponCode = undefined;
     item.initialPreviewQuote = undefined;
     item.quoteLoading = false;
+    item.checkoutLoading = false;
     item.previewLoading = false;
     item.passcodeDenied = false;
     item.stickyCheckout = false;
+    item.tenantId = "tnt_1";
+    item.theme = "light";
     item.error = null;
+    item.errorKind = null;
+    item.initialLoading = false;
+    item.eventLoading = false;
     item.activePasscode = "";
+    item.passcodeInput = "";
+    item.passcodeLoading = false;
     item.cartUpdate = { emit: vi.fn() };
     item.checkoutInit = { emit: vi.fn() };
     item.errorOccurred = { emit: vi.fn() };
+    item.analyticsEventSkipped = { emit: vi.fn() };
     item.client = {
         event: {
             get: vi.fn(),
@@ -172,6 +204,91 @@ function widget() {
     return item;
 }
 describe("session-services-ticketing component", () => {
+    beforeEach(() => {
+        botDetection.detectBot.mockReset();
+        botDetection.detectBot.mockReturnValue({ bot: false, signals: [] });
+        botDetection.isProductionApi.mockReset();
+        botDetection.isProductionApi.mockImplementation((apiUrl) => apiUrl === "https://api.session.services");
+        createClient.mockReset();
+        createClient.mockReturnValue({});
+        createAnalytics.mockReset();
+        createAnalytics.mockReturnValue({ page: vi.fn(), track: vi.fn() });
+    });
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.unstubAllGlobals();
+    });
+    it("defers production API loading when automation is detected", async () => {
+        const item = widget();
+        const loadEventData = vi
+            .fn()
+            .mockResolvedValue({ status: "success", event: event() });
+        item.event = null;
+        item.loadEventData = loadEventData;
+        botDetection.detectBot.mockReturnValue({
+            bot: true,
+            signals: ["webdriver"],
+        });
+        await item.initializeComponent();
+        expect(createClient).not.toHaveBeenCalled();
+        expect(loadEventData).not.toHaveBeenCalled();
+        expect(item.verificationRequired).toBe(true);
+        expect(textContent(item.pendingView())).toContain("Let’s get your tickets");
+        expect(textContent(item.pendingView())).toContain("We just need you to confirm before we load the ticket options");
+        expect(textContent(item.pendingView())).toContain("Load tickets");
+        expect(hasClass(rendered(item.pendingView(), (node) => node.tag === "button")[0], "checkout-btn")).toBe(true);
+    });
+    it("loads the normal flow after the user continues", async () => {
+        const item = widget();
+        const loadEventData = vi
+            .fn()
+            .mockResolvedValue({ status: "success", event: event() });
+        item.event = null;
+        item.loadEventData = loadEventData;
+        botDetection.detectBot.mockReturnValue({
+            bot: true,
+            signals: ["webdriver"],
+        });
+        await item.initializeComponent();
+        const button = rendered(item.pendingView(), (node) => node.tag === "button")[0];
+        await button.props.onClick();
+        expect(botDetection.detectBot).toHaveBeenCalledOnce();
+        expect(createClient).toHaveBeenCalledWith({
+            environment: "https://api.session.services",
+            tenantId: "tnt_1",
+        });
+        expect(loadEventData).toHaveBeenCalledOnce();
+        expect(item.verificationRequired).toBe(false);
+        await item.initializeComponent();
+        expect(botDetection.detectBot).toHaveBeenCalledOnce();
+        expect(loadEventData).toHaveBeenCalledTimes(2);
+    });
+    it("bypasses detection outside the production API", async () => {
+        const item = widget();
+        const loadEventData = vi
+            .fn()
+            .mockResolvedValue({ status: "success", event: event() });
+        item.apiUrl = "https://j-api.dev.session.services";
+        item.event = null;
+        item.loadEventData = loadEventData;
+        await item.initializeComponent();
+        expect(botDetection.detectBot).not.toHaveBeenCalled();
+        expect(createClient).toHaveBeenCalledOnce();
+        expect(loadEventData).toHaveBeenCalledOnce();
+        expect(item.verificationRequired).toBe(false);
+    });
+    it("uses the checkout action style for recoverable load errors", () => {
+        const item = widget();
+        item.error = "Failed to load event data";
+        item.event = null;
+        item.loading = false;
+        const view = item.pendingView();
+        const button = rendered(view, (node) => node.tag === "button")[0];
+        expect(textContent(view)).toContain("Tickets didn’t load");
+        expect(textContent(view)).toContain("Something got in the way. Try again to load the ticket options.");
+        expect(textContent(button)).toBe("Try again");
+        expect(hasClass(button, "checkout-btn")).toBe(true);
+    });
     it("clears stale cart quotes when requoting fails", async () => {
         const item = widget();
         item.quote = quote();
@@ -182,6 +299,24 @@ describe("session-services-ticketing component", () => {
         expect(item.quoteError).toBe("Failed to update cart. Please try again.");
         expect(item.isCheckoutDisabled()).toBe(true);
     });
+    it("offers an explicit retry when a cart quote fails", async () => {
+        const item = widget();
+        item.selectedItems = new Map([[selectionKey("adm_general", null), 1]]);
+        item.client.event.get = vi.fn().mockResolvedValue({
+            event: item.event,
+        });
+        item.client.order.quote = vi
+            .fn()
+            .mockRejectedValueOnce(new Error("Down"))
+            .mockResolvedValueOnce({ quote: quote() });
+        await item.updateQuote();
+        const view = item.renderReadyState();
+        const retry = rendered(view, (node) => node.tag === "button" && textContent(node) === "Try again");
+        expect(retry).toHaveLength(1);
+        await retry[0].props.onClick();
+        expect(item.quote).not.toBeNull();
+        expect(item.quoteError).toBeNull();
+    });
     it("does not commit failed cart coupon applications", async () => {
         const item = widget();
         const current = quote();
@@ -189,15 +324,18 @@ describe("session-services-ticketing component", () => {
         item.appliedCouponCode = "SAVE10";
         item.couponInput = "bad";
         item.selectedItems = new Map([[selectionKey("adm_general", null), 1]]);
+        item.client.event.get = vi.fn().mockResolvedValue({
+            event: item.event,
+        });
         item.client.order.quote = vi
             .fn()
             .mockRejectedValue(new Error("Invalid coupon"));
         await item.applyCoupon();
         expect(item.appliedCouponCode).toBe("SAVE10");
-        expect(item.couponInput).toBe("BAD");
+        expect(item.couponInput).toBe("SAVE10");
         expect(item.quote).toBe(current);
         expect(item.couponError).toBe("Failed to apply coupon. Please check the code.");
-        expect(item.client.order.quote).toHaveBeenCalledWith(expect.objectContaining({ couponCode: "BAD" }));
+        expect(vi.mocked(item.client.order.quote).mock.calls[0][0]).toEqual(expect.objectContaining({ couponCode: "BAD" }));
     });
     it("does not commit preview coupons when event reload fails", async () => {
         const item = widget();
@@ -206,7 +344,7 @@ describe("session-services-ticketing component", () => {
         item.loadEventData = vi.fn().mockRejectedValue(new Error("Down"));
         await item.applyCoupon();
         expect(item.appliedCouponCode).toBe("SAVE10");
-        expect(item.couponInput).toBe("BAD");
+        expect(item.couponInput).toBe("SAVE10");
         expect(item.couponError).toBe("Failed to apply coupon. Please check the code.");
     });
     it("does not apply stale cart coupons as preview coupons", async () => {
@@ -219,24 +357,61 @@ describe("session-services-ticketing component", () => {
             .fn()
             .mockReturnValueOnce(firstLoad.promise)
             .mockReturnValueOnce(secondLoad.promise)
-            .mockResolvedValue(undefined);
+            .mockResolvedValue({
+            status: "success",
+            event: item.event,
+        });
         item.client.order.quote = vi.fn().mockResolvedValue({ quote: quote() });
         const stale = item.applyCoupon();
         await Promise.resolve();
-        expect(item.appliedCouponCode).toBe("OLD");
+        expect(item.appliedCouponCode).toBe("");
         item.couponInput = "new";
         const latest = item.applyCoupon();
         await Promise.resolve();
-        expect(item.appliedCouponCode).toBe("NEW");
-        item.selectedItems = new Map();
-        firstLoad.resolve();
+        expect(item.appliedCouponCode).toBe("");
+        firstLoad.resolve({
+            status: "success",
+            event: item.event,
+        });
         await stale;
-        expect(item.appliedCouponCode).toBe("NEW");
-        expect(item.client.order.quote).not.toHaveBeenCalledWith(expect.objectContaining({ couponCode: "OLD" }));
-        secondLoad.resolve();
+        expect(item.appliedCouponCode).toBe("");
+        expect(vi
+            .mocked(item.client.order.quote)
+            .mock.calls.every(([input]) => input.couponCode !== "OLD")).toBe(true);
+        secondLoad.resolve({
+            status: "success",
+            event: item.event,
+        });
         await latest;
         expect(item.appliedCouponCode).toBe("NEW");
     });
+    it("fetches exactly one cart quote when applying a coupon", async () => {
+        const item = widget();
+        item.couponInput = "save10";
+        item.selectedItems = new Map([[selectionKey("adm_general", null), 2]]);
+        item.client.event.get = vi.fn().mockResolvedValue({
+            event: item.event,
+        });
+        item.client.order.quote = vi.fn().mockResolvedValue({ quote: quote() });
+        await item.applyCoupon();
+        expect(item.client.order.quote).toHaveBeenCalledOnce();
+        expect(vi.mocked(item.client.order.quote).mock.calls[0][0]).toEqual(expect.objectContaining({
+            couponCode: "SAVE10",
+            items: [expect.objectContaining({ quantity: 2 })],
+        }));
+    });
+    it("fetches exactly one preview quote when applying a coupon", async () => {
+        const item = widget();
+        item.couponInput = "save10";
+        item.selectedItems = new Map();
+        item.client.event.get = vi.fn().mockResolvedValue({
+            event: item.event,
+        });
+        item.client.order.quote = vi.fn().mockResolvedValue({ quote: quote() });
+        await item.applyCoupon();
+        expect(item.client.order.quote).toHaveBeenCalledOnce();
+        expect(vi.mocked(item.client.order.quote).mock.calls[0][0]).toEqual(expect.objectContaining({ couponCode: "SAVE10" }));
+    });
     it("keeps preview quote loading separate from cart quote loading", async () => {
         const item = widget();
         const next = deferred();
@@ -321,6 +496,12 @@ describe("session-services-ticketing component", () => {
         expect(increments).toHaveLength(1);
         expect(checkout).toHaveLength(1);
     });
+    it("does not add a redundant tab stop to admission cards", () => {
+        const item = widget();
+        const cards = rendered(item.renderReadyState(), (node) => node.props["data-testid"] === "event-admission-card");
+        expect(cards).toHaveLength(1);
+        expect(cards[0].props.tabindex).toBeUndefined();
+    });
     it("renders external ticketing in the sticky checkout bar", () => {
         const item = widget();
         item.event = event({ url: "https://tickets.example" });
@@ -357,10 +538,16 @@ describe("session-services-ticketing component", () => {
         const links = rendered(item.renderReadyState(), (node) => node.tag === "a");
         const inline = links.find((link) => hasClass(link, "inline-external-ticket-button"));
         const sticky = links.find((link) => hasClass(link, "sticky-checkout-btn"));
-        expect(typeof inline?.props.onClick).toBe("function");
-        expect(typeof sticky?.props.onClick).toBe("function");
-        (inline?.props.onClick)();
-        (sticky?.props.onClick)();
+        const inlineClick = inline?.props.onClick;
+        const stickyClick = sticky?.props.onClick;
+        expect(typeof inlineClick).toBe("function");
+        expect(typeof stickyClick).toBe("function");
+        if (typeof inlineClick !== "function" ||
+            typeof stickyClick !== "function") {
+            throw new Error("Expected both external ticket links to be clickable");
+        }
+        inlineClick();
+        stickyClick();
         expect(track).toHaveBeenCalledWith("Checkout Started", expect.objectContaining({
             event_id: "evt_1",
             team_id: "team_1",
@@ -377,22 +564,116 @@ describe("session-services-ticketing component", () => {
             cta_surface: "sticky",
         }));
     });
+    it("tracks page, product, and product list views after event load", () => {
+        const item = widget();
+        const page = vi.fn();
+        const track = vi.fn();
+        item.analytics = { page, track };
+        item.trackLoadedEvent(item.event);
+        expect(page).toHaveBeenCalledWith("Ticketing Widget", expect.objectContaining({
+            event_id: "evt_1",
+            team_id: "team_1",
+            promoter_id: "pro_1",
+            event_name: "Test Event",
+            event_slug: "event",
+        }));
+        expect(track).toHaveBeenCalledWith("Product Viewed", expect.objectContaining({
+            event_id: "evt_1",
+            product_id: "evt_1",
+            value: 22,
+            price: 22,
+            currency: "AUD",
+        }));
+        expect(track).toHaveBeenCalledWith("Product List Viewed", expect.objectContaining({
+            list_id: "evt_1",
+            products: [
+                expect.objectContaining({
+                    admission_id: "adm_general",
+                    price: 22,
+                    price_base: 2000,
+                    price_booking_fee: 200,
+                }),
+            ],
+        }));
+        expect(item.analyticsEventSkipped.emit).not.toHaveBeenCalled();
+    });
+    it("uses currency minor units for ticketing widget analytics", () => {
+        const item = widget();
+        const track = vi.fn();
+        item.analytics = { page: vi.fn(), track };
+        item.event = event({
+            currency: "JPY",
+            admissions: [
+                admission({
+                    price: {
+                        base: 2200,
+                        booking: 0,
+                        currency: "JPY",
+                    },
+                }),
+            ],
+        });
+        item.trackLoadedEvent(item.event);
+        expect(track).toHaveBeenCalledWith("Product Viewed", expect.objectContaining({
+            value: 2200,
+            price: 2200,
+            currency: "JPY",
+        }));
+        expect(track).toHaveBeenCalledWith("Product List Viewed", expect.objectContaining({
+            products: [
+                expect.objectContaining({
+                    price: 2200,
+                    price_base: 2200,
+                    price_booking_fee: 0,
+                }),
+            ],
+        }));
+    });
+    it("emits an analytics diagnostic when event identity is incomplete", () => {
+        const item = widget();
+        const page = vi.fn();
+        const track = vi.fn();
+        item.analytics = { page, track };
+        const missingTeam = event({ teamId: "" });
+        item.event = missingTeam;
+        item.trackLoadedEvent(missingTeam);
+        expect(page).not.toHaveBeenCalled();
+        expect(track).not.toHaveBeenCalled();
+        expect(item.analyticsEventSkipped.emit).toHaveBeenCalledWith({
+            eventType: "Page Viewed",
+            eventId: "evt_1",
+            reason: "missing_team_id",
+            promoterId: "pro_1",
+            teamId: undefined,
+        });
+    });
     it("tracks hosted checkout starts with the created order id", async () => {
         const item = widget();
         const track = vi.fn();
         item.analytics = { track };
-        item.quote = quote();
         item.selectedItems = new Map([[selectionKey("adm_general", null), 1]]);
+        item.client.order.quote = vi.fn().mockResolvedValue({ quote: quote() });
         item.client.order.create = vi.fn().mockResolvedValue({
             order: {
                 checkoutUrl: "https://checkout.example/ord_1",
                 id: "ord_1",
             },
         });
+        await item.updateQuote();
         await item.initiateCheckout();
         expect(track).toHaveBeenCalledWith("Checkout Started", expect.objectContaining({
             order_id: "ord_1",
             value: 22,
+            revenue: 22,
+            currency: "AUD",
+            products: [
+                expect.objectContaining({
+                    admission_id: "adm_general",
+                    price: 22,
+                    price_base: 2000,
+                    price_booking_fee: 200,
+                }),
+            ],
         }));
     });
     it("scrolls to the ticket selector with a 100px top offset", () => {
@@ -407,13 +688,29 @@ describe("session-services-ticketing component", () => {
             },
             getBoundingClientRect: () => ({ top: 900 }),
         };
-        vi.stubGlobal("window", { scrollY: 250, scrollTo });
-        item.handleStickyCheckoutClick(getTicketingState(item.event));
+        vi.stubGlobal("window", {
+            matchMedia: vi.fn().mockReturnValue({ matches: false }),
+            scrollY: 250,
+            scrollTo,
+        });
+        item.handleStickyCheckoutClick(getTicketingState(event()));
         expect(scrollTo).toHaveBeenCalledWith({
             behavior: "smooth",
             top: 570,
         });
-        vi.unstubAllGlobals();
+    });
+    it("shows only the placeholder name for secret event locations", () => {
+        const item = widget();
+        const node = item.renderEventLocation(event({
+            locationRevealAt: futureStart,
+            location: {
+                ...event().location,
+                name: "Secret location",
+            },
+        }), "admission-venue");
+        expect(node.children).toHaveLength(2);
+        expect(node.children).toContain("Secret location");
+        expect(textContent(node)).not.toContain("Address revealed");
     });
     it("classifies only passcode access failures as passcode errors", async () => {
         const item = widget();
@@ -430,4 +727,298 @@ describe("session-services-ticketing component", () => {
         await item.loadEventData();
         expect(item.passcodeDenied).toBe(true);
     });
+    it("starts initial loading without delaying the first render", () => {
+        const item = widget();
+        const initialize = vi.fn().mockResolvedValue(undefined);
+        item.event = null;
+        item.initialLoading = true;
+        item.loading = true;
+        item.initializeComponent = initialize;
+        expect(item.componentWillLoad()).toBeUndefined();
+        expect(initialize).toHaveBeenCalledOnce();
+        const view = item.pendingView();
+        const status = rendered(view, (node) => node.props.role === "status");
+        expect(status).toHaveLength(1);
+        expect(status[0].props["aria-live"]).toBe("polite");
+        expect(rendered(view, (node) => hasClass(node, "loading-admission"))).toHaveLength(3);
+    });
+    it("keeps ticket content mounted during a background event refresh", () => {
+        const item = widget();
+        item.initialLoading = false;
+        item.loading = false;
+        item.eventLoading = true;
+        const view = item.render();
+        expect(rendered(view, (node) => node.props["data-testid"] === "event-admission-card")).toHaveLength(1);
+        expect(rendered(view, (node) => hasClass(node, "loading-admission"))).toHaveLength(0);
+        expect(rendered(view, (node) => node.props["aria-busy"] === "true")).not.toHaveLength(0);
+    });
+    it("ignores an event response after a newer event load wins", async () => {
+        const item = widget();
+        const first = deferred();
+        const second = deferred();
+        const firstEvent = event({ id: "evt_first", slug: "first" });
+        const secondEvent = event({ id: "evt_second", slug: "second" });
+        item.event = null;
+        item.initialLoading = false;
+        item.loading = false;
+        item.client.event.get = vi
+            .fn()
+            .mockReturnValueOnce(first.promise)
+            .mockReturnValueOnce(second.promise);
+        item.eventId = firstEvent.id;
+        const stale = item.loadEventData();
+        item.eventId = secondEvent.id;
+        const latest = item.loadEventData();
+        second.resolve({ event: secondEvent });
+        await latest;
+        first.resolve({ event: firstEvent });
+        await stale;
+        expect(item.event?.id).toBe(secondEvent.id);
+        expect(item.eventId).toBe(secondEvent.id);
+    });
+    it("does not commit an event response after disconnection", async () => {
+        const item = widget();
+        const response = deferred();
+        item.event = null;
+        item.initialLoading = false;
+        item.loading = false;
+        item.client.event.get = vi.fn().mockReturnValue(response.promise);
+        vi.stubGlobal("document", { removeEventListener: vi.fn() });
+        const pending = item.loadEventData();
+        item.disconnectedCallback();
+        response.resolve({ event: event() });
+        await pending;
+        expect(item.event).toBeNull();
+        vi.unstubAllGlobals();
+    });
+    it("invalidates an active quote as soon as its selection changes", async () => {
+        vi.useFakeTimers();
+        const item = widget();
+        const stale = deferred();
+        item.selectedItems = new Map([[selectionKey("adm_general", null), 1]]);
+        item.client.order.quote = vi.fn().mockReturnValue(stale.promise);
+        const pending = item.updateQuote();
+        await Promise.resolve();
+        await item.updateQuantity("adm_general", null, -1);
+        stale.resolve({ quote: quote() });
+        await pending;
+        expect(item.selectedItems.size).toBe(0);
+        expect(item.quote).toBeNull();
+        expect(item.isCheckoutDisabled()).toBe(true);
+        vi.clearAllTimers();
+        vi.useRealTimers();
+    });
+    it("rolls back a coupon removal when the replacement quote fails", async () => {
+        const item = widget();
+        const currentEvent = item.event;
+        const currentQuote = quote();
+        item.appliedCouponCode = "SAVE10";
+        item.couponInput = "SAVE10";
+        item.quote = currentQuote;
+        item.selectedItems = new Map([[selectionKey("adm_general", null), 1]]);
+        item.client.event.get = vi.fn().mockResolvedValue({ event: currentEvent });
+        item.client.order.quote = vi.fn().mockRejectedValue(new Error("Down"));
+        await item.removeCoupon();
+        expect(item.appliedCouponCode).toBe("SAVE10");
+        expect(item.couponInput).toBe("SAVE10");
+        expect(item.event).toBe(currentEvent);
+        expect(item.quote).toBe(currentQuote);
+        expect(item.couponError).toContain("remove coupon");
+    });
+    it("keeps a valid quote retryable after checkout creation fails", async () => {
+        const item = widget();
+        item.selectedItems = new Map([[selectionKey("adm_general", null), 1]]);
+        item.client.order.quote = vi.fn().mockResolvedValue({ quote: quote() });
+        item.client.order.create = vi.fn().mockRejectedValue(new Error("Down"));
+        await item.updateQuote();
+        await item.initiateCheckout();
+        await item.initiateCheckout();
+        expect(item.quote).not.toBeNull();
+        expect(item.quoteError).toBeNull();
+        expect(item.checkoutError?.toLowerCase()).toContain("checkout");
+        expect(item.isCheckoutDisabled()).toBe(false);
+        const checkout = rendered(item.renderReadyState(), (node) => node.props["data-testid"] === "event-checkout-cta-desktop")[0];
+        expect(checkout.props.disabled).toBe(false);
+        const calls = vi.mocked(item.client.order.create).mock.calls;
+        expect(calls).toHaveLength(2);
+        const firstRequest = calls[0]?.[0];
+        if (typeof firstRequest !== "object" ||
+            firstRequest === null ||
+            !("idempotencyKey" in firstRequest) ||
+            typeof firstRequest.idempotencyKey !== "string") {
+            throw new Error("Expected the first checkout request to have a key");
+        }
+        const idempotencyKey = firstRequest.idempotencyKey;
+        expect(calls[0]?.[0]).toEqual(expect.objectContaining({ idempotencyKey: expect.any(String) }));
+        expect(calls[1]?.[0]).toEqual(expect.objectContaining({
+            idempotencyKey,
+        }));
+    });
+    it("blocks quantity changes while order creation is pending", async () => {
+        const item = widget();
+        const pending = deferred();
+        item.selectedItems = new Map([[selectionKey("adm_general", null), 1]]);
+        item.client.order.quote = vi.fn().mockResolvedValue({ quote: quote() });
+        item.client.order.create = vi.fn().mockReturnValue(pending.promise);
+        await item.updateQuote();
+        const checkout = item.initiateCheckout();
+        await vi.waitFor(() => {
+            expect(item.client.order.create).toHaveBeenCalledOnce();
+        });
+        await item.updateQuantity("adm_general", null, 1);
+        expect(item.selectedItems.get(selectionKey("adm_general", null))).toBe(1);
+        pending.resolve({ order: { id: "ord_1" } });
+        await checkout;
+    });
+    it("closes the modal when a refreshed event removes its admission", () => {
+        const item = widget();
+        item.openModalAdmissionId = "adm_removed";
+        item.pruneSelectedItems(event());
+        expect(item.openModalAdmissionId).toBeNull();
+    });
+    it("keeps refresh feedback visible when its retry fails", async () => {
+        const item = widget();
+        item.client.event.get = vi.fn().mockRejectedValue(new Error("Still down"));
+        await item.retryEventLoad();
+        expect(item.refreshError).toBe("Still down");
+        expect(item.error).toBeNull();
+    });
+    it("shows the applied coupon consistently until it is removed", () => {
+        const item = widget();
+        item.appliedCouponCode = "SAVE10";
+        item.couponInput = "BAD";
+        const input = rendered(item.renderReadyState(), (node) => node.tag === "input" && node.props["aria-label"] === "Coupon code")[0];
+        expect(input.props.value).toBe("SAVE10");
+        expect(input.props.disabled || input.props.readonly).toBe(true);
+    });
+    it("renders configuration failures without an unusable retry action", async () => {
+        const item = widget();
+        item.event = null;
+        item.tenantId = "";
+        await item.initializeComponent();
+        const view = item.pendingView();
+        expect(item.errorKind).toBe("configuration");
+        expect(textContent(view).toLowerCase()).toMatch(/configur|set ?up/);
+        expect(rendered(view, (node) => node.tag === "button")).toHaveLength(0);
+    });
+    it("renders not found separately from retryable load failures", async () => {
+        const item = widget();
+        item.event = null;
+        item.initialLoading = false;
+        item.loading = false;
+        item.client.event.get = vi.fn().mockRejectedValue(Object.assign(new Error("Missing"), {
+            code: "NOT_FOUND",
+        }));
+        await item.loadEventData();
+        const view = item.pendingView();
+        expect(item.errorKind).toBe("not_found");
+        expect(textContent(view)).toContain("Event not found");
+        expect(rendered(view, (node) => node.tag === "button")).toHaveLength(0);
+    });
+    it("announces transient load failures and keeps retry available", async () => {
+        const item = widget();
+        item.event = null;
+        item.initialLoading = false;
+        item.loading = false;
+        item.client.event.get = vi.fn().mockRejectedValue(new Error("Down"));
+        await item.loadEventData();
+        const view = item.pendingView();
+        const alert = rendered(view, (node) => node.props.role === "alert");
+        const retry = rendered(view, (node) => node.tag === "button" && textContent(node) === "Try again");
+        expect(item.errorKind).toBe("transient");
+        expect(alert).toHaveLength(1);
+        expect(alert[0].props["aria-live"]).toBe("assertive");
+        expect(retry).toHaveLength(1);
+        expect(hasClass(retry[0], "checkout-btn")).toBe(true);
+    });
+    it("keeps passcode feedback associated with the mounted form", () => {
+        const item = widget();
+        item.event = null;
+        item.initialLoading = false;
+        item.loading = false;
+        item.error = "Incorrect passcode";
+        item.errorKind = "access";
+        item.passcodeDenied = true;
+        item.activePasscode = "wrong";
+        item.passcodeInput = "wrong";
+        item.passcodeLoading = true;
+        const view = item.pendingView();
+        const input = rendered(view, (node) => node.tag === "input" && node.props.name === "passcode")[0];
+        const button = rendered(view, (node) => node.tag === "button" && node.props.type === "submit")[0];
+        const feedback = rendered(view, (node) => node.props.id === input.props["aria-describedby"])[0];
+        expect(input.props["aria-invalid"]).toBe(true);
+        expect(input.props["aria-describedby"]).toBeTruthy();
+        expect(feedback.props.role).toBe("alert");
+        expect(textContent(button)).toContain("Unlocking");
+    });
+    it("describes ticket detail dialogs with their visible content", () => {
+        const item = widget();
+        item.event = event({
+            admissions: [admission({ description: "Includes balcony access." })],
+        });
+        item.openModalAdmissionId = "adm_general";
+        const view = item.renderReadyState();
+        const dialog = rendered(view, (node) => node.props.role === "dialog")[0];
+        const description = rendered(view, (node) => node.props.id === dialog.props["aria-describedby"])[0];
+        expect(dialog.props["aria-modal"]).toBe("true");
+        expect(dialog.props["aria-describedby"]).toBeTruthy();
+        expect(textContent(description)).toContain("Includes balcony access.");
+    });
+    it("renders door-only sticky messaging as information, not a button", () => {
+        const item = widget();
+        item.stickyCheckout = true;
+        item.event = event({
+            admissions: [
+                admission({
+                    id: "adm_door",
+                    saleEndsAt: pastStart,
+                    saleEndsBehavior: "DOOR",
+                }),
+            ],
+        });
+        const view = item.renderReadyState();
+        const sticky = rendered(view, (node) => hasClass(node, "sticky-checkout-bar"));
+        expect(sticky).toHaveLength(1);
+        expect(textContent(sticky[0]).toLowerCase()).toContain("at the door");
+        expect(rendered(sticky[0], (node) => node.tag === "button")).toHaveLength(0);
+    });
+    it("recreates analytics for a new client without replaying a refresh view", async () => {
+        const item = widget();
+        const firstAnalytics = { page: vi.fn(), track: vi.fn() };
+        const secondAnalytics = { page: vi.fn(), track: vi.fn() };
+        const firstClient = {
+            event: { get: vi.fn().mockResolvedValue({ event: event() }) },
+            order: {
+                create: vi.fn(),
+                quote: vi.fn().mockResolvedValue({ quote: quote() }),
+            },
+        };
+        const secondEvent = event({ id: "evt_2", slug: "event-2" });
+        const secondClient = {
+            event: { get: vi.fn().mockResolvedValue({ event: secondEvent }) },
+            order: {
+                create: vi.fn(),
+                quote: vi.fn().mockResolvedValue({ quote: quote() }),
+            },
+        };
+        createClient
+            .mockReturnValueOnce(firstClient)
+            .mockReturnValueOnce(secondClient);
+        createAnalytics
+            .mockReturnValueOnce(firstAnalytics)
+            .mockReturnValueOnce(secondAnalytics);
+        item.event = null;
+        item.initialLoading = true;
+        item.loading = true;
+        await item.initializeComponent();
+        await item.loadEventData();
+        expect(firstAnalytics.page).toHaveBeenCalledOnce();
+        item.tenantId = "tnt_2";
+        item.eventId = secondEvent.id;
+        await item.initializeComponent();
+        expect(createAnalytics).toHaveBeenCalledTimes(2);
+        expect(createAnalytics).toHaveBeenNthCalledWith(1, expect.objectContaining({ client: firstClient }));
+        expect(createAnalytics).toHaveBeenNthCalledWith(2, expect.objectContaining({ client: secondClient }));
+        expect(secondAnalytics.page).toHaveBeenCalledOnce();
+    });
 });