castled-js-sdk 0.0.1 → 0.0.2

package/__tests__/utils/errorHandler.test.js

@@ -0,0 +1,60 @@
+import { handleError, normalizeError } from '../../src/utils/errorHandler';
+import { FAILED_REQUEST_ERR_MSG_PREFIX } from '../../src/utils/constants';
+
+window.HtEventsGlobals = {
+  errorReporting: {
+    notify: jest.fn(),
+  },
+};
+
+const staticMessage = '[handleError]::';
+const customMessage = '[Device-mode]:: [Destination: Sample]:: ';
+const sampleErrorMessage = 'Sample error message';
+
+describe("Test group for 'normalizeError' method", () => {
+  it('Should normalizeError for string input', () => {
+    const msg = sampleErrorMessage;
+    const errMessage = normalizeError(msg);
+    expect(errMessage).toBe(`${staticMessage} "${msg}"`);
+  });
+  it('Should normalizeError for Error object input', () => {
+    const newError = new Error('Test error');
+    const errMessage = normalizeError(newError);
+    expect(errMessage).toBe(`${staticMessage} "Test error"`);
+  });
+  it('Should normalizeError for array input', () => {
+    const arr = [1, 2, 3, 4];
+    const errMessage = normalizeError(arr);
+    expect(errMessage).toBe(`${staticMessage} "${JSON.stringify(arr)}"`);
+  });
+  it('Should normalizeError for customMessage input', () => {
+    const msg = sampleErrorMessage;
+    const errMessage = normalizeError(msg, customMessage);
+    expect(errMessage).toBe(`${staticMessage}${customMessage} "${msg}"`);
+  });
+  it('Should normalizeError for object with message property input', () => {
+    const msg = sampleErrorMessage;
+    const errMessage = normalizeError({ message: msg });
+    expect(errMessage).toBe(`${staticMessage} "${msg}"`);
+  });
+  it('Should normalizeError for object with no message property input', () => {
+    const obj = { random: 12345678 };
+    const errMessage = normalizeError(obj);
+    expect(errMessage).toBe(`${staticMessage} "${JSON.stringify(obj)}"`);
+  });
+});
+
+describe("Test group for 'handleError' method", () => {
+  it('Should notify errors when the error is not coming from request failed', () => {
+    const errMessage = `sample error message`;
+    const err = new Error(errMessage);
+    handleError(err);
+    expect(window.HtEventsGlobals.errorReporting.notify).toHaveBeenCalledWith(err);
+  });
+  it('Should not notify for request failed errors', () => {
+    const errMessage = `${FAILED_REQUEST_ERR_MSG_PREFIX} 504 for url: https://example.com`;
+    const obj = new Error(errMessage);
+    handleError(obj);
+    expect(window.HtEventsGlobals.errorReporting.notify).not.toHaveBeenCalled();
+  });
+});

package/__tests__/utils/eventProcessorUtils.test.js

@@ -0,0 +1,266 @@
+import { mergeContext, mergeTopLevelElementsMutator } from '../../src/utils/eventProcessorUtils';
+
+const libName = 'Events SDK JavaScript';
+
+describe('Event processor Utilities', () => {
+  const htElement = {
+    message: {
+      channel: 'web',
+      context: {
+        app: {
+          name: libName,
+          namespace: 'com.hightouch.javascript',
+          version: '2.22.0',
+        },
+        traits: {
+          firstName: 'Tintin',
+          phone: '1234567890',
+          email: 'tintin@twentiethcentury.com',
+          custom_flavor: 'chocolate',
+          custom_date: 1673597638545,
+          address: [
+            { label: 'office', city: 'Brussels', country: 'Belgium' },
+            { label: 'home', city: 'Kolkata', country: 'India' },
+          ],
+        },
+        library: { name: libName, version: '2.22.0' },
+        userAgent:
+          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
+        device: null,
+        network: null,
+        os: { name: '', version: '' },
+        locale: 'en-GB',
+        screen: { density: 2, width: 1440, height: 900, innerWidth: 1440, innerHeight: 253 },
+        sessionId: 1673597629454,
+        sessionStart: true,
+      },
+      type: 'identify',
+      messageId: '55fc2294-4622-4deb-be84-9c42372b64cd',
+      originalTimestamp: '2023-01-13T08:13:58.548Z',
+      anonymousId: '50cdaf05-ce75-418c-b666-98b9a9938f9f',
+      userId: 'user-id',
+      event: null,
+      properties: null,
+      integrations: { All: true },
+      user_properties: null,
+    },
+  };
+  const options = { a: 'moumita', key1: 123456, key2: { fg: 'shgjsh' } };
+  const optionsWithTopLevelContext = {
+    integrations: {
+      All: true,
+      'Google Analytics': false,
+    },
+    anonymousId: 'sample anonymousId',
+    originalTimestamp: '2023-01-13T09:13:58.548Z',
+  };
+  const optionsWithLibraryInfo = {
+    ...options,
+    library: {
+      name: 'Random SDK',
+    },
+    context: {
+      library: {
+        name: 'Random SDK no 2',
+      },
+      metaData: {
+        key3: 976545678,
+        key4: null,
+      },
+    },
+  };
+  const optionsWithNullContext = {
+    ...options,
+    context: null,
+  };
+
+  const expectedHtElement = {
+    message: {
+      channel: 'web',
+      context: {
+        a: 'moumita',
+        key1: 123456,
+        key2: { fg: 'shgjsh' },
+        app: {
+          name: libName,
+          namespace: 'com.hightouch.javascript',
+          version: '2.22.0',
+        },
+        traits: {
+          firstName: 'Tintin',
+          phone: '1234567890',
+          email: 'tintin@twentiethcentury.com',
+          custom_flavor: 'chocolate',
+          custom_date: 1673597638545,
+          address: [
+            { label: 'office', city: 'Brussels', country: 'Belgium' },
+            { label: 'home', city: 'Kolkata', country: 'India' },
+          ],
+        },
+        library: { name: libName, version: '2.22.0' },
+        userAgent:
+          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
+        device: null,
+        network: null,
+        os: { name: '', version: '' },
+        locale: 'en-GB',
+        screen: { density: 2, width: 1440, height: 900, innerWidth: 1440, innerHeight: 253 },
+        sessionId: 1673597629454,
+        sessionStart: true,
+      },
+      type: 'identify',
+      messageId: '55fc2294-4622-4deb-be84-9c42372b64cd',
+      originalTimestamp: '2023-01-13T08:13:58.548Z',
+      anonymousId: '50cdaf05-ce75-418c-b666-98b9a9938f9f',
+      userId: 'user-id',
+      event: null,
+      properties: null,
+      integrations: { All: true },
+      user_properties: null,
+    },
+  };
+  const expectedHtElementWithTopLevelElement = {
+    message: {
+      channel: 'web',
+      context: {
+        app: {
+          name: libName,
+          namespace: 'com.hightouch.javascript',
+          version: '2.22.0',
+        },
+        traits: {
+          firstName: 'Tintin',
+          phone: '1234567890',
+          email: 'tintin@twentiethcentury.com',
+          custom_flavor: 'chocolate',
+          custom_date: 1673597638545,
+          address: [
+            { label: 'office', city: 'Brussels', country: 'Belgium' },
+            { label: 'home', city: 'Kolkata', country: 'India' },
+          ],
+        },
+        library: { name: libName, version: '2.22.0' },
+        userAgent:
+          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
+        device: null,
+        network: null,
+        os: { name: '', version: '' },
+        locale: 'en-GB',
+        screen: { density: 2, width: 1440, height: 900, innerWidth: 1440, innerHeight: 253 },
+        sessionId: 1673597629454,
+        sessionStart: true,
+      },
+      type: 'identify',
+      messageId: '55fc2294-4622-4deb-be84-9c42372b64cd',
+      originalTimestamp: '2023-01-13T09:13:58.548Z',
+      anonymousId: 'sample anonymousId',
+      userId: 'user-id',
+      event: null,
+      properties: null,
+      integrations: { All: true, 'Google Analytics': false },
+      user_properties: null,
+    },
+  };
+
+  const expectedHtElementWithLibraryInfo = {
+    message: {
+      channel: 'web',
+      context: {
+        a: 'moumita',
+        key1: 123456,
+        key2: { fg: 'shgjsh' },
+        app: {
+          name: libName,
+          namespace: 'com.hightouch.javascript',
+          version: '2.22.0',
+        },
+        traits: {
+          firstName: 'Tintin',
+          phone: '1234567890',
+          email: 'tintin@twentiethcentury.com',
+          custom_flavor: 'chocolate',
+          custom_date: 1673597638545,
+          address: [
+            { label: 'office', city: 'Brussels', country: 'Belgium' },
+            { label: 'home', city: 'Kolkata', country: 'India' },
+          ],
+        },
+        library: { name: libName, version: '2.22.0' },
+        metaData: {
+          key3: 976545678,
+          key4: null,
+        },
+        userAgent:
+          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36',
+        device: null,
+        network: null,
+        os: { name: '', version: '' },
+        locale: 'en-GB',
+        screen: { density: 2, width: 1440, height: 900, innerWidth: 1440, innerHeight: 253 },
+        sessionId: 1673597629454,
+        sessionStart: true,
+      },
+      type: 'identify',
+      messageId: '55fc2294-4622-4deb-be84-9c42372b64cd',
+      originalTimestamp: '2023-01-13T08:13:58.548Z',
+      anonymousId: '50cdaf05-ce75-418c-b666-98b9a9938f9f',
+      userId: 'user-id',
+      event: null,
+      properties: null,
+      integrations: { All: true },
+      user_properties: null,
+    },
+  };
+
+  it('Should merge the context provided in options with the previous context', () => {
+    const mergedRudderMessageContext = mergeContext(htElement.message, options);
+    expect(mergedRudderMessageContext).toStrictEqual(expectedHtElement.message.context);
+  });
+
+  it('Should context object remain intact if no options provided', () => {
+    const mergedRudderMessageContext = mergeContext(htElement.message, undefined);
+    expect(mergedRudderMessageContext).toStrictEqual(htElement.message.context);
+  });
+
+  it('Should context object remain intact if null options provided', () => {
+    const mergedRudderMessageContext = mergeContext(htElement.message, null);
+    expect(mergedRudderMessageContext).toStrictEqual(htElement.message.context);
+  });
+
+  it('Should context object remain intact if non object type options provided', () => {
+    const mergedRudderMessageContext = mergeContext(htElement.message, 'options');
+    expect(mergedRudderMessageContext).toStrictEqual(htElement.message.context);
+  });
+
+  it('Should mutate the top level context in ht element if provided in options', () => {
+    mergeTopLevelElementsMutator(htElement.message, optionsWithTopLevelContext);
+    expect(htElement.message).toStrictEqual(expectedHtElementWithTopLevelElement.message);
+  });
+
+  it('Should top level context object remain intact if no options provided', () => {
+    mergeTopLevelElementsMutator(htElement.message, undefined);
+    expect(htElement.message).toStrictEqual(htElement.message);
+  });
+
+  it('Should top level context object remain intact if null options provided', () => {
+    mergeTopLevelElementsMutator(htElement.message, null);
+    expect(htElement.message).toStrictEqual(htElement.message);
+  });
+
+  it('Should top level context object remain intact if non object type options provided', () => {
+    mergeTopLevelElementsMutator(htElement.message, 'options');
+    expect(htElement.message).toStrictEqual(htElement.message);
+  });
+
+  it('Should not override library info in context if provided in options', () => {
+    const mergedRudderMessageContext = mergeContext(htElement.message, optionsWithLibraryInfo);
+    expect(mergedRudderMessageContext).toStrictEqual(
+      expectedHtElementWithLibraryInfo.message.context,
+    );
+  });
+
+  it('Should not merge null context if provided in options', () => {
+    const mergedRudderMessageContext = mergeContext(htElement.message, optionsWithNullContext);
+    expect(mergedRudderMessageContext).toStrictEqual(expectedHtElement.message.context);
+  });
+});

package/__tests__/utils/navigator.test.js

@@ -0,0 +1,38 @@
+import { getUserAgent, getLanguage } from '../../src/utils/navigator';
+import BraveBrowser from '../../__mocks__/BraveBrowser';
+
+describe('Navigator Utilities', () => {
+  const mockLanguage = 'en-US';
+  const chromeUserAgentString =
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.3';
+  const chromeVersion = '108.0.0.0';
+
+  afterEach(() => {
+    // Reset global.window.navigator mocks
+    global.navigator.userAgent = undefined;
+    global.navigator.brave = undefined;
+    global.navigator.language = undefined;
+  });
+
+  it('Should get User Agent when navigator is defined', () => {
+    global.navigator.userAgent = chromeUserAgentString;
+    const userAgent = getUserAgent();
+
+    expect(userAgent).toBe(chromeUserAgentString);
+  });
+
+  it('Should get User Agent with Braze info for braze browsers', () => {
+    global.navigator.userAgent = chromeUserAgentString;
+    global.navigator.brave = new BraveBrowser();
+    const userAgent = getUserAgent();
+
+    expect(userAgent).toBe(`${chromeUserAgentString} Brave/${chromeVersion}`);
+  });
+
+  it('Should get language when navigator is defined', () => {
+    global.navigator.language = mockLanguage;
+    const language = getLanguage();
+
+    expect(language).toBe(mockLanguage);
+  });
+});

package/__tests__/utils/preProcessQueue.test.js

@@ -0,0 +1,78 @@
+import PreProcessQueue from '../../src/utils/PreProcessQueue';
+import HtElement from '../../src/utils/HtElement';
+
+describe('PreProcessQueue', () => {
+  let preProcessQueue;
+
+  beforeEach(() => {
+    preProcessQueue = new PreProcessQueue();
+  });
+
+  afterEach(() => {
+    preProcessQueue = null;
+  });
+
+  describe('init()', () => {
+    it('should initialize the payloadQueue with default options', () => {
+      preProcessQueue.init();
+
+      expect(preProcessQueue.payloadQueue).toBeDefined();
+    });
+
+    it('should initialize the payloadQueue with custom options', () => {
+      const options = {
+        maxRetryDelay: 360000,
+        minRetryDelay: 1000,
+        backoffFactor: 2,
+        maxAttempts: Infinity,
+        maxItems: 100,
+      };
+      preProcessQueue.init(options);
+
+      expect(preProcessQueue.payloadQueue.backoff.FACTOR).toEqual(options.backoffFactor);
+      expect(preProcessQueue.payloadQueue.backoff.MAX_RETRY_DELAY).toEqual(options.maxRetryDelay);
+      expect(preProcessQueue.payloadQueue.backoff.MIN_RETRY_DELAY).toEqual(options.minRetryDelay);
+      expect(preProcessQueue.payloadQueue.maxAttempts).toEqual(options.maxAttempts);
+    });
+
+    it('should set the callback', () => {
+      const callback = jest.fn();
+      preProcessQueue.init(null, callback);
+
+      expect(preProcessQueue.callback).toEqual(callback);
+    });
+  });
+
+  describe('activateProcessor()', () => {
+    it('should set processQueueElements to true', () => {
+      preProcessQueue.activateProcessor();
+      expect(preProcessQueue.processQueueElements).toBe(true);
+    });
+  });
+
+  describe('processQueueElement()', () => {
+    it('should call the queueFn with null if processQueueElements is true', () => {
+      const type = 'track';
+      const htElement = new HtElement();
+      const queueFn = jest.fn();
+      const callback = jest.fn();
+      preProcessQueue.init({}, callback);
+
+      preProcessQueue.processQueueElements = true;
+      preProcessQueue.processQueueElement(type, htElement, queueFn);
+      expect(queueFn).toHaveBeenCalledWith(null);
+    });
+
+    it('should call the queueFn with an error if processQueueElements is false', () => {
+      const type = 'track';
+      const htElement = new HtElement();
+      const queueFn = jest.fn();
+
+      preProcessQueue.processQueueElements = false;
+      preProcessQueue.processQueueElement(type, htElement, queueFn);
+      expect(queueFn).toHaveBeenCalledWith(
+        new Error('The queue elements are not ready to be processed yet'),
+      );
+    });
+  });
+});

package/__tests__/utils/screenDetails.test.js

@@ -0,0 +1,19 @@
+import { getScreenDetails } from '../../src/utils/screenDetails';
+import { RudderScreenInfo } from '../../src/utils/RudderInfo';
+
+describe('Screen Details Utilities', () => {
+  const expectedScreenInfo = new RudderScreenInfo();
+  expectedScreenInfo.density = 1;
+  expectedScreenInfo.width = 1680;
+  expectedScreenInfo.height = 1024;
+  expectedScreenInfo.innerWidth = 1680;
+  expectedScreenInfo.innerHeight = 1024;
+
+  it('Should get Screen Details when window is defined', () => {
+    jest.spyOn(window.screen, 'width', 'get').mockReturnValue(1680);
+    jest.spyOn(window.screen, 'height', 'get').mockReturnValue(1024);
+    const screen = getScreenDetails();
+
+    expect(screen).toStrictEqual(expectedScreenInfo);
+  });
+});