@code-collective/booking-widget 1.0.10 → 1.0.12

package/src/lib/CartExpiryGuard.test.ts

@@ -1,331 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { cleanup, render, screen } from '@testing-library/svelte';
-import CartExpiryGuard from './CartExpiryGuard.svelte';
-import { postMessage, postedTypes, posted, resetMessages } from './test/messages-mock';
-import { apiError, buildCart, CART_TOKEN, fakeApi, fakeCartManager, settle } from './test/fixtures';
-import { EXPIRY_WARNING_MS, EXTENSION_ENABLED } from './cart-expiry';
-import { recallPaymentAttempt, rememberPaymentAttempt } from './payment-attempt';
-
-vi.mock('./messages', async () => await import('./test/messages-mock'));
-
-// The guard owns the whole "one clock" experience on the client: the still-there prompt, the extend, and the
-// server-confirmed expiry. Time is faked so a 20-minute cart can be walked to its deadline in a test, and the
-// server is a fake BookingApi whose answers each scenario sets.
-
-const MINUTE = 60_000;
-
-// The prompt is switched off in production for now (EXTENSION_ENABLED in cart-expiry.ts); these tests turn it
-// on explicitly so the extension path stays covered for the day it is turned back on. The "deadline passing"
-// tests below run with it on too - the expiry behaviour must be identical either way - and one test checks
-// the default.
-function mount(cart = buildCart(EXPIRY_WARNING_MS + MINUTE), extensionEnabled = true) {
-  const api = fakeApi(cart);
-  const cartManager = fakeCartManager();
-  render(CartExpiryGuard, { props: { api, cartManager, extensionEnabled } });
-  return { api, cartManager, cart };
-}
-
-async function advance(ms: number) {
-  await vi.advanceTimersByTimeAsync(ms);
-  await settle();
-}
-
-beforeEach(() => {
-  vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'Date'] });
-  vi.setSystemTime(new Date('2026-09-12T10:00:00Z'));
-  resetMessages();
-  sessionStorage.clear();
-});
-
-afterEach(() => {
-  cleanup();
-  vi.useRealTimers();
-});
-
-describe('with the extension switched off (the current default)', () => {
-  it('never shows the prompt - the shopper just sees the cart expire at 0:00', async () => {
-    // Mounted with the production default (EXTENSION_ENABLED, currently false), not this file's opt-in.
-    expect(EXTENSION_ENABLED).toBe(false);
-    const { api } = mount(buildCart(EXPIRY_WARNING_MS - 1000), EXTENSION_ENABLED);
-    await settle();
-    await advance(1000);
-    expect(screen.queryByText('Are you still there?')).toBeNull();
-
-    api.getCart = vi.fn().mockRejectedValue(apiError(401));
-    await advance(EXPIRY_WARNING_MS);
-
-    expect(screen.queryByText('Are you still there?')).toBeNull();
-    expect(screen.getByText('Your cart has expired')).toBeTruthy();
-    expect(api.extendCart).not.toHaveBeenCalled();
-  });
-});
-
-describe('the still-there prompt', () => {
-  it('appears once the deadline is within the warning window', async () => {
-    mount();
-    await settle();
-    expect(screen.queryByText('Are you still there?')).toBeNull();
-
-    await advance(MINUTE + 1000);
-
-    expect(screen.getByText('Are you still there?')).toBeTruthy();
-    expect(screen.getByRole('button', { name: "Yes, I'm still here" })).toBeTruthy();
-  });
-
-  it('is still shown while a Peach checkout is open - the clock keeps running on the card form', async () => {
-    mount();
-    await settle();
-    postMessage({ type: 'payment:started' });
-
-    await advance(MINUTE + 1000);
-
-    expect(screen.getByText('Are you still there?')).toBeTruthy();
-    expect(screen.getByRole('button', { name: "Yes, I'm still here" })).toBeTruthy();
-  });
-
-  it('Yes extends the cart and tells every other reader about the new deadline', async () => {
-    const { api } = mount();
-    await settle();
-    await advance(MINUTE + 1000);
-    const extended = buildCart(15 * MINUTE);
-    api.extendCart = vi.fn().mockResolvedValue(extended);
-
-    screen.getByRole('button', { name: "Yes, I'm still here" }).click();
-    await settle();
-
-    expect(api.extendCart).toHaveBeenCalledTimes(1);
-    expect(screen.queryByText('Are you still there?')).toBeNull();
-    expect(posted.at(-1)).toEqual({ type: 'cart:updated', cart: extended });
-  });
-
-  it('a refused hold extension (deadline comes back unmoved) just closes the prompt and leaves the clock', async () => {
-    const { api, cart } = mount();
-    await settle();
-    await advance(MINUTE + 1000);
-    api.extendCart = vi.fn().mockResolvedValue({ ...cart });
-
-    screen.getByRole('button', { name: "Yes, I'm still here" }).click();
-    await settle();
-
-    expect(screen.queryByText('Are you still there?')).toBeNull();
-    expect(screen.queryByText(/can't be held any longer/)).toBeNull();
-    // Not re-shown for the same deadline on the next tick.
-    await advance(5000);
-    expect(screen.queryByText('Are you still there?')).toBeNull();
-    // The clock is untouched: at the original deadline the guard asks the server, and expires on its 401.
-    api.getCart = vi.fn().mockRejectedValue(apiError(401));
-    await advance(EXPIRY_WARNING_MS);
-    expect(screen.getByText('Your cart has expired')).toBeTruthy();
-  });
-
-  it('only warns, without a Yes, once the cart is at its absolute ceiling', async () => {
-    mount(buildCart(2 * MINUTE, { ceilingMsFromNow: 2 * MINUTE }));
-    await settle();
-    await advance(1000);
-
-    expect(screen.getByText(/can't be held any longer/)).toBeTruthy();
-    expect(screen.queryByRole('button', { name: "Yes, I'm still here" })).toBeNull();
-  });
-});
-
-describe('the deadline passing', () => {
-  it('asks the server and shows the cart as expired on its 401, clearing the cart everywhere', async () => {
-    const { api, cartManager } = mount(buildCart(2000));
-    await settle();
-    api.getCart = vi.fn().mockRejectedValue(apiError(401));
-
-    await advance(3000);
-
-    expect(screen.getByText('Your cart has expired')).toBeTruthy();
-    expect(cartManager.reset).toHaveBeenCalledTimes(1);
-    // cart:expired is the more specific signal, posted right before the general cart:updated/null every
-    // other reader already listens for.
-    expect(postedTypes().slice(-2)).toEqual(['cart:expired', 'cart:updated']);
-    expect(posted.at(-1)).toEqual({ type: 'cart:updated', cart: null });
-  });
-
-  it('keeps a cart the server still reports live - the browser clock only decides when to ask', async () => {
-    const { api, cartManager } = mount(buildCart(2000));
-    await settle();
-    const stillLive = buildCart(2000);
-    api.getCart = vi.fn().mockResolvedValue(stillLive);
-
-    await advance(3000);
-
-    expect(screen.queryByText('Your cart has expired')).toBeNull();
-    expect(cartManager.reset).not.toHaveBeenCalled();
-    expect(posted.at(-1)).toEqual({ type: 'cart:updated', cart: stillLive });
-    // Exactly one read, then a 30s recheck - not a tight loop. Re-reading the cart hands the watcher a fresh
-    // Date for the same past deadline, and a watcher that fired once per effect run rather than once per
-    // deadline re-fired straight away, asking again, and again (CartExpiryWatcher's firedFor).
-    expect(api.getCart).toHaveBeenCalledTimes(1);
-    // The recheck was scheduled at T-0, one second into the advance above.
-    await advance(28_000);
-    expect(api.getCart).toHaveBeenCalledTimes(1);
-    await advance(2000);
-    expect(api.getCart).toHaveBeenCalledTimes(2);
-  });
-
-  it('with a payment in flight, asks the server first and hands a deadline it still reports as past to CheckoutModal', async () => {
-    const { api } = mount(buildCart(2000));
-    await settle();
-    postMessage({ type: 'payment:started' });
-    api.getCart = vi.fn().mockResolvedValue(buildCart(-1000));
-
-    await advance(3000);
-
-    // One ask, one hand-over - even though the cart read back carries a (still past) deadline the watcher had
-    // not fired for yet.
-    expect(api.getCart).toHaveBeenCalledTimes(1);
-    expect(postedTypes().filter((type) => type === 'payment:timed-out')).toHaveLength(1);
-    expect(postedTypes()).toContain('payment:timed-out');
-    expect(screen.queryByText('Your cart has expired')).toBeNull();
-  });
-
-  it('with a payment in flight, keeps a cart the server reports on a later deadline rather than tearing the attempt down', async () => {
-    // Another tab answered the prompt, or the server pushed the clock out to the payment floor when the
-    // attempt began and this guard never heard - either way the browser's deadline was stale, and acting on
-    // it would have destroyed a card form the shopper may be mid-way through.
-    const { api } = mount(buildCart(2000));
-    await settle();
-    postMessage({ type: 'payment:started' });
-    const movedOut = buildCart(5 * MINUTE);
-    api.getCart = vi.fn().mockResolvedValue(movedOut);
-
-    await advance(3000);
-
-    expect(postedTypes()).not.toContain('payment:timed-out');
-    expect(api.abandonPayment).not.toHaveBeenCalled();
-    expect(posted.at(-1)).toEqual({ type: 'cart:updated', cart: movedOut });
-    // The watcher re-armed on the later deadline and asks again there; this time the server agrees.
-    await advance(5 * MINUTE);
-    expect(api.getCart).toHaveBeenCalledTimes(2);
-    expect(postedTypes()).toContain('payment:timed-out');
-  });
-
-  it('with a payment in flight, a read that fails is no grounds to tear the attempt down - it asks again', async () => {
-    const { api } = mount(buildCart(2000));
-    await settle();
-    postMessage({ type: 'payment:started' });
-    api.getCart = vi.fn().mockRejectedValueOnce(apiError(500)).mockResolvedValue(buildCart(-1000));
-
-    await advance(3000);
-    expect(postedTypes()).not.toContain('payment:timed-out');
-
-    await advance(30_000);
-    expect(api.getCart).toHaveBeenCalledTimes(2);
-    expect(postedTypes()).toContain('payment:timed-out');
-  });
-
-  it('after the attempt is torn down, payment:ended brings it back to confirm the expiry', async () => {
-    const { api } = mount(buildCart(2000));
-    await settle();
-    postMessage({ type: 'payment:started' });
-    await advance(3000);
-    api.getCart = vi.fn().mockRejectedValue(apiError(401));
-
-    postMessage({ type: 'payment:ended' });
-    await settle();
-
-    expect(screen.getByText('Your cart has expired')).toBeTruthy();
-  });
-
-  it('with no checkout modal open to answer payment:timed-out, the guard abandons the attempt itself', async () => {
-    // After a reload the guard knows of the attempt from sessionStorage alone; nothing else would ever tear
-    // it down, so the cart would sit in limbo with no expiry shown.
-    rememberPaymentAttempt(CART_TOKEN, { checkoutId: 'peach-1', entityId: 'entity-1' });
-    const { api } = mount(buildCart(2000));
-    await settle();
-    // The server still holds the cart for the attempt (a cart awaiting payment is exempt from the 401), so the
-    // ask at T-0 gets it back unmoved; only once the attempt is abandoned does the reopened, past-deadline cart
-    // stop validating.
-    api.getCart = vi.fn().mockResolvedValueOnce(buildCart(-1000)).mockRejectedValue(apiError(401));
-
-    await advance(3000);
-    expect(postedTypes()).toContain('payment:timed-out');
-    expect(api.abandonPayment).not.toHaveBeenCalled();
-
-    await advance(5000);
-
-    expect(api.abandonPayment).toHaveBeenCalledWith('peach-1');
-    expect(recallPaymentAttempt(CART_TOKEN)).toBeNull();
-    expect(screen.getByText('Your cart has expired')).toBeTruthy();
-  });
-
-  it('a payment that ends while the guard is still asking the server falls through to the ordinary expiry check', async () => {
-    // CheckoutModal tears a resumed attempt down itself when it finds the deadline already past, and its
-    // payment:ended can land while this guard's own read is in flight. Nothing may be handed over after that,
-    // and the expiry still has to be confirmed and shown.
-    rememberPaymentAttempt(CART_TOKEN, { checkoutId: 'peach-1', entityId: 'entity-1' });
-    const { api } = mount(buildCart(2000));
-    await settle();
-    let answerTheRead: (cart: ReturnType<typeof buildCart>) => void = () => {};
-    const pendingRead = new Promise<ReturnType<typeof buildCart>>((resolve) => { answerTheRead = resolve; });
-    api.getCart = vi.fn().mockReturnValueOnce(pendingRead).mockRejectedValue(apiError(401));
-
-    await advance(3000);
-    expect(api.getCart).toHaveBeenCalledTimes(1);
-    postMessage({ type: 'payment:ended' });
-    await settle();
-    answerTheRead(buildCart(-1000));
-    await settle();
-
-    expect(postedTypes()).not.toContain('payment:timed-out');
-    expect(api.getCart).toHaveBeenCalledTimes(2);
-    expect(screen.getByText('Your cart has expired')).toBeTruthy();
-  });
-
-  it('drops the unanswered-timeout fallback when the guard is unmounted before it fires', async () => {
-    // A pending fallback outliving the guard would abandon a payment attempt on behalf of a page that no
-    // longer exists.
-    rememberPaymentAttempt(CART_TOKEN, { checkoutId: 'peach-1', entityId: 'entity-1' });
-    const { api } = mount(buildCart(2000));
-    await settle();
-
-    await advance(3000);
-    expect(postedTypes()).toContain('payment:timed-out');
-    cleanup();
-
-    await advance(5000);
-
-    expect(api.abandonPayment).not.toHaveBeenCalled();
-  });
-
-  it.each(['PAYMENT_PENDING', 'PAYMENT_SETTLED'])(
-    'opens checkout instead of tearing down an attempt Peach reports as live (%s), even with no modal to answer',
-    async (code) => {
-      // Money in motion is never torn down, but nothing else on the page would confirm it either: reopening
-      // checkout resumes the attempt into the modal's confirm loop.
-      rememberPaymentAttempt(CART_TOKEN, { checkoutId: 'peach-1', entityId: 'entity-1' });
-      const { api } = mount(buildCart(2000));
-      await settle();
-      api.abandonPayment = vi.fn().mockRejectedValue(apiError(409, code));
-      api.getCart = vi.fn().mockResolvedValue(buildCart(-1000));
-
-      await advance(3000 + 5000);
-
-      expect(api.abandonPayment).toHaveBeenCalledWith('peach-1');
-      expect(postedTypes()).toContain('modal:open');
-      // One read: the ask at T-0. Nothing asked about expiry after the refusal - the attempt is left as it is.
-      expect(api.getCart).toHaveBeenCalledTimes(1);
-      expect(recallPaymentAttempt(CART_TOKEN)).not.toBeNull();
-      expect(screen.queryByText('Your cart has expired')).toBeNull();
-    },
-  );
-
-  it("a late Yes the server refuses with CART_EXPIRED takes the same tear-down route", async () => {
-    const { api } = mount();
-    await settle();
-    postMessage({ type: 'payment:started' });
-    await advance(MINUTE + 1000);
-    api.extendCart = vi.fn().mockRejectedValue(apiError(409, 'CART_EXPIRED'));
-
-    screen.getByRole('button', { name: "Yes, I'm still here" }).click();
-    await settle();
-
-    expect(postedTypes()).toContain('payment:timed-out');
-    // CART_EXPIRED is the server's own word - nothing to ask before handing over.
-    expect(api.getCart).toHaveBeenCalledTimes(1);
-    expect(screen.queryByText('Your cart has expired')).toBeNull();
-  });
-});

package/src/lib/CheckoutModal.confirm-outcome.test.ts

@@ -1,91 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { cleanup, render, screen } from '@testing-library/svelte';
-import CheckoutModal from './CheckoutModal.svelte';
-import { resetMessages } from './test/messages-mock';
-import { apiError, buildCart, CART_TOKEN, fakeApi, installFakePeachSdk, settle } from './test/fixtures';
-import { rememberPaymentAttempt } from './payment-attempt';
-
-vi.mock('./messages', async () => await import('./test/messages-mock'));
-
-// confirmCart answers with a bare 402/409 both while Peach's webhook genuinely hasn't landed yet (worth
-// retrying) and once it has landed with a decline (nothing left to wait for) - PAYMENT_FAILED is the one
-// coded exception to that. Regression coverage for the bug this used to have: every one of these outcomes
-// used to retry into the same generic "still confirming" pending screen, so a declined card never told the
-// shopper their card was declined.
-
-const ATTEMPT = { checkoutId: 'peach-checkout-1', entityId: 'entity-1' };
-
-// Mirrors CheckoutModal.payment-timeout.test.ts's own approach: a remembered attempt makes CheckoutModal
-// resume straight onto the card form on mount (resumeInterruptedPayment), the same place a real payCart()
-// success lands, without having to drive the contact form through the UI first.
-function mount(cart = buildCart(10 * 60_000)) {
-  rememberPaymentAttempt(CART_TOKEN, ATTEMPT);
-  const api = fakeApi(cart);
-  const onClose = vi.fn();
-  const onOrderConfirmed = vi.fn();
-  const peach = installFakePeachSdk();
-  render(CheckoutModal, { props: { cart, api, onClose, onOrderConfirmed } });
-  return { api, onClose, onOrderConfirmed, peach };
-}
-
-beforeEach(() => {
-  vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'Date'] });
-  vi.setSystemTime(new Date('2026-09-12T10:00:00Z'));
-  resetMessages();
-  sessionStorage.clear();
-});
-
-afterEach(() => {
-  cleanup();
-  vi.useRealTimers();
-  delete (window as unknown as { Checkout?: unknown }).Checkout;
-});
-
-describe('a card Peach declined', () => {
-  it('shows Payment Failed with a Try Again button, on the first confirm attempt, not another "still confirming"', async () => {
-    const { api, peach } = mount();
-    api.confirmCart = vi.fn().mockRejectedValue(apiError(409, 'PAYMENT_FAILED'));
-    await settle();
-
-    peach.handlers().onCompleted();
-    await settle();
-
-    expect(api.confirmCart).toHaveBeenCalledTimes(1);
-    expect(screen.getByText('Payment Failed')).toBeTruthy();
-    expect(screen.getByRole('button', { name: /try again/i })).toBeTruthy();
-    expect(screen.queryByText('Payment Received')).toBeNull();
-  });
-
-  it('does not retry the way a webhook-not-landed-yet 402 does', async () => {
-    const { api, peach } = mount();
-    api.confirmCart = vi.fn().mockRejectedValue(apiError(409, 'PAYMENT_FAILED'));
-    await settle();
-
-    peach.handlers().onCompleted();
-    await settle();
-
-    // Even if the modal were still retrying (the bug this guards against), the retry delay would need real
-    // time to elapse - advancing well past it and confirming the call count never grows proves it settled
-    // immediately instead.
-    await vi.advanceTimersByTimeAsync(30_000);
-    await settle();
-
-    expect(api.confirmCart).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('a genuinely still-pending webhook, for contrast', () => {
-  it('keeps retrying a plain 402 rather than treating it as a decline', async () => {
-    const { api, peach } = mount();
-    api.confirmCart = vi.fn().mockRejectedValue(apiError(402));
-    await settle();
-
-    peach.handlers().onCompleted();
-    await settle();
-    await vi.advanceTimersByTimeAsync(30_000);
-    await settle();
-
-    expect(api.confirmCart.mock.calls.length).toBeGreaterThan(1);
-    expect(screen.queryByText('Payment Failed')).toBeNull();
-  });
-});

package/src/lib/CheckoutModal.payment-timeout.test.ts

@@ -1,140 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { cleanup, render, screen } from '@testing-library/svelte';
-import CheckoutModal from './CheckoutModal.svelte';
-import CartExpiryGuard from './CartExpiryGuard.svelte';
-import { postedTypes, resetMessages } from './test/messages-mock';
-import { apiError, buildCart, CART_TOKEN, fakeApi, fakeCartManager, installFakePeachSdk, settle } from './test/fixtures';
-import { rememberPaymentAttempt, recallPaymentAttempt } from './payment-attempt';
-
-vi.mock('./messages', async () => await import('./test/messages-mock'));
-
-// The cart's one clock running out while Peach's card form is open. The guard cannot confirm that expiry
-// itself (the server exempts a cart with a payment in flight so a landing charge can still be confirmed), so
-// CheckoutModal tears the attempt down through the same Peach-verified abandon a cancel uses. Both components
-// are mounted together on the shared message bus, exactly as they are on a real page, and PaymentPage mounts
-// against a fake Peach SDK so Peach's own callback contract is what drives the modal.
-
-const ATTEMPT = { checkoutId: 'peach-checkout-1', entityId: 'entity-1' };
-
-// `configure` runs before either component mounts: CheckoutModal acts on a resumed attempt synchronously
-// during its own init, so a server behaviour that has to be in place for that first call cannot be installed
-// on the api afterwards.
-function mountBoth(cart: ReturnType<typeof buildCart>, configure: (api: ReturnType<typeof fakeApi>) => void = () => {}) {
-  const api = fakeApi(cart);
-  configure(api);
-  const cartManager = fakeCartManager();
-  const onClose = vi.fn();
-  const peach = installFakePeachSdk();
-  render(CartExpiryGuard, { props: { api, cartManager } });
-  render(CheckoutModal, {
-    props: { cart, api, onClose, onOrderConfirmed: vi.fn() },
-  });
-  return { api, cartManager, onClose, peach };
-}
-
-// The server's side of an abandon that reopens the cart onto its already-past deadline: from then on the
-// cart no longer validates, so every read is a 401.
-function abandonExpiresTheCart(api: ReturnType<typeof fakeApi>) {
-  api.abandonPayment = vi.fn().mockImplementation(async () => {
-    api.getCart = vi.fn().mockRejectedValue(apiError(401));
-  });
-}
-
-beforeEach(() => {
-  vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval', 'Date'] });
-  vi.setSystemTime(new Date('2026-09-12T10:00:00Z'));
-  resetMessages();
-  sessionStorage.clear();
-  rememberPaymentAttempt(CART_TOKEN, ATTEMPT);
-});
-
-afterEach(() => {
-  cleanup();
-  vi.useRealTimers();
-  delete (window as unknown as { Checkout?: unknown }).Checkout;
-});
-
-describe('the clock running out on the card form', () => {
-  it('abandons the attempt (Peach permitting) and the shopper sees the cart expire over the card form', async () => {
-    const { api, onClose, peach } = mountBoth(buildCart(2000));
-    abandonExpiresTheCart(api);
-    await settle();
-    expect(peach.handlers().onCancelled).toBeTypeOf('function');
-
-    await vi.advanceTimersByTimeAsync(3000);
-    await settle();
-
-    expect(api.abandonPayment).toHaveBeenCalledWith(ATTEMPT.checkoutId);
-    expect(postedTypes()).toEqual(expect.arrayContaining(['payment:timed-out', 'payment:ended']));
-    expect(screen.getByText('Your cart has expired')).toBeTruthy();
-    expect(onClose).toHaveBeenCalled();
-    expect(recallPaymentAttempt(CART_TOKEN)).toBeNull();
-  });
-
-  it('never tears down an attempt Peach still has in flight - it waits for the outcome instead', async () => {
-    const { api } = mountBoth(buildCart(2000));
-    api.abandonPayment = vi.fn().mockRejectedValue(apiError(409, 'PAYMENT_PENDING'));
-    api.confirmCart = vi.fn().mockRejectedValue(apiError(402));
-    await settle();
-
-    await vi.advanceTimersByTimeAsync(3000);
-    await settle();
-
-    expect(api.abandonPayment).toHaveBeenCalledWith(ATTEMPT.checkoutId);
-    expect(api.confirmCart).toHaveBeenCalled();
-    expect(postedTypes()).not.toContain('payment:ended');
-    expect(screen.queryByText('Your cart has expired')).toBeNull();
-  });
-
-  it('a payment resumed after a reload onto an already-past deadline is torn down straight away', async () => {
-    const { api } = mountBoth(buildCart(-5000), abandonExpiresTheCart);
-
-    await settle();
-    await settle();
-
-    expect(api.abandonPayment).toHaveBeenCalledWith(ATTEMPT.checkoutId);
-    expect(screen.getByText('Your cart has expired')).toBeTruthy();
-  });
-});
-
-describe('the abandon call itself failing', () => {
-  it('leaves the payment in flight for the guard, whose own fallback then tears the attempt down', async () => {
-    // A blip on the abandon means the server still holds the cart awaiting payment for this attempt. Telling
-    // the guard the payment had ended would disarm the one thing left that will retry it.
-    const { api } = mountBoth(buildCart(2000));
-    api.abandonPayment = vi.fn()
-      .mockRejectedValueOnce(apiError(500))
-      .mockImplementation(async () => {
-        api.getCart = vi.fn().mockRejectedValue(apiError(401));
-      });
-    await settle();
-
-    await vi.advanceTimersByTimeAsync(3000);
-    await settle();
-    expect(api.abandonPayment).toHaveBeenCalledTimes(1);
-    expect(postedTypes()).not.toContain('payment:ended');
-
-    await vi.advanceTimersByTimeAsync(5000);
-    await settle();
-    await settle();
-
-    expect(api.abandonPayment).toHaveBeenCalledTimes(2);
-    expect(recallPaymentAttempt(CART_TOKEN)).toBeNull();
-    expect(screen.getByText('Your cart has expired')).toBeTruthy();
-  });
-});
-
-describe("Peach's own callbacks", () => {
-  it('a cancel abandons the attempt and returns the shopper to the contact step with the cart intact', async () => {
-    const { api, peach } = mountBoth(buildCart(10 * 60_000));
-    await settle();
-
-    peach.handlers().onCancelled();
-    await settle();
-
-    expect(api.abandonPayment).toHaveBeenCalledWith(ATTEMPT.checkoutId);
-    expect(postedTypes()).toContain('payment:ended');
-    expect(screen.queryByText('Your cart has expired')).toBeNull();
-    expect(screen.getByRole('button', { name: /pay now/i })).toBeTruthy();
-  });
-});

package/src/lib/test/fixtures.ts

@@ -1,107 +0,0 @@
-import { vi } from 'vitest';
-import type { BookingApi } from '../api';
-import { ApiError } from '../api';
-import type { CartManager } from '../cart-manager';
-import type { CheckoutCartDetailDto, CheckoutProductDto } from '../client-types';
-
-export const CART_TOKEN = 'cart-token-1';
-
-/** A one-item cart whose idle deadline is `msFromNow` away and whose ceiling is 35 minutes from creation. */
-export function buildCart(msFromNow: number, options: { ceilingMsFromNow?: number } = {}): CheckoutCartDetailDto {
-  const now = Date.now();
-  return {
-    cartToken: CART_TOKEN,
-    issuedAt: new Date(now - 60_000).toISOString(),
-    idleExpiresAt: new Date(now + msFromNow).toISOString(),
-    absoluteExpiresAt: new Date(now + (options.ceilingMsFromNow ?? 35 * 60_000)).toISOString(),
-    items: [
-      {
-        id: 'item-1',
-        bookingUuid: 'booking-1',
-        productId: 'product-1',
-        optionId: 'option-1',
-        unitItems: [{ unitId: 'adult' }],
-        availabilityId: '2026-10-01T09:00:00+02:00',
-        amount: 1000,
-        currencyCode: 'ZAR',
-        currencyPrecision: 2,
-      },
-    ],
-  };
-}
-
-export const product: CheckoutProductDto = {
-  id: 'product-1',
-  title: 'City Tour Pass',
-  options: [
-    {
-      id: 'option-1',
-      title: 'Day ticket',
-      units: [{ id: 'adult', title: 'Adult', pricing: [{ retail: 1000, currency: 'ZAR', currencyPrecision: 2 }] }],
-    },
-  ],
-} as unknown as CheckoutProductDto;
-
-export function apiError(status: number, code?: string): ApiError {
-  return new ApiError(status, code ? { error: code, errorMessage: code } : undefined);
-}
-
-/**
- * Every BookingApi member as a vi.fn, with the cart-shaped ones answering sensibly for a live cart by
- * default. Tests override the one or two members a scenario turns on with mockResolvedValue/
- * mockRejectedValue/mockImplementation.
- */
-export function fakeApi(cart: CheckoutCartDetailDto): BookingApi & { [K in keyof BookingApi]: BookingApi[K] } {
-  return {
-    sessionToken: 'session-token-1',
-    cartToken: CART_TOKEN,
-    startSession: vi.fn(),
-    refreshSession: vi.fn(),
-    getProduct: vi.fn().mockResolvedValue(product),
-    getAvailabilityCalendar: vi.fn(),
-    getAvailability: vi.fn(),
-    createCart: vi.fn(),
-    getCart: vi.fn().mockResolvedValue(cart),
-    addCartItem: vi.fn(),
-    updateCartItem: vi.fn(),
-    removeCartItem: vi.fn(),
-    payCart: vi.fn(),
-    confirmCart: vi.fn(),
-    extendCart: vi.fn().mockResolvedValue(cart),
-    abandonPayment: vi.fn().mockResolvedValue(undefined),
-  };
-}
-
-export function fakeCartManager(hasCart = true): CartManager {
-  return {
-    hasCart,
-    cartToken: CART_TOKEN,
-    reset: vi.fn(),
-    ensureCart: vi.fn(),
-  } as unknown as CartManager;
-}
-
-/**
- * A stand-in for Peach's embedded Checkout SDK global, so PaymentPage mounts for real and the test can drive
- * Peach's own callback contract - the handlers PaymentPage registers are captured here.
- */
-export function installFakePeachSdk(): { handlers: () => Record<string, () => void>; unmount: ReturnType<typeof vi.fn> } {
-  let captured: Record<string, () => void> = {};
-  const unmount = vi.fn();
-  (window as unknown as { Checkout: unknown }).Checkout = {
-    initiate: (options: { eventHandlers: Record<string, () => void> }) => {
-      captured = options.eventHandlers;
-      return { render: vi.fn(), unmount };
-    },
-  };
-  return { handlers: () => captured, unmount };
-}
-
-/** Flushes Svelte's effect queue and any microtask chain a component kicked off. */
-export async function settle(): Promise<void> {
-  const { tick } = await import('svelte');
-  for (let i = 0; i < 5; i++) {
-    await tick();
-    await Promise.resolve();
-  }
-}