@reservamos/browser-analytics 1.1.7-alpha.1 → 1.1.8-alpha.0

package/src/services/mixpanel.test.ts

@@ -9,6 +9,7 @@ import {
   it,
   vi,
 } from 'vitest';
+import { trackEvent } from '@/track';
 import { version } from '../../package.json';
 import mixpanelService from './mixpanel';
 
@@ -100,6 +101,66 @@ describe('Mixpanel SDK version metadata', () => {
     expect(people).toHaveBeenCalledWith({});
   });
 
+  it.each(['getItem', 'setItem'] as const)(
+    'keeps the live distinct ID when SDK storage %s fails',
+    (method) => {
+      vi.spyOn(mixpanel, 'get_distinct_id').mockReturnValue('live-id');
+      vi.spyOn(Storage.prototype, method).mockImplementation(() => {
+        throw new DOMException('Blocked', 'SecurityError');
+      });
+      expect(mixpanelService.getMixpanelDistinctId()).toBe('live-id');
+    },
+  );
+
+  it.each(['getItem', 'setItem'] as const)(
+    'submits the original event when SDK storage %s is blocked',
+    async (method) => {
+      const send = vi
+        .spyOn(transport, '_track_or_batch')
+        .mockImplementation(({ data }) => data);
+      mixpanel.identify('storage-test-id');
+      send.mockClear();
+      vi.spyOn(Storage.prototype, method).mockImplementation(() => {
+        throw new DOMException('Blocked', 'SecurityError');
+      });
+      await trackEvent('Storage Failure Test', { source: 'checkout' });
+      expect(send.mock.calls.map(([options]) => options.data)).toContainEqual({
+        event: 'Storage Failure Test',
+        properties: expect.objectContaining({
+          source: 'checkout',
+          distinct_id: 'storage-test-id',
+        }),
+      });
+    },
+  );
+
+  it('returns null when no live distinct ID is available and the cache is blocked', () => {
+    vi.spyOn(mixpanel, 'get_distinct_id').mockReturnValue('');
+    vi.spyOn(Storage.prototype, 'getItem').mockImplementation(() => {
+      throw new DOMException('Blocked', 'SecurityError');
+    });
+    expect(mixpanelService.getMixpanelDistinctId()).toBeNull();
+  });
+
+  it('uses the cached distinct ID when Mixpanel has no live ID', () => {
+    localStorage.setItem('mp_distinct_id', 'cached-id');
+    vi.spyOn(mixpanel, 'get_distinct_id').mockReturnValue('');
+    expect(mixpanelService.getMixpanelDistinctId()).toBe('cached-id');
+  });
+
+  it('preserves identify cache diagnostics and people updates on a write failure', () => {
+    vi.spyOn(mixpanel, 'identify').mockImplementation(() => undefined);
+    vi.spyOn(Storage.prototype, 'setItem').mockImplementation(() => {
+      throw new DOMException('Blocked', 'SecurityError');
+    });
+    vi.spyOn(mixpanel.people, 'set').mockImplementation(() => undefined);
+    vi.useFakeTimers();
+    const report = vi.fn();
+    mixpanelService.identify('user-id', {}, report);
+    expect(report).toHaveBeenCalledWith('cache', 'unavailable');
+    expect(mixpanel.people.set).toHaveBeenCalled();
+  });
+
   it.each([
     1,
     0,

package/src/services/mixpanel.ts

@@ -57,11 +57,7 @@ function identify(
   report?: IdentifyReporter,
 ): void {
   mixpanel.identify(userId);
-  try {
-    updateCachedDistinctId(userId);
-  } catch {
-    report?.('cache', 'unavailable');
-  }
+  if (!updateCachedDistinctId(userId)) report?.('cache', 'unavailable');
   if (!report) {
     mixpanel.people.set(properties);
     return;
@@ -136,26 +132,30 @@ function track(eventName: string, properties: Record<string, unknown>): void {
  * @returns {string | null} The distinct ID if available, or null if Mixpanel is not initialized.
  */
 export const getMixpanelDistinctId = (): string | null => {
-  const cachedId = localStorage.getItem(MIXPANEL_DISTINCT_ID_CACHE_KEY);
-
-  if (mixpanel && mixpanel.get_distinct_id) {
-    const distinctId = mixpanel.get_distinct_id();
-
+  const distinctId = mixpanel?.get_distinct_id?.();
+  if (distinctId) {
     updateCachedDistinctId(distinctId);
-
     return distinctId;
-  } else if (cachedId) {
-    return cachedId;
   }
-  return null;
+
+  try {
+    return localStorage.getItem(MIXPANEL_DISTINCT_ID_CACHE_KEY);
+  } catch {
+    return null;
+  }
 };
 /**
  * Updates the cached Mixpanel distinct ID.
  * Should be called when identifying a user to ensure cache stays in sync.
  * @param {string} distinctId - The distinct ID to cache
  */
-function updateCachedDistinctId(distinctId: string): void {
-  localStorage.setItem(MIXPANEL_DISTINCT_ID_CACHE_KEY, distinctId);
+function updateCachedDistinctId(distinctId: string): boolean {
+  try {
+    localStorage.setItem(MIXPANEL_DISTINCT_ID_CACHE_KEY, distinctId);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 const mixpanelService = {

package/src/track.test.ts

@@ -1,8 +1,9 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import botDetectionRelayService from '@/services/botDetectionRelay';
 import fingerprintService from '@/services/fingerprint';
 import mixpanelService from '@/services/mixpanel';
-import { trackEvent } from './track';
+import validator from '@/services/validator';
+import { trackEvent, trackEventError, tryTrackEvent } from './track';
 
 vi.mock('@/services/botDetectionRelay', () => ({
   default: {
@@ -14,6 +15,7 @@ vi.mock('@/services/botDetectionRelay', () => ({
 vi.mock('@/services/fingerprint', () => ({
   default: {
     getFingerprint: vi.fn(),
+    getCachedFingerprint: vi.fn(),
     identifyVisitor: vi.fn(),
     isFingerprintReady: vi.fn(),
   },
@@ -42,115 +44,357 @@ vi.mock('@/services/validator', () => ({
 
 describe('trackEvent Bot Detection relay', () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    vi.resetAllMocks();
     vi.mocked(mixpanelService.isReady).mockReturnValue(true);
     vi.mocked(mixpanelService.getMixpanelDistinctId).mockReturnValue(
       'distinct-123',
     );
-    vi.mocked(fingerprintService.isFingerprintReady).mockReturnValue(true);
-  });
-
-  it('uses a fresh identification and relays a configured event', async () => {
     vi.mocked(botDetectionRelayService.isEnabledFor).mockReturnValue(true);
+    vi.mocked(fingerprintService.isFingerprintReady).mockReturnValue(true);
+    vi.mocked(fingerprintService.getCachedFingerprint).mockReturnValue(
+      'cached-visitor',
+    );
     vi.mocked(fingerprintService.identifyVisitor).mockResolvedValue({
-      visitorId: 'visitor-123',
-      requestId: 'request-123',
-      visitorFound: true,
+      visitorId: 'fresh-visitor',
+      requestId: 'fresh-request',
       confidenceScore: 0.99,
       cacheHit: false,
     });
+    vi.mocked(botDetectionRelayService.relay).mockResolvedValue(undefined);
+  });
 
-    await trackEvent('Payment Attempt', { 'Payment Type': 'credit_card' });
+  describe.each(['Search', 'Payment Attempt', 'Purchase Attempt'])(
+    '%s',
+    (eventName) => {
+      it.each(['cached-visitor', null])(
+        'submits with cached identity %s before starting identification',
+        async (cachedVisitor) => {
+          vi.mocked(fingerprintService.getCachedFingerprint).mockReturnValue(
+            cachedVisitor,
+          );
+          vi.mocked(fingerprintService.identifyVisitor).mockImplementation(
+            () => {
+              expect(mixpanelService.track).toHaveBeenCalledWith(eventName, {
+                'User Fingerprint': cachedVisitor ?? '',
+                'Payment Type': 'credit_card',
+                'Checkout Source': 'web',
+              });
+              return Promise.resolve({
+                visitorId: 'fresh-visitor',
+                requestId: 'fresh-request',
+                confidenceScore: 0.99,
+                cacheHit: false,
+              });
+            },
+          );
 
-    expect(fingerprintService.identifyVisitor).toHaveBeenCalledWith(true);
-    expect(fingerprintService.getFingerprint).not.toHaveBeenCalled();
-    expect(mixpanelService.track).toHaveBeenCalledWith('Payment Attempt', {
-      'User Fingerprint': 'visitor-123',
-      'Payment Type': 'credit_card',
-    });
-    expect(botDetectionRelayService.relay).toHaveBeenCalledWith({
-      requestId: 'request-123',
-      visitorId: 'visitor-123',
-      distinctId: 'distinct-123',
-      eventName: 'Payment Attempt',
+          const completion = trackEvent(
+            eventName,
+            { 'Payment Type': 'credit_card' },
+            { 'Checkout Source': 'web' },
+          );
+
+          expect(mixpanelService.track).toHaveBeenCalledTimes(1);
+          await completion;
+          expect(fingerprintService.getFingerprint).not.toHaveBeenCalled();
+          expect(fingerprintService.identifyVisitor).toHaveBeenCalledWith(true);
+          await vi.waitFor(() =>
+            expect(botDetectionRelayService.relay).toHaveBeenCalledOnce(),
+          );
+          expect(botDetectionRelayService.relay).toHaveBeenCalledWith({
+            requestId: 'fresh-request',
+            visitorId: 'fresh-visitor',
+            distinctId: 'distinct-123',
+            eventName,
+          });
+        },
+      );
+
+      it('completes tracking while fresh identification is still pending', async () => {
+        let resolveIdentification!: (
+          value: Awaited<ReturnType<typeof fingerprintService.identifyVisitor>>,
+        ) => void;
+        vi.mocked(fingerprintService.identifyVisitor).mockReturnValue(
+          new Promise((resolve) => {
+            resolveIdentification = resolve;
+          }),
+        );
+        const onComplete = vi.fn();
+        const completion = trackEvent(eventName, {}).then(onComplete);
+        // A pending remote operation must not delay submission or completion.
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(mixpanelService.track).toHaveBeenCalledWith(eventName, {
+          'User Fingerprint': 'cached-visitor',
+        });
+        expect(onComplete).toHaveBeenCalledOnce();
+        expect(botDetectionRelayService.relay).not.toHaveBeenCalled();
+        resolveIdentification({
+          visitorId: 'late-visitor',
+          requestId: 'late-request',
+          confidenceScore: 0.99,
+          cacheHit: false,
+        });
+        await completion;
+        await vi.waitFor(() =>
+          expect(botDetectionRelayService.relay).toHaveBeenCalledOnce(),
+        );
+        expect(botDetectionRelayService.relay).toHaveBeenCalledWith({
+          requestId: 'late-request',
+          visitorId: 'late-visitor',
+          distinctId: 'distinct-123',
+          eventName,
+        });
+        expect(mixpanelService.track).toHaveBeenCalledTimes(1);
+      });
+
+      it('preserves the original event when identification rejects', async () => {
+        vi.mocked(fingerprintService.identifyVisitor).mockRejectedValue(
+          new Error('Identification failed'),
+        );
+        await trackEvent(eventName, {});
+        expect(mixpanelService.track).toHaveBeenCalledTimes(1);
+        expect(mixpanelService.track).toHaveBeenCalledWith(eventName, {
+          'User Fingerprint': 'cached-visitor',
+        });
+        expect(botDetectionRelayService.relay).not.toHaveBeenCalled();
+      });
+
+      it('submits without identity if reading the cache throws', async () => {
+        vi.mocked(fingerprintService.getCachedFingerprint).mockImplementation(
+          () => {
+            throw new Error('Cache unavailable');
+          },
+        );
+        await trackEvent(eventName, {});
+        expect(mixpanelService.track).toHaveBeenCalledTimes(1);
+        expect(mixpanelService.track).toHaveBeenCalledWith(eventName, {
+          'User Fingerprint': '',
+        });
+      });
+
+      it('submits without starting identification when the agent is unavailable', async () => {
+        vi.mocked(fingerprintService.isFingerprintReady).mockReturnValue(false);
+        await trackEvent(eventName, {});
+        expect(mixpanelService.track).toHaveBeenCalledWith(eventName, {
+          'User Fingerprint': 'cached-visitor',
+        });
+        expect(fingerprintService.identifyVisitor).not.toHaveBeenCalled();
+        expect(botDetectionRelayService.relay).not.toHaveBeenCalled();
+      });
+    },
+  );
+
+  it('relays the original distinct ID even if identity changes while identification is pending', async () => {
+    let resolveIdentification!: (
+      value: Awaited<ReturnType<typeof fingerprintService.identifyVisitor>>,
+    ) => void;
+    vi.mocked(fingerprintService.identifyVisitor).mockReturnValue(
+      new Promise((resolve) => {
+        resolveIdentification = resolve;
+      }),
+    );
+    await trackEvent('Payment Attempt', {});
+    vi.mocked(mixpanelService.getMixpanelDistinctId).mockReturnValue(
+      'new-distinct-id',
+    );
+    resolveIdentification({
+      visitorId: 'fresh-visitor',
+      requestId: 'fresh-request',
+      confidenceScore: 0.99,
+      cacheHit: false,
     });
+    await vi.waitFor(() =>
+      expect(botDetectionRelayService.relay).toHaveBeenCalledWith({
+        requestId: 'fresh-request',
+        visitorId: 'fresh-visitor',
+        distinctId: 'distinct-123',
+        eventName: 'Payment Attempt',
+      }),
+    );
   });
 
-  it('reports a failed fresh identification without tracking or relaying the configured event', async () => {
-    vi.mocked(botDetectionRelayService.isEnabledFor).mockReturnValue(true);
-    vi.mocked(fingerprintService.identifyVisitor).mockRejectedValue(
-      new Error('Fingerprint identification failed'),
+  it('contains an unexpected background relay rejection', async () => {
+    vi.mocked(botDetectionRelayService.relay).mockRejectedValue(
+      new Error('Relay failed'),
     );
-    const eventProperties = { 'Payment Type': 'credit_card' };
+    await trackEvent('Payment Attempt', {});
+    await Promise.resolve();
+    expect(mixpanelService.track).toHaveBeenCalledTimes(1);
+    expect(mixpanelService.track).toHaveBeenCalledWith('Payment Attempt', {
+      'User Fingerprint': 'cached-visitor',
+    });
+  });
 
-    await trackEvent('Payment Attempt', eventProperties);
+  it('retains tracking error behavior for invalid event properties', async () => {
+    vi.mocked(validator.parseEventProps).mockImplementationOnce(() => {
+      throw new Error('Invalid event properties');
+    });
+    await trackEvent('Payment Attempt', {});
+    expect(fingerprintService.identifyVisitor).not.toHaveBeenCalled();
+    expect(mixpanelService.track).toHaveBeenCalledTimes(1);
+    expect(mixpanelService.track).toHaveBeenCalledWith(
+      'Track Event Error',
+      expect.objectContaining({ 'Failed Event Name': 'Payment Attempt' }),
+    );
+  });
 
-    expect(fingerprintService.identifyVisitor).toHaveBeenCalledWith(true);
-    expect(fingerprintService.getFingerprint).not.toHaveBeenCalled();
+  it('does not start bot detection when submitting the original event throws', async () => {
+    vi.mocked(mixpanelService.track).mockImplementationOnce(() => {
+      throw new Error('Tracking failed');
+    });
+    await trackEvent('Payment Attempt', {});
+    expect(fingerprintService.identifyVisitor).not.toHaveBeenCalled();
     expect(botDetectionRelayService.relay).not.toHaveBeenCalled();
+  });
+
+  it('submits View Results with an empty fingerprint if identification rejects', async () => {
+    vi.mocked(botDetectionRelayService.isEnabledFor).mockReturnValue(false);
+    vi.mocked(fingerprintService.getFingerprint).mockRejectedValue(
+      new Error('Fingerprint failed'),
+    );
+    await trackEvent('View Results', { 'Results Count': 2 }, { source: 'web' });
+    expect(fingerprintService.getFingerprint).toHaveBeenCalledWith(false);
     expect(mixpanelService.track).toHaveBeenCalledTimes(1);
-    expect(mixpanelService.track).toHaveBeenCalledWith('Track Event Error', {
-      'Failed Event Name': 'Payment Attempt',
-      'Error Message': 'Fingerprint identification failed',
-      'Validation Errors': [],
-      'Event Payload': eventProperties,
+    expect(mixpanelService.track).toHaveBeenCalledWith('View Results', {
+      'User Fingerprint': '',
+      'Results Count': 2,
+      'source': 'web',
     });
   });
 
-  it('preserves existing fingerprint behavior for an unconfigured event', async () => {
+  it('preserves existing fingerprint behavior for events outside bot detection', async () => {
     vi.mocked(botDetectionRelayService.isEnabledFor).mockReturnValue(false);
     vi.mocked(fingerprintService.getFingerprint).mockResolvedValue(
       'cached-visitor',
     );
-
-    await trackEvent('Payment Attempt', { 'Payment Type': 'credit_card' });
-
+    await trackEvent('Seat Change', {});
     expect(fingerprintService.getFingerprint).toHaveBeenCalledWith(true);
+    expect(fingerprintService.getCachedFingerprint).not.toHaveBeenCalled();
     expect(fingerprintService.identifyVisitor).not.toHaveBeenCalled();
-    expect(mixpanelService.track).toHaveBeenCalledWith('Payment Attempt', {
+    expect(mixpanelService.track).toHaveBeenCalledWith('Seat Change', {
       'User Fingerprint': 'cached-visitor',
-      'Payment Type': 'credit_card',
     });
     expect(botDetectionRelayService.relay).not.toHaveBeenCalled();
   });
+});
 
-  it('uses a fresh identification and relays Search', async () => {
-    vi.mocked(botDetectionRelayService.isEnabledFor).mockReturnValue(true);
-    vi.mocked(fingerprintService.identifyVisitor).mockResolvedValue({
-      visitorId: 'visitor-123',
-      requestId: 'search-request-123',
-      visitorFound: true,
-      confidenceScore: 0.99,
-      cacheHit: false,
-    });
+describe('bounded tracking readiness', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.resetAllMocks();
+    vi.mocked(mixpanelService.isReady).mockReturnValue(false);
+    vi.mocked(botDetectionRelayService.isEnabledFor).mockReturnValue(false);
+    vi.mocked(fingerprintService.getFingerprint).mockResolvedValue('');
+    vi.mocked(fingerprintService.isFingerprintReady).mockReturnValue(false);
+    vi.spyOn(console, 'error').mockImplementation(() => undefined);
+  });
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it('submits at the deadline if Mixpanel loaded without a Tracker Ready signal', async () => {
+    const pending = trackEvent('Payment Attempt', { source: 'checkout' });
+    await vi.advanceTimersByTimeAsync(1000);
+    vi.mocked(mixpanelService.isReady).mockReturnValue(true);
+    await vi.advanceTimersByTimeAsync(4000);
+    await pending;
+    expect(mixpanelService.track).toHaveBeenCalledWith(
+      'Payment Attempt',
+      expect.objectContaining({ source: 'checkout' }),
+    );
+    expect(console.error).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
 
-    await trackEvent('Search', {});
+  it('holds multiple events until readiness and submits each once', async () => {
+    const remove = vi.spyOn(window, 'removeEventListener');
+    const first = trackEvent('Payment Attempt', { source: 'first' });
+    const second = trackEvent('Purchase Attempt', { source: 'second' });
+    void first.catch(() => undefined);
+    void second.catch(() => undefined);
+    expect(mixpanelService.track).not.toHaveBeenCalled();
+    vi.mocked(mixpanelService.isReady).mockReturnValue(true);
+    window.dispatchEvent(new CustomEvent('Tracker Ready'));
+    window.dispatchEvent(new CustomEvent('Tracker Ready'));
+    await expect(Promise.all([first, second])).resolves.toEqual([
+      undefined,
+      undefined,
+    ]);
+    expect(mixpanelService.track).toHaveBeenCalledTimes(2);
+    expect(mixpanelService.track).toHaveBeenCalledWith(
+      'Payment Attempt',
+      expect.objectContaining({ source: 'first' }),
+    );
+    expect(mixpanelService.track).toHaveBeenCalledWith(
+      'Purchase Attempt',
+      expect.objectContaining({ source: 'second' }),
+    );
+    expect(remove).toHaveBeenCalledWith('Tracker Ready', expect.any(Function));
+    expect(vi.getTimerCount()).toBe(0);
+  });
 
-    expect(fingerprintService.identifyVisitor).toHaveBeenCalledWith(true);
-    expect(fingerprintService.getFingerprint).not.toHaveBeenCalled();
-    expect(mixpanelService.track).toHaveBeenCalledWith('Search', {
-      'User Fingerprint': 'visitor-123',
+  it('expires cleanly, reports a controlled diagnostic, and ignores late readiness', async () => {
+    const remove = vi.spyOn(window, 'removeEventListener');
+    const pending = trackEvent('Payment Attempt', {
+      secret: 'private-payload',
     });
-    expect(botDetectionRelayService.relay).toHaveBeenCalledWith({
-      requestId: 'search-request-123',
-      visitorId: 'visitor-123',
-      distinctId: 'distinct-123',
-      eventName: 'Search',
+    void pending.catch(() => undefined);
+    await vi.advanceTimersByTimeAsync(5000);
+    await expect(pending).resolves.toBeUndefined();
+    expect(console.error).toHaveBeenCalledWith('Tracking diagnostic', {
+      eventName: 'Payment Attempt',
+      stage: 'readiness',
+      reason: 'timeout',
     });
+    expect(JSON.stringify(vi.mocked(console.error).mock.calls)).not.toContain(
+      'private-payload',
+    );
+    expect(remove).toHaveBeenCalledWith('Tracker Ready', expect.any(Function));
+    expect(vi.getTimerCount()).toBe(0);
+    vi.mocked(mixpanelService.isReady).mockReturnValue(true);
+    window.dispatchEvent(new CustomEvent('Tracker Ready'));
+    await Promise.resolve();
+    expect(mixpanelService.track).not.toHaveBeenCalled();
   });
 
-  it('tracks Search without a relay when Fingerprint is not ready', async () => {
-    vi.mocked(botDetectionRelayService.isEnabledFor).mockReturnValue(true);
-    vi.mocked(fingerprintService.isFingerprintReady).mockReturnValue(false);
-    vi.mocked(fingerprintService.getFingerprint).mockResolvedValue('');
+  it('does not execute when a readiness signal arrives before Mixpanel is ready', async () => {
+    const callback = vi.fn().mockResolvedValue(undefined);
+    const pending = tryTrackEvent(callback);
+    window.dispatchEvent(new CustomEvent('Tracker Ready'));
+    await Promise.resolve();
+    expect(callback).not.toHaveBeenCalled();
+    vi.mocked(mixpanelService.isReady).mockReturnValue(true);
+    window.dispatchEvent(new CustomEvent('Tracker Ready'));
+    await pending;
+    expect(callback).toHaveBeenCalledOnce();
+    expect(vi.getTimerCount()).toBe(0);
+  });
 
-    await trackEvent('Search', {});
+  it('consumes callback rejection after readiness', async () => {
+    const callback = vi
+      .fn()
+      .mockRejectedValue(new Error('private-callback-error'));
+    const pending = tryTrackEvent(callback);
+    vi.mocked(mixpanelService.isReady).mockReturnValue(true);
+    window.dispatchEvent(new CustomEvent('Tracker Ready'));
+    await expect(pending).resolves.toBeUndefined();
+    expect(callback).toHaveBeenCalledOnce();
+    expect(JSON.stringify(vi.mocked(console.error).mock.calls)).not.toContain(
+      'private-callback-error',
+    );
+    expect(vi.getTimerCount()).toBe(0);
+  });
 
-    expect(fingerprintService.identifyVisitor).not.toHaveBeenCalled();
-    expect(fingerprintService.getFingerprint).toHaveBeenCalledWith(false);
-    expect(mixpanelService.track).toHaveBeenCalledWith('Search', {
-      'User Fingerprint': '',
-    });
-    expect(botDetectionRelayService.relay).not.toHaveBeenCalled();
+  it('expires a queued tracking diagnostic without creating another listener', async () => {
+    const add = vi.spyOn(window, 'addEventListener');
+    trackEventError('Payment Attempt', new Error('failed'), {});
+    await vi.advanceTimersByTimeAsync(5000);
+    expect(
+      add.mock.calls.filter(([name]) => name === 'Tracker Ready'),
+    ).toHaveLength(1);
+    expect(vi.getTimerCount()).toBe(0);
   });
 });