iureiure 1.0.0

package/packages/analytics-v1.1/__tests__/data-residency.test.js

@@ -0,0 +1,236 @@
+import { resolveDataPlaneUrl } from '../src/utils/utils';
+
+const usDataplaneUrl = 'https://sample.rudderlabs.com/us';
+const euDataplaneUrl = 'https://sample.rudderlabs.com/eu';
+const serverUrl = 'https://sample.rudderlabs.com';
+
+const sourceConfigWithBothDataPlane = {
+  source: {
+    dataplanes: {
+      US: [
+        {
+          url: usDataplaneUrl,
+          default: true,
+        },
+      ],
+      EU: [
+        {
+          url: euDataplaneUrl,
+          default: true,
+        },
+      ],
+    },
+  },
+};
+
+const sourceConfigWithUSDataPlane = {
+  source: {
+    dataplanes: {
+      US: [
+        {
+          url: usDataplaneUrl,
+          default: true,
+        },
+      ],
+    },
+  },
+};
+
+const sourceConfigWithEUDataPlane = {
+  source: {
+    dataplanes: {
+      EU: [
+        {
+          url: euDataplaneUrl,
+          default: true,
+        },
+      ],
+    },
+  },
+};
+const sourceConfigWithEmptyDataPlanes = { source: {} };
+
+const invalidResidencyServer1 = { residencyServer: 1234 };
+const invalidResidencyServer2 = { residencyServer: 'test' };
+const validResidencyServerUS = { residencyServer: 'US' };
+const validResidencyServerEU = { residencyServer: 'EU' };
+
+const testCaseData = [
+  // {
+  //   description:
+  //     'When dataplane is not provided in source config or in load API, default dataplane Url will be selected',
+  //   input: {
+  //     response: sourceConfigWithEmptyDataPlanes,
+  //   },
+  //   output: DEFAULT_DATAPLANE_URL,
+  // },
+  {
+    description:
+      'When dataplane is not provided in source config but provided in load API, dataplane Url from load option will be selected',
+    input: {
+      response: sourceConfigWithEmptyDataPlanes,
+      serverUrl: serverUrl,
+    },
+    output: serverUrl,
+  },
+  {
+    description: 'When dataplane is provided in source config that dataplane Url will be selected',
+    input: {
+      response: sourceConfigWithBothDataPlane,
+      serverUrl: serverUrl,
+    },
+    output: usDataplaneUrl,
+  },
+  // {
+  //   description:
+  //     'In case of invalid residencyServer option: dataplane is not provided in source config or in load API, default dataplane Url will be selected',
+  //   input: {
+  //     response: sourceConfigWithEmptyDataPlanes,
+  //     options: invalidResidencyServer1,
+  //   },
+  //   output: DEFAULT_DATAPLANE_URL,
+  // },
+  {
+    description:
+      'In case of invalid residencyServer option: dataplane is not provided in source config but provided in load API, dataplane Url from load option will be selected',
+    input: {
+      response: sourceConfigWithEmptyDataPlanes,
+      serverUrl: serverUrl,
+      options: invalidResidencyServer2,
+    },
+    output: serverUrl,
+  },
+  {
+    description:
+      'In case of invalid residencyServer option: dataplane is provided in source config that dataplane Url will be selected',
+    input: {
+      response: sourceConfigWithBothDataPlane,
+      serverUrl: serverUrl,
+      options: invalidResidencyServer1,
+    },
+    output: usDataplaneUrl,
+  },
+  // {
+  //   description:
+  //     'In case of valid residencyServer(US) option: dataplane is not provided in source config or in load API, default dataplane Url will be selected',
+  //   input: {
+  //     response: sourceConfigWithEmptyDataPlanes,
+  //     options: validResidencyServerUS,
+  //   },
+  //   output: DEFAULT_DATAPLANE_URL,
+  // },
+  {
+    description:
+      'In case of valid residencyServer(US) option: dataplane is not provided in source config but provided in load API, dataplane Url from load option will be selected',
+    input: {
+      response: sourceConfigWithEmptyDataPlanes,
+      serverUrl: serverUrl,
+      options: validResidencyServerUS,
+    },
+    output: serverUrl,
+  },
+  {
+    description:
+      'In case of valid residencyServer(US) option: dataplane is provided in source config that dataplane Url will be selected',
+    input: {
+      response: sourceConfigWithBothDataPlane,
+      serverUrl: serverUrl,
+      options: validResidencyServerUS,
+    },
+    output: usDataplaneUrl,
+  },
+  {
+    description:
+      'In case of valid residencyServer(US) option: dataplane is provided but US region not available in source config then load API dataplane Url will be selected',
+    input: {
+      response: sourceConfigWithEUDataPlane,
+      serverUrl: serverUrl,
+      options: validResidencyServerUS,
+    },
+    output: serverUrl,
+  },
+  // {
+  //   description:
+  //     'In case of valid residencyServer(EU) option: dataplane is not provided in source config or in load API, default dataplane Url will be selected',
+  //   input: {
+  //     response: sourceConfigWithEmptyDataPlanes,
+  //     options: validResidencyServerEU,
+  //   },
+  //   output: DEFAULT_DATAPLANE_URL,
+  // },
+  {
+    description:
+      'In case of valid residencyServer(EU) option: dataplane is not provided in source config but provided in load API, dataplane Url from load option will be selected',
+    input: {
+      response: sourceConfigWithEmptyDataPlanes,
+      serverUrl: serverUrl,
+      options: validResidencyServerEU,
+    },
+    output: serverUrl,
+  },
+  {
+    description:
+      'In case of valid residencyServer(EU) option: dataplane is provided in source config that dataplane Url will be selected',
+    input: {
+      response: sourceConfigWithBothDataPlane,
+      serverUrl: serverUrl,
+      options: validResidencyServerEU,
+    },
+    output: euDataplaneUrl,
+  },
+  {
+    description:
+      'In case of valid residencyServer(EU) option: dataplane is provided only for US region not available in source config then US region dataplane Url will be selected',
+    input: {
+      response: sourceConfigWithUSDataPlane,
+      serverUrl: serverUrl,
+      options: validResidencyServerEU,
+    },
+    output: usDataplaneUrl,
+  },
+];
+
+const testCaseDataWithInvalidDataplaneUrl = [
+  {
+    description:
+      'When dataplane is not provided in source config or in load API, default dataplane Url will be selected',
+    input: {
+      response: sourceConfigWithEmptyDataPlanes,
+      serverUrl: null,
+    },
+  },
+  {
+    description:
+      'In case of invalid residencyServer option: dataplane is not provided in source config or in load API, default dataplane Url will be selected',
+    input: {
+      response: sourceConfigWithEmptyDataPlanes,
+      options: invalidResidencyServer1,
+    },
+  },
+  {
+    description:
+      'In case of valid residencyServer(US) option: dataplane is not provided in source config or in load API, default dataplane Url will be selected',
+    input: {
+      response: sourceConfigWithEmptyDataPlanes,
+      options: validResidencyServerUS,
+    },
+  },
+  {
+    description:
+      'In case of valid residencyServer(EU) option: dataplane is not provided in source config or in load API, default dataplane Url will be selected',
+    input: {
+      response: sourceConfigWithEmptyDataPlanes,
+      options: validResidencyServerEU,
+    },
+  },
+];
+
+test.each(testCaseData)('$description', ({ input, output }) => {
+  const url = resolveDataPlaneUrl(input.response, input.serverUrl, input.options);
+  expect(url).toEqual(output);
+});
+
+test.each(testCaseDataWithInvalidDataplaneUrl)('$description', ({ input }) => {
+  const url = () => resolveDataPlaneUrl(input.response, input.serverUrl, input.options);
+  expect(url).toThrow('Unable to load the SDK due to invalid data plane url');
+});

package/packages/analytics-v1.1/__tests__/features/core/metrics/errorReporting/ErrorReportingService.test.js

@@ -0,0 +1,80 @@
+import { logger } from '@rudderstack/analytics-js-common/v1.1/utils/logUtil';
+import { ErrorReportingService } from '../../../../../src/features/core/metrics/errorReporting/ErrorReportingService';
+
+const errorReportingService = new ErrorReportingService(logger);
+const DEFAULT_ERROR_REPORT_PROVIDER = 'rs-bugsnag';
+const sourceId = 'random-source-id';
+
+describe('Error reporting service Test suite', () => {
+  test('Should print error message and return if source config or sourceId is not provided in init call', () => {
+    const outcome = errorReportingService.init();
+    expect(outcome).toBe(undefined);
+  });
+  test('Should not initialize provider if not enabled from source config in init call', () => {
+    errorReportingService.init({ statsCollection: { errors: { enabled: false } } }, sourceId);
+    expect(errorReportingService.isEnabled).toEqual(false);
+  });
+  test('Should initialize provider if enabled from source config in init call', async () => {
+    errorReportingService.init({ statsCollection: { errors: { enabled: true } } }, sourceId);
+    expect(errorReportingService.isEnabled).toEqual(true);
+  });
+  test('Should initialize default provider if enabled from source config but provider name is not there', async () => {
+    window.bugsnag = jest.fn(() => ({ notifier: { version: '6.0.0' } }));
+    errorReportingService.exposeToGlobal = jest.fn();
+    errorReportingService.onClientReady = jest.fn(() => errorReportingService.exposeToGlobal());
+    errorReportingService.init({ statsCollection: { errors: { enabled: true } } }, sourceId);
+    expect(errorReportingService.providerName).toEqual(DEFAULT_ERROR_REPORT_PROVIDER);
+    expect(errorReportingService.onClientReady).toHaveBeenCalledTimes(1);
+    expect(errorReportingService.exposeToGlobal).toHaveBeenCalledTimes(1);
+  });
+  test('Should not initialize provider if provider from source config does not match with SDK supported list', async () => {
+    window.bugsnag = undefined;
+    errorReportingService.init(
+      { statsCollection: { errors: { enabled: true, provider: 'test' } } },
+      sourceId,
+    );
+    expect(errorReportingService.provider.client).toEqual(undefined);
+    expect(errorReportingService.onClientReady).toHaveBeenCalledTimes(0);
+  });
+  test('Should not initialize provider if the enabled flag is missing from the source config (default state is to not load)', async () => {
+    window.bugsnag = undefined;
+    errorReportingService.init({ statsCollection: { errors: { provider: 'test' } } }, sourceId);
+    expect(errorReportingService.provider.client).toEqual(undefined);
+    expect(errorReportingService.onClientReady).toHaveBeenCalledTimes(0);
+  });
+  test('Should not initialize provider if the error collection enabled flag is not a boolean', async () => {
+    window.bugsnag = undefined;
+    errorReportingService.init(
+      { statsCollection: { errors: { enabled: 'true', provider: 'test' } } },
+      sourceId,
+    );
+    expect(errorReportingService.provider.client).toEqual(undefined);
+    expect(errorReportingService.onClientReady).toHaveBeenCalledTimes(0);
+  });
+});
+
+describe('Bugsnag Test suite', () => {
+  test('Should not initialize bugsnag if version > 6 of bugsnag is present in window scope', async () => {
+    window.bugsnag = { _client: { _notifier: { version: '7.0.0' } } };
+    errorReportingService.init({ statsCollection: { errors: { enabled: true } } }, sourceId);
+    expect(errorReportingService.provider.client).toEqual(undefined);
+  });
+  test('Should not initialize bugsnag if version <6 of bugsnag is present in window scope', async () => {
+    window.bugsnag = jest.fn(() => ({ notifier: { version: '4.0.0' } }));
+    errorReportingService.init({ statsCollection: { errors: { enabled: true } } }, sourceId);
+    expect(errorReportingService.provider.client).toEqual(undefined);
+  });
+  test('Should initialize bugsnag if version 6 of bugsnag is present in window scope', async () => {
+    window.bugsnag = jest.fn(() => ({ notifier: { version: '6.0.0' } }));
+    errorReportingService.init({ statsCollection: { errors: { enabled: true } } }, sourceId);
+    expect(errorReportingService.provider.client).not.toBe(undefined);
+  });
+  test('Should initialize Bugsnag if provider from source config matches with SDK supported list', async () => {
+    window.bugsnag = jest.fn(() => ({ notifier: { version: '6.0.0' } }));
+    errorReportingService.init(
+      { statsCollection: { errors: { enabled: true, provider: 'rs-bugsnag' } } },
+      sourceId,
+    );
+    expect(errorReportingService.provider.client).not.toEqual(undefined);
+  });
+});

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

@@ -0,0 +1,49 @@
+import { Ketch } from '../src/features/core/cookieConsent/ketch';
+
+window.ketchConsent = {
+  analytics: true,
+  email_mktg: false,
+  behavioral_advertising: false,
+};
+
+const expectedDeniedPurposes = ['email_mktg', 'behavioral_advertising'];
+
+const ketch = new Ketch();
+
+describe('Test suit for Ketch consent manager', () => {
+  it('Should allow events when no category is set in destination config', () => {
+    const destConfig = {};
+    const allowEvent = ketch.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should allow events when purpose in destination config is present in consented categories', () => {
+    const destConfig = {
+      ketchConsentPurposes: [{ purpose: 'analytics' }],
+    };
+    const allowEvent = ketch.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should not allow events when consented category name is not present in destination config', () => {
+    const destConfig = {
+      ketchConsentPurposes: [{ purpose: 'performance' }],
+    };
+    const allowEvent = ketch.isEnabled(destConfig);
+    expect(allowEvent).toBe(false);
+  });
+
+  it('Should not allow events when all the category IDs in destination config present in consented category IDs', () => {
+    const destConfig = {
+      ketchConsentPurposes: [{ purpose: 'analytics' }, { purpose: 'email_mktg' }],
+    };
+    const allowEvent = ketch.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should return the category IDs that the user has not consented for', () => {
+    const actualDeniedPurposes = ketch.getDeniedList();
+    expect(actualDeniedPurposes).toEqual(expectedDeniedPurposes);
+  });
+  it('Should return the category IDs that the user has not consented for', () => {
+    const actualDeniedPurposes = ketch.getDeniedList();
+    expect(actualDeniedPurposes).toEqual(expectedDeniedPurposes);
+  });
+});

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

@@ -0,0 +1,89 @@
+import { OneTrust } from '../src/features/core/cookieConsent/OneTrust';
+
+window.OneTrust = {
+  GetDomainData: jest.fn(() => ({
+    Groups: [
+      { CustomGroupId: 'C0001', GroupName: 'Functional Cookies' },
+      { CustomGroupId: 'C0002', GroupName: 'Performance Cookies' },
+      { CustomGroupId: 'C0003', GroupName: 'Analytical Cookies' },
+      { CustomGroupId: 'C0004', GroupName: 'Targeting Cookies' },
+      { CustomGroupId: 'C0005', GroupName: 'Social Media Cookies' },
+      { CustomGroupId: 'C0006', GroupName: 'Advertisement Cookies' },
+    ],
+  })),
+};
+window.OnetrustActiveGroups = ',C0001,C0003,';
+
+const expectedDeniedConsentIds = ['C0002', 'C0004', 'C0005', 'C0006'];
+
+const oneTrust = new OneTrust();
+
+describe('Test suit for OneTrust cookie consent manager', () => {
+  it('Should allow events when no category is set in destination config', () => {
+    const destConfig = {};
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should allow events when oneTrustCookieCategory in destination config is present in consented categories', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [{ oneTrustCookieCategory: 'analytical cookies' }],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should allow events when category ID in destination config is present in consented category IDs', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [{ oneTrustCookieCategory: 'c0003' }],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should allow events when category ID and name both is present in destination config and present in consented categories', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [
+        { oneTrustCookieCategory: 'c0001' },
+        { oneTrustCookieCategory: 'Analytical Cookies' },
+      ],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(true);
+  });
+  it('Should not allow events when consented category name is not present in destination config', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [{ oneTrustCookieCategory: 'Performance Cookies' }],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(false);
+  });
+  it('Should not allow events when consented category ID is not present in destination config', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [{ oneTrustCookieCategory: 'c0005' }],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(false);
+  });
+  it('Should not allow events when all the category IDs in destination config present in consented category IDs', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [
+        { oneTrustCookieCategory: 'c0001' },
+        { oneTrustCookieCategory: 'c0005' },
+      ],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(false);
+  });
+  it('Should not allow events when all the category IDs/names in destination config present in consented category IDs/names', () => {
+    const destConfig = {
+      oneTrustCookieCategories: [
+        { oneTrustCookieCategory: 'analytical cookies' },
+        { oneTrustCookieCategory: 'c0005' },
+      ],
+    };
+    const allowEvent = oneTrust.isEnabled(destConfig);
+    expect(allowEvent).toBe(false);
+  });
+  it('Should return the category IDs that the user has not consented for', () => {
+    const actualDeniedConsentIds = oneTrust.getDeniedList();
+    expect(actualDeniedConsentIds).toEqual(expectedDeniedConsentIds);
+  });
+});

package/packages/analytics-v1.1/__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 = ` `;
+    rudderanalytics = window.rudderanalytics = [];
+    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];
+      rudderanalytics[method] = (function (d) {
+        return function () {
+          rudderanalytics.push([d, ...arguments]);
+        };
+      })(method);
+    }
+    rudderanalytics.load('WRITE_KEY', 'DATA_PLANE_URL');
+    require('../__mocks__/cdnSDK.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();
+    rudderanalytics.page();
+    require('../__mocks__/cdnSDK.js');
+
+    expect(global.rudderanalytics.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', () => {
+    rudderanalytics.page();
+    rudderanalytics.track('test-event');
+    rudderanalytics.identify('jest-user');
+    rudderanalytics.group('jest-group');
+    rudderanalytics.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 = rudderanalytics.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 = rudderanalytics.getAnonymousId();
+
+      // SDK remembers the previously generated anonymous ID and returns the same value
+      const anonIdRes2 = rudderanalytics.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)
+      rudderanalytics.identify(userId, userTraits);
+      rudderanalytics.group(groupUserId, groupTraits);
+
+      const anonId = 'jest-anon-ID';
+      rudderanalytics.setAnonymousId(anonId);
+
+      // SDK clears all the persisted data except for anonymous ID
+      rudderanalytics.reset();
+
+      // SDK remembers the previously generated anonymous ID and returns the same value
+      const anonIdRes = rudderanalytics.getAnonymousId();
+
+      expect(anonId).toEqual(anonIdRes);
+      expect(rudderanalytics.getUserId()).toEqual('');
+      expect(rudderanalytics.getUserTraits()).toEqual({});
+      expect(rudderanalytics.getGroupId()).toEqual('');
+      expect(rudderanalytics.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)
+      rudderanalytics.identify(userId, userTraits);
+      rudderanalytics.group(groupUserId, groupTraits);
+
+      const anonId = 'jest-anon-ID';
+      rudderanalytics.setAnonymousId(anonId);
+
+      // SDK clears all the persisted data
+      rudderanalytics.reset(true);
+
+      // SDK remembers the previously generated anonymous ID and returns the same value
+      const anonIdRes = rudderanalytics.getAnonymousId();
+
+      expect(anonId).not.toEqual(anonIdRes);
+      expect(rudderanalytics.getUserId()).toEqual('');
+      expect(rudderanalytics.getUserTraits()).toEqual({});
+      expect(rudderanalytics.getGroupId()).toEqual('');
+      expect(rudderanalytics.getGroupTraits()).toEqual({});
+    });
+  });
+});