iureiure 1.0.0

package/packages/analytics-v1.1/__tests__/transformationHandler.test.js

@@ -0,0 +1,179 @@
+/* eslint-disable no-plusplus */
+import { http, HttpResponse } from 'msw';
+import { DeviceModeTransformations } from '../src/features/core/deviceModeTransformation/transformationHandler';
+import { createPayload } from '../src/features/core/deviceModeTransformation/util';
+import { server } from '../__fixtures__/msw.server';
+import {
+  dummyDataplaneHost,
+  dummyWriteKey,
+  samplePageEvent,
+  retryCount,
+  samplePayloadPartialSuccess,
+  actualErrorMessage,
+  samplePayloadSuccess,
+} from '../__fixtures__/fixtures';
+
+describe('Test suite for device mode transformation feature', () => {
+  beforeAll(() => {
+    server.listen();
+  });
+
+  afterEach(() => {
+    server.resetHandlers();
+  });
+
+  afterAll(() => {
+    server.close();
+  });
+
+  let payload;
+  const destinationIds = ['id1', 'id2', 'id3'];
+  beforeEach(() => {
+    payload = createPayload(samplePageEvent, destinationIds, 'sample-auth-token');
+  });
+
+  it('Validate payload format', () => {
+    expect(payload).toEqual({
+      metadata: {
+        'Custom-Authorization': 'sample-auth-token',
+      },
+      batch: [
+        {
+          orderNo: expect.any(Number),
+          destinationIds,
+          event: samplePageEvent.message,
+        },
+      ],
+    });
+  });
+
+  it('Transformation server returning response in right format in case of successful transformation', async () => {
+    DeviceModeTransformations.init(dummyWriteKey, `${dummyDataplaneHost}/success`);
+
+    await DeviceModeTransformations.sendEventForTransformation(payload, retryCount)
+      .then(response => {
+        expect(Array.isArray(response.transformedPayload)).toEqual(true);
+
+        const destObj = response.transformedPayload[0];
+
+        expect(typeof destObj).toEqual('object');
+        expect(Object.prototype.hasOwnProperty.call(destObj, 'id')).toEqual(true);
+        expect(Object.prototype.hasOwnProperty.call(destObj, 'payload')).toEqual(true);
+      })
+      .catch(e => {
+        console.log(e);
+        expect('to').toBe('fail');
+      });
+  });
+
+  it('Validate whether the SDK is sending the original event in case server returns 404', async () => {
+    DeviceModeTransformations.init(dummyWriteKey, `${dummyDataplaneHost}/accessDenied`);
+
+    await DeviceModeTransformations.sendEventForTransformation(payload, retryCount)
+      .then(response => {
+        expect(response.status).toEqual(404);
+      })
+      .catch(e => {
+        console.log(e);
+        expect('to').toBe('fail');
+      });
+  });
+
+  it('Validate whether the SDK is retrying the request in case failures', async () => {
+    let counter = 0;
+    server.use(
+      http.post(`${dummyDataplaneHost}/serverDown/transform`, () => {
+        counter += 1;
+        return new HttpResponse(null, {
+          status: 500,
+        });
+      }),
+    );
+
+    DeviceModeTransformations.init(dummyWriteKey, `${dummyDataplaneHost}/serverDown`);
+
+    await DeviceModeTransformations.sendEventForTransformation(payload, retryCount)
+      .then(response => {
+        console.log(response);
+        expect(counter).toEqual(retryCount + 1); // retryCount+ first attempt
+        expect(response.errorMessage).toBe('Retries exhausted');
+        expect(response.status).toBe(500);
+      })
+      .catch(e => {
+        expect(typeof e).toBe('string');
+        expect(counter).toEqual(retryCount + 1); // retryCount+ first attempt
+      });
+  });
+
+  it('Should not filter transformed events that are not 200', async () => {
+    DeviceModeTransformations.init(dummyWriteKey, `${dummyDataplaneHost}/partialSuccess`);
+
+    await DeviceModeTransformations.sendEventForTransformation(payload, retryCount)
+      .then(response => {
+        let totalTransformedEvents = 0;
+        let totalTransformedEventsInResponse = 0;
+        samplePayloadPartialSuccess.transformedBatch.forEach(dest => {
+          totalTransformedEvents += dest.payload.length;
+        });
+        response.transformedPayload.forEach(dest => {
+          totalTransformedEventsInResponse += dest.payload.length;
+        });
+        expect(totalTransformedEventsInResponse).toEqual(totalTransformedEvents);
+      })
+      .catch(e => {
+        console.log(e);
+        expect('to').toBe('fail');
+      });
+  });
+
+  it('Transformation server returns bad request error', async () => {
+    DeviceModeTransformations.init(dummyWriteKey, `${dummyDataplaneHost}/badRequest`);
+
+    await DeviceModeTransformations.sendEventForTransformation(payload, retryCount)
+      .then(response => {
+        console.log(response);
+        expect(typeof response.errorMessage).toBe('string');
+        expect(response.status).toBe(400);
+      })
+      .catch(e => {
+        expect(typeof e).toBe('string');
+        expect(e).toEqual(actualErrorMessage);
+      });
+  });
+
+  it('Transformation server returns success after intermediate retry', async () => {
+    let counter = 0;
+    server.use(
+      http.post(`${dummyDataplaneHost}/success/transform`, () => {
+        if (counter === 0) {
+          counter += 1;
+          return new HttpResponse(null, {
+            status: 500,
+          });
+        }
+        counter += 1;
+        return new HttpResponse(JSON.stringify(samplePayloadSuccess), {
+          status: 200,
+        });
+      }),
+    );
+
+    DeviceModeTransformations.init(dummyWriteKey, `${dummyDataplaneHost}/success`);
+
+    await DeviceModeTransformations.sendEventForTransformation(payload, retryCount)
+      .then(response => {
+        expect(counter).toBeGreaterThan(1);
+        expect(Array.isArray(response.transformedPayload)).toEqual(true);
+
+        const destObj = response.transformedPayload[0];
+
+        expect(typeof destObj).toEqual('object');
+        expect(Object.prototype.hasOwnProperty.call(destObj, 'id')).toEqual(true);
+        expect(Object.prototype.hasOwnProperty.call(destObj, 'payload')).toEqual(true);
+      })
+      .catch(e => {
+        console.log(e);
+        expect('to').toBe('fail');
+      });
+  });
+});

package/packages/analytics-v1.1/__tests__/utils/IntegrationsData.test.js

@@ -0,0 +1,105 @@
+import {
+  constructMessageIntegrationsObj,
+  getMergedClientSuppliedIntegrations,
+} from '../../src/utils/IntegrationsData';
+
+const mockIntegrationsData = {};
+
+const mockIntegrationInstances = [
+  {
+    name: 'Mock GA4 Integration instance',
+    getDataForIntegrationsObject: () => ({
+      'Google Analytics 4': {
+        sessionId: '1669961395',
+      },
+    }),
+  },
+  {
+    name: 'Mock AM Integration instance',
+  },
+];
+
+const expectedEnhancedIntegrationsObject = {
+  'Google Analytics 4': {
+    sessionId: '1669961395',
+  },
+};
+
+const mockEnhancedIntegrationsData = {
+  'Google Analytics 4': {
+    sessionId: '1669961395',
+  },
+  AM: true,
+};
+
+const mockClientSuppliedIntegrations = {
+  'Google Analytics 4': true,
+};
+
+const expectedMergedClientSuppliedIntegrationsObject = {
+  'Google Analytics 4': {
+    sessionId: '1669961395',
+  },
+  AM: true,
+};
+
+const mockClientSuppliedIntegrationsWithKeys = {
+  'Google Analytics 4': {
+    sessionId: '16678456735',
+    trackingId: 't-rtcyuTcrw',
+  },
+};
+
+const expectedMergedClientSuppliedIntegrationsWithKeysObject = {
+  'Google Analytics 4': {
+    sessionId: '16678456735',
+    trackingId: 't-rtcyuTcrw',
+  },
+  AM: true,
+};
+
+const mockClientSuppliedIntegrationsWithInactive = {
+  'Google Analytics 4': true,
+  AM: false,
+};
+
+const expectedMergedClientSuppliedIntegrationsWithInactiveObject = {
+  'Google Analytics 4': {
+    sessionId: '1669961395',
+  },
+  AM: false,
+};
+
+describe('IntegrationsData utilities', () => {
+  it('should construct message integrations object with integrations specific data attached', () => {
+    const mergedArray = constructMessageIntegrationsObj(
+      mockIntegrationsData,
+      mockIntegrationInstances,
+    );
+    expect(mergedArray).toEqual(expectedEnhancedIntegrationsObject);
+  });
+
+  it('should merge data for Client Supplied Integrations', () => {
+    const mergedArray = getMergedClientSuppliedIntegrations(
+      mockEnhancedIntegrationsData,
+      mockClientSuppliedIntegrations,
+    );
+    expect(mergedArray).toEqual(expectedMergedClientSuppliedIntegrationsObject);
+  });
+
+  it('should merge data for Client Supplied Integrations keeping any client defined keys', () => {
+    const mergedArray = getMergedClientSuppliedIntegrations(
+      mockEnhancedIntegrationsData,
+      mockClientSuppliedIntegrationsWithKeys,
+    );
+    expect(mergedArray).toEqual(expectedMergedClientSuppliedIntegrationsWithKeysObject);
+  });
+
+  it('should merge data for Client Supplied Integrations keeping any client inactive integrations', () => {
+    const mergedArray = getMergedClientSuppliedIntegrations(
+      mockEnhancedIntegrationsData,
+      mockClientSuppliedIntegrationsWithInactive,
+    );
+    expect(mergedArray).toEqual(expectedMergedClientSuppliedIntegrationsWithInactiveObject);
+  });
+});

package/packages/analytics-v1.1/__tests__/utils/cdnPaths.test.js

@@ -0,0 +1,63 @@
+import { getIntegrationsCDNPath } from '../../src/utils/cdnPaths';
+import { CDN_INT_DIR, DEST_SDK_BASE_URL, SDK_CDN_BASE_URL } from '../../src/utils/constants';
+import { getSDKUrlInfo } from '../../src/utils/utils';
+
+jest.mock('../../src/utils/utils', () => {
+  const originalModule = jest.requireActual('../../src/utils/utils');
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    getSDKUrlInfo: jest.fn(),
+  };
+});
+
+describe('CDN Paths: getIntegrationsCDNPath', () => {
+  const dummyCustomURL = 'https://www.dummy.url/integrations';
+  const dummyScriptURL = 'https://www.dummy.url/fromScript/v1.1/rudder-analytics.js';
+  const dummyVersion = '2.x.x';
+
+  beforeEach(() => {
+    getSDKUrlInfo.mockImplementation(() => ({ sdkURL: dummyScriptURL }));
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it('should return custom url if valid url is provided', () => {
+    const integrationsCDNPath = getIntegrationsCDNPath(dummyVersion, false, dummyCustomURL);
+    expect(integrationsCDNPath).toBe(dummyCustomURL);
+  });
+
+  it('should throw error if invalid custom url is provided', () => {
+    const integrationsCDNPath = () => getIntegrationsCDNPath(dummyVersion, false, '/');
+    expect(integrationsCDNPath).toThrow(
+      'Failed to load Rudder SDK: CDN base URL for integrations is not valid',
+    );
+  });
+
+  it('should return script src path if script src exists and integrations version is not locked', () => {
+    const integrationsCDNPath = getIntegrationsCDNPath(dummyVersion, false);
+    expect(integrationsCDNPath).toBe('https://www.dummy.url/fromScript/v1.1/js-integrations');
+  });
+
+  it('should return script src path with versioned folder if script src exists and integrations version is locked', () => {
+    const integrationsCDNPath = getIntegrationsCDNPath(dummyVersion, true);
+    expect(integrationsCDNPath).toBe('https://www.dummy.url/fromScript/2.x.x/js-integrations');
+  });
+
+  it('should return default path if no script src exists and integrations version is not locked', () => {
+    getSDKUrlInfo.mockImplementation(() => ({ sdkURL: undefined }));
+
+    const integrationsCDNPath = getIntegrationsCDNPath(dummyVersion, false);
+    expect(integrationsCDNPath).toBe(DEST_SDK_BASE_URL);
+  });
+
+  it('should return default path with versioned folder if no script src exists and integrations version is locked', () => {
+    getSDKUrlInfo.mockImplementation(() => ({ sdkURL: undefined }));
+
+    const integrationsCDNPath = getIntegrationsCDNPath(dummyVersion, true);
+    expect(integrationsCDNPath).toBe(`${SDK_CDN_BASE_URL}/${dummyVersion}/${CDN_INT_DIR}`);
+  });
+});

package/packages/analytics-v1.1/__tests__/utils/clientHint.test.js

@@ -0,0 +1,87 @@
+/* eslint-disable sonarjs/no-duplicate-string */
+import { getUserAgentClientHint } from '../../src/utils/clientHint';
+
+describe('User Agent Client Hint Utilities', () => {
+  const chromeDefaultUACH = {
+    brands: [
+      { brand: 'Chromium', version: '110' },
+      { brand: 'Not A(Brand', version: '24' },
+      { brand: 'Google Chrome', version: '110' },
+    ],
+    mobile: false,
+    platform: 'macOS',
+  };
+
+  const chromeFullUACH = {
+    architecture: 'x86',
+    bitness: '64',
+    brands: [
+      {
+        brand: 'Chromium',
+        version: '110',
+      },
+      {
+        brand: 'Not A(Brand',
+        version: '24',
+      },
+      {
+        brand: 'Google Chrome',
+        version: '110',
+      },
+    ],
+    fullVersionList: [
+      {
+        brand: 'Chromium',
+        version: '110.0.5481.100',
+      },
+      {
+        brand: 'Not A(Brand',
+        version: '24.0.0.0',
+      },
+      {
+        brand: 'Google Chrome',
+        version: '110.0.5481.100',
+      },
+    ],
+    mobile: false,
+    model: '',
+    platform: 'macOS',
+    platformVersion: '13.2.1',
+    uaFullVersion: '110.0.5481.100',
+    wow64: false,
+  };
+
+  afterEach(() => {
+    // Reset global.window.navigator mocks
+    global.navigator.userAgentData = undefined;
+  });
+
+  it('Should return undefined when none is passed as the level', () => {
+    const callback = jest.fn(userAgentClientHint => {
+      expect(userAgentClientHint).toBe(undefined);
+    });
+    getUserAgentClientHint(callback, 'none');
+  });
+  it('Should return undefined if no argument is passed as the level', () => {
+    const callback = jest.fn(userAgentClientHint => {
+      expect(userAgentClientHint).toBe(undefined);
+    });
+    getUserAgentClientHint(callback);
+  });
+  it('Should return default client-hint object if default is passed as the level', () => {
+    global.navigator.userAgentData = chromeDefaultUACH;
+    const callback = jest.fn(userAgentClientHint => {
+      expect(userAgentClientHint).toBe(chromeDefaultUACH);
+    });
+    getUserAgentClientHint(callback, 'default');
+  });
+  it('Should return default client-hint object if full is passed as the level', () => {
+    navigator.userAgentData = {
+      getHighEntropyValues: jest.fn().mockResolvedValue(chromeFullUACH),
+    };
+    const callback = jest.fn(userAgentClientHint => {
+      expect(userAgentClientHint).toBe(chromeFullUACH);
+    });
+    getUserAgentClientHint(callback, 'full');
+  });
+});

package/packages/analytics-v1.1/__tests__/utils/eventProcessorUtils.test.js

@@ -0,0 +1,264 @@
+import { mergeContext, mergeTopLevelElementsMutator } from '../../src/utils/eventProcessorUtils';
+
+describe('Event processor Utilities', () => {
+  const rudderElement = {
+    message: {
+      channel: 'web',
+      context: {
+        app: {
+          name: 'RudderLabs JavaScript SDK',
+          namespace: 'com.rudderlabs.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: 'RudderLabs JavaScript SDK', 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 expectedRudderElement = {
+    message: {
+      channel: 'web',
+      context: {
+        a: 'moumita',
+        key1: 123456,
+        key2: { fg: 'shgjsh' },
+        app: {
+          name: 'RudderLabs JavaScript SDK',
+          namespace: 'com.rudderlabs.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: 'RudderLabs JavaScript SDK', 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 expectedRudderElementWithTopLevelElement = {
+    message: {
+      channel: 'web',
+      context: {
+        app: {
+          name: 'RudderLabs JavaScript SDK',
+          namespace: 'com.rudderlabs.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: 'RudderLabs JavaScript SDK', 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 expectedRudderElementWithLibraryInfo = {
+    message: {
+      channel: 'web',
+      context: {
+        a: 'moumita',
+        key1: 123456,
+        key2: { fg: 'shgjsh' },
+        app: {
+          name: 'RudderLabs JavaScript SDK',
+          namespace: 'com.rudderlabs.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: 'RudderLabs JavaScript SDK', 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(rudderElement.message, options);
+    expect(mergedRudderMessageContext).toStrictEqual(expectedRudderElement.message.context);
+  });
+
+  it('Should context object remain intact if no options provided', () => {
+    const mergedRudderMessageContext = mergeContext(rudderElement.message, undefined);
+    expect(mergedRudderMessageContext).toStrictEqual(rudderElement.message.context);
+  });
+
+  it('Should context object remain intact if null options provided', () => {
+    const mergedRudderMessageContext = mergeContext(rudderElement.message, null);
+    expect(mergedRudderMessageContext).toStrictEqual(rudderElement.message.context);
+  });
+
+  it('Should context object remain intact if non object type options provided', () => {
+    const mergedRudderMessageContext = mergeContext(rudderElement.message, 'options');
+    expect(mergedRudderMessageContext).toStrictEqual(rudderElement.message.context);
+  });
+
+  it('Should mutate the top level context in rudder element if provided in options', () => {
+    mergeTopLevelElementsMutator(rudderElement.message, optionsWithTopLevelContext);
+    expect(rudderElement.message).toStrictEqual(expectedRudderElementWithTopLevelElement.message);
+  });
+
+  it('Should top level context object remain intact if no options provided', () => {
+    mergeTopLevelElementsMutator(rudderElement.message, undefined);
+    expect(rudderElement.message).toStrictEqual(rudderElement.message);
+  });
+
+  it('Should top level context object remain intact if null options provided', () => {
+    mergeTopLevelElementsMutator(rudderElement.message, null);
+    expect(rudderElement.message).toStrictEqual(rudderElement.message);
+  });
+
+  it('Should top level context object remain intact if non object type options provided', () => {
+    mergeTopLevelElementsMutator(rudderElement.message, 'options');
+    expect(rudderElement.message).toStrictEqual(rudderElement.message);
+  });
+
+  it('Should not override library info in context if provided in options', () => {
+    const mergedRudderMessageContext = mergeContext(rudderElement.message, optionsWithLibraryInfo);
+    expect(mergedRudderMessageContext).toStrictEqual(
+      expectedRudderElementWithLibraryInfo.message.context,
+    );
+  });
+
+  it('Should not merge null context if provided in options', () => {
+    const mergedRudderMessageContext = mergeContext(rudderElement.message, optionsWithNullContext);
+    expect(mergedRudderMessageContext).toStrictEqual(expectedRudderElement.message.context);
+  });
+});