@reservamos/browser-analytics 1.1.8-alpha.1 → 1.1.8-alpha.3

package/src/events/identify/identify.ts

@@ -1,9 +1,10 @@
 import type { IdentifyReporter } from '@/util/identifyAttempt';
-import { createAnonymousProfileForIdentify } from '@/profiles/createAnonymousProfile/createAnonymousProfile';
 import configService from '@/services/config';
 import { getFingerprintForIdentify } from '@/services/fingerprint';
 import geolocationService from '@/services/geolocation';
 import mixpanelService from '@/services/mixpanel';
+import profileEnrichment from '@/services/profileEnrichment';
+import trackingLifecycle from '@/services/trackingLifecycle';
 import validatorService from '@/services/validator';
 import {
   createIdentifyReporter,
@@ -15,6 +16,7 @@ import { DefaultProperties } from './identifySchema';
 
 const KNOWN_PROPERTIES = ['firstName', 'lastName', 'email', 'phone'];
 const FINGERPRINT_PROPERTY = 'Known Fingerprints';
+let latestAttempt = 0;
 
 export interface UserProperties
   extends DefaultProperties,
@@ -112,21 +114,74 @@ const identifyWithLocation = async (
   }
 };
 
+async function enrichProfileAndLocation(
+  userId: string,
+  properties: UserProperties,
+  isActive: () => boolean,
+  report: IdentifyReporter,
+): Promise<void> {
+  const profile = await profileEnrichment.enrich(
+    userId,
+    properties,
+    isActive,
+    report,
+  );
+  if (!isActive()) return;
+  const enriched = {
+    ...properties,
+    ...(profile && { reservamos_one_id: profile.id }),
+  };
+  void identifyWithLocation(userId, enriched, report);
+}
+
+async function enrichFingerprint(
+  isActive: () => boolean,
+  report: IdentifyReporter,
+): Promise<void> {
+  const fingerprint = await waitForIdentifyStage(
+    'fingerprint',
+    2000,
+    (context) =>
+      !isActive()
+        ? Promise.resolve('')
+        : getFingerprintForIdentify({
+            isActive: () => context.isActive() && isActive(),
+            report: context.report,
+          }),
+    report,
+  );
+  if (!fingerprint || !isActive()) return;
+  try {
+    mixpanelService.attachProperty(FINGERPRINT_PROPERTY, fingerprint);
+  } catch {
+    report('fingerprint', 'failed');
+  }
+}
+
 /**
- * Identifies a user with given properties and fingerprint.
+ * Applies identity and initial properties before optional enrichment.
  * @param {string} userId - The unique identifier for the user.
- * @param {UserProperties} properties - Optional user properties.
- * @returns {Promise<void>} Resolves after a bounded local attempt, not confirmed remote delivery.
+ * @param {UserProperties} properties - Optional user properties; never mutated.
+ * @returns {Promise<void>} Resolves after the local identity submission, not enrichment or remote delivery.
  */
 async function identify(
   userId: string,
   properties: UserProperties = {},
 ): Promise<void> {
+  const attempt = ++latestAttempt;
+  const input = { ...properties };
   const report = createIdentifyReporter();
-  if (!(await waitForIdentifyReady(report))) return;
+  const initialLifecycle = trackingLifecycle.capture();
+  if (
+    !(await waitForIdentifyReady(report)) ||
+    attempt !== latestAttempt ||
+    !initialLifecycle()
+  )
+    return;
+  let submitted = false;
   try {
     try {
-      validatorService.parseIdentifyProps(properties);
+      validatorService.parseIdentifyProps(input);
       if (!userId) {
         report('validation', 'invalid_input');
         return;
@@ -135,40 +190,22 @@ async function identify(
       report('validation', 'invalid_input');
       return;
     }
-    const anonymousProfile = await waitForIdentifyStage(
-      'profile',
-      3000,
-      (context) =>
-        createAnonymousProfileForIdentify({ ...properties }, context.report),
-      report,
-    );
-
-    if (anonymousProfile) {
-      properties.reservamos_one_id = anonymousProfile.id;
-    }
-    const mappedProps = mapProperties(properties);
     try {
-      mixpanelService.identify(userId, mappedProps, report);
+      mixpanelService.identify(userId, mapProperties(input), report);
     } catch {
       report('mixpanel', 'failed');
+      return;
     }
-    const fingerprint = await waitForIdentifyStage(
-      'fingerprint',
-      2000,
-      getFingerprintForIdentify,
-      report,
-    );
-    if (fingerprint) {
-      try {
-        mixpanelService.attachProperty(FINGERPRINT_PROPERTY, fingerprint);
-      } catch {
-        report('fingerprint', 'failed');
-      }
-    }
-  } catch {
-    report('mixpanel', 'failed');
+    const currentLifecycle = trackingLifecycle.capture();
+    const isActive = () => attempt === latestAttempt && currentLifecycle();
+    const scopedReport: IdentifyReporter = (...args) => {
+      if (isActive()) report(...args);
+    };
+    submitted = true;
+    void enrichProfileAndLocation(userId, input, isActive, scopedReport);
+    void enrichFingerprint(isActive, scopedReport);
   } finally {
-    void identifyWithLocation(userId, properties, report);
+    if (!submitted) void identifyWithLocation(userId, { ...input }, report);
   }
 }
 

package/src/events/passengersCreated/passengersCreatedSchema.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest';
+import paymentAttemptSchema from '@/events/paymentAttempt/paymentAttemptSchema';
+import validatorService from '@/services/validator';
+import passengersCreatedSchema from './passengersCreatedSchema';
+
+const trip = {
+  'Departure Arrival': '2026-10-20T14:30:00',
+  'Departure Destination': 'Destination City',
+  'Departure Destination Terminal': 'Destination Terminal',
+  'Departure Line': 'Synthetic Line',
+  'Departure Origin': 'Origin City',
+  'Departure Origin Terminal': 'Origin Terminal',
+  'Departure Price': 450.5,
+  'Departure Route': 'Origin City - Destination City',
+  'Departure Stops': 1,
+  'Departure Time': '2026-10-20T08:00:00',
+  'Departure Transport Type': 'bus',
+  'Departure Transporter': 'Synthetic Transporter',
+  'Recommended Trip': false,
+};
+
+const passenger = {
+  'Passenger Birthdate': '1990-01-01',
+  'Passenger Seat': '12',
+  'Passenger Name': 'Synthetic Passenger',
+  'Passenger Document Type': 'passport',
+  'Passenger Document Id': 'X0000000',
+};
+
+const basePayload = {
+  'Trips': [trip],
+  'Passenger Count': 1,
+  'Trip Count': 1,
+  'Total': 450.5,
+  'product': 'web',
+  'Passengers': [passenger],
+};
+
+const paymentAttemptPayload = { ...basePayload, 'Payment Type': 'card' };
+
+const without = (source: object, key: string) =>
+  Object.fromEntries(Object.entries(source).filter(([name]) => name !== key));
+
+describe('passengersCreatedSchema', () => {
+  it('accepts a valid payload without Coupon', () => {
+    expect(passengersCreatedSchema.parse(basePayload)).toEqual(basePayload);
+  });
+
+  it('accepts a valid payload with Coupon', () => {
+    const payload = { ...basePayload, Coupon: 'PROMO10' };
+
+    expect(passengersCreatedSchema.parse(payload)).toEqual(payload);
+  });
+
+  it.each([10, true, null, {}])('rejects Coupon given as %j', (coupon) => {
+    expect(
+      passengersCreatedSchema.safeParse({ ...basePayload, Coupon: coupon })
+        .success,
+    ).toBe(false);
+  });
+
+  it('rejects an empty Coupon', () => {
+    expect(
+      passengersCreatedSchema.safeParse({ ...basePayload, Coupon: '' }).success,
+    ).toBe(false);
+  });
+
+  it('keeps rejecting keys outside the schema', () => {
+    const result = passengersCreatedSchema.safeParse({
+      ...basePayload,
+      Insurance: true,
+    });
+
+    expect(result.success).toBe(false);
+    expect(result.error?.issues[0]?.code).toBe('unrecognized_keys');
+  });
+
+  it('accepts the payload shape previously rejected for its Coupon key', () => {
+    expect(() =>
+      validatorService.parseEventProps('Passengers Created', {
+        ...basePayload,
+        Coupon: 'PROMO10',
+      }),
+    ).not.toThrow();
+  });
+
+  it('rejects a trip without Departure Arrival', () => {
+    expect(
+      passengersCreatedSchema.safeParse({
+        ...basePayload,
+        Trips: [without(trip, 'Departure Arrival')],
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe('checkout events with an empty passenger list', () => {
+  it.each([
+    ['Passengers Created', passengersCreatedSchema, basePayload],
+    ['Payment Attempt', paymentAttemptSchema, paymentAttemptPayload],
+  ] as const)(
+    '%s rejects an empty Passengers list',
+    (_name, schema, payload) => {
+      const result = schema.safeParse({ ...payload, Passengers: [] });
+
+      expect(result.success).toBe(false);
+      expect(result.error?.issues.map((issue) => issue.message)).toContain(
+        'Passengers must have at least 1 items',
+      );
+    },
+  );
+
+  it.each([
+    ['Passengers Created', passengersCreatedSchema, basePayload],
+    ['Payment Attempt', paymentAttemptSchema, paymentAttemptPayload],
+  ] as const)(
+    '%s accepts an omitted Passengers list',
+    (_name, schema, payload) => {
+      expect(schema.safeParse(without(payload, 'Passengers')).success).toBe(
+        true,
+      );
+    },
+  );
+});
+
+describe('Coupon parity with Payment Attempt', () => {
+  it.each(['PROMO10', '', 10])(
+    'gives the same verdict for Coupon %j',
+    (coupon) => {
+      const passengersCreated = passengersCreatedSchema.safeParse({
+        ...basePayload,
+        Coupon: coupon,
+      });
+      const paymentAttempt = paymentAttemptSchema.safeParse({
+        ...paymentAttemptPayload,
+        Coupon: coupon,
+      });
+
+      expect(passengersCreated.success).toBe(paymentAttempt.success);
+    },
+  );
+});

package/src/events/passengersCreated/passengersCreatedSchema.ts

@@ -1,5 +1,10 @@
 import { z } from 'zod';
-import { arrayField, intField, numberField } from '@/util/primitiveFields';
+import {
+  arrayField,
+  intField,
+  numberField,
+  stringField,
+} from '@/util/primitiveFields';
 import productValidation from '@/util/productValidation';
 import passengerSchema from '../sharedSchemas/passengerSchema';
 import tripSchema from '../sharedSchemas/tripSchema';
@@ -12,6 +17,7 @@ const passengersCreatedSchema = z
     'Total': numberField('Total'),
     'product': productValidation,
     'Passengers': arrayField(passengerSchema, 'Passengers', 1).optional(),
+    'Coupon': stringField('Coupon').optional(),
   })
   .strict();
 

package/src/events/purchaseConfirmation/purchaseConfirmation.integration.test.ts

@@ -0,0 +1,49 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import analytics from '@/index';
+import mixpanelService from '@/services/mixpanel';
+
+vi.mock('@/services/mixpanel', () => ({
+  default: {
+    isReady: vi.fn().mockReturnValue(true),
+    track: vi.fn(),
+    getMixpanelDistinctId: vi.fn().mockReturnValue('identified-user'),
+  },
+}));
+
+afterEach(() => {
+  vi.clearAllMocks();
+  localStorage.clear();
+});
+
+it('exposes the asynchronous wait through the public analytics facade', async () => {
+  localStorage.setItem(
+    'default_fingerprint_cache',
+    JSON.stringify({
+      fingerprint: 'cached-visitor',
+      expiresAt: Date.now() + 60000,
+    }),
+  );
+  await expect(analytics.identifiers.waitForFingerprintId()).resolves.toBe(
+    'cached-visitor',
+  );
+  expect(analytics.identifiers.getFingerprintId()).toBe('cached-visitor');
+});
+
+it('validates and submits confirmation product through the real tracking pipeline', async () => {
+  analytics.track.purchaseConfirmation({
+    'Operation Id': 'ORDER-1',
+    'Payment Status': 'confirmed',
+    'product': 'web',
+  });
+  await vi.waitFor(() =>
+    expect(mixpanelService.track).toHaveBeenCalledWith(
+      'Purchase Confirmation Viewed',
+      expect.objectContaining({
+        'Operation Id': 'ORDER-1',
+        'Payment Status': 'confirmed',
+        'product': 'web',
+      }),
+    ),
+  );
+  expect(mixpanelService.track).toHaveBeenCalledTimes(1);
+});

package/src/events/purchaseConfirmation/purchaseConfirmation.test.ts

@@ -28,6 +28,22 @@ describe('purchaseConfirmationSchema', () => {
     expect(purchaseConfirmationSchema.parse(payload)).toEqual(payload);
   });
 
+  it.each(['confirmed', 'pending_pix'] as const)(
+    'preserves optional product for %s',
+    (status) => {
+      const payload = {
+        'Operation Id': 'MOB-123',
+        'Payment Status': status,
+        'product': 'web',
+      };
+      expect(purchaseConfirmationSchema.parse(payload)).toEqual(payload);
+      expect(
+        purchaseConfirmationSchema.safeParse({ ...payload, product: 'invalid' })
+          .success,
+      ).toBe(false);
+    },
+  );
+
   it('rejects a payload missing Operation Id', () => {
     expect(() =>
       purchaseConfirmationSchema.parse({ 'Payment Status': 'confirmed' }),
@@ -81,6 +97,7 @@ describe('trackPurchaseConfirmation', () => {
     const eventData = {
       'Operation Id': 'MOB-123',
       'Payment Status': 'confirmed' as const,
+      'product': 'web' as const,
     };
     const meta = { source: 'checkout' };
 

package/src/events/purchaseConfirmation/purchaseConfirmationSchema.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import productValidation from '@/util/productValidation';
 
 const purchaseConfirmationSchema = z
   .object({
@@ -6,6 +7,7 @@ const purchaseConfirmationSchema = z
     'Payment Status': z.enum(['confirmed', 'pending_pix']),
     'Payment Type': z.string().optional(),
     'Total': z.number().optional(),
+    'product': productValidation.optional(),
   })
   .strict();
 

package/src/index.ts

@@ -51,6 +51,7 @@ const analytics = {
   identify,
   identifiers: {
     getFingerprintId: fingerprintService.getCachedFingerprint,
+    waitForFingerprintId: fingerprintService.waitForFingerprintId,
     getDistinctId: mixpanelService.getMixpanelDistinctId,
   },
   profiles: {

package/src/init.ts

@@ -4,6 +4,7 @@ import configService from '@/services/config';
 import fingerprintService from '@/services/fingerprint';
 import geolocationService from '@/services/geolocation';
 import mixpanelService from '@/services/mixpanel';
+import profileEnrichment from '@/services/profileEnrichment';
 import validator, { InitConfigSchema } from '@/services/validator';
 
 /**
@@ -51,12 +52,20 @@ async function init(config: InitConfig) {
   if (appName) {
     configService.setAppName(appName);
   }
-  coreApi.setConfig(configService.getCoreAPIConfig());
+  const coreConfig = configService.getCoreAPIConfig();
+  coreApi.setConfig(coreConfig);
 
   // Dispatch the 'Tracker Ready' event
   onLoaded();
   if (!isCurrent()) return;
 
+  profileEnrichment.initialize({
+    project: mixpanelToken,
+    proxy: mixpanelProxyUrl,
+    apiBaseUrl: coreConfig.baseUrl,
+    appName: coreConfig.defaultHeaders?.['x-app-name'],
+  });
+
   await Promise.all([
     initializeOptionalStage('fingerprint', () =>
       isCurrent()

package/src/profiles/createAnonymousProfile/createAnonymousProfile.ts

@@ -87,6 +87,16 @@ async function requestAnonymousProfile(
   payload: CreateAnonymousProfileProps,
   report?: IdentifyReporter,
 ): Promise<AnonymousProfile | undefined> {
+  return requestPreparedAnonymousProfile(
+    prepareAnonymousProfileForIdentify(payload, report),
+  );
+}
+
+/** Captures exactly the normalized Core request, including its original identifiers. */
+export function prepareAnonymousProfileForIdentify(
+  payload: CreateAnonymousProfileProps,
+  report?: IdentifyReporter,
+): CreateAnonymousProfilePayload {
   validatorService.validateProps(payload, CreateAnonymousProfileSchema);
 
   const identifiers: AnonymousIdentifier[] = [];
@@ -108,8 +118,14 @@ async function requestAnonymousProfile(
     identifiers.push({ key: 'fingerprint', value: userFingerprintId });
   if (distinctId) identifiers.push({ key: 'distinct_id', value: distinctId });
 
-  const dataPayload = getAnonymousProfilePayload(payload, identifiers);
-  return await coreApi.profiles.createAnonymousProfile(dataPayload);
+  return getAnonymousProfilePayload(payload, identifiers);
+}
+
+/** Sends a captured request without rebuilding identifiers from destination state. */
+export function requestPreparedAnonymousProfile(
+  payload: CreateAnonymousProfilePayload,
+): Promise<AnonymousProfile> {
+  return coreApi.profiles.createAnonymousProfile(payload);
 }
 
 export default createAnonymousProfile;

package/src/services/botDetectionRelay.test.ts

@@ -50,7 +50,7 @@ describe('botDetectionRelayService', () => {
 
     expect(fetchMock).toHaveBeenCalledWith(
       'https://data-lake.reservamossaas.com/api/v1/fingerprint/bot-detection',
-      {
+      expect.objectContaining({
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
@@ -64,7 +64,8 @@ describe('botDetectionRelayService', () => {
           eventName: 'Fingerprint Requested',
         }),
         signal: expect.any(AbortSignal),
-      },
+        keepalive: true,
+      }),
     );
   });
 

package/src/services/fingerprint.test.ts

@@ -1,4 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import trackingLifecycle from '@/services/trackingLifecycle';
 import fingerprintService, { getFingerprintForIdentify } from './fingerprint';
 
 const visitorData = {
@@ -396,3 +397,174 @@ describe('fingerprintService', () => {
     consoleError.mockRestore();
   });
 });
+
+describe('bounded fingerprint waiting', () => {
+  beforeEach(async () => {
+    vi.useFakeTimers();
+    localStorage.clear();
+    initMock.mockResolvedValue(undefined);
+    getVisitorDataMock.mockReset().mockResolvedValue(visitorData);
+    clientMock.mockImplementation(() => ({
+      init: initMock,
+      getVisitorData: getVisitorDataMock,
+    }));
+    await fingerprintService.initFingerprint('wait-key');
+  });
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    localStorage.clear();
+  });
+
+  it('returns cache without a provider request', async () => {
+    localStorage.setItem(
+      'default_fingerprint_cache',
+      JSON.stringify({ fingerprint: 'cached', expiresAt: Date.now() + 1000 }),
+    );
+    await expect(fingerprintService.waitForFingerprintId()).resolves.toBe(
+      'cached',
+    );
+    expect(getVisitorDataMock).not.toHaveBeenCalled();
+  });
+  it('joins a fresh request already in flight and serves concurrent waiters', async () => {
+    let finish!: (value: typeof visitorData) => void;
+    getVisitorDataMock.mockReturnValue(
+      new Promise((resolve) => {
+        finish = resolve;
+      }),
+    );
+    const existing = fingerprintService.identifyVisitor(true);
+    const first = fingerprintService.waitForFingerprintId();
+    const second = fingerprintService.waitForFingerprintId();
+    finish(visitorData);
+    await expect(Promise.all([first, second])).resolves.toEqual([
+      'visitor-123',
+      'visitor-123',
+    ]);
+    await existing;
+    expect(getVisitorDataMock).toHaveBeenCalledTimes(1);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+  it('waits for an agent still loading, then identifies only once', async () => {
+    let finish!: () => void;
+    initMock.mockReturnValue(
+      new Promise<void>((resolve) => {
+        finish = resolve;
+      }),
+    );
+    const initialization = fingerprintService.initFingerprint('late-key');
+    const first = fingerprintService.waitForFingerprintId();
+    const second = fingerprintService.waitForFingerprintId();
+    expect(getVisitorDataMock).not.toHaveBeenCalled();
+    finish();
+    await initialization;
+    await expect(Promise.all([first, second])).resolves.toEqual([
+      'visitor-123',
+      'visitor-123',
+    ]);
+    expect(getVisitorDataMock).toHaveBeenCalledTimes(1);
+    expect(getVisitorDataMock).toHaveBeenCalledWith({}, false);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+  it('resolves null when the pending agent fails to load', async () => {
+    let fail!: (error: Error) => void;
+    initMock.mockReturnValue(
+      new Promise((_resolve, reject) => {
+        fail = reject;
+      }),
+    );
+    const initialization = fingerprintService.initFingerprint('blocked-key');
+    const pending = fingerprintService.waitForFingerprintId();
+    const rejected = expect(initialization).rejects.toThrow('blocked');
+    fail(new Error('blocked'));
+    await rejected;
+    await expect(pending).resolves.toBeNull();
+    expect(getVisitorDataMock).not.toHaveBeenCalled();
+  });
+  it.each([-1, Infinity, NaN])(
+    'resolves null for invalid budget %s',
+    async (budget) => {
+      await expect(
+        fingerprintService.waitForFingerprintId(budget),
+      ).resolves.toBeNull();
+      expect(getVisitorDataMock).not.toHaveBeenCalled();
+    },
+  );
+  it('keeps a late successful result after the caller times out without another lookup', async () => {
+    let finish!: (value: typeof visitorData) => void;
+    getVisitorDataMock.mockReturnValue(
+      new Promise((resolve) => {
+        finish = resolve;
+      }),
+    );
+    setPeoplePropertiesMock.mockClear();
+    const pending = fingerprintService.waitForFingerprintId(2000);
+    await vi.advanceTimersByTimeAsync(2000);
+    await expect(pending).resolves.toBeNull();
+    await vi.advanceTimersByTimeAsync(500);
+    finish(visitorData);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(fingerprintService.getCachedFingerprint()).toBe('visitor-123');
+    expect(setPeoplePropertiesMock).toHaveBeenCalledWith({
+      'Visitor Found': true,
+    });
+    await expect(fingerprintService.waitForFingerprintId()).resolves.toBe(
+      'visitor-123',
+    );
+    expect(getVisitorDataMock).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+  it('suppresses a timed-out request after its user lifecycle changes', async () => {
+    let finish!: (value: typeof visitorData) => void;
+    getVisitorDataMock.mockReturnValue(
+      new Promise((resolve) => {
+        finish = resolve;
+      }),
+    );
+    setPeoplePropertiesMock.mockClear();
+    const pending = fingerprintService.waitForFingerprintId(2000);
+    await vi.advanceTimersByTimeAsync(2000);
+    await expect(pending).resolves.toBeNull();
+    trackingLifecycle.identify('replacement-user-after-timeout');
+    finish(visitorData);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(fingerprintService.getCachedFingerprint()).toBeNull();
+    expect(setPeoplePropertiesMock).not.toHaveBeenCalled();
+    expect(getVisitorDataMock).toHaveBeenCalledTimes(1);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+  it('resolves null at its timeout and consumes late rejection', async () => {
+    let fail!: (error: Error) => void;
+    getVisitorDataMock.mockReturnValue(
+      new Promise((_resolve, reject) => {
+        fail = reject;
+      }),
+    );
+    const pending = fingerprintService.waitForFingerprintId(100);
+    await vi.advanceTimersByTimeAsync(100);
+    await expect(pending).resolves.toBeNull();
+    fail(new Error('offline'));
+    await vi.advanceTimersByTimeAsync(0);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+  it('cancels when initialization changes and ignores an old result', async () => {
+    let finish!: (value: typeof visitorData) => void;
+    getVisitorDataMock.mockReturnValue(
+      new Promise((resolve) => {
+        finish = resolve;
+      }),
+    );
+    const pending = fingerprintService.waitForFingerprintId();
+    await fingerprintService.initFingerprint('replacement');
+    await expect(pending).resolves.toBeNull();
+    finish(visitorData);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(fingerprintService.getCachedFingerprint()).toBeNull();
+    await vi.advanceTimersByTimeAsync(0);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+});