iureiure 1.0.0

package/packages/analytics-js-integrations/__tests__/integrations/GoogleAds/utils.test.js

@@ -0,0 +1,121 @@
+import {
+  getConversionData,
+  shouldSendConversionEvent,
+  shouldSendDynamicRemarketingEvent,
+  newCustomerAcquisitionReporting,
+} from '../../../src/integrations/GoogleAds/utils';
+import {
+  mockEvents,
+  productAdded,
+  orderCompleted,
+  mockEventTypeConversions,
+} from './__fixtures__/data';
+
+describe('GoogleAds utilities shouldSendEvent function tests', () => {
+  // Old Config
+  test('dynamicRemarketing flag disabled', () => {
+    const eventToSend = shouldSendConversionEvent(
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      false,
+    );
+    expect(eventToSend).toEqual(true);
+  });
+
+  test('dynamicRemarketing flag enabled', () => {
+    const eventToSend = shouldSendDynamicRemarketingEvent(
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      true,
+    );
+    expect(eventToSend).toEqual(true);
+  });
+
+  // New Config
+  test('event tracking is enabled and event filtering is disabled', () => {
+    const eventToSend = shouldSendConversionEvent(productAdded, true, false, mockEvents, undefined);
+    expect(eventToSend).toEqual(true);
+  });
+
+  test('event tracking is disabled and event filtering is disabled', () => {
+    const eventToSend = shouldSendDynamicRemarketingEvent(
+      'Product Viewed',
+      false,
+      false,
+      mockEvents,
+      undefined,
+    );
+    expect(eventToSend).toEqual(false);
+  });
+
+  test('event tracking is enabled and event filtering is enabled but event is not added to events list', () => {
+    const eventToSend = shouldSendConversionEvent(
+      'Product Added',
+      true,
+      true,
+      mockEvents,
+      undefined,
+    );
+    expect(eventToSend).toEqual(false);
+  });
+
+  test('event tracking is enabled and event filtering is enabled and event is added to events list', () => {
+    const eventToSend = shouldSendDynamicRemarketingEvent(
+      orderCompleted,
+      true,
+      true,
+      mockEvents,
+      undefined,
+    );
+    expect(eventToSend).toEqual(true);
+  });
+
+  test('when both config (new + old) is present, new config should be given first priority', () => {
+    const eventToSend = shouldSendConversionEvent('Cart Checkout', true, true, mockEvents, false);
+    expect(eventToSend).toEqual(false);
+  });
+
+  test('when both config (new + old) is present, new config should be given first priority', () => {
+    const eventToSend = shouldSendDynamicRemarketingEvent(
+      orderCompleted,
+      true,
+      true,
+      mockEvents,
+      true,
+    );
+    expect(eventToSend).toEqual(true);
+  });
+});
+
+describe('GoogleAds utilities getConversionData function tests', () => {
+  test('Event name is present in mapping', () => {
+    const conversionData = getConversionData(mockEventTypeConversions, 'Sign Up', '');
+    expect(conversionData.eventName).toEqual('Sign Up');
+    expect(conversionData.conversionLabel).toEqual('15klCKLCs4gYETIBi58p');
+  });
+
+  test('No event name is present', () => {
+    const conversionData = getConversionData(mockEventTypeConversions, '', 'KhF2CKvCs4gYETIBi58p');
+    expect(conversionData.eventName).toEqual('Viewed a Page');
+    expect(conversionData.conversionLabel).toEqual('KhF2CKvCs4gYETIBi58p');
+  });
+
+  test('No matching event name is present and no defaultPageConversion is present', () => {
+    const conversionData = getConversionData(mockEventTypeConversions, 'Cart Checkout', '');
+    expect(conversionData).toEqual({});
+  });
+});
+
+describe('GoogleAds utilities newCustomerAcquisitionReporting function tests', () => {
+  test('newCustomerAcquisitionReporting function should set new_customer property when properties.newCustomer is present', () => {
+    const mockProperties = {
+      newCustomer: true,
+    };
+    const properties = newCustomerAcquisitionReporting(mockProperties);
+    expect(properties.new_customer).toEqual(true);
+  });
+});

package/packages/analytics-js-integrations/__tests__/integrations/Hotjar/browser.test.js

@@ -0,0 +1,108 @@
+import Hotjar from '../../../src/integrations/Hotjar/browser';
+
+afterAll(() => {
+  jest.restoreAllMocks();
+});
+describe('Hotjar init tests', () => {
+  let hotjar;
+
+  test('Testing init call of Hotjar', () => {
+    hotjar = new Hotjar({ siteId: '12567839' }, { loglevel: 'debug' });
+    hotjar.init();
+    expect(typeof window.hj).toBe('function');
+  });
+});
+
+const traits = {
+  name: 'Alex Keener',
+  email: 'alex@example.com',
+  company: {
+    id: 'group01',
+    name: 'Tech Group',
+    remove: true,
+  },
+};
+
+describe('Hotjar Identify event', () => {
+  let hotjar;
+  beforeEach(() => {
+    hotjar = new Hotjar({ siteId: '12567839' }, { loglevel: 'debug' });
+    hotjar.analytics.loadOnlyIntegrations = {};
+    window.hj = jest.fn();
+  });
+  test('Testing Identify Events to create or update user information', () => {
+    hotjar.identify({
+      message: {
+        userId: 'rudder01',
+        anonymousId: 'urgyffsd43weehjdbs44fvdsd',
+        context: { traits },
+        createdAt: 'Mon May 19 2019 18:34:24 GMT0000 (UTC)',
+      },
+    });
+    expect(window.hj.mock.calls[0][0]).toEqual('identify');
+    expect(window.hj.mock.calls[0][1]).toEqual('rudder01');
+    expect(window.hj.mock.calls[0][2]).toEqual(traits);
+  });
+});
+
+describe('Hotjar Track event', () => {
+  let hotjar;
+  beforeEach(() => {
+    hotjar = new Hotjar({ siteId: '12567839' }, { loglevel: 'debug' });
+    window.hj = jest.fn();
+  });
+  test('Testing Track Events', () => {
+    hotjar.track({
+      message: {
+        context: {},
+        event: 'Order Completed',
+        properties: {
+          order_id: '140021222',
+          checkout_id: 'WAP3211',
+          products: 'sports_shoes',
+          revenue: 77.95,
+          currency: 'USD',
+        },
+      },
+    });
+    expect(window.hj.mock.calls[0][0]).toEqual('event');
+    expect(window.hj.mock.calls[0][1]).toEqual('Order_Completed');
+  });
+  test('Testing Track Events without event', () => {
+    try {
+      hotjar.track({
+        message: {
+          context: {},
+          properties: {
+            order_id: '140021222',
+            checkout_id: 'WAP3211',
+            products: 'sports_shoes',
+            revenue: 77.95,
+            currency: 'USD',
+          },
+        },
+      });
+    } catch (error) {
+      expect(error).toEqual('Event name is not present');
+    }
+  });
+  test('Testing Track Events with non-string event name', () => {
+    try {
+      hotjar.track({
+        message: {
+          context: {},
+          event: 43434,
+          properties: {
+            order_id: '140021222',
+            checkout_id: 'WAP3211',
+            products: 'sports_shoes',
+            revenue: 77.95,
+            currency: 'USD',
+          },
+        },
+      });
+    } catch (error) {
+      expect(error).toEqual('Event name should be string');
+    }
+  });
+});

package/packages/analytics-js-integrations/__tests__/integrations/Intercom/browser.test.js

@@ -0,0 +1,135 @@
+import INTERCOM from '../../../src/integrations/INTERCOM/browser';
+
+afterAll(() => {
+  jest.restoreAllMocks();
+});
+describe('Intercom init tests', () => {
+  let intercom;
+
+  test('Testing init call of Intercom', () => {
+    intercom = new INTERCOM({ appId: '12567839' }, { loglevel: 'debug' });
+    intercom.init();
+    expect(typeof window.Intercom).toBe('function');
+  });
+});
+
+beforeEach(() => {
+  // Add a dummy script as it is required by the init script
+  const scriptElement = document.createElement('script');
+  scriptElement.type = 'text/javascript';
+  scriptElement.id = 'dummyScript';
+  const headElements = document.getElementsByTagName('head');
+  headElements[0].insertBefore(scriptElement, headElements[0].firstChild);
+  delete window.Intercom;
+});
+
+describe('Intercom Identify event', () => {
+  let intercom;
+  beforeEach(() => {
+    intercom = new INTERCOM({ appId: '12567839' }, { loglevel: 'debug' });
+    intercom.analytics.loadOnlyIntegrations = {};
+    window.Intercom = jest.fn();
+  });
+  test('Testing Identify Events to create or update user information', () => {
+    intercom.identify({
+      message: {
+        userId: 'rudder01',
+        anonymousId: 'urgyffsd43weehjdbs44fvdsd',
+        context: {
+          traits: {
+            name: 'Alex Keener',
+            email: 'alex@example.com',
+            company: {
+              id: 'group01',
+              name: 'Tech Group',
+              remove: true,
+            },
+          },
+        },
+        createdAt: 'Mon May 19 2019 18:34:24 GMT0000 (UTC)',
+      },
+    });
+    expect(window.Intercom.mock.calls[0][0]).toEqual('update');
+    expect(window.Intercom.mock.calls[0][1]).toEqual({
+      name: 'Alex Keener',
+      email: 'alex@example.com',
+      companies: [
+        {
+          company_id: 'group01',
+          name: 'Tech Group',
+          remove: true,
+        },
+      ],
+      user_id: 'rudder01',
+    });
+  });
+  test('Identify Events to create or update user information', () => {
+    intercom.identify({
+      message: {
+        userId: 'rudder01',
+        anonymousId: 'urgyffsd43weehjdbs44fvdsd',
+        context: {
+          traits: {
+            name: 'Alex Keener',
+            email: 'alex@example.com',
+            company: {
+              id: 'group01',
+              name: 'Tech Group',
+              remove: true,
+            },
+          },
+        },
+        createdAt: 'Mon May 19 2019 18:34:24 GMT0000 (UTC)',
+      },
+    });
+    expect(window.Intercom.mock.calls[0][0]).toEqual('update');
+    expect(window.Intercom.mock.calls[0][1]).toEqual({
+      name: 'Alex Keener',
+      email: 'alex@example.com',
+      companies: [
+        {
+          company_id: 'group01',
+          name: 'Tech Group',
+          remove: true,
+        },
+      ],
+      user_id: 'rudder01',
+    });
+  });
+});
+
+describe('Intercom Track event', () => {
+  let intercom;
+  beforeEach(() => {
+    intercom = new INTERCOM({ appId: '12567839' }, { loglevel: 'debug' });
+    window.Intercom = jest.fn();
+  });
+  test('Testing Track Events', () => {
+    intercom.track({
+      message: {
+        context: {},
+        // eslint-disable-next-line sonarjs/no-duplicate-string
+        event: 'Order Completed',
+        properties: {
+          order_id: '140021222',
+          checkout_id: 'WAP3211',
+          products: 'sports_shoes',
+          revenue: 77.95,
+          currency: 'USD',
+        },
+      },
+    });
+    expect(window.Intercom.mock.calls[0][0]).toEqual('trackEvent');
+    expect(window.Intercom.mock.calls[0][1]).toEqual('Order Completed');
+    expect(window.Intercom.mock.calls[0][2]).toEqual({
+      checkout_id: 'WAP3211',
+      created_at: NaN,
+      currency: 'USD',
+      event_name: 'Order Completed',
+      order_id: '140021222',
+      products: 'sports_shoes',
+      revenue: 77.95,
+      user_id: undefined,
+    });
+  });
+});

package/packages/analytics-js-integrations/__tests__/integrations/Intercom/util.test.js

@@ -0,0 +1,69 @@
+import {
+  processCompanyField,
+  processIdentityVerificationProps,
+  processNameField,
+} from '../../../src/integrations/INTERCOM/utils';
+
+describe('processIdentityVerificationProps', () => {
+  it('should return payload after populating identity verification props', () => {
+    const props = { user_hash: '9c56cc51b374c3ba189210d5b6d4bf57790d351c96c47c02190ecf1e430635ab' };
+    const result = processIdentityVerificationProps(props);
+    expect(result).toEqual({
+      user_hash: '9c56cc51b374c3ba189210d5b6d4bf57790d351c96c47c02190ecf1e430635ab',
+    });
+  });
+});
+
+describe('processCompanyField', () => {
+  it('should return the company obj after taking the companyField and company_id should have the value of id', () => {
+    const companyField = {
+      id: 'group01',
+      name: 'Tech Group',
+      remove: true,
+    };
+    const result = processCompanyField(companyField);
+    expect(result).toEqual({ company_id: 'group01', name: 'Tech Group', remove: true });
+  });
+
+  it('should return the company obj after taking the companyField and company_id should have the value of md5 hashed name', () => {
+    const companyField = {
+      name: 'Techno Group',
+      remove: true,
+    };
+    const result = processCompanyField(companyField);
+    expect(result).toEqual({
+      company_id: 'ea0331050f91c1aa1b0be9a8727b1eb9',
+      name: 'Techno Group',
+      remove: true,
+    });
+  });
+
+  it('should return the company obj after taking the companyField and company_id should have the value of md5 hashed name', () => {
+    const companyField = 'Techno X Group';
+    const result = processCompanyField(companyField);
+    expect(result).toEqual({
+      company_id: '8dbae98a998da9e706b1506ca920e5a5',
+    });
+  });
+});
+
+describe('processNameField', () => {
+  it('should return the combination of firstName and lastName if both are present & name not present', () => {
+    const traits = {
+      firstName: 'Chris',
+      lastName: 'Evans ',
+    };
+    const result = processNameField(traits);
+    expect(result).toEqual('Chris Evans');
+  });
+
+  it('should return the name if name is present', () => {
+    const traits = {
+      firstName: 'Chris',
+      lastName: 'Evans ',
+      name: 'Alex Chriss',
+    };
+    const result = processNameField(traits);
+    expect(result).toEqual('Alex Chriss');
+  });
+});

package/packages/analytics-js-integrations/__tests__/integrations/LaunchDarkly/__fixtures__/data.js

@@ -0,0 +1,61 @@
+const mockUserId = 'test-userId-123';
+const mockAnonymousId = 'e1315e19-1f4f-4e4c-a4ce-face6139c84a';
+const mockClientSideId = 'test-client-side-id';
+const mockAnonymousUsersSharedKey = 'test-anonymousUsers-shared-key';
+const testEvent = 'Test Event';
+
+const launchDarklyConfigs = [
+  {
+    clientSideId: null,
+    anonymousUsersSharedKey: null,
+  },
+  {
+    clientSideId: mockClientSideId,
+    anonymousUsersSharedKey: null,
+  },
+  {
+    clientSideId: mockClientSideId,
+    anonymousUsersSharedKey: mockAnonymousUsersSharedKey,
+  },
+];
+
+const mockTraits = {
+  anonymous: false,
+  avatar: 'https://avatarfiles.alphacoders.com/837/83744.jpg',
+  country: 'USA',
+  custom: {
+    favourite_color: 'black',
+  },
+  email: 'alex@example.com',
+  firstName: 'Alex',
+  ip: '12.23.34.45',
+  lastName: 'Keener',
+  name: 'Alex Keener',
+  privateAttributeNames: ['avatar', 'country'],
+  secondary: 'abcd21234',
+};
+
+const mockProperties = {
+  foo: 'bar',
+  key1: 'value1',
+};
+
+const trackCallPayload = {
+  message: {
+    context: {},
+    event: testEvent,
+    properties: mockProperties,
+  },
+};
+
+export {
+  launchDarklyConfigs,
+  trackCallPayload,
+  mockTraits,
+  mockAnonymousId,
+  mockUserId,
+  mockClientSideId,
+  mockAnonymousUsersSharedKey,
+  testEvent,
+  mockProperties,
+};

package/packages/analytics-js-integrations/__tests__/integrations/LaunchDarkly/browser.test.js

@@ -0,0 +1,151 @@
+import LaunchDarkly from '../../../src/integrations/LaunchDarkly/browser';
+import {
+  launchDarklyConfigs,
+  mockTraits,
+  mockAnonymousId,
+  mockUserId,
+  mockClientSideId,
+  mockAnonymousUsersSharedKey,
+  trackCallPayload,
+  mockProperties,
+  testEvent,
+} from './__fixtures__/data';
+
+afterAll(() => {
+  jest.restoreAllMocks();
+});
+
+const destinationInfo = {
+  areTransformationsConnected: false,
+  destinationId: 'sample-destination-id',
+};
+
+describe('LaunchDarkly init tests', () => {
+  test('Testing init call of Launch Darkly without client side id', () => {
+    const launchdarkly = new LaunchDarkly(launchDarklyConfigs[0], {}, destinationInfo);
+    try {
+      launchdarkly.init();
+    } catch (error) {
+      expect(error).toEqual(
+        'LAUNCHDARKLY :: Unable to initialize destination - clientSideId is missing in config',
+      );
+    }
+  });
+});
+
+describe('LaunchDarkly Identify call tests', () => {
+  let launchdarkly;
+
+  test('Testing identify call with anonymousId', () => {
+    launchdarkly = new LaunchDarkly(launchDarklyConfigs[1], {}, destinationInfo);
+    launchdarkly.init();
+    window.LDClient = {};
+    window.LDClient.initialize = jest.fn();
+    launchdarkly.identify({
+      message: {
+        context: {
+          traits: mockTraits,
+        },
+        anonymousId: mockAnonymousId,
+      },
+    });
+
+    expect(window.LDClient.initialize.mock.calls[0][0]).toEqual(mockClientSideId);
+    expect(window.LDClient.initialize.mock.calls[0][1]).toEqual({
+      key: mockAnonymousId,
+      ...mockTraits,
+    });
+  });
+
+  test('Testing identify call with userId', () => {
+    launchdarkly = new LaunchDarkly(launchDarklyConfigs[1], {}, destinationInfo);
+    launchdarkly.init();
+    window.LDClient = {};
+    window.LDClient.initialize = jest.fn();
+    launchdarkly.identify({
+      message: {
+        context: {
+          traits: mockTraits,
+        },
+        userId: mockUserId,
+      },
+    });
+
+    expect(window.LDClient.initialize.mock.calls[0][0]).toEqual(mockClientSideId);
+    expect(window.LDClient.initialize.mock.calls[0][1]).toEqual({
+      key: mockUserId,
+      ...mockTraits,
+    });
+  });
+
+  test('Testing identify call with anonymous user shared key', () => {
+    launchdarkly = new LaunchDarkly(launchDarklyConfigs[2], {}, destinationInfo);
+    launchdarkly.init();
+    window.LDClient = {};
+    window.LDClient.initialize = jest.fn();
+    launchdarkly.identify({
+      message: {
+        context: {
+          traits: mockTraits,
+        },
+        userId: mockUserId,
+      },
+    });
+
+    expect(window.LDClient.initialize.mock.calls[0][0]).toEqual(mockClientSideId);
+    expect(window.LDClient.initialize.mock.calls[0][1]).toEqual({
+      key: mockAnonymousUsersSharedKey,
+      ...mockTraits,
+    });
+  });
+});
+
+describe('LaunchDarkly Track call tests', () => {
+  let launchdarkly;
+  beforeEach(() => {
+    launchdarkly = new LaunchDarkly(launchDarklyConfigs[1], {}, destinationInfo);
+    launchdarkly.init();
+    window.ldclient = {};
+    window.ldclient.track = jest.fn();
+  });
+
+  test('Testing track call', () => {
+    launchdarkly.track(trackCallPayload);
+    expect(window.ldclient.track.mock.calls[0][0]).toEqual(testEvent);
+    expect(window.ldclient.track.mock.calls[0][1]).toEqual(mockProperties);
+  });
+});
+
+describe('LaunchDarkly Alias call tests', () => {
+  let launchdarkly;
+  beforeEach(() => {
+    launchdarkly = new LaunchDarkly({ clientSideId: 'test-client-side-id' }, {}, destinationInfo);
+    launchdarkly.init();
+    window.ldclient = {};
+    window.ldclient.alias = jest.fn();
+    window.ldclient.identify = jest.fn();
+    launchdarkly.identify({
+      message: {
+        context: {
+          traits: mockTraits,
+        },
+        anonymousId: mockAnonymousId,
+      },
+    });
+  });
+
+  test('Testing alias call to merge anonymous and identified user', () => {
+    launchdarkly.alias({
+      message: {
+        context: {},
+        userId: mockUserId,
+      },
+    });
+
+    expect(window.ldclient.alias.mock.calls[0][0]).toEqual({ key: mockUserId });
+    expect(window.ldclient.alias.mock.calls[0][1]).toEqual({
+      key: mockAnonymousId,
+      ...mockTraits,
+    });
+  });
+});

package/packages/analytics-js-integrations/__tests__/integrations/LaunchDarkly/utils.test.js

@@ -0,0 +1,36 @@
+import { createUser } from '../../../src/integrations/LaunchDarkly/utils';
+import { mockAnonymousUsersSharedKey, mockTraits, mockUserId } from './__fixtures__/data';
+
+afterAll(() => {
+  jest.restoreAllMocks();
+});
+
+describe('LaunchDarkly utilities createUser function tests', () => {
+  test('Testing create user with key as userId', () => {
+    expect(
+      createUser({
+        context: {
+          traits: mockTraits,
+        },
+        userId: mockUserId,
+      }),
+    ).toEqual({
+      key: mockUserId,
+      ...mockTraits,
+    });
+  });
+
+  test('Testing create user with key as anonymous users shared key', () => {
+    expect(
+      createUser(
+        {
+          context: {
+            traits: mockTraits,
+          },
+          userId: mockUserId,
+        },
+        mockAnonymousUsersSharedKey,
+      ),
+    ).toEqual({ key: mockAnonymousUsersSharedKey, ...mockTraits });
+  });
+});