iureiure 1.0.0

package/packages/analytics-js-common/__tests__/services/ExternalSrcLoader/ExternalSrcLoader.test.ts

@@ -0,0 +1,170 @@
+import { ExternalSrcLoader } from '../../../src/services/ExternalSrcLoader';
+import {
+  createScriptElement,
+  insertScript,
+} from '../../../src/services/ExternalSrcLoader/jsFileLoader';
+import { server } from '../../../__fixtures__/msw.server';
+import { dummyDataplaneHost } from '../../../__fixtures__/fixtures';
+
+describe('External Source Loader', () => {
+  let externalSrcLoaderInstance: ExternalSrcLoader;
+  const defaultErrorHandler = {
+    onError: jest.fn((): void => {}),
+  };
+  const defaultLogger = {
+    error: jest.fn((): void => {}),
+  };
+
+  beforeAll(() => {
+    server.listen();
+  });
+
+  beforeEach(() => {
+    externalSrcLoaderInstance = new ExternalSrcLoader(defaultErrorHandler, defaultLogger);
+  });
+
+  afterEach(() => {
+    server.resetHandlers();
+    server.events.removeAllListeners();
+    // Reset DOM to original state
+    document.getElementById('dummyScript')?.remove();
+  });
+
+  afterAll(() => {
+    server.close();
+  });
+
+  it(`should retrieve remote script & trigger the callback with value`, done => {
+    const cb = (loadedScript?: string) => {
+      expect(loadedScript).toStrictEqual('dummyScript');
+      const newScriptElement = document.getElementById('dummyScript') as HTMLScriptElement;
+      expect(newScriptElement).toBeDefined();
+      expect(newScriptElement.src).toStrictEqual(`${dummyDataplaneHost}/jsFileSample.js`);
+      done();
+    };
+
+    externalSrcLoaderInstance.loadJSFile({
+      url: `${dummyDataplaneHost}/jsFileSample.js`,
+      id: 'dummyScript',
+      callback: cb,
+    });
+  });
+
+  it(`should handle error in remote script retrieval & trigger the callback with no value`, done => {
+    const cb = (loadedScript?: string) => {
+      expect(loadedScript).toBeUndefined();
+      const newScriptElement = document.getElementById('dummyScript') as HTMLScriptElement;
+      expect(newScriptElement).toBeDefined();
+      expect(newScriptElement.src).toStrictEqual(`${dummyDataplaneHost}/noConnectionSample`);
+      expect(defaultErrorHandler.onError).toHaveBeenCalledTimes(1);
+      expect(defaultErrorHandler.onError).toHaveBeenCalledWith(
+        new Error(
+          'Failed to load the script with the id "dummyScript" from URL "https://dummy.dataplane.host.com/noConnectionSample".',
+        ),
+        'ExternalSrcLoader',
+      );
+      done();
+    };
+
+    externalSrcLoaderInstance.loadJSFile({
+      url: `${dummyDataplaneHost}/noConnectionSample`,
+      id: 'dummyScript',
+      callback: cb,
+    });
+  });
+
+  it(`should handle error if script with same id already exists`, done => {
+    const cb = (loadedScript?: string) => {
+      expect(loadedScript).toBeUndefined();
+      const newScriptElement = document.getElementById('dummyScript') as HTMLScriptElement;
+      expect(newScriptElement).toBeDefined();
+      expect(newScriptElement.src).toStrictEqual(`${dummyDataplaneHost}/jsFileSample.js`);
+      expect(defaultErrorHandler.onError).toHaveBeenCalledTimes(1);
+      expect(defaultErrorHandler.onError).toHaveBeenCalledWith(
+        new Error(
+          'A script with the id "dummyScript" is already loaded. Skipping the loading of this script to prevent conflicts.',
+        ),
+        'ExternalSrcLoader',
+      );
+      document.getElementById('dummyScript')?.remove();
+      done();
+    };
+
+    const dummyElement = createScriptElement(
+      `${dummyDataplaneHost}/jsFileSample.js`,
+      'dummyScript',
+    );
+    insertScript(dummyElement);
+    const scriptElement = document.getElementById('dummyScript') as HTMLScriptElement;
+    expect(scriptElement).toBeDefined();
+    expect(scriptElement.src).toStrictEqual(`${dummyDataplaneHost}/jsFileSample.js`);
+
+    externalSrcLoaderInstance.loadJSFile({
+      url: `${dummyDataplaneHost}/noConnectionSample`,
+      id: 'dummyScript',
+      callback: cb,
+    });
+  });
+
+  it(`should append the script in DOM in correct place`, () => {
+    const dummyElement = createScriptElement(
+      `${dummyDataplaneHost}/jsFileSample.js`,
+      'dummyScript',
+    );
+
+    // If head exists should be placed as first script
+    insertScript(createScriptElement(`${dummyDataplaneHost}/jsFileEmpty.js`, 'dummyScript1'));
+    insertScript(dummyElement);
+    let scriptElement = document.getElementById('dummyScript') as HTMLScriptElement;
+    expect(scriptElement).toBeDefined();
+    expect(scriptElement.parentElement?.tagName).toStrictEqual('HEAD');
+    expect(scriptElement.nextElementSibling?.id).toStrictEqual('dummyScript1');
+    document.getElementById('dummyScript1')?.remove();
+    document.getElementById('dummyScript')?.remove();
+
+    // If no head exists should be placed as first script if another script exists
+    document.getElementsByTagName('head')[0].remove();
+    const scriptElement1 = document.createElement('script');
+    scriptElement1.type = 'text/javascript';
+    scriptElement1.src = `${dummyDataplaneHost}/jsFileEmpty.js`;
+    scriptElement1.id = 'dummyScript1';
+    document.getElementsByTagName('body')[0].append(scriptElement1);
+    insertScript(dummyElement);
+    scriptElement = document.getElementById('dummyScript') as HTMLScriptElement;
+    expect(scriptElement).toBeDefined();
+    expect(scriptElement.nextElementSibling).toBeDefined();
+    expect(scriptElement.nextElementSibling?.id).toStrictEqual('dummyScript1');
+    document.getElementById('dummyScript1')?.remove();
+    document.getElementById('dummyScript')?.remove();
+    document.getElementsByTagName('html')[0].append(document.createElement('head'));
+
+    // If no head and no other script create head and add there
+    document.getElementsByTagName('head')[0].remove();
+    insertScript(dummyElement);
+    scriptElement = document.getElementById('dummyScript') as HTMLScriptElement;
+    expect(scriptElement).toBeDefined();
+    expect(scriptElement.parentElement?.tagName).toStrictEqual('HEAD');
+    document.getElementById('dummyScript')?.remove();
+  });
+
+  it(`should append the script in DOM with extra attributes in the tag`, done => {
+    const cb = () => {
+      const newScriptElement = document.getElementById('dummyScript') as HTMLScriptElement;
+      expect(newScriptElement).toBeDefined();
+      expect(newScriptElement.src).toStrictEqual(`${dummyDataplaneHost}/jsFileSample.js`);
+      expect(newScriptElement.crossOrigin).toStrictEqual('anonymous');
+      expect(newScriptElement.getAttribute('integrity')).toStrictEqual('filehash');
+      done();
+    };
+
+    externalSrcLoaderInstance.loadJSFile({
+      url: `${dummyDataplaneHost}/jsFileSample.js`,
+      id: 'dummyScript',
+      callback: cb,
+      extraAttributes: {
+        crossOrigin: 'anonymous',
+        integrity: 'filehash',
+      },
+    });
+  });
+});

package/packages/analytics-js-common/__tests__/utilities/checks.test.ts

@@ -0,0 +1,95 @@
+import {
+  isFunction,
+  isNull,
+  isString,
+  isUndefined,
+  isNullOrUndefined,
+  isTypeOfError,
+  isDefined,
+  isDefinedAndNotNull,
+} from '../../src/utilities/checks';
+
+describe('Common Utils - Checks', () => {
+  describe('isFunction', () => {
+    it('should check if value is function', () => {
+      expect(isFunction(() => {})).toBeTruthy();
+      expect(isFunction('')).toBeFalsy();
+    });
+  });
+
+  describe('isString', () => {
+    it('should check if value is strng', () => {
+      expect(isString('')).toBeTruthy();
+      expect(isString({})).toBeFalsy();
+      expect(isString(0)).toBeFalsy();
+      expect(isString([])).toBeFalsy();
+      expect(isString(undefined)).toBeFalsy();
+    });
+  });
+
+  describe('isNull', () => {
+    it('should check if value is null', () => {
+      expect(isNull(null)).toBeTruthy();
+      expect(isNull('')).toBeFalsy();
+      expect(isNull(0)).toBeFalsy();
+      expect(isNull([])).toBeFalsy();
+      expect(isNull(undefined)).toBeFalsy();
+    });
+  });
+
+  describe('isUndefined', () => {
+    it('should check if value is undefined', () => {
+      expect(isUndefined('')).toBeFalsy();
+      expect(isUndefined({})).toBeFalsy();
+      expect(isUndefined(0)).toBeFalsy();
+      expect(isUndefined([])).toBeFalsy();
+      expect(isUndefined(null)).toBeFalsy();
+      expect(isUndefined(undefined)).toBeTruthy();
+    });
+  });
+
+  describe('isNullOrUndefined', () => {
+    it('should check if value is undefined', () => {
+      expect(isNullOrUndefined('')).toBeFalsy();
+      expect(isNullOrUndefined({})).toBeFalsy();
+      expect(isNullOrUndefined(0)).toBeFalsy();
+      expect(isNullOrUndefined([])).toBeFalsy();
+      expect(isNullOrUndefined(null)).toBeTruthy();
+      expect(isNullOrUndefined(undefined)).toBeTruthy();
+    });
+  });
+
+  describe('isTypeOfError', () => {
+    it('should check if value is instance of Error', () => {
+      expect(isTypeOfError(new Error())).toBeTruthy();
+      expect(isTypeOfError('')).toBeFalsy();
+      expect(isTypeOfError({})).toBeFalsy();
+      expect(isTypeOfError(0)).toBeFalsy();
+      expect(isTypeOfError([])).toBeFalsy();
+      expect(isTypeOfError(null)).toBeFalsy();
+      expect(isTypeOfError(undefined)).toBeFalsy();
+    });
+  });
+
+  describe('isDefined', () => {
+    it('should check if value is defined', () => {
+      expect(isDefined('')).toBeTruthy();
+      expect(isDefined({})).toBeTruthy();
+      expect(isDefined(0)).toBeTruthy();
+      expect(isDefined([])).toBeTruthy();
+      expect(isDefined(null)).toBeTruthy();
+      expect(isDefined(undefined)).toBeFalsy();
+    });
+  });
+
+  describe('isDefinedAndNotNull', () => {
+    it('should check if value is defined and not null', () => {
+      expect(isDefinedAndNotNull('')).toBeTruthy();
+      expect(isDefinedAndNotNull({})).toBeTruthy();
+      expect(isDefinedAndNotNull(0)).toBeTruthy();
+      expect(isDefinedAndNotNull([])).toBeTruthy();
+      expect(isDefinedAndNotNull(null)).toBeFalsy();
+      expect(isDefinedAndNotNull(undefined)).toBeFalsy();
+    });
+  });
+});

package/packages/analytics-js-common/__tests__/utilities/destinations.test.ts

@@ -0,0 +1,44 @@
+import {
+  getNonCloudDestinations,
+  isNonCloudDestination,
+  isHybridModeDestination,
+} from '../../src/utilities/destinations';
+import { dummySourceConfigResponse } from '../../__fixtures__/fixtures';
+
+describe('Config manager util - filterEnabledDestination', () => {
+  it('should get non-cloud destinations', () => {
+    const actualOutcome = getNonCloudDestinations(dummySourceConfigResponse.source.destinations);
+    expect(actualOutcome.length).toBe(3);
+  });
+
+  it('should detect if destination is non-cloud', () => {
+    const hybridDestination = isNonCloudDestination(
+      dummySourceConfigResponse.source.destinations[0],
+    );
+    expect(hybridDestination).toBeTruthy();
+
+    const nativeDest = isNonCloudDestination(dummySourceConfigResponse.source.destinations[1]);
+    expect(nativeDest).toBeTruthy();
+
+    const cloudDest = isNonCloudDestination(dummySourceConfigResponse.source.destinations[2]);
+    expect(cloudDest).toBeFalsy();
+  });
+
+  it('should detect if a destination is hybrid', () => {
+    const hybridDestination = isHybridModeDestination(
+      dummySourceConfigResponse.source.destinations[0],
+    );
+    expect(hybridDestination).toBeTruthy();
+
+    const nativeDest = isHybridModeDestination(dummySourceConfigResponse.source.destinations[1]);
+    expect(nativeDest).toBeFalsy();
+
+    const cloudDest = isHybridModeDestination(dummySourceConfigResponse.source.destinations[2]);
+    expect(cloudDest).toBeFalsy();
+
+    const hybridDestination2 = isHybridModeDestination(
+      dummySourceConfigResponse.source.destinations[3],
+    );
+    expect(hybridDestination2).toBeTruthy();
+  });
+});

package/packages/analytics-js-common/__tests__/utilities/detect.test.ts

@@ -0,0 +1,22 @@
+import { isSDKRunningInChromeExtension } from '../../src/utilities/detect';
+
+describe('Detect env/feature/capabilities', () => {
+  const reset = () => {
+    (window as any).chrome = undefined;
+  };
+  afterEach(reset);
+  describe('isSDKRunningInChromeExtension', () => {
+    it('should return true if SDK is running inside chrome extension', () => {
+      (window as any).chrome = {
+        runtime: { id: 'sample-id' },
+      };
+      expect(isSDKRunningInChromeExtension()).toBeTruthy();
+    });
+    it('should return false if SDK is not running inside chrome extension', () => {
+      (window as any).chrome = {
+        runtime: { id: undefined },
+      };
+      expect(isSDKRunningInChromeExtension()).toBeFalsy();
+    });
+  });
+});

package/packages/analytics-js-common/__tests__/utilities/eventMethodOverloads.test.ts

@@ -0,0 +1,260 @@
+import {
+  aliasArgumentsToCallOptions,
+  groupArgumentsToCallOptions,
+  identifyArgumentsToCallOptions,
+  pageArgumentsToCallOptions,
+  trackArgumentsToCallOptions,
+} from '../../src/utilities/eventMethodOverloads';
+
+describe('Core - Event Method Overloads', () => {
+  const callbackMock = jest.fn();
+
+  it('should convert facade page method arguments to analytics page call options', () => {
+    expect(
+      pageArgumentsToCallOptions('category', 'name', { props: {} }, { options: {} }, callbackMock),
+    ).toStrictEqual({
+      callback: callbackMock,
+      category: 'category',
+      name: 'name',
+      properties: { props: {}, category: 'category', name: 'name' },
+      options: { options: {} },
+    });
+    expect(
+      pageArgumentsToCallOptions('category', 'name', { props: {} }, callbackMock),
+    ).toStrictEqual({
+      callback: callbackMock,
+      category: 'category',
+      name: 'name',
+      properties: { props: {}, category: 'category', name: 'name' },
+    });
+    expect(pageArgumentsToCallOptions('category', 'name', callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      category: 'category',
+      name: 'name',
+      properties: { category: 'category', name: 'name' },
+    });
+    expect(pageArgumentsToCallOptions('category', callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      name: 'category',
+      properties: { category: null, name: 'category' },
+    });
+    expect(pageArgumentsToCallOptions('category')).toStrictEqual({
+      name: 'category',
+      properties: { category: null, name: 'category' },
+    });
+    expect(pageArgumentsToCallOptions('category', 'name')).toStrictEqual({
+      name: 'name',
+      category: 'category',
+      properties: { category: 'category', name: 'name' },
+    });
+    expect(pageArgumentsToCallOptions('category', 'name', { props: {} })).toStrictEqual({
+      name: 'name',
+      category: 'category',
+      properties: { category: 'category', name: 'name', props: {} },
+    });
+    expect(
+      pageArgumentsToCallOptions('category', 'name', { props: {} }, { options: {} }),
+    ).toStrictEqual({
+      name: 'name',
+      category: 'category',
+      options: {
+        options: {},
+      },
+      properties: { category: 'category', name: 'name', props: {} },
+    });
+    expect(pageArgumentsToCallOptions('category', { props: {} }, { options: {} })).toStrictEqual({
+      name: 'category',
+      options: {
+        options: {},
+      },
+      properties: { category: null, name: 'category', props: {} },
+    });
+    expect(pageArgumentsToCallOptions(undefined, 'name', callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      name: 'name',
+      properties: { category: null, name: 'name' },
+    });
+    expect(pageArgumentsToCallOptions(callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      properties: { category: null, name: null },
+    });
+    expect(pageArgumentsToCallOptions({ props: {} }, { options: {} }, callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      properties: { props: {}, category: null, name: null },
+      options: { options: {} },
+    });
+    expect(
+      pageArgumentsToCallOptions('category', { props: {} }, { options: {} }, callbackMock),
+    ).toStrictEqual({
+      callback: callbackMock,
+      name: 'category',
+      properties: { props: {}, category: null, name: 'category' },
+      options: { options: {} },
+    });
+    expect(pageArgumentsToCallOptions('category', 'name', null, {}, callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      category: 'category',
+      name: 'name',
+      properties: { category: 'category', name: 'name' },
+      options: {},
+    });
+  });
+
+  it('should convert facade track method arguments to analytics track call options', () => {
+    expect(
+      trackArgumentsToCallOptions('event', { props: {} }, { options: {} }, callbackMock),
+    ).toStrictEqual({
+      callback: callbackMock,
+      name: 'event',
+      properties: { props: {} },
+      options: { options: {} },
+    });
+    expect(trackArgumentsToCallOptions('event', { props: {} }, callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      name: 'event',
+      properties: { props: {} },
+    });
+    expect(trackArgumentsToCallOptions('event', callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      name: 'event',
+      properties: {},
+    });
+    expect(trackArgumentsToCallOptions('event', { properties: {} }, { options: {} })).toStrictEqual(
+      {
+        properties: { properties: {} },
+        options: { options: {} },
+        name: 'event',
+      },
+    );
+    expect(trackArgumentsToCallOptions('event', { properties: {} })).toStrictEqual({
+      properties: { properties: {} },
+      name: 'event',
+    });
+    expect(trackArgumentsToCallOptions('event')).toStrictEqual({
+      properties: {},
+      name: 'event',
+    });
+  });
+
+  it('should convert facade identify method arguments to analytics identify call options', () => {
+    expect(
+      identifyArgumentsToCallOptions(1234, { traits: {} }, { options: {} }, callbackMock),
+    ).toStrictEqual({
+      callback: callbackMock,
+      userId: '1234',
+      traits: { traits: {} },
+      options: { options: {} },
+    });
+    expect(identifyArgumentsToCallOptions('userId', { traits: {} }, callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      userId: 'userId',
+      traits: { traits: {} },
+    });
+    expect(identifyArgumentsToCallOptions('userId', callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      userId: 'userId',
+    });
+    expect(
+      identifyArgumentsToCallOptions({ traits: {} }, { options: {} }, callbackMock),
+    ).toStrictEqual({
+      callback: callbackMock,
+      userId: null,
+      traits: { traits: {} },
+      options: { options: {} },
+    });
+    expect(identifyArgumentsToCallOptions(1234, { traits: {} }, { options: {} })).toStrictEqual({
+      userId: '1234',
+      traits: { traits: {} },
+      options: { options: {} },
+    });
+    expect(
+      identifyArgumentsToCallOptions(undefined, { traits: {} }, { options: {} }),
+    ).toStrictEqual({
+      traits: { traits: {} },
+      options: { options: {} },
+    });
+  });
+
+  it('should convert facade alias method arguments to analytics alias call options', () => {
+    expect(aliasArgumentsToCallOptions('to', 'from', { options: {} }, callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      to: 'to',
+      from: 'from',
+      options: { options: {} },
+    });
+    expect(aliasArgumentsToCallOptions('to', 'from', callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      to: 'to',
+      from: 'from',
+    });
+    expect(aliasArgumentsToCallOptions('to', callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      to: 'to',
+    });
+    expect(aliasArgumentsToCallOptions('to', { options: {} }, callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      to: 'to',
+      options: { options: {} },
+    });
+    expect(aliasArgumentsToCallOptions(callbackMock)).toStrictEqual({
+      callback: callbackMock,
+    });
+    expect(identifyArgumentsToCallOptions(1234, { traits: {} }, { options: {} })).toStrictEqual({
+      userId: '1234',
+      traits: { traits: {} },
+      options: { options: {} },
+    });
+    expect(aliasArgumentsToCallOptions({ options: {} })).toStrictEqual({
+      options: { options: {} },
+    });
+  });
+
+  it('should convert facade group method arguments to analytics group call options', () => {
+    expect(
+      groupArgumentsToCallOptions(1234, { traits: {} }, { options: {} }, callbackMock),
+    ).toStrictEqual({
+      callback: callbackMock,
+      groupId: '1234',
+      traits: { traits: {} },
+      options: { options: {} },
+    });
+    expect(groupArgumentsToCallOptions('groupId', { traits: {} }, callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      groupId: 'groupId',
+      traits: { traits: {} },
+    });
+    expect(groupArgumentsToCallOptions('groupId', callbackMock)).toStrictEqual({
+      callback: callbackMock,
+      traits: {},
+      groupId: 'groupId',
+    });
+    expect(groupArgumentsToCallOptions(callbackMock)).toStrictEqual({
+      groupId: null,
+      traits: {},
+      callback: callbackMock,
+    });
+    expect(
+      groupArgumentsToCallOptions({ traits: {} }, { options: {} }, callbackMock),
+    ).toStrictEqual({
+      groupId: null,
+      callback: callbackMock,
+      traits: { traits: {} },
+      options: { options: {} },
+    });
+    expect(groupArgumentsToCallOptions({ traits: {} }, callbackMock)).toStrictEqual({
+      groupId: null,
+      callback: callbackMock,
+      options: null,
+      traits: { traits: {} },
+    });
+    expect(groupArgumentsToCallOptions(1234, { traits: {} }, { options: {} })).toStrictEqual({
+      groupId: '1234',
+      traits: { traits: {} },
+      options: { options: {} },
+    });
+    expect(groupArgumentsToCallOptions(undefined, { traits: {} }, { options: {} })).toStrictEqual({
+      traits: { traits: {} },
+      options: { options: {} },
+    });
+  });
+});