coveo.analytics 2.30.56 → 2.32.0

package/src/coveoua/simpleanalytics.spec.ts

@@ -1,3 +1,5 @@
+import {vi} from 'vitest';
+import type {Mock} from 'vitest';
 import coveoua from './simpleanalytics';
 import {createAnalyticsClientMock, visitorIdMock} from '../../tests/analyticsClientMock';
 import {TestPlugin} from '../../tests/pluginMock';
@@ -7,539 +9,552 @@ import {mockFetch, lastCallBody} from '../../tests/fetchMock';
 import {CookieStorage} from '../storage';
 import {libVersion} from '../version';
 
-const uuidv4Mock = jest.fn();
-jest.mock('uuid', () => ({v4: () => uuidv4Mock()}));
+const uuidv4Mock = vi.fn();
+vi.mock('uuid', () => ({v4: () => uuidv4Mock()}));
 
 const {fetchMock, fetchMockBeforeEach} = mockFetch();
 
 class TestPluginWithSpy extends TestPlugin {
-    public static readonly Id: 'test';
-    public static spy: jest.Mock;
-    constructor({client, uuidGenerator = uuidv4}: PluginOptions) {
-        super({client, uuidGenerator});
-        TestPluginWithSpy.spy = jest.fn();
+  public static readonly Id: 'test';
+  public static spy: Mock;
+  constructor({client, uuidGenerator = uuidv4}: PluginOptions) {
+    super({client, uuidGenerator});
+    TestPluginWithSpy.spy = vi.fn();
+  }
+
+  public getApi(name: string): Function | null {
+    switch (name) {
+      case 'testMethod':
+        return this.testMethod;
+      default:
+        return null;
     }
+  }
 
-    public getApi(name: string): Function | null {
-        switch (name) {
-            case 'testMethod':
-                return this.testMethod;
-            default:
-                return null;
-        }
-    }
-
-    testMethod(...args: any[]) {
-        TestPluginWithSpy.spy(args);
-    }
+  testMethod(...args: any[]) {
+    TestPluginWithSpy.spy(args);
+  }
 }
 
 describe('simpleanalytics', () => {
-    const analyticsClientMock = createAnalyticsClientMock();
-    const analyticsEndpoint = 'https://analytics.cloud.coveo.com/rest/ua/v15/analytics';
-    const someRandomEventName = 'kawabunga';
+  const analyticsClientMock = createAnalyticsClientMock();
+  const analyticsEndpoint = 'https://analytics.cloud.coveo.com/rest/ua/v15/analytics';
+  const someRandomEventName = 'testeventname';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    fetchMockBeforeEach();
+
+    new CookieStorage().removeItem('visitorId');
+    localStorage.clear();
+    fetchMock.mock('*', {});
+    uuidv4Mock.mockImplementationOnce(() => visitorIdMock);
+    coveoua('reset');
+  });
+
+  afterEach(() => {
+    fetchMock.reset();
+    fetchMock.resetHistory();
+    fetchMock.resetBehavior();
+  });
+
+  describe('init', () => {
+    it('throws when initializing without a token', () => {
+      expect(() => coveoua('init')).toThrow(`You must pass your token when you call 'init'`);
+    });
 
-    beforeEach(() => {
-        jest.clearAllMocks();
-        fetchMockBeforeEach();
+    it('throws when initializing with a token that is not a string nor a AnalyticClient', () => {
+      expect(() => coveoua('init', {})).toThrow(
+        `You must pass either your token or a valid object when you call 'init'`
+      );
+    });
 
-        new CookieStorage().removeItem('visitorId');
-        localStorage.clear();
-        fetchMock.mock('*', {});
-        uuidv4Mock.mockImplementationOnce(() => visitorIdMock);
-        coveoua('reset');
+    it('can initialize with analyticsClient', () => {
+      expect(() => coveoua('init', analyticsClientMock)).not.toThrow();
     });
 
-    afterEach(() => {
-        fetchMock.reset();
-        fetchMock.resetHistory();
-        fetchMock.resetBehavior();
+    it('can initialize with a token', () => {
+      expect(() => coveoua('init', 'SOME TOKEN')).not.toThrow();
     });
 
-    describe('init', () => {
-        it('throws when initializing without a token', () => {
-            expect(() => coveoua('init')).toThrow(`You must pass your token when you call 'init'`);
-        });
+    it('default to analytics.cloud.coveo.com when no endpoint is given', async () => {
+      coveoua('init', 'SOME TOKEN');
 
-        it('throws when initializing with a token that is not a string nor a AnalyticClient', () => {
-            expect(() => coveoua('init', {})).toThrow(
-                `You must pass either your token or a valid object when you call 'init'`,
-            );
-        });
+      await coveoua('send', 'pageview');
 
-        it('can initialize with analyticsClient', () => {
-            expect(() => coveoua('init', analyticsClientMock)).not.toThrow();
-        });
+      expect(fetchMock.calls().length).toBe(1);
+      const foo = fetchMock.lastUrl();
+      expect(fetchMock.lastUrl()).toMatch(/^https:\/\/analytics\.cloud\.coveo\.com\/rest\/ua/);
+    });
 
-        it('can initialize with a token', () => {
-            expect(() => coveoua('init', 'SOME TOKEN')).not.toThrow();
-        });
+    it('default to analytics.cloud.coveo.com when the endpoint is an empty string', async () => {
+      coveoua('init', 'SOME TOKEN', '');
 
-        it('default to analytics.cloud.coveo.com when no endpoint is given', async () => {
-            coveoua('init', 'SOME TOKEN');
+      await coveoua('send', 'pageview');
 
-            await coveoua('send', 'pageview');
+      expect(fetchMock.calls().length).toBe(1);
+      const foo = fetchMock.lastUrl();
+      expect(fetchMock.lastUrl()).toMatch(/^https:\/\/analytics\.cloud\.coveo\.com\/rest\/ua/);
+    });
 
-            expect(fetchMock.calls().length).toBe(1);
-            const foo = fetchMock.lastUrl();
-            expect(fetchMock.lastUrl()).toMatch(/^https:\/\/analytics\.cloud\.coveo\.com\/rest\/ua/);
-        });
+    it('default to analytics.cloud.coveo.com when an options object is given but does not include an endpoint', async () => {
+      coveoua('init', 'SOME TOKEN', {});
 
-        it('default to analytics.cloud.coveo.com when the endpoint is an empty string', async () => {
-            coveoua('init', 'SOME TOKEN', '');
+      await coveoua('send', 'pageview');
 
-            await coveoua('send', 'pageview');
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toMatch(/^https:\/\/analytics\.cloud\.coveo\.com\/rest\/ua/);
+    });
 
-            expect(fetchMock.calls().length).toBe(1);
-            const foo = fetchMock.lastUrl();
-            expect(fetchMock.lastUrl()).toMatch(/^https:\/\/analytics\.cloud\.coveo\.com\/rest\/ua/);
-        });
+    it('default to analytics.cloud.coveo.com when an options object is given but the endpoint property is falsy', async () => {
+      coveoua('init', 'SOME TOKEN', {endpoint: ''});
 
-        it('default to analytics.cloud.coveo.com when an options object is given but does not include an endpoint', async () => {
-            coveoua('init', 'SOME TOKEN', {});
+      await coveoua('send', 'pageview');
 
-            await coveoua('send', 'pageview');
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toMatch(/^https:\/\/analytics\.cloud\.coveo\.com\/rest\/ua/);
+    });
 
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toMatch(/^https:\/\/analytics\.cloud\.coveo\.com\/rest\/ua/);
-        });
+    it('uses the endpoint given if its a non-empty string', async () => {
+      coveoua('init', 'SOME TOKEN', 'https://someendpoint.com');
 
-        it('default to analytics.cloud.coveo.com when an options object is given but the endpoint property is falsy', async () => {
-            coveoua('init', 'SOME TOKEN', {endpoint: ''});
+      await coveoua('send', 'pageview');
 
-            await coveoua('send', 'pageview');
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toMatch(/^https:\/\/someendpoint\.com/);
+    });
 
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toMatch(/^https:\/\/analytics\.cloud\.coveo\.com\/rest\/ua/);
-        });
+    it('uses the endpoint given if the options object include a non-empty string', async () => {
+      coveoua('init', 'SOME TOKEN', {endpoint: 'https://someendpoint.com'});
 
-        it('uses the endpoint given if its a non-empty string', async () => {
-            coveoua('init', 'SOME TOKEN', 'https://someendpoint.com');
+      await coveoua('send', 'pageview');
 
-            await coveoua('send', 'pageview');
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toMatch(/^https:\/\/someendpoint\.com/);
+    });
 
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toMatch(/^https:\/\/someendpoint\.com/);
-        });
+    it('uses EC, SVC and Link plugins by default', () => {
+      coveoua('init', 'SOME TOKEN');
+      expect(() => coveoua('callPlugin', 'ec', 'missingFunction')).toThrow(/does not exist/);
+      expect(() => coveoua('callPlugin', 'svc', 'missingFunction')).toThrow(/does not exist/);
+      expect(() => coveoua('callPlugin', 'link', 'missingFunction')).toThrow(/does not exist/);
+    });
 
-        it('uses the endpoint given if the options object include a non-empty string', async () => {
-            coveoua('init', 'SOME TOKEN', {endpoint: 'https://someendpoint.com'});
+    it('can accept no plugins', () => {
+      coveoua('init', 'SOME TOKEN', {plugins: []});
+      expect(() => coveoua('callPlugin', 'ec', 'missingFunction')).toThrow(/is not required/);
+      expect(() => coveoua('callPlugin', 'svc', 'missingFunction')).toThrow(/is not required/);
+      expect(() => coveoua('callPlugin', 'link', 'missingFunction')).toThrow(/is not required/);
+    });
 
-            await coveoua('send', 'pageview');
+    it('can accept one plugin', () => {
+      coveoua('init', 'SOME TOKEN', {plugins: ['svc']});
+      expect(() => coveoua('callPlugin', 'ec', 'missingFunction')).toThrow(/is not required/);
+      expect(() => coveoua('callPlugin', 'link', 'missingFunction')).toThrow(/is not required/);
+      expect(() => coveoua('callPlugin', 'svc', 'missingFunction')).toThrow(/does not exist/);
+    });
 
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toMatch(/^https:\/\/someendpoint\.com/);
-        });
-
-        it('uses EC, SVC and Link plugins by default', () => {
-            coveoua('init', 'SOME TOKEN');
-            expect(() => coveoua('callPlugin', 'ec', 'nosuchfunction')).toThrow(/does not exist/);
-            expect(() => coveoua('callPlugin', 'svc', 'nosuchfunction')).toThrow(/does not exist/);
-            expect(() => coveoua('callPlugin', 'link', 'nosuchfunction')).toThrow(/does not exist/);
-        });
-
-        it('can accept no plugins', () => {
-            coveoua('init', 'SOME TOKEN', {plugins: []});
-            expect(() => coveoua('callPlugin', 'ec', 'nosuchfunction')).toThrow(/is not required/);
-            expect(() => coveoua('callPlugin', 'svc', 'nosuchfunction')).toThrow(/is not required/);
-            expect(() => coveoua('callPlugin', 'link', 'nosuchfunction')).toThrow(/is not required/);
-        });
-
-        it('can accept one plugin', () => {
-            coveoua('init', 'SOME TOKEN', {plugins: ['svc']});
-            expect(() => coveoua('callPlugin', 'ec', 'nosuchfunction')).toThrow(/is not required/);
-            expect(() => coveoua('callPlugin', 'link', 'nosuchfunction')).toThrow(/is not required/);
-            expect(() => coveoua('callPlugin', 'svc', 'nosuchfunction')).toThrow(/does not exist/);
-        });
-
-        it('can send pageview with analyticsClient', () => {
-            coveoua('init', analyticsClientMock);
-            expect(() => coveoua('send', 'pageview')).not.toThrow();
-        });
-    });
-
-    describe('initForProxy', () => {
-        it(`throw if the initForProxy don't receive an endpoint`, () => {
-            expect(() => coveoua('initForProxy')).toThrow(`You must pass your endpoint when you call 'initForProxy'`);
-        });
-
-        it(`throw if the initForProxy receive an endpoint that is not a string`, () => {
-            expect(() => coveoua('initForProxy', {})).toThrow(
-                `You must pass a string as the endpoint parameter when you call 'initForProxy'`,
-            );
-        });
-    });
-
-    describe('send', () => {
-        it('throws when not initialized', () => {
-            expect(() => coveoua('send')).toThrow(`You must call init before sending an event`);
-        });
-
-        it('throws when send is called without any other arguments', () => {
-            coveoua('init', 'MYTOKEN');
-            expect(() => coveoua('send')).toThrow(`You must provide an event type when calling "send".`);
-        });
-
-        it('can send pageview', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: []});
-            await coveoua('send', 'pageview');
-
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/pageview`);
-        });
-
-        it('can send pageview with customdata', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: []});
-            await coveoua('send', 'pageview', {somedata: 'asd'});
-
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/pageview`);
-            expect(JSON.parse(lastCallBody(fetchMock))).toEqual({somedata: 'asd'});
-        });
-
-        it('can send view event with clientId', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: []});
-            await coveoua('send', 'view');
-
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/view?visitor=${visitorIdMock}`);
-            expect(JSON.parse(lastCallBody(fetchMock)).clientId).toBe(visitorIdMock);
-        });
-
-        it('can send any event to the endpoint', async () => {
-            coveoua('init', 'MYTOKEN');
-            await coveoua('send', someRandomEventName);
-
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
-        });
-
-        it('can send an event with a proxy endpoint', async () => {
-            coveoua('initForProxy', 'https://myProxyEndpoint.com');
-            await coveoua('send', someRandomEventName);
-
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toBe(`https://myproxyendpoint.com/rest/v15/analytics/${someRandomEventName}`);
-        });
-
-        describe('will restrict referrers and url lengths', () => {
-            const max: number = 2048;
-            const reallyLongPath1: string = 'http://coveo.com/?q=' + 'a'.repeat(max);
-            const reallyLongPath2: string = 'http://coveo.com/?q=' + 'b'.repeat(max);
-            expect(reallyLongPath1.length).toBeGreaterThan(max);
-            expect(reallyLongPath2.length).toBeGreaterThan(max);
-            it('does this for pageviews', async () => {
-                coveoua('init', 'MYTOKEN');
-                await coveoua('send', 'pageview', reallyLongPath1);
-                await coveoua('send', 'pageview', reallyLongPath2);
-                const body = JSON.parse(lastCallBody(fetchMock));
-                expect(body.dr.length).toBeLessThanOrEqual(max);
-                expect(body.dl.length).toBeLessThanOrEqual(max);
-                expect(body.dp.length).toBeLessThanOrEqual(max);
-            });
-            it('does this for generic events', async () => {
-                coveoua('init', 'MYTOKEN');
-                await coveoua('send', 'pageview', reallyLongPath1);
-                await coveoua('send', 'pageview', reallyLongPath2);
-                await coveoua('send', 'event');
-                const body = JSON.parse(lastCallBody(fetchMock));
-                expect(body.dr.length).toBeLessThanOrEqual(max);
-                expect(body.dl.length).toBeLessThanOrEqual(max);
-            });
-        });
-    });
-
-    describe('set', () => {
-        it('can set a new parameter', async () => {
-            coveoua('init', 'MYTOKEN');
-            coveoua('set', 'userId', 'something');
-            await coveoua('send', someRandomEventName);
-
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
-            expect(JSON.parse(lastCallBody(fetchMock))).toEqual({userId: 'something'});
-        });
-
-        it('can set parameters using an object', async () => {
-            coveoua('init', 'MYTOKEN');
-            coveoua('set', {
-                userId: 'something',
-            });
-            await coveoua('send', someRandomEventName);
-
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
-            expect(JSON.parse(lastCallBody(fetchMock))).toEqual({userId: 'something'});
-        });
-
-        it('can set a custom_website parameter on a collect event', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: ['ec']});
-            coveoua('set', 'custom', {context_website: 'MY_WEBSITE'});
-            await coveoua('send', 'pageview');
-
-            expect(fetchMock.calls().length).toBe(1);
-            let result = JSON.parse(lastCallBody(fetchMock));
-            expect(result).toHaveProperty('context_website', 'MY_WEBSITE');
-        });
-
-        it('does not set custom parameters which are strings', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: ['ec']});
-            coveoua('set', 'custom', 'test');
-            await coveoua('send', 'pageview');
-
-            expect(fetchMock.calls().length).toBe(1);
-            let result = JSON.parse(lastCallBody(fetchMock));
-            expect(Object.keys(result).length).toBe(11);
-        });
-
-        it('does not set custom parameters which are arrays', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: ['ec']});
-            coveoua('set', 'custom', ['test']);
-            await coveoua('send', 'pageview');
-
-            expect(fetchMock.calls().length).toBe(1);
-            let result = JSON.parse(lastCallBody(fetchMock));
-            expect(Object.keys(result).length).toBe(11);
-        });
-
-        it('does not set custom parameters which are null', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: ['ec']});
-            coveoua('set', 'custom', null);
-            await coveoua('send', 'pageview');
-
-            expect(fetchMock.calls().length).toBe(1);
-            let result = JSON.parse(lastCallBody(fetchMock));
-            expect(Object.keys(result).length).toBe(11);
-        });
-
-        it('does not set custom parameters which are undefined', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: ['ec']});
-            coveoua('set', 'custom', undefined);
-            await coveoua('send', 'pageview');
-
-            expect(fetchMock.calls().length).toBe(1);
-            let result = JSON.parse(lastCallBody(fetchMock));
-            expect(Object.keys(result).length).toBe(11);
-        });
-
-        it('can set a custom_website parameter on a non-collect event', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: []});
-            coveoua('set', 'custom', {context_website: 'MY_WEBSITE'});
-            await coveoua('send', 'view', {somedata: 'something'});
-
-            expect(fetchMock.calls().length).toBe(1);
-            let result = JSON.parse(lastCallBody(fetchMock));
-            expect(result).toHaveProperty('somedata', 'something');
-            expect(result).toHaveProperty('customData.context_website', 'MY_WEBSITE');
-        });
-
-        it('does not add a customData entry for custom params which are null', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: []});
-            coveoua('set', 'custom', null);
-            await coveoua('send', 'view', {somedata: 'something'});
-
-            expect(fetchMock.calls().length).toBe(1);
-            let result = JSON.parse(lastCallBody(fetchMock));
-            expect(result).toHaveProperty('somedata', 'something');
-            expect(result).not.toHaveProperty('customData');
-        });
-
-        it('does not add a customData entry for custom params which are undefined', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: []});
-            coveoua('set', 'custom', undefined);
-            await coveoua('send', 'view', {somedata: 'something'});
-
-            expect(fetchMock.calls().length).toBe(1);
-            let result = JSON.parse(lastCallBody(fetchMock));
-            expect(result).toHaveProperty('somedata', 'something');
-            expect(result).not.toHaveProperty('customData');
-        });
-
-        it('does not add a customData entry for customData params which are strings', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: []});
-            coveoua('set', 'custom', 'test');
-            await coveoua('send', 'view', {somedata: 'something'});
-
-            expect(fetchMock.calls().length).toBe(1);
-            let result = JSON.parse(lastCallBody(fetchMock));
-            expect(result).toHaveProperty('somedata', 'something');
-            expect(result).not.toHaveProperty('customData');
-        });
-
-        it('does not add a customData entry for customData params which are arrays', async () => {
-            coveoua('init', 'MYTOKEN', [{plugins: []}]);
-            coveoua('set', 'custom', [test]);
-            await coveoua('send', 'view', {somedata: 'something'});
-
-            expect(fetchMock.calls().length).toBe(1);
-            let result = JSON.parse(lastCallBody(fetchMock));
-            expect(result).toHaveProperty('somedata', 'something');
-            expect(result).not.toHaveProperty('customData');
-        });
-
-        it('will not override hardcoded customData parameters', async () => {
-            coveoua('init', 'MYTOKEN', {plugins: []});
-            coveoua('set', 'custom', {context_website: 'MY_WEBSITE'});
-            await coveoua('send', 'view', {somedata: 'something', customData: {context_website: 'MY_OTHER_WEBSITE'}});
-
-            expect(fetchMock.calls().length).toBe(1);
-            let result = JSON.parse(lastCallBody(fetchMock));
-            expect(result).toHaveProperty('somedata', 'something');
-            expect(result).toHaveProperty('customData.context_website', 'MY_OTHER_WEBSITE');
-        });
-
-        it('can set trackingId', async () => {
-            const trackingId = 'yourbestfriend';
-            coveoua('init', 'MYTOKEN');
-            coveoua('set', 'trackingId', trackingId);
-            await coveoua('send', someRandomEventName);
-
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
-            expect(JSON.parse(lastCallBody(fetchMock))).toHaveProperty('trackingId', trackingId);
-        });
+    it('can send pageview with analyticsClient', () => {
+      coveoua('init', analyticsClientMock);
+      expect(() => coveoua('send', 'pageview')).not.toThrow();
+    });
+  });
 
-        it('context_website does not overwrite trackingId', async () => {
-            const trackingId = 'yourbestfriend';
-            const contextWebsite = 'yoursite';
-            coveoua('init', 'MYTOKEN');
-            coveoua('set', 'custom', {context_website: contextWebsite});
-            coveoua('set', 'trackingId', trackingId);
-            await coveoua('send', someRandomEventName);
+  describe('initForProxy', () => {
+    it(`throw if the initForProxy don't receive an endpoint`, () => {
+      expect(() => coveoua('initForProxy')).toThrow(
+        `You must pass your endpoint when you call 'initForProxy'`
+      );
+    });
 
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
-            expect(JSON.parse(lastCallBody(fetchMock))).toHaveProperty('trackingId', trackingId);
-        });
+    it(`throw if the initForProxy receive an endpoint that is not a string`, () => {
+      expect(() => coveoua('initForProxy', {})).toThrow(
+        `You must pass a string as the endpoint parameter when you call 'initForProxy'`
+      );
     });
+  });
 
-    describe('onLoad', () => {
-        it('can execute callback with onLoad event', () => {
-            var callback = jest.fn();
+  describe('send', () => {
+    it('throws when not initialized', () => {
+      expect(() => coveoua('send')).toThrow(`You must call init before sending an event`);
+    });
 
-            coveoua('onLoad', callback);
+    it('throws when send is called without any other arguments', () => {
+      coveoua('init', 'MYTOKEN');
+      expect(() => coveoua('send')).toThrow(`You must provide an event type when calling "send".`);
+    });
 
-            expect(callback).toHaveBeenCalledTimes(1);
-        });
+    it('can send pageview', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: []});
+      await coveoua('send', 'pageview');
 
-        it('throws when registering an invalid onLoad event', () => {
-            expect(() => coveoua('onLoad', undefined)).toThrow();
-        });
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/pageview`);
     });
 
-    describe('provide', () => {
-        it('register properly', () => {
-            coveoua('provide', 'test', TestPlugin);
+    it('can send pageview with customdata', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: []});
+      await coveoua('send', 'pageview', {somedata: 'asd'});
 
-            coveoua('init', 'MYTOKEN');
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/pageview`);
+      expect(JSON.parse(lastCallBody(fetchMock))).toEqual({somedata: 'asd'});
+    });
 
-            expect(() => coveoua('require', 'test')).not.toThrow();
-        });
+    it('can send view event with clientId', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: []});
+      await coveoua('send', 'view');
+
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/view?visitor=${visitorIdMock}`);
+      expect(JSON.parse(lastCallBody(fetchMock)).clientId).toBe(visitorIdMock);
     });
 
-    describe('version', () => {
-        it('returns the current version string', () => {
-            coveoua('init', 'MYTOKEN');
-            expect(coveoua('version')).toBe(libVersion);
-        });
+    it('can send any event to the endpoint', async () => {
+      coveoua('init', 'MYTOKEN');
+      await coveoua('send', someRandomEventName);
+
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
     });
 
-    describe('callPlugin', () => {
-        it('resolves properly plugin actions', () => {
-            coveoua('provide', 'test', TestPluginWithSpy);
-            coveoua('init', 'MYTOKEN', {plugins: ['test']});
+    it('can send an event with a proxy endpoint', async () => {
+      coveoua('initForProxy', 'https://myProxyEndpoint.com');
+      await coveoua('send', someRandomEventName);
 
-            coveoua('callPlugin', 'test', 'testMethod', 'foo', 'bar');
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toBe(
+        `https://myproxyendpoint.com/rest/v15/analytics/${someRandomEventName}`
+      );
+    });
+
+    describe('will restrict referrers and url lengths', () => {
+      const max: number = 2048;
+      const reallyLongPath1: string = 'http://coveo.com/?q=' + 'a'.repeat(max);
+      const reallyLongPath2: string = 'http://coveo.com/?q=' + 'b'.repeat(max);
+      expect(reallyLongPath1.length).toBeGreaterThan(max);
+      expect(reallyLongPath2.length).toBeGreaterThan(max);
+      it('does this for pageviews', async () => {
+        coveoua('init', 'MYTOKEN');
+        await coveoua('send', 'pageview', reallyLongPath1);
+        await coveoua('send', 'pageview', reallyLongPath2);
+        const body = JSON.parse(lastCallBody(fetchMock));
+        expect(body.dr.length).toBeLessThanOrEqual(max);
+        expect(body.dl.length).toBeLessThanOrEqual(max);
+        expect(body.dp.length).toBeLessThanOrEqual(max);
+      });
+      it('does this for generic events', async () => {
+        coveoua('init', 'MYTOKEN');
+        await coveoua('send', 'pageview', reallyLongPath1);
+        await coveoua('send', 'pageview', reallyLongPath2);
+        await coveoua('send', 'event');
+        const body = JSON.parse(lastCallBody(fetchMock));
+        expect(body.dr.length).toBeLessThanOrEqual(max);
+        expect(body.dl.length).toBeLessThanOrEqual(max);
+      });
+    });
+  });
+
+  describe('set', () => {
+    it('can set a new parameter', async () => {
+      coveoua('init', 'MYTOKEN');
+      coveoua('set', 'userId', 'something');
+      await coveoua('send', someRandomEventName);
+
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
+      expect(JSON.parse(lastCallBody(fetchMock))).toEqual({
+        userId: 'something',
+      });
+    });
+
+    it('can set parameters using an object', async () => {
+      coveoua('init', 'MYTOKEN');
+      coveoua('set', {
+        userId: 'something',
+      });
+      await coveoua('send', someRandomEventName);
+
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
+      expect(JSON.parse(lastCallBody(fetchMock))).toEqual({
+        userId: 'something',
+      });
+    });
+
+    it('can set a custom_website parameter on a collect event', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: ['ec']});
+      coveoua('set', 'custom', {context_website: 'MY_WEBSITE'});
+      await coveoua('send', 'pageview');
+
+      expect(fetchMock.calls().length).toBe(1);
+      let result = JSON.parse(lastCallBody(fetchMock));
+      expect(result).toHaveProperty('context_website', 'MY_WEBSITE');
+    });
+
+    it('does not set custom parameters which are strings', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: ['ec']});
+      coveoua('set', 'custom', 'test');
+      await coveoua('send', 'pageview');
 
-            expect(TestPluginWithSpy.spy).toHaveBeenCalledTimes(1);
-            expect(TestPluginWithSpy.spy).toHaveBeenCalledWith(['foo', 'bar']);
-        });
+      expect(fetchMock.calls().length).toBe(1);
+      let result = JSON.parse(lastCallBody(fetchMock));
+      expect(Object.keys(result).length).toBe(11);
+    });
+
+    it('does not set custom parameters which are arrays', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: ['ec']});
+      coveoua('set', 'custom', ['test']);
+      await coveoua('send', 'pageview');
+
+      expect(fetchMock.calls().length).toBe(1);
+      let result = JSON.parse(lastCallBody(fetchMock));
+      expect(Object.keys(result).length).toBe(11);
+    });
+
+    it('does not set custom parameters which are null', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: ['ec']});
+      coveoua('set', 'custom', null);
+      await coveoua('send', 'pageview');
 
-        it('throws when a namespaced action is called and that the namespace/plugin is not required', () => {
-            coveoua('init', 'SOME TOKEN', {plugins: ['ec']});
+      expect(fetchMock.calls().length).toBe(1);
+      let result = JSON.parse(lastCallBody(fetchMock));
+      expect(Object.keys(result).length).toBe(11);
+    });
+
+    it('does not set custom parameters which are undefined', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: ['ec']});
+      coveoua('set', 'custom', undefined);
+      await coveoua('send', 'pageview');
 
-            expect(() => coveoua('callPlugin', 'svc', 'setTicket')).toThrow(/is not required/);
-        });
+      expect(fetchMock.calls().length).toBe(1);
+      let result = JSON.parse(lastCallBody(fetchMock));
+      expect(Object.keys(result).length).toBe(11);
+    });
 
-        it('throws when a namespaced action is called and that this action does not exists on the plugin', () => {
-            coveoua('init', 'SOME TOKEN', {plugins: ['svc']});
+    it('can set a custom_website parameter on a non-collect event', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: []});
+      coveoua('set', 'custom', {context_website: 'MY_WEBSITE'});
+      await coveoua('send', 'view', {somedata: 'something'});
 
-            expect(() => coveoua('callPlugin', 'svc', 'fooBarBaz')).toThrow(/does not exist/);
-        });
+      expect(fetchMock.calls().length).toBe(1);
+      let result = JSON.parse(lastCallBody(fetchMock));
+      expect(result).toHaveProperty('somedata', 'something');
+      expect(result).toHaveProperty('customData.context_website', 'MY_WEBSITE');
     });
 
-    describe('require', () => {
-        it('can require a plugin', () => {
-            coveoua('provide', 'test', TestPlugin);
-            coveoua('init', 'MYTOKEN', {plugins: []});
+    it('does not add a customData entry for custom params which are null', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: []});
+      coveoua('set', 'custom', null);
+      await coveoua('send', 'view', {somedata: 'something'});
+
+      expect(fetchMock.calls().length).toBe(1);
+      let result = JSON.parse(lastCallBody(fetchMock));
+      expect(result).toHaveProperty('somedata', 'something');
+      expect(result).not.toHaveProperty('customData');
+    });
 
-            expect(() => coveoua('require', 'test')).not.toThrow();
-        });
+    it('does not add a customData entry for custom params which are undefined', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: []});
+      coveoua('set', 'custom', undefined);
+      await coveoua('send', 'view', {somedata: 'something'});
 
-        it('throws if not initialized', () => {
-            expect(() => coveoua('require', 'test')).toThrow(`You must call init before requiring a plugin`);
-        });
+      expect(fetchMock.calls().length).toBe(1);
+      let result = JSON.parse(lastCallBody(fetchMock));
+      expect(result).toHaveProperty('somedata', 'something');
+      expect(result).not.toHaveProperty('customData');
+    });
 
-        it('throws if the plugin is not registered first', () => {
-            coveoua('init', 'MYTOKEN', {plugins: []});
+    it('does not add a customData entry for customData params which are strings', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: []});
+      coveoua('set', 'custom', 'test');
+      await coveoua('send', 'view', {somedata: 'something'});
 
-            expect(() => coveoua('require', 'test')).toThrow(
-                `No plugin named "test" is currently registered. If you use a custom plugin, use 'provide' first.`,
-            );
-        });
+      expect(fetchMock.calls().length).toBe(1);
+      let result = JSON.parse(lastCallBody(fetchMock));
+      expect(result).toHaveProperty('somedata', 'something');
+      expect(result).not.toHaveProperty('customData');
     });
 
-    describe('reset', () => {
-        it('reset the client', () => {
-            coveoua('init', 'MYTOKEN');
+    it('does not add a customData entry for customData params which are arrays', async () => {
+      coveoua('init', 'MYTOKEN', [{plugins: []}]);
+      coveoua('set', 'custom', [test]);
+      await coveoua('send', 'view', {somedata: 'something'});
 
-            coveoua('reset');
+      expect(fetchMock.calls().length).toBe(1);
+      let result = JSON.parse(lastCallBody(fetchMock));
+      expect(result).toHaveProperty('somedata', 'something');
+      expect(result).not.toHaveProperty('customData');
+    });
 
-            expect(() => coveoua('send')).toThrow(`You must call init before sending an event`);
-        });
+    it('will not override hardcoded customData parameters', async () => {
+      coveoua('init', 'MYTOKEN', {plugins: []});
+      coveoua('set', 'custom', {context_website: 'MY_WEBSITE'});
+      await coveoua('send', 'view', {
+        somedata: 'something',
+        customData: {context_website: 'MY_OTHER_WEBSITE'},
+      });
+
+      expect(fetchMock.calls().length).toBe(1);
+      let result = JSON.parse(lastCallBody(fetchMock));
+      expect(result).toHaveProperty('somedata', 'something');
+      expect(result).toHaveProperty('customData.context_website', 'MY_OTHER_WEBSITE');
+    });
 
-        it('reset the plugins', () => {
-            const fakePlugin = TestPlugin;
-            coveoua('provide', 'test', fakePlugin);
-            coveoua('init', 'MYTOKEN', {plugins: ['test']});
+    it('can set trackingId', async () => {
+      const trackingId = 'yourbestfriend';
+      coveoua('init', 'MYTOKEN');
+      coveoua('set', 'trackingId', trackingId);
+      await coveoua('send', someRandomEventName);
 
-            coveoua('reset');
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
+      expect(JSON.parse(lastCallBody(fetchMock))).toHaveProperty('trackingId', trackingId);
+    });
 
-            expect(() => coveoua('init', 'MYTOKEN', {plugins: ['test']})).toThrow(
-                `No plugin named "test" is currently registered. If you use a custom plugin, use 'provide' first.`,
-            );
-        });
+    it('context_website does not overwrite trackingId', async () => {
+      const trackingId = 'yourbestfriend';
+      const contextWebsite = 'yoursite';
+      coveoua('init', 'MYTOKEN');
+      coveoua('set', 'custom', {context_website: contextWebsite});
+      coveoua('set', 'trackingId', trackingId);
+      await coveoua('send', someRandomEventName);
+
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
+      expect(JSON.parse(lastCallBody(fetchMock))).toHaveProperty('trackingId', trackingId);
+    });
+  });
 
-        it('reset the params', async () => {
-            coveoua('init', 'MYTOKEN');
-            coveoua('set', 'userId', 'something');
+  describe('onLoad', () => {
+    it('can execute callback with onLoad event', () => {
+      var callback = vi.fn();
 
-            coveoua('reset');
+      coveoua('onLoad', callback);
 
-            coveoua('init', 'MYTOKEN');
-            await coveoua('send', someRandomEventName);
+      expect(callback).toHaveBeenCalledTimes(1);
+    });
 
-            expect(fetchMock.calls().length).toBe(1);
-            expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
-            expect(JSON.parse(lastCallBody(fetchMock))).toEqual({});
-        });
+    it('throws when registering an invalid onLoad event', () => {
+      expect(() => coveoua('onLoad', undefined)).toThrow();
     });
+  });
 
-    it('throws when called with an unknown action', () => {
-        coveoua('init', 'SOME TOKEN', {plugins: ['svc']});
+  describe('provide', () => {
+    it('register properly', () => {
+      coveoua('provide', 'test', TestPlugin);
 
-        expect(() => coveoua('potato')).toThrow(
-            `The action "potato" does not exist. Available actions: init, set, send, onLoad, callPlugin, reset, require, provide, version.`,
-        );
+      coveoua('init', 'MYTOKEN');
+
+      expect(() => coveoua('require', 'test')).not.toThrow();
+    });
+  });
+
+  describe('version', () => {
+    it('returns the current version string', () => {
+      coveoua('init', 'MYTOKEN');
+      expect(coveoua('version')).toBe(libVersion);
     });
+  });
 
+  describe('callPlugin', () => {
     it('resolves properly plugin actions', () => {
-        coveoua('provide', 'test', TestPluginWithSpy);
-        coveoua('init', 'MYTOKEN', {plugins: ['test']});
+      coveoua('provide', 'test', TestPluginWithSpy);
+      coveoua('init', 'MYTOKEN', {plugins: ['test']});
 
-        coveoua('test:testMethod', 'foo', 'bar');
+      coveoua('callPlugin', 'test', 'testMethod', 'foo', 'bar');
 
-        expect(TestPluginWithSpy.spy).toHaveBeenCalledTimes(1);
-        expect(TestPluginWithSpy.spy).toHaveBeenCalledWith(['foo', 'bar']);
+      expect(TestPluginWithSpy.spy).toHaveBeenCalledTimes(1);
+      expect(TestPluginWithSpy.spy).toHaveBeenCalledWith(['foo', 'bar']);
     });
+
+    it('throws when a namespaced action is called and that the namespace/plugin is not required', () => {
+      coveoua('init', 'SOME TOKEN', {plugins: ['ec']});
+
+      expect(() => coveoua('callPlugin', 'svc', 'setTicket')).toThrow(/is not required/);
+    });
+
+    it('throws when a namespaced action is called and that this action does not exists on the plugin', () => {
+      coveoua('init', 'SOME TOKEN', {plugins: ['svc']});
+
+      expect(() => coveoua('callPlugin', 'svc', 'fooBarBaz')).toThrow(/does not exist/);
+    });
+  });
+
+  describe('require', () => {
+    it('can require a plugin', () => {
+      coveoua('provide', 'test', TestPlugin);
+      coveoua('init', 'MYTOKEN', {plugins: []});
+
+      expect(() => coveoua('require', 'test')).not.toThrow();
+    });
+
+    it('throws if not initialized', () => {
+      expect(() => coveoua('require', 'test')).toThrow(
+        `You must call init before requiring a plugin`
+      );
+    });
+
+    it('throws if the plugin is not registered first', () => {
+      coveoua('init', 'MYTOKEN', {plugins: []});
+
+      expect(() => coveoua('require', 'test')).toThrow(
+        `No plugin named "test" is currently registered. If you use a custom plugin, use 'provide' first.`
+      );
+    });
+  });
+
+  describe('reset', () => {
+    it('reset the client', () => {
+      coveoua('init', 'MYTOKEN');
+
+      coveoua('reset');
+
+      expect(() => coveoua('send')).toThrow(`You must call init before sending an event`);
+    });
+
+    it('reset the plugins', () => {
+      const fakePlugin = TestPlugin;
+      coveoua('provide', 'test', fakePlugin);
+      coveoua('init', 'MYTOKEN', {plugins: ['test']});
+
+      coveoua('reset');
+
+      expect(() => coveoua('init', 'MYTOKEN', {plugins: ['test']})).toThrow(
+        `No plugin named "test" is currently registered. If you use a custom plugin, use 'provide' first.`
+      );
+    });
+
+    it('reset the params', async () => {
+      coveoua('init', 'MYTOKEN');
+      coveoua('set', 'userId', 'something');
+
+      coveoua('reset');
+
+      coveoua('init', 'MYTOKEN');
+      await coveoua('send', someRandomEventName);
+
+      expect(fetchMock.calls().length).toBe(1);
+      expect(fetchMock.lastUrl()).toBe(`${analyticsEndpoint}/${someRandomEventName}`);
+      expect(JSON.parse(lastCallBody(fetchMock))).toEqual({});
+    });
+  });
+
+  it('throws when called with an unknown action', () => {
+    coveoua('init', 'SOME TOKEN', {plugins: ['svc']});
+
+    expect(() => coveoua('potato')).toThrow(
+      `The action "potato" does not exist. Available actions: init, set, send, onLoad, callPlugin, reset, require, provide, version.`
+    );
+  });
+
+  it('resolves properly plugin actions', () => {
+    coveoua('provide', 'test', TestPluginWithSpy);
+    coveoua('init', 'MYTOKEN', {plugins: ['test']});
+
+    coveoua('test:testMethod', 'foo', 'bar');
+
+    expect(TestPluginWithSpy.spy).toHaveBeenCalledTimes(1);
+    expect(TestPluginWithSpy.spy).toHaveBeenCalledWith(['foo', 'bar']);
+  });
 });