castled-js-sdk 0.0.1 → 0.0.2

package/__tests__/script.test.js

@@ -0,0 +1,167 @@
+function wait(time) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, time);
+  });
+}
+
+describe('Test suite for the SDK', () => {
+  const xhrMock = {
+    open: jest.fn(),
+    setRequestHeader: jest.fn(),
+    onload: jest.fn(),
+    onreadystatechange: jest.fn(),
+    readyState: 4,
+    responseText: JSON.stringify({
+      source: {
+        config: {},
+        id: 'id',
+        destinations: [],
+      },
+    }),
+    status: 200,
+  };
+
+  xhrMock['send'] = jest.fn(() => xhrMock.onload());
+
+  const userId = 'jest-user-id';
+  const userTraits = {
+    'jest-user-trait-key-1': 'jest-user-trait-value-1',
+    'jest-user-trait-key-2': 'jest-user-trait-value-2',
+  };
+
+  const groupUserId = 'jest-group-id';
+  const groupTraits = {
+    'jest-group-trait-key-1': 'jest-group-trait-value-1',
+    'jest-group-trait-key-2': 'jest-group-trait-value-2',
+  };
+
+  beforeEach(async () => {
+    jest.resetModules();
+
+    window.XMLHttpRequest = jest.fn(() => xhrMock);
+
+    document.head.innerHTML = ` `;
+    hightouchevents = window.hightouchevents = [];
+    for (
+      var methods = [
+          'load',
+          'page',
+          'track',
+          'alias',
+          'group',
+          'identify',
+          'ready',
+          'reset',
+          'getUserTraits',
+          'getAnonymousId',
+          'getUserId',
+          'getUserTraits',
+          'getGroupId',
+          'getGroupTraits',
+          'setAnonymousId',
+        ],
+        i = 0;
+      i < methods.length;
+      i++
+    ) {
+      var method = methods[i];
+      hightouchevents[method] = (function (d) {
+        return function () {
+          hightouchevents.push([d, ...arguments]);
+        };
+      })(method);
+    }
+    hightouchevents.load('WRITE_KEY', 'DATA_PLANE_URL');
+    require('./prodsdk.js');
+    await wait(500);
+  });
+
+  it("If SDK script is 'required' (imported), then check that it is loaded and queued API calls are processed", () => {
+    // Only done for this case to test the
+    // API calls queuing functionality
+    jest.resetModules();
+    hightouchevents.page();
+    require('./prodsdk.js');
+
+    expect(global.hightouchevents.push).not.toBe(Array.prototype.push);
+
+    // one source config endpoint call and one implicit page call
+    // Refer to above 'beforeEach'
+    expect(xhrMock.send).toHaveBeenCalledTimes(2);
+  });
+
+  it('If APIs are called, then appropriate network requests are made', () => {
+    hightouchevents.page();
+    hightouchevents.track('test-event');
+    hightouchevents.identify('jest-user');
+    hightouchevents.group('jest-group');
+    hightouchevents.alias('new-jest-user', 'jest-user');
+
+    // one source config endpoint call and above API requests
+    expect(xhrMock.send).toHaveBeenCalledTimes(6);
+  });
+
+  describe("Test group for 'getAnonymousId' API", () => {
+    it("If 'getAnonymousId' API is invoked with no prior persisted data, then a UUID value is returned", () => {
+      const anonId = hightouchevents.getAnonymousId();
+
+      const uuidRegEx = /^[a-z0-9]{8}-[a-z0-9]{4}-4[a-z0-9]{3}-[a-z0-9]{4}-[a-z0-9]{12}$/;
+      expect(anonId).toMatch(uuidRegEx);
+    });
+
+    it("If SDK generates anonymous ID, then it'll be persisted", () => {
+      const anonIdRes1 = hightouchevents.getAnonymousId();
+
+      // SDK remembers the previously generated anonymous ID and returns the same value
+      const anonIdRes2 = hightouchevents.getAnonymousId();
+
+      expect(anonIdRes1).toEqual(anonIdRes2);
+    });
+  });
+
+  describe("Test group for 'reset' API", () => {
+    it("If 'reset' API is invoked without setting the flag, then all persisted data except for anonymous ID is cleared", () => {
+      // Make identify and group API calls to let the SDK persist
+      // user (ID and traits) and group data (ID and traits)
+      hightouchevents.identify(userId, userTraits);
+      hightouchevents.group(groupUserId, groupTraits);
+
+      const anonId = 'jest-anon-ID';
+      hightouchevents.setAnonymousId(anonId);
+
+      // SDK clears all the persisted data except for anonymous ID
+      hightouchevents.reset();
+
+      // SDK remembers the previously generated anonymous ID and returns the same value
+      const anonIdRes = hightouchevents.getAnonymousId();
+
+      expect(anonId).toEqual(anonIdRes);
+      expect(hightouchevents.getUserId()).toEqual('');
+      expect(hightouchevents.getUserTraits()).toEqual({});
+      expect(hightouchevents.getGroupId()).toEqual('');
+      expect(hightouchevents.getGroupTraits()).toEqual({});
+    });
+
+    it("If 'reset' API is invoked with the flag set to 'true', then all the persisted data is cleared", () => {
+      // Make identify and group API calls to let the SDK persist
+      // user (ID and traits) and group data (ID and traits)
+      hightouchevents.identify(userId, userTraits);
+      hightouchevents.group(groupUserId, groupTraits);
+
+      const anonId = 'jest-anon-ID';
+      hightouchevents.setAnonymousId(anonId);
+
+      // SDK clears all the persisted data
+      hightouchevents.reset(true);
+
+      // SDK remembers the previously generated anonymous ID and returns the same value
+      const anonIdRes = hightouchevents.getAnonymousId();
+
+      expect(anonId).not.toEqual(anonIdRes);
+      expect(hightouchevents.getUserId()).toEqual('');
+      expect(hightouchevents.getUserTraits()).toEqual({});
+      expect(hightouchevents.getGroupId()).toEqual('');
+      expect(hightouchevents.getGroupTraits()).toEqual({});
+    });
+  });
+});

package/__tests__/service-worker/__mocks__/fixtures.js

@@ -0,0 +1,79 @@
+const identifyRequestPayload = {
+  userId: '123456',
+  traits: {
+    name: 'Name Username',
+    email: 'name@website.com',
+    plan: 'Free',
+    friends: 21,
+  },
+};
+
+const trackRequestPayload = {
+  userId: '123456',
+  event: 'Item Viewed',
+  properties: {
+    revenue: 19.95,
+    shippingMethod: 'Premium',
+  },
+};
+
+const pageRequestPayload = {
+  userId: '12345',
+  category: 'Food',
+  name: 'Pizza',
+  properties: {
+    url: 'https://dominos.com',
+    title: 'Pizza',
+    referrer: 'https://google.com',
+  },
+};
+
+const screenRequestPayload = {
+  userId: '12345',
+  category: 'Food',
+  name: 'Pizza',
+  properties: {
+    screenSize: 10,
+    title: 'Pizza',
+    referrer: 'https://google.com',
+  },
+};
+
+const groupRequestPayload = {
+  userId: '12345',
+  groupId: '1',
+  traits: {
+    name: 'Company',
+    description: 'Google',
+  },
+};
+
+const aliasRequestPayload = {
+  previousId: 'old_id',
+  userId: 'new_id',
+};
+
+const dummyWriteKey = 'dummyWriteKey';
+
+const dummyDataplaneHost = 'https://dummy.dataplane.host.com';
+
+const dummyInitOptions = {
+  timeout: false,
+  flushAt: 1,
+  flushInterval: 200000,
+  maxInternalQueueSize: 1,
+  logLevel: 'off',
+  enable: true,
+};
+
+export {
+  identifyRequestPayload,
+  trackRequestPayload,
+  pageRequestPayload,
+  screenRequestPayload,
+  groupRequestPayload,
+  aliasRequestPayload,
+  dummyWriteKey,
+  dummyInitOptions,
+  dummyDataplaneHost,
+};

package/__tests__/service-worker/__mocks__/msw.server.js

@@ -0,0 +1,12 @@
+import { setupServer } from 'msw/node';
+import { dummyDataplaneHost } from './fixtures';
+
+const server = setupServer({
+  url: `${dummyDataplaneHost}/v1/batch`,
+  response: () => null,
+  status: 200,
+  method: 'post',
+  responseHeaders: { Environment: 'local' },
+});
+
+export { server };

package/__tests__/service-worker/index.test.js

@@ -0,0 +1,109 @@
+import { advanceTo } from 'jest-date-mock';
+import { Analytics } from '../../src/service-worker';
+import { server } from './__mocks__/msw.server';
+import {
+  aliasRequestPayload,
+  dummyDataplaneHost,
+  dummyInitOptions,
+  dummyWriteKey,
+  groupRequestPayload,
+  identifyRequestPayload,
+  pageRequestPayload,
+  screenRequestPayload,
+  trackRequestPayload,
+} from './__mocks__/fixtures';
+
+jest.mock('uuid', () => ({ v4: () => '123456789' }));
+
+describe('JS SDK Service Worker', () => {
+  let hightouchEventsClient = null;
+  let requestBody;
+
+  beforeAll(() => {
+    advanceTo(new Date(2022, 1, 21, 0, 0, 0));
+    server.listen();
+  });
+
+  beforeEach(() => {
+    hightouchEventsClient = new Analytics(dummyWriteKey, dummyDataplaneHost, dummyInitOptions);
+    server.events.on('request:start', (req) => {
+      requestBody = req.body;
+    });
+  });
+
+  afterEach(() => {
+    hightouchEventsClient = null;
+    server.resetHandlers();
+    server.events.removeAllListeners();
+    requestBody = null;
+  });
+
+  afterAll(() => {
+    server.close();
+  });
+
+  it('Should initialise with correct values', () => {
+    expect(hightouchEventsClient.writeKey).toBe(dummyWriteKey);
+    expect(hightouchEventsClient.host).toBe(dummyDataplaneHost);
+    expect(hightouchEventsClient.timeout).toBe(dummyInitOptions.timeout);
+    expect(hightouchEventsClient.flushAt).toBe(dummyInitOptions.flushAt);
+    expect(hightouchEventsClient.flushInterval).toBe(dummyInitOptions.flushInterval);
+    expect(hightouchEventsClient.maxInternalQueueSize).toBe(dummyInitOptions.maxInternalQueueSize);
+    expect(hightouchEventsClient.logLevel).toBe(dummyInitOptions.logLevel);
+    expect(hightouchEventsClient.enable).toBe(dummyInitOptions.enable);
+  });
+
+  it('Should record identify', async () => {
+    hightouchEventsClient.identify(identifyRequestPayload);
+    hightouchEventsClient.flush();
+
+    await new Promise((r) => setTimeout(r, 1));
+
+    expect(requestBody.batch[0]).toEqual(expect.objectContaining(identifyRequestPayload));
+  });
+
+  it('Should record track', async () => {
+    hightouchEventsClient.track(trackRequestPayload);
+    hightouchEventsClient.flush();
+
+    await new Promise((r) => setTimeout(r, 1));
+
+    expect(requestBody.batch[0]).toEqual(expect.objectContaining(trackRequestPayload));
+  });
+
+  it('Should record page', async () => {
+    hightouchEventsClient.page(pageRequestPayload);
+    hightouchEventsClient.flush();
+
+    await new Promise((r) => setTimeout(r, 1));
+
+    expect(requestBody.batch[0]).toEqual(expect.objectContaining(pageRequestPayload));
+  });
+
+  it('Should record screen', async () => {
+    hightouchEventsClient.screen(screenRequestPayload);
+    hightouchEventsClient.flush();
+
+    await new Promise((r) => setTimeout(r, 1));
+
+    expect(requestBody.batch[0]).toEqual(expect.objectContaining(screenRequestPayload));
+  });
+
+  it('Should record group', async () => {
+    hightouchEventsClient.group(groupRequestPayload);
+    hightouchEventsClient.flush();
+
+    await new Promise((r) => setTimeout(r, 1));
+
+    expect(requestBody.batch[0]).toEqual(expect.objectContaining(groupRequestPayload));
+  });
+
+  it('Should record alias', async () => {
+    hightouchEventsClient.alias(aliasRequestPayload);
+    hightouchEventsClient.flush();
+
+    await new Promise((r) => setTimeout(r, 1));
+
+    expect(requestBody.batch[0]).toEqual(expect.objectContaining(aliasRequestPayload));
+  });
+});

package/__tests__/transformationHandler.test.js

@@ -0,0 +1,169 @@
+/* eslint-disable no-plusplus */
+import { rest } from 'msw';
+import { DeviceModeTransformations } from '../src/features/core/deviceModeTransformation/transformationHandler';
+import { createPayload } from '../src/features/core/deviceModeTransformation/util';
+import { server } from '../__mocks__/msw.server';
+import {
+  dummyDataplaneHost,
+  dummyWriteKey,
+  samplePageEvent,
+  retryCount,
+  samplePayloadPartialSuccess,
+  actualErrorMessage,
+  samplePayloadSuccess,
+} from '../__mocks__/fixtures';
+
+describe('Test suite for device mode transformation feature', () => {
+  beforeAll(() => {
+    server.listen();
+  });
+
+  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 orginal 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(
+      rest.post(`${dummyDataplaneHost}/serverDown/transform`, (req, res, ctx) => {
+        counter += 1;
+        return res(ctx.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(
+      rest.post(`${dummyDataplaneHost}/success/transform`, (req, res, ctx) => {
+        if (counter === 0) {
+          counter += 1;
+          return res(ctx.status(500));
+        }
+        counter += 1;
+        return res(ctx.status(200), ctx.json(samplePayloadSuccess));
+      }),
+    );
+
+    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/__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);
+  });
+});