@getmicdrop/venue-calendar 3.3.1 → 3.3.3

package/src/lib/utils/api.test.js

@@ -1,1284 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import {
-  createPaymentIntent,
-  fetchAllVenues,
-  fetchVenueEvents,
-  getMonthEvents,
-  getOrgMonthEvents,
-  transformEventData,
-  fetchEventDetails,
-  fetchEventTickets,
-  validatePromoCode,
-  hasPromoCodes,
-  extendCheckoutSession,
-  getSessionStatus,
-  completeReservation,
-  cancelReservation,
-  fetchEventPerformers,
-  getSeriesOccurrences,
-  checkEventPassword,
-  testNetworkConnection,
-  fetchSeriesOccurrences,
-} from './api.js';
-
-describe('api.js', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  // Note: Stripe publishable key is now fetched dynamically from the payment intent API response
-  // No more STRIPE_PUBLISHABLE_KEY or getStripePublishableKey exports
-
-  describe('createPaymentIntent', () => {
-    it('creates payment intent successfully', async () => {
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ ip: '1.2.3.4' }) })
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ clientSecret: 'pi_secret' }) });
-
-      const result = await createPaymentIntent('cart-123', { 1: 2 });
-      expect(result.clientSecret).toBe('pi_secret');
-    });
-
-    it('returns null on payment failure', async () => {
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ ip: '1.2.3.4' }) })
-        .mockResolvedValueOnce({ ok: false, json: () => Promise.resolve({ error: 'Failed' }) });
-
-      const result = await createPaymentIntent('cart-123', {});
-      expect(result).toBeNull();
-    });
-
-    it('returns null on network error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await createPaymentIntent('cart-123', {});
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('fetchAllVenues', () => {
-    it('returns venues array on success', async () => {
-      const mockVenues = [{ id: 1, name: 'Venue 1' }, { id: 2, name: 'Venue 2' }];
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockVenues),
-      });
-
-      const result = await fetchAllVenues(123);
-      expect(result).toEqual(mockVenues);
-    });
-
-    it('returns empty array when no orgId', async () => {
-      const result = await fetchAllVenues(null);
-      expect(result).toEqual([]);
-    });
-
-    it('returns empty array on API error', async () => {
-      global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 500, statusText: 'Error' });
-
-      const result = await fetchAllVenues(123);
-      expect(result).toEqual([]);
-    });
-
-    it('returns empty array on network error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await fetchAllVenues(123);
-      expect(result).toEqual([]);
-    });
-
-    it('returns empty array when API returns non-array', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(null),
-      });
-
-      const result = await fetchAllVenues(123);
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('fetchVenueEvents', () => {
-    it('returns events array on success', async () => {
-      const mockEvents = [{ id: 1, title: 'Event 1' }];
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockEvents),
-      });
-
-      const result = await fetchVenueEvents(456);
-      expect(result).toEqual(mockEvents);
-    });
-
-    it('returns empty array when no venueId', async () => {
-      const result = await fetchVenueEvents(null);
-      expect(result).toEqual([]);
-    });
-
-    it('returns empty array on API error', async () => {
-      global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 404 });
-
-      const result = await fetchVenueEvents(456);
-      expect(result).toEqual([]);
-    });
-
-    it('returns empty array on network error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await fetchVenueEvents(456);
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('getMonthEvents', () => {
-    it('returns events and pagination on success', async () => {
-      const mockData = {
-        events: [{ id: 1 }],
-        pagination: { hasPrevMonth: false, hasNextMonth: true },
-        year: 2025,
-        month: 6,
-      };
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockData),
-      });
-
-      const result = await getMonthEvents(456, 2025, 6);
-      expect(result.events).toHaveLength(1);
-      expect(result.pagination).toBeDefined();
-      expect(result.year).toBe(2025);
-      expect(result.month).toBe(6);
-    });
-
-    it('returns empty when no venueId', async () => {
-      const result = await getMonthEvents(null, 2025, 6);
-      expect(result.events).toEqual([]);
-      expect(result.pagination).toBeNull();
-    });
-
-    it('returns empty on API error', async () => {
-      global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 500 });
-
-      const result = await getMonthEvents(456, 2025, 6);
-      expect(result.events).toEqual([]);
-    });
-
-    it('returns empty on network error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await getMonthEvents(456, 2025, 6);
-      expect(result.events).toEqual([]);
-    });
-  });
-
-  describe('getOrgMonthEvents', () => {
-    it('returns events and pagination on success', async () => {
-      const mockData = {
-        events: [{ id: 1 }],
-        pagination: { hasPrevMonth: true, hasNextMonth: false },
-      };
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockData),
-      });
-
-      const result = await getOrgMonthEvents(123, 2025, 7);
-      expect(result.events).toHaveLength(1);
-    });
-
-    it('returns empty when no orgId', async () => {
-      const result = await getOrgMonthEvents(null, 2025, 7);
-      expect(result.events).toEqual([]);
-    });
-  });
-
-  describe('transformEventData', () => {
-    it('transforms API event to frontend format', () => {
-      const apiEvent = {
-        id: 123,
-        title: 'Test Event',
-        startDateTime: '2025-06-15T19:00:00Z',
-        endDateTime: '2025-06-15T22:00:00Z',
-        timeZone: 'UTC',
-        image: '/poster.jpg',
-        status: 'On Sale',
-        venueId: 456,
-        description: 'A test event',
-        eventSeriesId: 789,
-        availableTickets: [
-          { remainingCapacity: 50, totalCapacity: 100, salesChannel: 1 },
-        ],
-      };
-
-      const result = transformEventData(apiEvent);
-      expect(result.id).toBe(123);
-      expect(result.name).toBe('Test Event');
-      expect(result.image).toContain('https://moxy.sfo3.digitaloceanspaces.com');
-      expect(result.status).toBe('On Sale');
-      expect(result.venueId).toBe(456);
-      expect(result.eventSeriesId).toBe(789);
-      expect(result.ticketsRemaining).toBe(50);
-      expect(result.ticketsTotal).toBe(100);
-      expect(result.isSoldOut).toBe(false);
-    });
-
-    it('handles event with no tickets', () => {
-      const apiEvent = { id: 1, title: 'No Tickets' };
-      const result = transformEventData(apiEvent);
-      expect(result.ticketsRemaining).toBe(0);
-      expect(result.ticketsTotal).toBe(0);
-      expect(result.isSoldOut).toBe(false);
-    });
-
-    it('handles sold out event', () => {
-      const apiEvent = {
-        id: 1,
-        availableTickets: [
-          { remainingCapacity: 0, totalCapacity: 100, salesChannel: 1 },
-        ],
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.isSoldOut).toBe(true);
-    });
-
-    it('excludes door-only tickets from scarcity', () => {
-      const apiEvent = {
-        id: 1,
-        availableTickets: [
-          { remainingCapacity: 0, totalCapacity: 50, salesChannel: 2 }, // Door only
-          { remainingCapacity: 25, totalCapacity: 50, salesChannel: 1 },
-        ],
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.ticketsRemaining).toBe(25);
-      expect(result.ticketsTotal).toBe(50);
-    });
-
-    it('handles various image URL formats', () => {
-      expect(transformEventData({ image: '/poster.jpg' }).image).toContain('digitaloceanspaces.com');
-      expect(transformEventData({ imageUrl: '/cover.jpg' }).image).toContain('digitaloceanspaces.com');
-      expect(transformEventData({ image_url: '/img.jpg' }).image).toContain('digitaloceanspaces.com');
-      expect(transformEventData({ image: 'https://example.com/img.jpg' }).image).toBe('https://example.com/img.jpg');
-    });
-
-    it('handles timezone conversion', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        timeZone: 'California USA',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeZone).toBe('America/Los_Angeles');
-    });
-
-    it('uses fallback fields for name and date', () => {
-      const apiEvent1 = { name: 'Event Name' };
-      expect(transformEventData(apiEvent1).name).toBe('Event Name');
-
-      const apiEvent2 = { date: '2025-06-15' };
-      expect(transformEventData(apiEvent2).date).toBe('2025-06-15');
-    });
-  });
-
-  describe('fetchEventDetails', () => {
-    it('fetches event details successfully', async () => {
-      const mockEvent = { id: 123, title: 'Test' };
-      const mockFetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockEvent),
-      });
-
-      const result = await fetchEventDetails(123, mockFetch);
-      expect(result).toEqual(mockEvent);
-    });
-
-    it('throws on API error', async () => {
-      const mockFetch = vi.fn().mockResolvedValue({ ok: false, status: 404 });
-
-      await expect(fetchEventDetails(123, mockFetch)).rejects.toThrow();
-    });
-  });
-
-  describe('fetchEventTickets', () => {
-    it('fetches tickets successfully', async () => {
-      const mockTickets = [{ id: 1, name: 'GA' }];
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(mockTickets),
-      });
-
-      const result = await fetchEventTickets(123);
-      expect(result).toEqual(mockTickets);
-    });
-
-    it('throws on API error', async () => {
-      global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 500 });
-
-      await expect(fetchEventTickets(123)).rejects.toThrow();
-    });
-
-    it('returns empty array for non-array response', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(null),
-      });
-
-      const result = await fetchEventTickets(123);
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('validatePromoCode', () => {
-    it('returns valid response for good code', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ valid: true, discountType: 'percentage', amount: 10 }),
-      });
-
-      const result = await validatePromoCode('event123', 'SAVE10');
-      expect(result.valid).toBe(true);
-      expect(result.discountType).toBe('percentage');
-    });
-
-    it('returns invalid for bad code', async () => {
-      global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 400 });
-
-      const result = await validatePromoCode('event123', 'BADCODE');
-      expect(result.valid).toBe(false);
-    });
-
-    it('returns invalid on error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await validatePromoCode('event123', 'CODE');
-      expect(result.valid).toBe(false);
-    });
-  });
-
-  describe('hasPromoCodes', () => {
-    it('returns true when promo codes exist', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ hasPromoCodes: true }),
-      });
-
-      const result = await hasPromoCodes('event123');
-      expect(result).toBe(true);
-    });
-
-    it('returns false when no promo codes', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ hasPromoCodes: false }),
-      });
-
-      const result = await hasPromoCodes('event123');
-      expect(result).toBe(false);
-    });
-
-    it('defaults to true on error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Error'));
-
-      const result = await hasPromoCodes('event123');
-      expect(result).toBe(true);
-    });
-
-    it('defaults to true on API error', async () => {
-      global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 500 });
-
-      const result = await hasPromoCodes('event123');
-      expect(result).toBe(true);
-    });
-  });
-
-  describe('extendCheckoutSession', () => {
-    it('extends session successfully', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          newExpiryTime: '2025-01-15T12:15:00Z',
-          remainingExtensions: 2,
-        }),
-      });
-
-      const result = await extendCheckoutSession('order-uuid');
-      expect(result.success).toBe(true);
-      expect(result.newExpiryTime).toBeDefined();
-    });
-
-    it('returns error on failure', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: false,
-        json: () => Promise.resolve({ error: 'Max extensions reached' }),
-      });
-
-      const result = await extendCheckoutSession('order-uuid');
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('extensions');
-    });
-
-    it('handles network error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await extendCheckoutSession('order-uuid');
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Network');
-    });
-  });
-
-  describe('getSessionStatus', () => {
-    it('gets session status successfully', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          expiresAt: '2025-01-15T12:00:00Z',
-          extensionCount: 1,
-          remainingExtensions: 2,
-          canExtend: true,
-        }),
-      });
-
-      const result = await getSessionStatus('order-uuid');
-      expect(result.expiresAt).toBeDefined();
-      expect(result.canExtend).toBe(true);
-    });
-
-    it('returns error for invalid session', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: false,
-        json: () => Promise.resolve({ error: 'No session' }),
-      });
-
-      const result = await getSessionStatus('order-uuid');
-      expect(result.error).toBeDefined();
-    });
-  });
-
-  describe('completeReservation', () => {
-    it('completes reservation successfully', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ message: 'Reservation completed' }),
-      });
-
-      const result = await completeReservation('order-uuid');
-      expect(result.success).toBe(true);
-    });
-
-    it('returns error on failure', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: false,
-        json: () => Promise.resolve({ error: 'Failed' }),
-      });
-
-      const result = await completeReservation('order-uuid');
-      expect(result.success).toBe(false);
-    });
-  });
-
-  describe('cancelReservation', () => {
-    it('cancels reservation successfully', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ message: 'Cancelled' }),
-      });
-
-      const result = await cancelReservation('order-uuid');
-      expect(result.success).toBe(true);
-    });
-
-    it('handles network error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await cancelReservation('order-uuid');
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Network');
-    });
-  });
-
-  describe('fetchEventPerformers', () => {
-    it('fetches performers successfully', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          performers: [{ id: 1, stageName: 'DJ Cool' }],
-          showPerformers: true,
-        }),
-      });
-
-      const result = await fetchEventPerformers(123);
-      expect(result.performers).toHaveLength(1);
-      expect(result.showPerformers).toBe(true);
-    });
-
-    it('returns empty when no eventId', async () => {
-      const result = await fetchEventPerformers(null);
-      expect(result.performers).toEqual([]);
-      expect(result.showPerformers).toBe(false);
-    });
-
-    it('returns empty on API error', async () => {
-      global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 404 });
-
-      const result = await fetchEventPerformers(123);
-      expect(result.performers).toEqual([]);
-    });
-  });
-
-  describe('getSeriesOccurrences', () => {
-    it('gets series occurrences successfully', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          seriesId: 1,
-          seriesName: 'Weekly Show',
-          occurrences: [{ id: 1, startDateTime: '2025-01-15T20:00:00Z' }],
-        }),
-      });
-
-      const result = await getSeriesOccurrences(1);
-      expect(result.seriesId).toBe(1);
-      expect(result.occurrences).toHaveLength(1);
-    });
-
-    it('returns error for invalid series', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: false,
-        json: () => Promise.resolve({ error: 'Not found' }),
-      });
-
-      const result = await getSeriesOccurrences(999);
-      expect(result.error).toBeDefined();
-    });
-  });
-
-  describe('checkEventPassword', () => {
-    it('returns valid for correct password', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ valid: true }),
-      });
-
-      const result = await checkEventPassword('event123', 'secret');
-      expect(result.valid).toBe(true);
-    });
-
-    it('returns invalid for wrong password', async () => {
-      global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 401 });
-
-      const result = await checkEventPassword('event123', 'wrong');
-      expect(result.valid).toBe(false);
-    });
-
-    it('handles boolean response', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve(true),
-      });
-
-      const result = await checkEventPassword('event123', 'secret');
-      expect(result.valid).toBe(true);
-    });
-
-    it('returns invalid on error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Error'));
-
-      const result = await checkEventPassword('event123', 'secret');
-      expect(result.valid).toBe(false);
-    });
-  });
-
-  describe('testNetworkConnection', () => {
-    beforeEach(() => {
-      vi.useFakeTimers();
-    });
-
-    afterEach(() => {
-      vi.useRealTimers();
-    });
-
-    it('tests organization connection', async () => {
-      global.fetch = vi.fn().mockResolvedValue({ ok: true });
-
-      const promise = testNetworkConnection(123, null);
-      vi.runAllTimers();
-      const result = await promise;
-      expect(result.organization).toBe(true);
-      expect(result.timestamp).toBeDefined();
-    });
-
-    it('tests venue connection', async () => {
-      global.fetch = vi.fn().mockResolvedValue({ ok: true });
-
-      const promise = testNetworkConnection(null, 456);
-      vi.runAllTimers();
-      const result = await promise;
-      expect(result.venue).toBe(true);
-    });
-
-    it('handles connection failures', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Timeout'));
-
-      const promise = testNetworkConnection(123, 456);
-      vi.runAllTimers();
-      const result = await promise;
-      expect(result.organization).toBe(false);
-      expect(result.venue).toBe(false);
-    });
-  });
-
-  describe('fetchSeriesOccurrences', () => {
-    it('returns empty for invalid series ID', async () => {
-      const result = await fetchSeriesOccurrences(0, 456);
-      expect(result).toEqual([]);
-    });
-
-    it('returns empty for null series ID', async () => {
-      const result = await fetchSeriesOccurrences(null, 456);
-      expect(result).toEqual([]);
-    });
-
-    it('fetches occurrences from new API', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          seriesId: 1,
-          occurrences: [
-            { id: 1, startDateTime: '2025-01-20T20:00:00Z', slug: 'event-1' },
-            { id: 2, startDateTime: '2025-01-15T20:00:00Z', slug: 'event-2' },
-          ],
-        }),
-      });
-
-      const result = await fetchSeriesOccurrences(1, 456);
-      expect(result).toHaveLength(2);
-      // Should be sorted by date
-      expect(result[0].id).toBe(2);
-      expect(result[1].id).toBe(1);
-    });
-
-    it('falls back to listAllEvents when new API fails', async () => {
-      global.fetch = vi.fn()
-        // First call - getSeriesOccurrences fails
-        .mockResolvedValueOnce({
-          ok: false,
-          json: () => Promise.resolve({ error: 'Not found' }),
-        })
-        // Second call - listAllEvents
-        .mockResolvedValueOnce({
-          ok: true,
-          json: () => Promise.resolve([
-            { id: 1, eventSeriesId: 1 },
-            { id: 2, eventSeriesId: 2 }, // Different series
-            { id: 3, eventSeriesId: 1 },
-          ]),
-        })
-        // Third and fourth calls - getEvent for each matching event
-        .mockResolvedValueOnce({
-          ok: true,
-          json: () => Promise.resolve({
-            id: 1,
-            startDateTime: '2025-01-15T20:00:00Z',
-            availableTickets: [],
-          }),
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          json: () => Promise.resolve({
-            id: 3,
-            startDateTime: '2025-01-16T20:00:00Z',
-            availableTickets: [],
-          }),
-        });
-
-      const result = await fetchSeriesOccurrences(1, 456);
-      expect(result.length).toBeGreaterThan(0);
-    });
-
-    it('handles network error gracefully', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await fetchSeriesOccurrences(1, 456);
-      expect(result).toEqual([]);
-    });
-
-    it('returns empty when no venueId for fallback', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: false,
-        json: () => Promise.resolve({ error: 'Not found' }),
-      });
-
-      const result = await fetchSeriesOccurrences(1, null);
-      expect(result).toEqual([]);
-    });
-
-    it('handles getEvent failure in fallback', async () => {
-      global.fetch = vi.fn()
-        // getSeriesOccurrences fails
-        .mockResolvedValueOnce({
-          ok: false,
-          json: () => Promise.resolve({ error: 'Not found' }),
-        })
-        // listAllEvents succeeds
-        .mockResolvedValueOnce({
-          ok: true,
-          json: () => Promise.resolve([
-            { id: 1, eventSeriesId: 1 },
-          ]),
-        })
-        // getEvent fails
-        .mockResolvedValueOnce({ ok: false, status: 500 });
-
-      const result = await fetchSeriesOccurrences(1, 456);
-      // Should filter out null (failed) events
-      expect(result).toEqual([]);
-    });
-
-    it('handles listAllEvents failure in fallback', async () => {
-      global.fetch = vi.fn()
-        // getSeriesOccurrences fails
-        .mockResolvedValueOnce({
-          ok: false,
-          json: () => Promise.resolve({ error: 'Not found' }),
-        })
-        // listAllEvents also fails
-        .mockResolvedValueOnce({ ok: false, status: 500 });
-
-      const result = await fetchSeriesOccurrences(1, 456);
-      expect(result).toEqual([]);
-    });
-
-    it('computes CTA state for sold out tickets', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          seriesId: 1,
-          occurrences: [
-            {
-              id: 1,
-              startDateTime: '2025-06-15T20:00:00Z',
-              availableTickets: [
-                { remainingCapacity: 0, soldOut: true, salesChannel: 1 },
-              ],
-            },
-          ],
-        }),
-      });
-
-      const result = await fetchSeriesOccurrences(1, 456);
-      expect(result).toHaveLength(1);
-      // ctaState should be computed
-      expect(result[0].ctaState).toBeDefined();
-    });
-
-    it('computes CTA state for sales ended', async () => {
-      const pastDate = new Date(Date.now() - 86400000).toISOString();
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          seriesId: 1,
-          occurrences: [
-            {
-              id: 1,
-              startDateTime: pastDate,
-              endDateTime: pastDate,
-              availableTickets: [
-                { remainingCapacity: 10, salesEnd: pastDate, salesChannel: 1 },
-              ],
-            },
-          ],
-        }),
-      });
-
-      const result = await fetchSeriesOccurrences(1, 456);
-      expect(result).toHaveLength(1);
-    });
-
-    it('computes CTA state for coming soon tickets', async () => {
-      const futureDate = new Date(Date.now() + 86400000).toISOString();
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          seriesId: 1,
-          occurrences: [
-            {
-              id: 1,
-              startDateTime: futureDate,
-              availableTickets: [
-                { remainingCapacity: 100, salesBegin: futureDate, salesChannel: 1 },
-              ],
-            },
-          ],
-        }),
-      });
-
-      const result = await fetchSeriesOccurrences(1, 456);
-      expect(result).toHaveLength(1);
-    });
-
-    it('uses occurrence ctaState if provided by API', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({
-          seriesId: 1,
-          occurrences: [
-            {
-              id: 1,
-              startDateTime: '2025-06-15T20:00:00Z',
-              ctaState: { text: 'Get tickets', disabled: false, reason: 'available' },
-            },
-          ],
-        }),
-      });
-
-      const result = await fetchSeriesOccurrences(1, 456);
-      expect(result[0].ctaState.text).toBe('Get tickets');
-    });
-  });
-
-  describe('transformEventData timezone handling', () => {
-    it('handles New York timezone', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        timeZone: 'New York',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeZone).toBe('America/New_York');
-    });
-
-    it('handles Chicago timezone', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        timeZone: 'Chicago USA',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeZone).toBe('America/Chicago');
-    });
-
-    it('handles Denver timezone', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        timeZone: 'Denver',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeZone).toBe('America/Denver');
-    });
-
-    it('handles Phoenix timezone', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        timeZone: 'Phoenix USA',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeZone).toBe('America/Phoenix');
-    });
-
-    it('handles UTC timezone', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        timeZone: 'UTC',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeZone).toBe('UTC');
-    });
-
-    it('handles NaN timezone (defaults to LA)', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        timeZone: 'NaN',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeZone).toBe('America/Los_Angeles');
-    });
-
-    it('handles null timezone (defaults to LA)', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        timeZone: null,
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeZone).toBe('America/Los_Angeles');
-    });
-
-    it('handles valid IANA timezone directly', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        timeZone: 'Europe/London',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeZone).toBe('Europe/London');
-    });
-
-    it('handles invalid timezone string (defaults to LA)', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        timeZone: 'Invalid/Timezone/Name',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeZone).toBe('America/Los_Angeles');
-    });
-  });
-
-  describe('transformEventData time formatting', () => {
-    it('formats start and end time', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        endDateTime: '2025-06-15T22:00:00Z',
-        timeZone: 'UTC',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeline).toContain('-');
-    });
-
-    it('formats start time only when no end time', () => {
-      const apiEvent = {
-        id: 1,
-        startDateTime: '2025-06-15T19:00:00Z',
-        endDateTime: null,
-        timeZone: 'UTC',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeline).not.toContain('-');
-    });
-
-    it('uses fallback startTime/endTime fields', () => {
-      const apiEvent = {
-        id: 1,
-        startTime: '7:00 PM',
-        endTime: '10:00 PM',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeline).toBe('7:00 PM - 10:00 PM');
-    });
-
-    it('uses fallback startTime only', () => {
-      const apiEvent = {
-        id: 1,
-        startTime: '7:00 PM',
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.timeline).toBe('7:00 PM');
-    });
-
-    it('returns empty timeline when no time data', () => {
-      const apiEvent = { id: 1 };
-      const result = transformEventData(apiEvent);
-      expect(result.timeline).toBe('');
-    });
-  });
-
-  describe('transformEventData ticket fields', () => {
-    it('handles quantityRemaining field', () => {
-      const apiEvent = {
-        id: 1,
-        availableTickets: [
-          { quantityRemaining: 25, salesChannel: 1 },
-        ],
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.ticketsRemaining).toBe(25);
-    });
-
-    it('handles quantity field as fallback', () => {
-      const apiEvent = {
-        id: 1,
-        availableTickets: [
-          { quantity: 30, salesChannel: 1 },
-        ],
-      };
-      const result = transformEventData(apiEvent);
-      expect(result.ticketsRemaining).toBe(30);
-    });
-  });
-
-  describe('extendCheckoutSession edge cases', () => {
-    it('handles json parse error on failure response', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: false,
-        json: () => Promise.reject(new Error('Parse error')),
-      });
-
-      const result = await extendCheckoutSession('order-uuid');
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Failed to extend session');
-    });
-  });
-
-  describe('getSessionStatus edge cases', () => {
-    it('handles network error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await getSessionStatus('order-uuid');
-      expect(result.error).toContain('Network');
-    });
-
-    it('handles json parse error on failure response', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: false,
-        json: () => Promise.reject(new Error('Parse error')),
-      });
-
-      const result = await getSessionStatus('order-uuid');
-      expect(result.error).toBe('No active session found');
-    });
-  });
-
-  describe('completeReservation edge cases', () => {
-    it('handles json parse error on failure response', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: false,
-        json: () => Promise.reject(new Error('Parse error')),
-      });
-
-      const result = await completeReservation('order-uuid');
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Failed to complete reservation');
-    });
-
-    it('handles network error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await completeReservation('order-uuid');
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Network');
-    });
-  });
-
-  describe('cancelReservation edge cases', () => {
-    it('handles json parse error on failure response', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: false,
-        json: () => Promise.reject(new Error('Parse error')),
-      });
-
-      const result = await cancelReservation('order-uuid');
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Failed to cancel reservation');
-    });
-  });
-
-  describe('getSeriesOccurrences edge cases', () => {
-    it('handles network error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await getSeriesOccurrences(123);
-      expect(result.error).toContain('Network');
-    });
-  });
-
-  describe('getMonthEvents edge cases', () => {
-    it('handles non-array events response', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ events: null }),
-      });
-
-      const result = await getMonthEvents(456, 2025, 6);
-      expect(result.events).toEqual([]);
-    });
-  });
-
-  describe('getOrgMonthEvents edge cases', () => {
-    it('handles API error', async () => {
-      global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 500 });
-
-      const result = await getOrgMonthEvents(123, 2025, 6);
-      expect(result.events).toEqual([]);
-    });
-
-    it('handles network error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await getOrgMonthEvents(123, 2025, 6);
-      expect(result.events).toEqual([]);
-    });
-
-    it('handles non-array events response', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ events: null }),
-      });
-
-      const result = await getOrgMonthEvents(123, 2025, 6);
-      expect(result.events).toEqual([]);
-    });
-  });
-
-  describe('fetchEventPerformers edge cases', () => {
-    it('handles non-array performers response', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        json: () => Promise.resolve({ performers: null, showPerformers: true }),
-      });
-
-      const result = await fetchEventPerformers(123);
-      expect(result.performers).toEqual([]);
-    });
-
-    it('handles network error', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
-
-      const result = await fetchEventPerformers(123);
-      expect(result.performers).toEqual([]);
-      expect(result.showPerformers).toBe(false);
-    });
-  });
-
-  describe('createPaymentIntent edge cases', () => {
-    it('handles json parse error on failure response', async () => {
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ ip: '1.2.3.4' }) })
-        .mockResolvedValueOnce({
-          ok: false,
-          json: () => Promise.reject(new Error('Parse error')),
-        });
-
-      const result = await createPaymentIntent('cart-123', {});
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('Stripe publishable key in payment intent response', () => {
-    // These tests verify that createPaymentIntent returns the stripe_publishable_key
-    // from the API response. This is critical for third-party embeds (WordPress,
-    // Squarespace, etc.) that cannot use environment variables.
-
-    it('returns stripe_publishable_key from API response', async () => {
-      const mockResponse = {
-        client_secret: 'pi_test_secret_123',
-        stripe_publishable_key: 'pk_test_51ABC123xyz',
-        amount_total: 5000,
-        tax_amount_exclusive: 450,
-        service_fee: 250,
-      };
-
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ ip: '1.2.3.4' }) })
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockResponse) });
-
-      const result = await createPaymentIntent('cart-123', { 1: 2 });
-
-      expect(result).not.toBeNull();
-      expect(result.stripe_publishable_key).toBe('pk_test_51ABC123xyz');
-      expect(result.client_secret).toBe('pi_test_secret_123');
-    });
-
-    it('returns live stripe_publishable_key from API response', async () => {
-      const mockResponse = {
-        client_secret: 'pi_live_secret_456',
-        stripe_publishable_key: 'pk_live_51ABC123xyz',
-        amount_total: 10000,
-      };
-
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ ip: '1.2.3.4' }) })
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockResponse) });
-
-      const result = await createPaymentIntent('cart-123', { 1: 1 });
-
-      expect(result).not.toBeNull();
-      expect(result.stripe_publishable_key).toBe('pk_live_51ABC123xyz');
-      expect(result.stripe_publishable_key.startsWith('pk_live_')).toBe(true);
-    });
-
-    it('handles missing stripe_publishable_key gracefully', async () => {
-      // API might return response without the key (e.g., misconfigured backend)
-      const mockResponse = {
-        client_secret: 'pi_test_secret_123',
-        amount_total: 5000,
-        // stripe_publishable_key is missing
-      };
-
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ ip: '1.2.3.4' }) })
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockResponse) });
-
-      const result = await createPaymentIntent('cart-123', { 1: 2 });
-
-      // Should still return the result (client code handles missing key)
-      expect(result).not.toBeNull();
-      expect(result.stripe_publishable_key).toBeUndefined();
-      expect(result.client_secret).toBe('pi_test_secret_123');
-    });
-
-    it('handles empty stripe_publishable_key', async () => {
-      const mockResponse = {
-        client_secret: 'pi_test_secret_123',
-        stripe_publishable_key: '',
-        amount_total: 5000,
-      };
-
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ ip: '1.2.3.4' }) })
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockResponse) });
-
-      const result = await createPaymentIntent('cart-123', { 1: 2 });
-
-      expect(result).not.toBeNull();
-      expect(result.stripe_publishable_key).toBe('');
-    });
-
-    it('includes full payment intent response with all fields', async () => {
-      const mockResponse = {
-        client_secret: 'pi_test_secret_abc',
-        stripe_publishable_key: 'pk_test_xyz789',
-        amount_total: 7500,
-        tax_amount_exclusive: 675,
-        tax_amount_inclusive: 0,
-        tax_rate: 9.0,
-        service_fee: 375,
-        tax_breakdown: [
-          { jurisdiction: 'CA', rate: 0.0725, amount: 500 },
-          { jurisdiction: 'City', rate: 0.0175, amount: 175 },
-        ],
-        line_items: [
-          { ticket_type_id: 1, quantity: 2, unit_price: 2500 },
-          { ticket_type_id: 2, quantity: 1, unit_price: 2500 },
-        ],
-      };
-
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ ip: '1.2.3.4' }) })
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockResponse) });
-
-      const result = await createPaymentIntent('cart-123', { 1: 2, 2: 1 });
-
-      expect(result).not.toBeNull();
-      expect(result.stripe_publishable_key).toBe('pk_test_xyz789');
-      expect(result.amount_total).toBe(7500);
-      expect(result.tax_rate).toBe(9.0);
-      expect(result.tax_breakdown).toHaveLength(2);
-      expect(result.line_items).toHaveLength(2);
-    });
-
-    it('stripe_publishable_key is distinct from client_secret', async () => {
-      const mockResponse = {
-        client_secret: 'pi_test_secret_abc123',
-        stripe_publishable_key: 'pk_test_xyz789',
-      };
-
-      global.fetch = vi.fn()
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve({ ip: '1.2.3.4' }) })
-        .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockResponse) });
-
-      const result = await createPaymentIntent('cart-123', {});
-
-      // Publishable key should NOT be the same as client_secret
-      expect(result.stripe_publishable_key).not.toBe(result.client_secret);
-      // Publishable key should start with 'pk_'
-      expect(result.stripe_publishable_key.startsWith('pk_')).toBe(true);
-      // Client secret should start with 'pi_' (payment intent)
-      expect(result.client_secret.startsWith('pi_')).toBe(true);
-    });
-  });
-});