castled-js-sdk 0.0.1 → 0.0.2

package/__tests__/integrations/GoogleAds/browser.test.js

@@ -0,0 +1,202 @@
+import GoogleAds from '../../../src/integrations/GoogleAds/browser';
+import {
+  products,
+  mockOrderId,
+  orderCompleted,
+  googleAdsConfigs,
+  trackCallPayload,
+  mockConversionId,
+} from './__mocks__/data';
+
+afterAll(() => {
+  jest.restoreAllMocks();
+});
+const destinationInfo = { areTransformationsConnected: false, destinationId: 'sample-destination-id' };
+
+describe('GoogleAds init tests', () => {
+  let googleAds;
+
+  test('Testing init call of Google Ads with ConversionId', () => {
+    googleAds = new GoogleAds({ conversionID: 'AW-11071053757' }, {}, destinationInfo);
+    googleAds.init();
+    expect(typeof window.gtag).toBe('function');
+  });
+});
+
+// Old Config Test Cases
+describe('Scenario to test conversion event by keeping dynamicRemarketing flag disabled', () => {
+  let googleAds;
+  beforeEach(() => {
+    googleAds = new GoogleAds(googleAdsConfigs[0], {}, destinationInfo);
+    googleAds.init();
+    window.gtag = jest.fn();
+  });
+
+  test('Send Order Completed event as conversion', () => {
+    googleAds.track(trackCallPayload);
+
+    // verify conversion events
+    expect(window.gtag.mock.calls[0][0]).toEqual('event');
+    expect(window.gtag.mock.calls[0][1]).toEqual(orderCompleted);
+    expect(window.gtag.mock.calls[0][2]).toEqual({
+      currency: 'IND',
+      send_to: `${mockConversionId}/TCBjCKjCs4gYEIXBi58p`,
+      transaction_id: mockOrderId,
+    });
+  });
+});
+
+describe('Scenario to test dynamic remarketing event by enabling the dynamicRemarketing flag', () => {
+  let googleAds;
+  beforeEach(() => {
+    googleAds = new GoogleAds(googleAdsConfigs[1], {}, destinationInfo);
+    googleAds.init();
+    window.gtag = jest.fn();
+  });
+
+  test('Send Order Completed event as dynamic remarketing', () => {
+    googleAds.track(trackCallPayload);
+
+    // verify dynamic remarketing events
+    expect(window.gtag.mock.calls[0][0]).toEqual('event');
+    expect(window.gtag.mock.calls[0][1]).toEqual('Lead');
+    expect(window.gtag.mock.calls[0][2]).toEqual({
+      send_to: mockConversionId,
+      event_id: 'purchaseId',
+      order_id: mockOrderId,
+      value: 35.0,
+      shipping: 4.0,
+      currency: 'IND',
+      products,
+    });
+  });
+});
+
+// New Config Test Cases
+describe('Scenario to test conversion and dynamic remarketing events', () => {
+  let googleAds;
+  beforeEach(() => {
+    googleAds = new GoogleAds(googleAdsConfigs[2], {}, destinationInfo);
+    googleAds.init();
+    window.gtag = jest.fn();
+  });
+
+  test('Send Order Completed event as conversion and dynamic remarketing', () => {
+    googleAds.track(trackCallPayload);
+
+    // verify conversion events
+    expect(window.gtag.mock.calls[0][0]).toEqual('event');
+    expect(window.gtag.mock.calls[0][1]).toEqual(orderCompleted);
+    expect(window.gtag.mock.calls[0][2]).toEqual({
+      currency: 'IND',
+      send_to: `${mockConversionId}/TCBjCKjCs4gYEIXBi58p`,
+      transaction_id: mockOrderId,
+    });
+
+    // verify dynamic remarketing events
+    expect(window.gtag.mock.calls[1][0]).toEqual('event');
+    expect(window.gtag.mock.calls[1][1]).toEqual('Lead');
+    expect(window.gtag.mock.calls[1][2]).toEqual({
+      send_to: mockConversionId,
+      event_id: 'purchaseId',
+      order_id: mockOrderId,
+      value: 35.0,
+      shipping: 4.0,
+      currency: 'IND',
+      products,
+    });
+  });
+});
+
+describe('Scenario to test only conversion events when track conversion button is enabled', () => {
+  let googleAds;
+  beforeEach(() => {
+    googleAds = new GoogleAds(googleAdsConfigs[3], {}, destinationInfo);
+    googleAds.init();
+    window.gtag = jest.fn();
+  });
+
+  test('Send Order Completed event as conversion but not dynamic remarketing', () => {
+    googleAds.track(trackCallPayload);
+
+    // verify conversion events
+    expect(window.gtag.mock.calls[0][0]).toEqual('event');
+    expect(window.gtag.mock.calls[0][1]).toEqual('Order Completed');
+    expect(window.gtag.mock.calls[0][2]).toEqual({
+      currency: 'IND',
+      send_to: `${mockConversionId}/TCBjCKjCs4gYEIXBi58p`,
+      transaction_id: mockOrderId,
+    });
+  });
+});
+
+describe('Scenario to test only dynamic remarketing events when track dynamic remarketing button is enabled', () => {
+  let googleAds;
+  beforeEach(() => {
+    googleAds = new GoogleAds(googleAdsConfigs[4], {}, destinationInfo);
+    googleAds.init();
+    window.gtag = jest.fn();
+  });
+
+  test('Send Order Completed event as dynamic remarketing but not as conversion', () => {
+    googleAds.track(trackCallPayload);
+
+    // verify dynamic remarketing events
+    expect(window.gtag.mock.calls[0][0]).toEqual('event');
+    expect(window.gtag.mock.calls[0][1]).toEqual('Lead');
+    expect(window.gtag.mock.calls[0][2]).toEqual({
+      send_to: mockConversionId,
+      event_id: 'purchaseId',
+      order_id: mockOrderId,
+      value: 35.0,
+      shipping: 4.0,
+      currency: 'IND',
+      products,
+    });
+  });
+});
+
+describe('Scenario to test only conversion events when track conversion button and event filtering is enabled', () => {
+  let googleAds;
+  beforeEach(() => {
+    googleAds = new GoogleAds(googleAdsConfigs[5], {}, destinationInfo);
+    googleAds.init();
+    window.gtag = jest.fn();
+  });
+
+  test('Send Order Completed event as conversion', () => {
+    googleAds.track(trackCallPayload);
+
+    // verify conversion events
+    expect(window.gtag.mock.calls[0][0]).toEqual('event');
+    expect(window.gtag.mock.calls[0][1]).toEqual(orderCompleted);
+    expect(window.gtag.mock.calls[0][2]).toEqual({
+      currency: 'IND',
+      send_to: `${mockConversionId}/TCBjCKjCs4gYEIXBi58p`,
+      transaction_id: mockOrderId,
+    });
+  });
+});
+
+// Old + New config test
+describe('Scenario to test both configs together, old config should be given first priority', () => {
+  let googleAds;
+  beforeEach(() => {
+    googleAds = new GoogleAds(googleAdsConfigs[6], {}, destinationInfo);
+    googleAds.init();
+    window.gtag = jest.fn();
+  });
+
+  test('As dynamicRemarketing flag is disabled, send order completed event as conversion event', () => {
+    googleAds.track(trackCallPayload);
+
+    // verify conversion events
+    expect(window.gtag.mock.calls[0][0]).toEqual('event');
+    expect(window.gtag.mock.calls[0][1]).toEqual(orderCompleted);
+    expect(window.gtag.mock.calls[0][2]).toEqual({
+      currency: 'IND',
+      send_to: `${mockConversionId}/TCBjCKjCs4gYEIXBi58p`,
+      transaction_id: mockOrderId,
+    });
+  });
+});

package/__tests__/integrations/GoogleAds/utils.test.js

@@ -0,0 +1,110 @@
+import {
+  getConversionData,
+  shouldSendConversionEvent,
+  shouldSendDynamicRemarketingEvent,
+} from '../../../src/integrations/GoogleAds/utils';
+import {
+  mockEvents,
+  productAdded,
+  orderCompleted,
+  mockEventTypeConversions,
+} from './__mocks__/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({});
+  });
+});

package/__tests__/integrations/LaunchDarkly/__mocks__/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/__tests__/integrations/LaunchDarkly/browser.test.js

@@ -0,0 +1,148 @@
+import LaunchDarkly from '../../../src/integrations/LaunchDarkly/browser';
+import {
+  launchDarklyConfigs,
+  mockTraits,
+  mockAnonymousId,
+  mockUserId,
+  mockClientSideId,
+  mockAnonymousUsersSharedKey,
+  trackCallPayload,
+  mockProperties,
+  testEvent,
+} from './__mocks__/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/__tests__/integrations/LaunchDarkly/utils.test.js

@@ -0,0 +1,36 @@
+import createUser from '../../../src/integrations/LaunchDarkly/utils';
+import { mockAnonymousUsersSharedKey, mockTraits, mockUserId } from './__mocks__/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 });
+  });
+});