iureiure 1.0.0

package/packages/analytics-js/__tests__/components/utilities/page.test.ts

@@ -0,0 +1,235 @@
+import {
+  getCanonicalUrl,
+  getLanguage,
+  getUserAgent,
+  getDefaultPageProperties,
+  getReferrer,
+} from '../../../src/components/utilities/page';
+
+describe('utilities - page', () => {
+  let windowSpy: any;
+  let documentSpy: any;
+  let navigatorSpy: any;
+  let locationSpy: any;
+
+  beforeEach(() => {
+    windowSpy = jest.spyOn(window, 'window', 'get');
+    documentSpy = jest.spyOn(window, 'document', 'get');
+    navigatorSpy = jest.spyOn(globalThis, 'navigator', 'get');
+    locationSpy = jest.spyOn(globalThis, 'location', 'get');
+  });
+
+  afterEach(() => {
+    windowSpy.mockRestore();
+    documentSpy.mockRestore();
+    navigatorSpy.mockRestore();
+    locationSpy.mockRestore();
+  });
+
+  describe('getUserAgent', () => {
+    it('should get User Agent', () => {
+      expect(getUserAgent()).toContain('Mozilla/5.0');
+    });
+
+    it('should not get user agent if window navigator is undefined', () => {
+      navigatorSpy.mockReturnValue(undefined);
+      expect(getUserAgent()).toBe(null);
+    });
+
+    it('should get Brave user agent for Brave browser', () => {
+      const brave = {};
+      Object.setPrototypeOf(brave, { isBrave: true });
+      navigatorSpy.mockReturnValue({
+        userAgent:
+          'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.114 Safari/537.36',
+        brave,
+      });
+
+      expect(getUserAgent()).toBe(
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.5060.114 Safari/537.36 Brave/103.0.5060.114',
+      );
+    });
+  });
+
+  describe('getLanguage', () => {
+    it('should get browser language', () => {
+      navigatorSpy.mockReturnValue({
+        language: 'en-US',
+      });
+      expect(getLanguage()).toBe('en-US');
+    });
+
+    it('should not get browser language if window navigator is undefined', () => {
+      navigatorSpy.mockReturnValue(undefined);
+
+      expect(getLanguage()).toBe(null);
+    });
+
+    it('should get browser language if navigator.language is undefined', () => {
+      navigatorSpy.mockImplementation(() => ({
+        language: undefined,
+        browserLanguage: 'en-US',
+      }));
+
+      expect(getLanguage()).toBe('en-US');
+    });
+  });
+
+  describe('getCanonicalUrl', () => {
+    it('should get canonical URL if present in the DOM', () => {
+      const linkScript = document.createElement('link');
+      linkScript.rel = 'canonical';
+      linkScript.href = 'https://rudderlabs.com/';
+
+      const anotherLinkScript = document.createElement('link');
+      anotherLinkScript.rel = 'canonical';
+      anotherLinkScript.href = 'https://rudderlabs.com/blog';
+
+      documentSpy.mockImplementation(() => ({
+        getElementsByTagName: () => [linkScript, anotherLinkScript],
+      }));
+
+      expect(getCanonicalUrl()).toBe('https://rudderlabs.com/');
+    });
+
+    it('should get empty string if canonical URL is not present in the DOM', () => {
+      expect(getCanonicalUrl()).toBe('');
+    });
+
+    it('should get empty canonical URL if no valid canonical tags are present in the DOM', () => {
+      const linkScript = document.createElement('link');
+      linkScript.href = 'https://rudderlabs.com/';
+
+      documentSpy.mockImplementation(() => ({
+        getElementsByTagName: () => [linkScript],
+      }));
+
+      expect(getCanonicalUrl()).toBe('');
+    });
+  });
+
+  describe('getReferrer', () => {
+    it('should get referrer if defined', () => {
+      documentSpy.mockImplementation(() => ({
+        referrer: 'https://rudderlabs.com/',
+      }));
+
+      expect(getReferrer()).toBe('https://rudderlabs.com/');
+    });
+
+    it('should get default referrer string if referrer is not defined', () => {
+      documentSpy.mockImplementation(() => ({
+        referrer: '',
+      }));
+
+      expect(getReferrer()).toBe('$direct');
+    });
+  });
+
+  describe('getDefaultPageProperties', () => {
+    it('should get default page properties with canonical url', () => {
+      // Create a canonical link tag
+      const linkScript = document.createElement('link');
+      linkScript.rel = 'canonical';
+      linkScript.href = 'https://rudderlabs.com/docs/';
+
+      documentSpy.mockImplementation(() => ({
+        referrer: 'https://google.com/',
+        title: 'RudderStack',
+        getElementsByTagName: () => [linkScript],
+      }));
+
+      locationSpy.mockImplementation(() => ({
+        href: 'https://rudderlabs.com/docs/#some-page?someKey=someVal',
+        search: '?someKey=someVal',
+        pathname: '/docs/',
+        host: 'www.rudderstack.com',
+        hostname: 'www.rudderstack.com',
+        origin: 'https://www.rudderstack.com',
+      }));
+
+      expect(getDefaultPageProperties()).toEqual({
+        url: 'https://rudderlabs.com/docs/?someKey=someVal',
+        path: '/docs/',
+        search: '?someKey=someVal',
+        title: 'RudderStack',
+        referrer: 'https://google.com/',
+        referring_domain: 'google.com',
+        tab_url: 'https://rudderlabs.com/docs/#some-page?someKey=someVal',
+      });
+    });
+
+    it('should get default page properties without canonical url', () => {
+      documentSpy.mockImplementation(() => ({
+        referrer: 'https://google.com/',
+        title: 'RudderStack',
+        getElementsByTagName: () => [],
+      }));
+
+      locationSpy.mockImplementation(() => ({
+        href: 'https://rudderlabs.com/docs/#some-page?someKey=someVal',
+        search: '?someKey=someVal',
+        pathname: '/docs/',
+        host: 'www.rudderstack.com',
+        hostname: 'www.rudderstack.com',
+        origin: 'https://www.rudderstack.com',
+      }));
+
+      expect(getDefaultPageProperties()).toEqual({
+        url: 'https://rudderlabs.com/docs/',
+        path: '/docs/',
+        search: '?someKey=someVal',
+        title: 'RudderStack',
+        referrer: 'https://google.com/',
+        referring_domain: 'google.com',
+        tab_url: 'https://rudderlabs.com/docs/#some-page?someKey=someVal',
+      });
+    });
+
+    it('should get default page properties with canonical url that has query params', () => {
+      // Create a canonical link tag
+      const linkScript = document.createElement('link');
+      linkScript.rel = 'canonical';
+      linkScript.href = 'https://rudderlabs.com/docs/?canonicalQueryParam=test';
+
+      documentSpy.mockImplementation(() => ({
+        referrer: 'https://google.com/',
+        title: 'RudderStack',
+        getElementsByTagName: () => [linkScript],
+      }));
+
+      locationSpy.mockImplementation(() => ({
+        href: 'https://rudderlabs.com/docs/#some-page?someKey=someVal',
+        search: '?someKey=someVal',
+        pathname: '/docs/',
+        host: 'www.rudderstack.com',
+        hostname: 'www.rudderstack.com',
+        origin: 'https://www.rudderstack.com',
+      }));
+
+      expect(getDefaultPageProperties()).toEqual({
+        url: 'https://rudderlabs.com/docs/?canonicalQueryParam=test',
+        path: '/docs/',
+        search: '?someKey=someVal',
+        title: 'RudderStack',
+        referrer: 'https://google.com/',
+        referring_domain: 'google.com',
+        tab_url: 'https://rudderlabs.com/docs/#some-page?someKey=someVal',
+      });
+    });
+
+    it('should get current page details', () => {
+      documentSpy.mockRestore();
+
+      expect(getDefaultPageProperties()).toEqual({
+        url: 'http://www.test-host.com/',
+        path: '/',
+        search: '',
+        title: '',
+        referrer: '$direct',
+        referring_domain: '',
+        tab_url: 'http://www.test-host.com/',
+      });
+    });
+  });
+});

package/packages/analytics-js/__tests__/components/utilities/sort.test.ts

@@ -0,0 +1,17 @@
+import { sortObjectArrayByProp } from '../../../src/components/utilities/sort';
+
+describe('Common Utils - Sort', () => {
+  const objArray = [{ order: 3 }, { order: 1 }, { order: 2 }];
+
+  it('should sort Object Array by property value', () => {
+    const sortedArray = sortObjectArrayByProp(objArray, 'order');
+
+    expect(sortedArray).toStrictEqual([{ order: 1 }, { order: 2 }, { order: 3 }]);
+  });
+
+  it('should not sort Object Array by undefined property', () => {
+    const sortedArray = sortObjectArrayByProp(objArray, 'dummyKey');
+
+    expect(sortedArray).toStrictEqual([{ order: 3 }, { order: 1 }, { order: 2 }]);
+  });
+});

package/packages/analytics-js/__tests__/components/utilities/statsCollection.test.ts

@@ -0,0 +1,84 @@
+import {
+  isErrorReportingEnabled,
+  getErrorReportingProviderNameFromConfig,
+  isMetricsReportingEnabled,
+} from '../../../src/components/utilities/statsCollection';
+
+describe('Stats Collection Utilities', () => {
+  describe('isErrorReportingEnabled', () => {
+    it('should return true when error reporting is enabled', () => {
+      const sourceConfig = {
+        statsCollection: {
+          errors: {
+            enabled: true,
+          },
+        },
+      };
+      expect(isErrorReportingEnabled(sourceConfig)).toBe(true);
+    });
+
+    it('should return false when error reporting is not enabled', () => {
+      const sourceConfig = {
+        statsCollection: {
+          errors: {
+            enabled: false,
+          },
+        },
+      };
+      expect(isErrorReportingEnabled(sourceConfig)).toBe(false);
+    });
+
+    it('should return false when error reporting is not configured', () => {
+      const sourceConfig = {};
+      expect(isErrorReportingEnabled(sourceConfig)).toBe(false);
+    });
+  });
+
+  describe('getErrorReportingProviderNameFromConfig', () => {
+    it('should return the provider name when it is defined', () => {
+      const sourceConfig = {
+        statsCollection: {
+          errors: {
+            enabled: true,
+            provider: 'bugsnag',
+          },
+        },
+      };
+      expect(getErrorReportingProviderNameFromConfig(sourceConfig)).toBe('bugsnag');
+    });
+
+    it('should return undefined when error reporting is not configured', () => {
+      const sourceConfig = {};
+      expect(getErrorReportingProviderNameFromConfig(sourceConfig)).toBe(undefined);
+    });
+  });
+
+  describe('isMetricsReportingEnabled', () => {
+    it('should return true when metrics reporting is enabled', () => {
+      const sourceConfig = {
+        statsCollection: {
+          metrics: {
+            enabled: true,
+          },
+        },
+      };
+      expect(isMetricsReportingEnabled(sourceConfig)).toBe(true);
+    });
+
+    it('should return false when metrics reporting is not enabled', () => {
+      const sourceConfig = {
+        statsCollection: {
+          metrics: {
+            enabled: false,
+          },
+        },
+      };
+      expect(isMetricsReportingEnabled(sourceConfig)).toBe(false);
+    });
+
+    it('should return false when metrics reporting is not configured', () => {
+      const sourceConfig = {};
+      expect(isMetricsReportingEnabled(sourceConfig)).toBe(false);
+    });
+  });
+});

package/packages/analytics-js/__tests__/components/utilities/url.test.ts

@@ -0,0 +1,51 @@
+import {
+  extractUTMParameters,
+  getUrlWithoutHash,
+  getReferringDomain,
+} from '../../../src/components/utilities/url';
+
+describe('utilities - url', () => {
+  it('should get URL without hash', () => {
+    expect(getUrlWithoutHash('https://rudderlabs.com/?abc=def#blog')).toBe(
+      'https://rudderlabs.com/?abc=def',
+    );
+  });
+
+  it('should get URL same as the input if it does not contain any hash', () => {
+    expect(getUrlWithoutHash('https://rudderlabs.com/blog')).toBe('https://rudderlabs.com/blog');
+  });
+
+  it('should get URL same as the input if it is not a valid URL', () => {
+    expect(getUrlWithoutHash('abcdotcom')).toBe('abcdotcom');
+  });
+
+  it('should get referring domain if referrer is a valid URL', () => {
+    expect(getReferringDomain('https://rudderlabs.com:8080/')).toBe('rudderlabs.com:8080');
+  });
+
+  it('should get empty string if referrer is not a valid URL', () => {
+    expect(getReferringDomain('abcd')).toBe('');
+  });
+
+  it('should get UTM parameters if present in the URL', () => {
+    expect(
+      extractUTMParameters(
+        'https://rudderlabs.com/?utm_source=google&utm_medium=cpc&utm_campaign=brand&utm_term=rudderstack&utm_content=homepage&non_utm=value',
+      ),
+    ).toEqual({
+      source: 'google',
+      medium: 'cpc',
+      name: 'brand',
+      term: 'rudderstack',
+      content: 'homepage',
+    });
+  });
+
+  it('should get empty object if UTM parameters are not present in the URL', () => {
+    expect(extractUTMParameters('https://rudderlabs.com/')).toEqual({});
+  });
+
+  it('should get empty object as UTM parameters if the URL is not valid', () => {
+    expect(extractUTMParameters('abcd')).toEqual({});
+  });
+});

package/packages/analytics-js/__tests__/services/ErrorHandler/ErrorHandler.test.ts

@@ -0,0 +1,272 @@
+import { SDKError } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import { IExternalSrcLoader } from '@rudderstack/analytics-js-common/services/ExternalSrcLoader/types';
+import { defaultLogger } from '../../../src/services/Logger';
+import { defaultPluginEngine } from '../../../src/services/PluginEngine';
+import { ErrorHandler } from '../../../src/services/ErrorHandler';
+import { state } from '../../../src/state';
+
+jest.mock('../../../src/services/Logger', () => {
+  const originalModule = jest.requireActual('../../../src/services/Logger');
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    defaultLogger: {
+      error: jest.fn((): void => {}),
+    },
+  };
+});
+
+jest.mock('../../../src/services/PluginEngine', () => {
+  const originalModule = jest.requireActual('../../../src/services/PluginEngine');
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    defaultPluginEngine: {
+      invokeSingle: jest.fn((): void => {}),
+    },
+  };
+});
+
+jest.mock('../../../src/services/ErrorHandler/processError', () => {
+  const originalModule = jest.requireActual('../../../src/services/ErrorHandler/processError');
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    processError: jest.fn((error: SDKError): string => error.message || error || ''),
+  };
+});
+
+describe('ErrorHandler', () => {
+  let errorHandlerInstance: ErrorHandler;
+
+  beforeEach(() => {
+    errorHandlerInstance = new ErrorHandler(defaultLogger, defaultPluginEngine);
+  });
+
+  it('should leaveBreadcrumb if plugin engine is provided', () => {
+    errorHandlerInstance.leaveBreadcrumb('breadcrumb');
+    expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledTimes(1);
+    expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledWith(
+      'errorReporting.breadcrumb',
+      defaultPluginEngine,
+      undefined,
+      'breadcrumb',
+      expect.any(Object),
+    );
+  });
+
+  it('should notifyError if plugin engine is provided', () => {
+    errorHandlerInstance.notifyError(new Error('notify'));
+    expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledTimes(1);
+    expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledWith(
+      'errorReporting.notify',
+      defaultPluginEngine,
+      undefined,
+      expect.any(Error),
+      state,
+      expect.any(Object),
+    );
+  });
+
+  it('should log error for Errors with context and custom message if logger exists', () => {
+    errorHandlerInstance.onError(new Error('dummy error'), 'Unit test', 'dummy  custom  message');
+
+    expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledTimes(1);
+    expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledWith(
+      'errorReporting.notify',
+      defaultPluginEngine,
+      undefined,
+      expect.any(Error),
+      state,
+      expect.any(Object),
+    );
+
+    expect(defaultLogger.error).toHaveBeenCalledTimes(1);
+    expect(defaultLogger.error).toHaveBeenCalledWith(
+      'Unit test:: dummy custom message dummy error',
+    );
+  });
+
+  it('should log error for messages with context and custom message if logger exists', () => {
+    errorHandlerInstance.onError('dummy error', 'Unit test', 'dummy custom message');
+
+    expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledTimes(1);
+    expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledWith(
+      'errorReporting.notify',
+      defaultPluginEngine,
+      undefined,
+      expect.any(Error),
+      state,
+      expect.any(Object),
+    );
+
+    expect(defaultLogger.error).toHaveBeenCalledTimes(1);
+    expect(defaultLogger.error).toHaveBeenCalledWith(
+      'Unit test:: dummy custom message dummy error',
+    );
+  });
+
+  it('should log and throw for messages with context and custom message if logger exists and shouldAlwaysThrow', () => {
+    try {
+      errorHandlerInstance.onError('dummy error', 'Unit test', 'dummy custom message', true);
+    } catch (err) {
+      expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledTimes(1);
+      expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledWith(
+        'errorReporting.notify',
+        defaultPluginEngine,
+        undefined,
+        expect.any(Error),
+        state,
+        expect.any(Object),
+      );
+
+      expect(defaultLogger.error).toHaveBeenCalledTimes(1);
+      expect(defaultLogger.error).toHaveBeenCalledWith(
+        'Unit test:: dummy custom message dummy error',
+      );
+      expect(err.message).toStrictEqual('Unit test:: dummy custom message dummy error');
+    }
+  });
+
+  it('should throw error for Errors with context and custom message if logger does not exist', () => {
+    errorHandlerInstance = new ErrorHandler();
+    try {
+      errorHandlerInstance.onError(new Error('dummy error'), 'Unit test', 'dummy  custom  message');
+    } catch (err) {
+      expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledTimes(0);
+      expect(defaultLogger.error).toHaveBeenCalledTimes(0);
+      expect(err.message).toStrictEqual('Unit test:: dummy custom message dummy error');
+    }
+  });
+
+  it('should throw error for messages with context and custom message if logger does not exist', () => {
+    errorHandlerInstance = new ErrorHandler();
+    try {
+      errorHandlerInstance.onError('dummy error', 'Unit test', 'dummy custom message');
+    } catch (err) {
+      expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledTimes(0);
+      expect(defaultLogger.error).toHaveBeenCalledTimes(0);
+      expect(err.message).toStrictEqual('Unit test:: dummy custom message dummy error');
+    }
+  });
+
+  it('should swallow Errors based on processError logic', () => {
+    errorHandlerInstance.onError('');
+
+    expect(defaultPluginEngine.invokeSingle).toHaveBeenCalledTimes(0);
+    expect(defaultLogger.error).toHaveBeenCalledTimes(0);
+  });
+
+  it('should log error on notifyError if invoking plugin results in an exception', () => {
+    defaultPluginEngine.invokeSingle = jest.fn(() => {
+      throw new Error('dummy error');
+    });
+
+    errorHandlerInstance.notifyError(new Error('notify'));
+
+    expect(defaultLogger.error).toHaveBeenCalledTimes(1);
+    expect(defaultLogger.error).toHaveBeenCalledWith(
+      'ErrorHandler:: Failed to notify the error.',
+      new Error('dummy error'),
+    );
+  });
+
+  it('should invoke onError on leaveBreadcrumb if invoking plugin results in an exception', () => {
+    defaultPluginEngine.invokeSingle = jest.fn(() => {
+      throw new Error('dummy error');
+    });
+
+    const onErrorSpy = jest.spyOn(errorHandlerInstance, 'onError');
+    errorHandlerInstance.leaveBreadcrumb('breadcrumb');
+
+    expect(onErrorSpy).toHaveBeenCalledTimes(1);
+    expect(onErrorSpy).toHaveBeenCalledWith(
+      expect.any(Error),
+      'ErrorHandler',
+      'errorReporting.breadcrumb',
+    );
+    onErrorSpy.mockRestore();
+  });
+
+  describe('init', () => {
+    const extSrcLoader = {} as IExternalSrcLoader;
+
+    it('reporting client should not be defined if the plugin engine is not supplied', () => {
+      errorHandlerInstance = new ErrorHandler(defaultLogger);
+      errorHandlerInstance.init(extSrcLoader);
+
+      expect(errorHandlerInstance.errReportingClient).toBeUndefined();
+    });
+
+    it('reporting client should be defined', done => {
+      const invokeSingleSpy = jest
+        .spyOn(defaultPluginEngine, 'invokeSingle')
+        .mockReturnValue(Promise.resolve({}));
+
+      errorHandlerInstance.init(extSrcLoader);
+
+      expect(invokeSingleSpy).toHaveBeenCalledTimes(1);
+      expect(invokeSingleSpy).toHaveBeenCalledWith(
+        'errorReporting.init',
+        state,
+        defaultPluginEngine,
+        extSrcLoader,
+        defaultLogger,
+      );
+
+      setTimeout(() => {
+        expect(errorHandlerInstance.errReportingClient).toBeDefined();
+        invokeSingleSpy.mockRestore();
+        done();
+      }, 0);
+    });
+
+    it('reporting client should not be defined if the plugin returns a promise that rejects', done => {
+      const invokeSingleSpy = jest
+        .spyOn(defaultPluginEngine, 'invokeSingle')
+        .mockReturnValue(Promise.reject(new Error('dummy error')));
+
+      errorHandlerInstance.init(extSrcLoader);
+
+      expect(invokeSingleSpy).toHaveBeenCalledTimes(1);
+      setTimeout(() => {
+        expect(errorHandlerInstance.errReportingClient).toBeUndefined();
+        expect(defaultLogger.error).toHaveBeenCalledTimes(1);
+        expect(defaultLogger.error).toHaveBeenCalledWith(
+          'ErrorHandler:: Failed to initialize the error reporting plugin.',
+          new Error('dummy error'),
+        );
+
+        invokeSingleSpy.mockRestore();
+        done();
+      }, 0);
+    });
+
+    it('should invoke onError if invoking the plugin results in an exception', () => {
+      defaultPluginEngine.invokeSingle = jest.fn(() => {
+        throw new Error('dummy error');
+      });
+
+      const onErrorSpy = jest.spyOn(errorHandlerInstance, 'onError');
+      errorHandlerInstance.init(extSrcLoader);
+
+      expect(onErrorSpy).toHaveBeenCalledTimes(1);
+      expect(onErrorSpy).toHaveBeenCalledWith(expect.any(Error), 'ErrorHandler');
+      onErrorSpy.mockRestore();
+    });
+  });
+
+  it('should attach error listeners', () => {
+    const unhandledRejectionListener = jest.spyOn(window, 'addEventListener');
+    errorHandlerInstance.attachErrorListeners();
+    expect(unhandledRejectionListener).toHaveBeenCalledTimes(2);
+    expect(unhandledRejectionListener).toHaveBeenCalledWith('error', expect.any(Function));
+    expect(unhandledRejectionListener).toHaveBeenCalledWith(
+      'unhandledrejection',
+      expect.any(Function),
+    );
+  });
+});

package/packages/analytics-js/__tests__/services/ErrorHandler/processError.test.ts

@@ -0,0 +1,33 @@
+import { processError } from '../../../src/services/ErrorHandler/processError';
+
+jest.mock('../../../src/components/utilities/event', () => {
+  const originalModule = jest.requireActual('../../../src/components/utilities/event');
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    isEvent: jest.fn((event): boolean => event && Boolean(event.target)),
+  };
+});
+
+describe('ErrorHandler - process error', () => {
+  it('should not throw error for non supported argument value', () => {
+    const msg = processError(null);
+    expect(msg).toStrictEqual("Unknown error: Cannot read properties of null (reading 'message')");
+  });
+
+  it('should process string argument value', () => {
+    const msg = processError('dummy error');
+    expect(msg).toStrictEqual('dummy error');
+  });
+
+  it('should process Error argument value', () => {
+    const msg = processError(new Error('dummy error'));
+    expect(msg).toStrictEqual('dummy error');
+  });
+
+  it('should process any other type of argument value', () => {
+    const msg = processError({ foo: 'bar' });
+    expect(msg).toStrictEqual('{"foo":"bar"}');
+  });
+});