coveo.analytics 2.30.55 → 2.31.0

package/src/plugins/ec.spec.ts

@@ -1,559 +1,587 @@
+import {vi} from 'vitest';
 import {ECPlugin, ECPluginEventTypes, Product} from './ec';
 import {createAnalyticsClientMock} from '../../tests/analyticsClientMock';
 
 describe('EC plugin', () => {
-    let ec: ECPlugin;
-    let client: ReturnType<typeof createAnalyticsClientMock>;
-
-    const someUUIDGenerator = jest.fn(() => someUUID);
-    const someUUID = '13ccebdb-0138-45e8-bf70-884817ead190';
-    const defaultResult = {
-        pageViewId: someUUID,
-        encoding: document.characterSet,
-        location: 'http://localhost/',
-        referrer: 'http://somewhere.over/thereferrer',
-        title: 'MAH PAGE',
-        screenColor: '24-bit',
-        screenResolution: '0x0',
-        time: expect.any(Number),
-        userAgent: navigator.userAgent,
-        language: 'en-US',
-        hitType: ECPluginEventTypes.event,
-        eventId: someUUID,
-    };
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        client = createAnalyticsClientMock();
-        ec = new ECPlugin({client, uuidGenerator: someUUIDGenerator as any});
+  let ec: ECPlugin;
+  let client: ReturnType<typeof createAnalyticsClientMock>;
+
+  const someUUIDGenerator = vi.fn(() => someUUID);
+  const someUUID = '13ccebdb-0138-45e8-bf70-884817ead190';
+  const defaultResult = {
+    pageViewId: someUUID,
+    encoding: document.characterSet,
+    location: 'http://localhost/',
+    referrer: 'http://somewhere.over/thereferrer',
+    title: 'MAH PAGE',
+    screenColor: '24-bit',
+    screenResolution: '0x0',
+    time: expect.any(Number),
+    userAgent: navigator.userAgent,
+    language: 'en-US',
+    hitType: ECPluginEventTypes.event,
+    eventId: someUUID,
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    client = createAnalyticsClientMock();
+    ec = new ECPlugin({client, uuidGenerator: someUUIDGenerator as any});
+  });
+
+  it('should register a hook in the client', () => {
+    expect(client.registerBeforeSendEventHook).toHaveBeenCalledTimes(1);
+  });
+
+  it('should register a mapping for each EC type', () => {
+    expect(client.addEventTypeMapping).toHaveBeenCalledTimes(
+      Object.keys(ECPluginEventTypes).length
+    );
+  });
+
+  describe('products', () => {
+    it('should append the product with the specific format when the hook is called', () => {
+      ec.addProduct({id: 'C0V30'});
+
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+
+      expect(result).toEqual({...defaultResult, pr1id: 'C0V30'});
     });
 
-    it('should register a hook in the client', () => {
-        expect(client.registerBeforeSendEventHook).toHaveBeenCalledTimes(1);
-    });
+    it('should append the product with the pageview event', () => {
+      ec.addProduct({name: 'Relevance T-Shirt'});
 
-    it('should register a mapping for each EC type', () => {
-        expect(client.addEventTypeMapping).toHaveBeenCalledTimes(Object.keys(ECPluginEventTypes).length);
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+
+      expect(result).toEqual({...defaultResult, pr1nm: 'Relevance T-Shirt'});
     });
 
-    describe('products', () => {
-        it('should append the product with the specific format when the hook is called', () => {
-            ec.addProduct({id: 'C0V30'});
+    it('should not append the product with a random event type', () => {
+      ec.addProduct({id: ':testProductId:'});
 
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+      const result = executeRegisteredHook('🎲', {});
 
-            expect(result).toEqual({...defaultResult, pr1id: 'C0V30'});
-        });
+      expect(result).toEqual({});
+    });
 
-        it('should append the product with the pageview event', () => {
-            ec.addProduct({name: 'Relevance T-Shirt'});
+    it('should keep the products until a valid event type is used', () => {
+      ec.addProduct({id: 'P12345'});
 
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+      executeRegisteredHook('🎲', {});
+      executeRegisteredHook('🐟', {});
+      executeRegisteredHook('💀', {});
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-            expect(result).toEqual({...defaultResult, pr1nm: 'Relevance T-Shirt'});
-        });
+      expect(result).toEqual({...defaultResult, pr1id: 'P12345'});
+    });
 
-        it('should not append the product with a random event type', () => {
-            ec.addProduct({id: ':sorandom:'});
+    it('should convert known product keys into the measurement protocol format', () => {
+      ec.addProduct({name: '🧀', price: 5.99});
 
-            const result = executeRegisteredHook('🎲', {});
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-            expect(result).toEqual({});
-        });
+      expect(result).toEqual({...defaultResult, pr1nm: '🧀', pr1pr: 5.99});
+    });
 
-        it('should keep the products until a valid event type is used', () => {
-            ec.addProduct({id: 'P12345'});
+    it('should keep custom metadata in the product', () => {
+      ec.addProduct({name: '🧀', price: 5.99, custom: {verycustom: 'value'}});
 
-            executeRegisteredHook('🎲', {});
-            executeRegisteredHook('🐟', {});
-            executeRegisteredHook('💀', {});
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-            expect(result).toEqual({...defaultResult, pr1id: 'P12345'});
-        });
+      expect(result).toEqual({
+        ...defaultResult,
+        pr1nm: '🧀',
+        pr1pr: 5.99,
+        pr1custom: {verycustom: 'value'},
+      });
+    });
 
-        it('should convert known product keys into the measurement protocol format', () => {
-            ec.addProduct({name: '🧀', price: 5.99});
+    it('should allow adding multiple products', () => {
+      ec.addProduct({name: '🍟', price: 1.99});
+      ec.addProduct({name: '🍿', price: 3});
+      ec.addProduct({name: '🥤', price: 2});
+
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+
+      expect(result).toEqual({
+        ...defaultResult,
+        pr1nm: '🍟',
+        pr1pr: 1.99,
+        pr2nm: '🍿',
+        pr2pr: 3,
+        pr3nm: '🥤',
+        pr3pr: 2,
+      });
+    });
 
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+    it('should flush the products once they are sent', () => {
+      ec.addProduct({name: '🍟', price: 1.99});
+      ec.addProduct({name: '🍿', price: 3});
 
-            expect(result).toEqual({...defaultResult, pr1nm: '🧀', pr1pr: 5.99});
-        });
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-        it('should keep custom metadata in the product', () => {
-            ec.addProduct({name: '🧀', price: 5.99, custom: {verycustom: 'value'}});
+      expect(result).not.toEqual({});
 
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+      const secondResult = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-            expect(result).toEqual({...defaultResult, pr1nm: '🧀', pr1pr: 5.99, pr1custom: {verycustom: 'value'}});
-        });
+      expect(secondResult).toEqual({...defaultResult});
+    });
 
-        it('should allow adding multiple products', () => {
-            ec.addProduct({name: '🍟', price: 1.99});
-            ec.addProduct({name: '🍿', price: 3});
-            ec.addProduct({name: '🥤', price: 2});
-
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
-
-            expect(result).toEqual({
-                ...defaultResult,
-                pr1nm: '🍟',
-                pr1pr: 1.99,
-                pr2nm: '🍿',
-                pr2pr: 3,
-                pr3nm: '🥤',
-                pr3pr: 2,
-            });
-        });
+    it('should convert position to number if possible', () => {
+      const validValues = ['13', '5.5'];
+      for (const value of validValues) {
+        // @ts-ignore
+        ec.addProduct({name: 'product', position: value});
 
-        it('should flush the products once they are sent', () => {
-            ec.addProduct({name: '🍟', price: 1.99});
-            ec.addProduct({name: '🍿', price: 3});
+        const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+        const expected: Record<string, any> = {
+          ...defaultResult,
+          pr1nm: 'product',
+          pr1ps: +value,
+        };
 
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+        expect(result).toEqual(expected);
+      }
+    });
 
-            expect(result).not.toEqual({});
+    it('should keep original value if position is not a number', () => {
+      const invalidValues = ['1-2-3', '.', '-', '123abc'];
+      for (const value of invalidValues) {
+        // @ts-ignore
+        ec.addProduct({name: 'product', position: value});
 
-            const secondResult = executeRegisteredHook(ECPluginEventTypes.event, {});
+        const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+        const expected: Record<string, unknown> = {
+          ...defaultResult,
+          pr1nm: 'product',
+          pr1ps: value,
+        };
 
-            expect(secondResult).toEqual({...defaultResult});
-        });
+        expect(result).toEqual(expected);
+      }
+    });
 
-        it('should convert position to number if possible', () => {
-            const validValues = ['13', '5.5'];
-            for (const value of validValues) {
-                // @ts-ignore
-                ec.addProduct({name: 'product', position: value});
+    it('should convert quantity to number if possible', () => {
+      const validValues = ['13', '0', '.0', '-10', '5.0', '-1.1', '3.124e7'];
+      for (const value of validValues) {
+        // @ts-ignore
+        ec.addProduct({name: 'product', quantity: value});
 
-                const result = executeRegisteredHook(ECPluginEventTypes.event, {});
-                const expected: Record<string, any> = {...defaultResult, pr1nm: 'product', pr1ps: +value};
+        const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+        const expected: Record<string, any> = {
+          ...defaultResult,
+          pr1nm: 'product',
+          pr1qt: +value,
+        };
 
-                expect(result).toEqual(expected);
-            }
-        });
+        expect(result).toEqual(expected);
+      }
+    });
 
-        it('should keep original value if position is not a number', () => {
-            const invalidValues = ['1-2-3', '.', '-', '123abc'];
-            for (const value of invalidValues) {
-                // @ts-ignore
-                ec.addProduct({name: 'product', position: value});
+    it('should keep original value if quantity is not a number', () => {
+      const invalidValues = ['1-2-3', '', '.', '5..', '-', '123abc', 'abc123'];
+      for (const value of invalidValues) {
+        // @ts-ignore
+        ec.addProduct({name: 'product', quantity: value});
 
-                const result = executeRegisteredHook(ECPluginEventTypes.event, {});
-                const expected: Record<string, unknown> = {...defaultResult, pr1nm: 'product', pr1ps: value};
+        const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+        const expected: Record<string, unknown> = {
+          ...defaultResult,
+          pr1nm: 'product',
+          pr1qt: value,
+        };
 
-                expect(result).toEqual(expected);
-            }
-        });
+        expect(result).toEqual(expected);
+      }
+    });
 
-        it('should convert quantity to number if possible', () => {
-            const validValues = ['13', '0', '.0', '-10', '5.0', '-1.1', '3.124e7'];
-            for (const value of validValues) {
-                // @ts-ignore
-                ec.addProduct({name: 'product', quantity: value});
+    describe('when the position is invalid', () => {
+      it('should warn when executing hook on added product', () => {
+        vi.spyOn(console, 'warn').mockImplementation();
 
-                const result = executeRegisteredHook(ECPluginEventTypes.event, {});
-                const expected: Record<string, any> = {...defaultResult, pr1nm: 'product', pr1qt: +value};
+        const aProductWithATooSmallPosition = {
+          name: 'A product with a too small position',
+          position: 0,
+        };
 
-                expect(result).toEqual(expected);
-            }
-        });
+        ec.addProduct(aProductWithATooSmallPosition);
 
-        it('should keep original value if quantity is not a number', () => {
-            const invalidValues = ['1-2-3', '', '.', '5..', '-', '123abc', 'abc123'];
-            for (const value of invalidValues) {
-                // @ts-ignore
-                ec.addProduct({name: 'product', quantity: value});
+        expect(console.warn).not.toHaveBeenCalled();
 
-                const result = executeRegisteredHook(ECPluginEventTypes.event, {});
-                const expected: Record<string, unknown> = {...defaultResult, pr1nm: 'product', pr1qt: value};
+        executeRegisteredHook(ECPluginEventTypes.event, {});
 
-                expect(result).toEqual(expected);
-            }
-        });
+        expect(console.warn).toHaveBeenCalledWith(
+          `The position for product '${aProductWithATooSmallPosition.name}' must be greater than 0 when provided.`
+        );
+        expect(console.warn).toHaveBeenCalledTimes(1);
+      });
 
-        describe('when the position is invalid', () => {
-            it('should warn when executing hook on added product', () => {
-                jest.spyOn(console, 'warn').mockImplementation();
+      it('should remove the position when executing hook on added product', () => {
+        vi.spyOn(console, 'warn').mockImplementation();
 
-                const aProductWithATooSmallPosition = {
-                    name: 'A product with a too small position',
-                    position: 0,
-                };
+        ec.addProduct({
+          name: 'A product with a too small position',
+          position: 0,
+        });
 
-                ec.addProduct(aProductWithATooSmallPosition);
+        const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-                expect(console.warn).not.toHaveBeenCalled();
+        const positionProperty = 'il1pi1ps';
+        expect(result).not.toHaveProperty(positionProperty);
+      });
 
-                executeRegisteredHook(ECPluginEventTypes.event, {});
+      it('should warn first using the product name then the id', () => {
+        vi.spyOn(console, 'warn').mockImplementation();
 
-                expect(console.warn).toHaveBeenCalledWith(
-                    `The position for product '${aProductWithATooSmallPosition.name}' must be greater than 0 when provided.`,
-                );
-                expect(console.warn).toHaveBeenCalledTimes(1);
-            });
+        const aProductWithANameAndId = {
+          name: 'A product with a name and id',
+          id: 'A product id',
+          position: 0,
+        };
+        const aProductWithOnlyAnId = {
+          id: 'A product id',
+          position: 0,
+        };
 
-            it('should remove the position when executing hook on added product', () => {
-                jest.spyOn(console, 'warn').mockImplementation();
+        ec.addProduct(aProductWithANameAndId);
+        ec.addProduct(aProductWithOnlyAnId);
 
-                ec.addProduct({
-                    name: 'A product with a too small position',
-                    position: 0,
-                });
+        executeRegisteredHook(ECPluginEventTypes.event, {});
 
-                const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+        expect(console.warn).toHaveBeenNthCalledWith(
+          1,
+          `The position for product '${aProductWithANameAndId.name}' must be greater than 0 when provided.`
+        );
+        expect(console.warn).toHaveBeenNthCalledWith(
+          2,
+          `The position for product '${aProductWithOnlyAnId.id}' must be greater than 0 when provided.`
+        );
+      });
 
-                const positionProperty = 'il1pi1ps';
-                expect(result).not.toHaveProperty(positionProperty);
-            });
+      it('should tolerate an absent or undefined position', () => {
+        vi.spyOn(console, 'warn').mockImplementation();
 
-            it('should warn first using the product name then the id', () => {
-                jest.spyOn(console, 'warn').mockImplementation();
+        ec.addProduct({
+          name: 'A product with no position',
+        });
 
-                const aProductWithANameAndId = {
-                    name: 'A product with a name and id',
-                    id: 'A product id',
-                    position: 0,
-                };
-                const aProductWithOnlyAnId = {
-                    id: 'A product id',
-                    position: 0,
-                };
+        ec.addProduct({
+          name: 'A product with an undefined position',
+          position: undefined,
+        });
 
-                ec.addProduct(aProductWithANameAndId);
-                ec.addProduct(aProductWithOnlyAnId);
+        const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-                executeRegisteredHook(ECPluginEventTypes.event, {});
+        expect(console.warn).not.toHaveBeenCalled();
+        expect(result).not.toHaveProperty('pr1ps');
+        expect(result).toHaveProperty('pr2ps', undefined);
+      });
+    });
+  });
 
-                expect(console.warn).toHaveBeenNthCalledWith(
-                    1,
-                    `The position for product '${aProductWithANameAndId.name}' must be greater than 0 when provided.`,
-                );
-                expect(console.warn).toHaveBeenNthCalledWith(
-                    2,
-                    `The position for product '${aProductWithOnlyAnId.id}' must be greater than 0 when provided.`,
-                );
-            });
+  describe('impressions', () => {
+    it('should append the impression with the specific format when the hook is called', () => {
+      ec.addImpression({id: 'C0V30'});
 
-            it('should tolerate an absent or undefined position', () => {
-                jest.spyOn(console, 'warn').mockImplementation();
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-                ec.addProduct({
-                    name: 'A product with no position',
-                });
+      expect(result).toEqual({...defaultResult, il1pi1id: 'C0V30'});
+    });
 
-                ec.addProduct({
-                    name: 'A product with an undefined position',
-                    position: undefined,
-                });
+    it('should append the impression with the pageview event', () => {
+      ec.addImpression({name: 'Relevance T-Shirt'});
 
-                const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-                expect(console.warn).not.toHaveBeenCalled();
-                expect(result).not.toHaveProperty('pr1ps');
-                expect(result).toHaveProperty('pr2ps', undefined);
-            });
-        });
+      expect(result).toEqual({
+        ...defaultResult,
+        il1pi1nm: 'Relevance T-Shirt',
+      });
     });
 
-    describe('impressions', () => {
-        it('should append the impression with the specific format when the hook is called', () => {
-            ec.addImpression({id: 'C0V30'});
+    it('should not append the impression with a random event type', () => {
+      ec.addImpression({id: ':testProductId:'});
 
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+      const result = executeRegisteredHook('🎲', {});
 
-            expect(result).toEqual({...defaultResult, il1pi1id: 'C0V30'});
-        });
+      expect(result).toEqual({});
+    });
 
-        it('should append the impression with the pageview event', () => {
-            ec.addImpression({name: 'Relevance T-Shirt'});
+    it('should keep the impressions until a valid event type is used', () => {
+      ec.addImpression({id: 'P12345'});
 
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+      executeRegisteredHook('🎲', {});
+      executeRegisteredHook('🐟', {});
+      executeRegisteredHook('💀', {});
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-            expect(result).toEqual({
-                ...defaultResult,
-                il1pi1nm: 'Relevance T-Shirt',
-            });
-        });
+      expect(result).toEqual({...defaultResult, il1pi1id: 'P12345'});
+    });
 
-        it('should not append the impression with a random event type', () => {
-            ec.addImpression({id: ':sorandom:'});
+    it('should convert known impression keys into the measurement protocol format', () => {
+      ec.addImpression({name: '🧀', price: 5.99});
 
-            const result = executeRegisteredHook('🎲', {});
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-            expect(result).toEqual({});
-        });
+      expect(result).toEqual({
+        ...defaultResult,
+        il1pi1nm: '🧀',
+        il1pi1pr: 5.99,
+      });
+    });
 
-        it('should keep the impressions until a valid event type is used', () => {
-            ec.addImpression({id: 'P12345'});
+    it('should convert known impression keys that are extended for Coveo into the measurement protocol format', () => {
+      ec.addImpression({name: '🧀', group: 'testGroup'});
 
-            executeRegisteredHook('🎲', {});
-            executeRegisteredHook('🐟', {});
-            executeRegisteredHook('💀', {});
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-            expect(result).toEqual({...defaultResult, il1pi1id: 'P12345'});
-        });
+      expect(result).toEqual({
+        ...defaultResult,
+        il1pi1nm: '🧀',
+        il1pi1group: 'testGroup',
+      });
+    });
 
-        it('should convert known impression keys into the measurement protocol format', () => {
-            ec.addImpression({name: '🧀', price: 5.99});
+    it('should keep custom metadata in the impression', () => {
+      ec.addImpression({
+        name: '🧀',
+        price: 5.99,
+        custom: {verycustom: 'value'},
+      });
+
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+
+      expect(result).toEqual({
+        ...defaultResult,
+        il1pi1nm: '🧀',
+        il1pi1pr: 5.99,
+        il1pi1custom: {verycustom: 'value'},
+      });
+    });
 
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+    it('should allow adding multiple impressions', () => {
+      ec.addImpression({name: '🍟', price: 1.99});
+      ec.addImpression({name: '🍿', price: 3});
+      ec.addImpression({name: '🥤', price: 2});
+
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+
+      expect(result).toEqual({
+        ...defaultResult,
+        il1pi1nm: '🍟',
+        il1pi1pr: 1.99,
+        il1pi2nm: '🍿',
+        il1pi2pr: 3,
+        il1pi3nm: '🥤',
+        il1pi3pr: 2,
+      });
+    });
 
-            expect(result).toEqual({
-                ...defaultResult,
-                il1pi1nm: '🧀',
-                il1pi1pr: 5.99,
-            });
-        });
+    it('should allow adding impressions from multiple lists', () => {
+      ec.addImpression({list: 'food', name: '🍟', price: 1.99});
+      ec.addImpression({list: 'food', name: '🍿', price: 3});
+      ec.addImpression({list: 'drinks', name: '🥤', price: 2});
+      ec.addImpression({list: 'drinks', name: '🧃', price: 0.99});
+
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+
+      expect(result).toEqual({
+        ...defaultResult,
+        il1nm: 'food',
+        il1pi1nm: '🍟',
+        il1pi1pr: 1.99,
+        il1pi2nm: '🍿',
+        il1pi2pr: 3,
+        il2nm: 'drinks',
+        il2pi1nm: '🥤',
+        il2pi1pr: 2,
+        il2pi2nm: '🧃',
+        il2pi2pr: 0.99,
+      });
+    });
 
-        it('should convert known impression keys that are extended for Coveo into the measurement protocol format', () => {
-            ec.addImpression({name: '🧀', group: 'mahgroup'});
+    it('should flush the products once they are sent', () => {
+      ec.addImpression({name: '🍟', price: 1.99});
+      ec.addImpression({name: '🍿', price: 3});
 
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+      const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-            expect(result).toEqual({
-                ...defaultResult,
-                il1pi1nm: '🧀',
-                il1pi1group: 'mahgroup',
-            });
-        });
+      expect(result).not.toEqual({});
 
-        it('should keep custom metadata in the impression', () => {
-            ec.addImpression({name: '🧀', price: 5.99, custom: {verycustom: 'value'}});
+      const secondResult = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+      expect(secondResult).toEqual({...defaultResult});
+    });
 
-            expect(result).toEqual({
-                ...defaultResult,
-                il1pi1nm: '🧀',
-                il1pi1pr: 5.99,
-                il1pi1custom: {verycustom: 'value'},
-            });
-        });
+    describe('when the position is invalid', () => {
+      it('should warn when executing hook on added impression', () => {
+        vi.spyOn(console, 'warn').mockImplementation();
 
-        it('should allow adding multiple impressions', () => {
-            ec.addImpression({name: '🍟', price: 1.99});
-            ec.addImpression({name: '🍿', price: 3});
-            ec.addImpression({name: '🥤', price: 2});
-
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
-
-            expect(result).toEqual({
-                ...defaultResult,
-                il1pi1nm: '🍟',
-                il1pi1pr: 1.99,
-                il1pi2nm: '🍿',
-                il1pi2pr: 3,
-                il1pi3nm: '🥤',
-                il1pi3pr: 2,
-            });
-        });
+        const anImpression = {
+          name: 'An impression with a too small position',
+          position: 0,
+        };
 
-        it('should allow adding impressions from multiple lists', () => {
-            ec.addImpression({list: 'food', name: '🍟', price: 1.99});
-            ec.addImpression({list: 'food', name: '🍿', price: 3});
-            ec.addImpression({list: 'drinks', name: '🥤', price: 2});
-            ec.addImpression({list: 'drinks', name: '🧃', price: 0.99});
-
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
-
-            expect(result).toEqual({
-                ...defaultResult,
-                il1nm: 'food',
-                il1pi1nm: '🍟',
-                il1pi1pr: 1.99,
-                il1pi2nm: '🍿',
-                il1pi2pr: 3,
-                il2nm: 'drinks',
-                il2pi1nm: '🥤',
-                il2pi1pr: 2,
-                il2pi2nm: '🧃',
-                il2pi2pr: 0.99,
-            });
-        });
+        ec.addImpression(anImpression);
 
-        it('should flush the products once they are sent', () => {
-            ec.addImpression({name: '🍟', price: 1.99});
-            ec.addImpression({name: '🍿', price: 3});
+        expect(console.warn).not.toHaveBeenCalled();
 
-            const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+        executeRegisteredHook(ECPluginEventTypes.event, {});
 
-            expect(result).not.toEqual({});
+        expect(console.warn).toHaveBeenCalledWith(
+          `The position for impression '${anImpression.name}' must be greater than 0 when provided.`
+        );
+        expect(console.warn).toHaveBeenCalledTimes(1);
+      });
 
-            const secondResult = executeRegisteredHook(ECPluginEventTypes.event, {});
+      it('should remove the position when executing hook on added impression', () => {
+        vi.spyOn(console, 'warn').mockImplementation();
 
-            expect(secondResult).toEqual({...defaultResult});
+        ec.addImpression({
+          name: 'An impression with a too small position',
+          position: 0,
         });
 
-        describe('when the position is invalid', () => {
-            it('should warn when executing hook on added impression', () => {
-                jest.spyOn(console, 'warn').mockImplementation();
-
-                const anImpression = {
-                    name: 'An impression with a too small position',
-                    position: 0,
-                };
-
-                ec.addImpression(anImpression);
-
-                expect(console.warn).not.toHaveBeenCalled();
-
-                executeRegisteredHook(ECPluginEventTypes.event, {});
-
-                expect(console.warn).toHaveBeenCalledWith(
-                    `The position for impression '${anImpression.name}' must be greater than 0 when provided.`,
-                );
-                expect(console.warn).toHaveBeenCalledTimes(1);
-            });
-
-            it('should remove the position when executing hook on added impression', () => {
-                jest.spyOn(console, 'warn').mockImplementation();
-
-                ec.addImpression({
-                    name: 'An impression with a too small position',
-                    position: 0,
-                });
-
-                const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+        const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-                const positionProperty = 'il1pi1ps';
-                expect(result).not.toHaveProperty(positionProperty);
-            });
+        const positionProperty = 'il1pi1ps';
+        expect(result).not.toHaveProperty(positionProperty);
+      });
 
-            it('should warn first using the impression name then the id', () => {
-                jest.spyOn(console, 'warn').mockImplementation();
+      it('should warn first using the impression name then the id', () => {
+        vi.spyOn(console, 'warn').mockImplementation();
 
-                const anImpressionWithANameAndId = {
-                    name: 'An impression with a name and id',
-                    id: 'An id',
-                    position: 0,
-                };
-                const anImpressionWithOnlyAnId = {
-                    id: 'An id',
-                    position: 0,
-                };
+        const anImpressionWithANameAndId = {
+          name: 'An impression with a name and id',
+          id: 'An id',
+          position: 0,
+        };
+        const anImpressionWithOnlyAnId = {
+          id: 'An id',
+          position: 0,
+        };
 
-                ec.addImpression(anImpressionWithANameAndId);
-                ec.addImpression(anImpressionWithOnlyAnId);
+        ec.addImpression(anImpressionWithANameAndId);
+        ec.addImpression(anImpressionWithOnlyAnId);
 
-                executeRegisteredHook(ECPluginEventTypes.event, {});
+        executeRegisteredHook(ECPluginEventTypes.event, {});
 
-                expect(console.warn).toHaveBeenNthCalledWith(
-                    1,
-                    `The position for impression '${anImpressionWithANameAndId.name}' must be greater than 0 when provided.`,
-                );
-                expect(console.warn).toHaveBeenNthCalledWith(
-                    2,
-                    `The position for impression '${anImpressionWithOnlyAnId.id}' must be greater than 0 when provided.`,
-                );
-            });
+        expect(console.warn).toHaveBeenNthCalledWith(
+          1,
+          `The position for impression '${anImpressionWithANameAndId.name}' must be greater than 0 when provided.`
+        );
+        expect(console.warn).toHaveBeenNthCalledWith(
+          2,
+          `The position for impression '${anImpressionWithOnlyAnId.id}' must be greater than 0 when provided.`
+        );
+      });
 
-            it('should tolerate an absent or undefined position', () => {
-                jest.spyOn(console, 'warn').mockImplementation();
+      it('should tolerate an absent or undefined position', () => {
+        vi.spyOn(console, 'warn').mockImplementation();
 
-                ec.addImpression({
-                    name: 'An impression with no position',
-                });
+        ec.addImpression({
+          name: 'An impression with no position',
+        });
 
-                ec.addImpression({
-                    name: 'An impression with an undefined position',
-                    position: undefined,
-                });
+        ec.addImpression({
+          name: 'An impression with an undefined position',
+          position: undefined,
+        });
 
-                const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+        const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-                expect(console.warn).not.toHaveBeenCalled();
-                expect(result).not.toHaveProperty('il1pi1ps');
-                expect(result).toHaveProperty('il1pi2ps', undefined);
-            });
-        });
+        expect(console.warn).not.toHaveBeenCalled();
+        expect(result).not.toHaveProperty('il1pi1ps');
+        expect(result).toHaveProperty('il1pi2ps', undefined);
+      });
     });
+  });
 
-    it('should be able to set an action', () => {
-        ec.setAction('ok');
+  it('should be able to set an action', () => {
+    ec.setAction('ok');
 
-        const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+    const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-        expect(result).toEqual({
-            ...defaultResult,
-            action: 'ok',
-        });
+    expect(result).toEqual({
+      ...defaultResult,
+      action: 'ok',
     });
+  });
 
-    it('should flush the action once it is sent', () => {
-        ec.setAction('ok');
+  it('should flush the action once it is sent', () => {
+    ec.setAction('ok');
 
-        const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+    const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-        expect(result).not.toEqual({});
+    expect(result).not.toEqual({});
 
-        const secondResult = executeRegisteredHook(ECPluginEventTypes.event, {});
+    const secondResult = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-        expect(secondResult).toEqual({...defaultResult});
-    });
+    expect(secondResult).toEqual({...defaultResult});
+  });
 
-    it('should be able to clear all the data', () => {
-        ec.addProduct({name: '🍨', price: 2.99});
-        ec.addImpression({id: '🍦', price: 3.49});
-        ec.clearData();
+  it('should be able to clear all the data', () => {
+    ec.addProduct({name: '🍨', price: 2.99});
+    ec.addImpression({id: '🍦', price: 3.49});
+    ec.clearData();
 
-        const result = executeRegisteredHook(ECPluginEventTypes.event, {});
+    const result = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-        expect(result).toEqual({...defaultResult});
-    });
+    expect(result).toEqual({...defaultResult});
+  });
 
-    it('should convert known EC keys to the measurement protocol format in the hook', () => {
-        const payload = {
-            clientId: '1234',
-            encoding: 'en-GB',
-            action: 'bloup',
-        };
+  it('should convert known EC keys to the measurement protocol format in the hook', () => {
+    const payload = {
+      clientId: '1234',
+      encoding: 'en-GB',
+      action: 'bloup',
+    };
 
-        const result = executeRegisteredHook(ECPluginEventTypes.event, payload);
+    const result = executeRegisteredHook(ECPluginEventTypes.event, payload);
 
-        expect(result).toEqual({
-            ...defaultResult,
-            clientId: payload.clientId,
-            encoding: payload.encoding,
-            action: payload.action,
-        });
+    expect(result).toEqual({
+      ...defaultResult,
+      clientId: payload.clientId,
+      encoding: payload.encoding,
+      action: payload.action,
     });
+  });
 
-    it('should call the uuidv4 method', async () => {
-        await executeRegisteredHook(ECPluginEventTypes.event, {});
-        await executeRegisteredHook(ECPluginEventTypes.event, {});
-        await executeRegisteredHook(ECPluginEventTypes.event, {});
+  it('should call the uuidv4 method', async () => {
+    await executeRegisteredHook(ECPluginEventTypes.event, {});
+    await executeRegisteredHook(ECPluginEventTypes.event, {});
+    await executeRegisteredHook(ECPluginEventTypes.event, {});
 
-        // One for generating pageViewId, one for each individual event.
-        expect(someUUIDGenerator).toHaveBeenCalledTimes(1 + 3);
-    });
+    // One for generating pageViewId, one for each individual event.
+    expect(someUUIDGenerator).toHaveBeenCalledTimes(1 + 3);
+  });
 
-    it('should update the location when sending a pageview with the page parameter', () => {
-        const payload = {
-            page: '/somepage',
-        };
+  it('should update the location when sending a pageview with the page parameter', () => {
+    const payload = {
+      page: '/somepage',
+    };
 
-        const pageview = executeRegisteredHook(ECPluginEventTypes.pageview, payload);
-        const event = executeRegisteredHook(ECPluginEventTypes.event, {});
+    const pageview = executeRegisteredHook(ECPluginEventTypes.pageview, payload);
+    const event = executeRegisteredHook(ECPluginEventTypes.event, {});
 
-        expect(pageview).toEqual({
-            ...defaultResult,
-            hitType: ECPluginEventTypes.pageview,
-            page: payload.page,
-            location: `${defaultResult.location}${payload.page.substring(1)}`,
-        });
-        expect(event).toEqual({
-            ...defaultResult,
-            hitType: ECPluginEventTypes.event,
-            location: `${defaultResult.location}${payload.page.substring(1)}`,
-        });
+    expect(pageview).toEqual({
+      ...defaultResult,
+      hitType: ECPluginEventTypes.pageview,
+      page: payload.page,
+      location: `${defaultResult.location}${payload.page.substring(1)}`,
     });
-
-    const executeRegisteredHook = (eventType: string, payload: any) => {
-        const [beforeHook] = client.registerBeforeSendEventHook.mock.calls[0];
-        const [afterHook] = client.registerAfterSendEventHook.mock.calls[0];
-        const result = beforeHook(eventType, payload);
-        afterHook(eventType, result);
-        return result;
-    };
+    expect(event).toEqual({
+      ...defaultResult,
+      hitType: ECPluginEventTypes.event,
+      location: `${defaultResult.location}${payload.page.substring(1)}`,
+    });
+  });
+
+  const executeRegisteredHook = (eventType: string, payload: any) => {
+    const [beforeHook] = client.registerBeforeSendEventHook.mock.calls[0];
+    const [afterHook] = client.registerAfterSendEventHook.mock.calls[0];
+    const result = beforeHook(eventType, payload);
+    afterHook(eventType, result);
+    return result;
+  };
 });