iureiure 1.0.0

package/packages/analytics-js/__tests__/components/userSessionManager/utils.test.ts

@@ -0,0 +1,103 @@
+import {
+  hasSessionExpired,
+  generateSessionId,
+  generateAutoTrackingSession,
+  generateManualTrackingSession,
+  MIN_SESSION_ID_LENGTH,
+  isStorageTypeValidForStoringData,
+} from '../../../src/components/userSessionManager/utils';
+import { defaultLogger } from '../../../src/services/Logger';
+
+describe('Utility: User session manager', () => {
+  describe('hasSessionExpired:', () => {
+    it('should return true for valid session', () => {
+      const outcome = hasSessionExpired(Date.now() + 1000);
+      expect(outcome).toEqual(false);
+    });
+    it('hasSessionExpired: should return false for valid session', () => {
+      const outcome = hasSessionExpired(Date.now() - 1000);
+      expect(outcome).toEqual(true);
+    });
+  });
+
+  describe('generateSessionId:', () => {
+    it('should return newly generated session id', () => {
+      const outcome = generateSessionId();
+      expect(typeof outcome).toBe('number');
+      expect(outcome.toString().length).toEqual(13);
+    });
+  });
+  describe('generateAutoTrackingSession:', () => {
+    it('should return newly generated auto tracking session', () => {
+      const timeout = 10 * 60 * 1000;
+      const outcome = generateAutoTrackingSession(timeout);
+      expect(outcome).toEqual({
+        autoTrack: true,
+        timeout,
+        expiresAt: expect.any(Number),
+        id: expect.any(Number),
+        sessionStart: undefined,
+      });
+    });
+  });
+
+  describe('generateManualTrackingSession:', () => {
+    it('should return newly generated manual session', () => {
+      const sessionId = 1234567890;
+      const outcome = generateManualTrackingSession(sessionId);
+      expect(outcome).toEqual({
+        manualTrack: true,
+        id: sessionId,
+        sessionStart: undefined,
+      });
+    });
+    it('should return newly generated manual session if session id is not provided', () => {
+      const outcome = generateManualTrackingSession();
+      expect(outcome).toEqual({
+        manualTrack: true,
+        id: expect.any(Number),
+        sessionStart: undefined,
+      });
+    });
+    it('should print a error message if the provided session id is not a number', () => {
+      const sessionId = '1234567890';
+      defaultLogger.warn = jest.fn();
+      generateManualTrackingSession(sessionId, defaultLogger);
+      expect(defaultLogger.warn).toHaveBeenCalledWith(
+        `UserSessionManager:: The provided session ID (${sessionId}) is either invalid, not a positive integer, or not at least "${MIN_SESSION_ID_LENGTH}" digits long. A new session ID will be auto-generated instead.`,
+      );
+    });
+    it('should print a error message if the provided session id a decimal number', () => {
+      const sessionId = 1234.5;
+      defaultLogger.warn = jest.fn();
+      generateManualTrackingSession(sessionId, defaultLogger);
+      expect(defaultLogger.warn).toHaveBeenCalledWith(
+        `UserSessionManager:: The provided session ID (${sessionId}) is either invalid, not a positive integer, or not at least "${MIN_SESSION_ID_LENGTH}" digits long. A new session ID will be auto-generated instead.`,
+      );
+    });
+    it('should print a error message if the provided session id is not 10 digits', () => {
+      const sessionId = 1234;
+      defaultLogger.warn = jest.fn();
+      generateManualTrackingSession(sessionId, defaultLogger);
+      expect(defaultLogger.warn).toHaveBeenCalledWith(
+        `UserSessionManager:: The provided session ID (${sessionId}) is either invalid, not a positive integer, or not at least "${MIN_SESSION_ID_LENGTH}" digits long. A new session ID will be auto-generated instead.`,
+      );
+    });
+  });
+  describe('isStorageTypeValidForStoringData:', () => {
+    it('should return true only for storage type cookie/LS/memory', () => {
+      const outcome1 = isStorageTypeValidForStoringData('cookieStorage');
+      const outcome2 = isStorageTypeValidForStoringData('localStorage');
+      const outcome3 = isStorageTypeValidForStoringData('memoryStorage');
+      const outcome4 = isStorageTypeValidForStoringData('sessionStorage');
+      const outcome5 = isStorageTypeValidForStoringData('none');
+      const outcome6 = isStorageTypeValidForStoringData('random');
+      expect(outcome1).toEqual(true);
+      expect(outcome2).toEqual(true);
+      expect(outcome3).toEqual(true);
+      expect(outcome4).toEqual(true);
+      expect(outcome5).toEqual(false);
+      expect(outcome6).toEqual(false);
+    });
+  });
+});

package/packages/analytics-js/__tests__/components/utilities/consent.test.ts

@@ -0,0 +1,192 @@
+import { resetState, state } from '@rudderstack/analytics-js/state';
+import {
+  getUserSelectedConsentManager,
+  getValidPostConsentOptions,
+  getConsentManagementData,
+} from '../../../src/components/utilities/consent';
+
+describe('consent utilties', () => {
+  beforeEach(() => {
+    resetState();
+  });
+
+  describe('getUserSelectedConsentManager', () => {
+    it('should return the name of the consent manager if provided in load option', () => {
+      const input1 = {
+        oneTrust: {
+          enabled: true,
+        },
+      };
+      const input2 = {
+        cookieBot: {
+          enabled: true,
+        },
+      };
+      const input3 = {
+        oneTrust: {
+          enabled: false,
+        },
+      };
+      const input4 = {
+        random: {},
+      };
+      const input5 = {};
+      const input6 = 124356;
+      const input7 = null;
+      const input8 = undefined;
+      const expectedOutcome1 = 'oneTrust';
+      const expectedOutcome2 = 'cookieBot';
+      const expectedOutcome3 = undefined;
+      const expectedOutcome4 = undefined;
+      const expectedOutcome5 = undefined;
+      const expectedOutcome6 = undefined;
+      const expectedOutcome7 = undefined;
+      const expectedOutcome8 = undefined;
+      const consentManager1 = getUserSelectedConsentManager(input1);
+      const consentManager2 = getUserSelectedConsentManager(input2);
+      const consentManager3 = getUserSelectedConsentManager(input3);
+      const consentManager4 = getUserSelectedConsentManager(input4);
+      const consentManager5 = getUserSelectedConsentManager(input5);
+      const consentManager6 = getUserSelectedConsentManager(input6);
+      const consentManager7 = getUserSelectedConsentManager(input7);
+      const consentManager8 = getUserSelectedConsentManager(input8);
+      expect(consentManager1).toBe(expectedOutcome1);
+      expect(consentManager2).toBe(expectedOutcome2);
+      expect(consentManager3).toBe(expectedOutcome3);
+      expect(consentManager4).toBe(expectedOutcome4);
+      expect(consentManager5).toBe(expectedOutcome5);
+      expect(consentManager6).toBe(expectedOutcome6);
+      expect(consentManager7).toBe(expectedOutcome7);
+      expect(consentManager8).toBe(expectedOutcome8);
+    });
+  });
+
+  describe('getValidPostConsentOptions', () => {
+    // write tests for this utility function
+    it('should return object with default values if no options are passed', () => {
+      const expectedOutcome = {
+        sendPageEvent: false,
+        trackConsent: false,
+        discardPreConsentEvents: false,
+      };
+      const validOptions = getValidPostConsentOptions();
+      expect(validOptions).toEqual(expectedOutcome);
+    });
+
+    it('should return normalized options object if options are passed', () => {
+      state.consents.enabled.value = true;
+
+      const consentOptions = {
+        integrations: {
+          All: false,
+          GoogleAnalytics: true,
+          Braze: true,
+        },
+        discardPreConsentEvents: true,
+        sendPageEvent: 'false',
+        consentManagement: {
+          allowedConsentIds: ['test1'],
+          deniedConsentIds: ['test2'],
+        },
+      };
+
+      const expectedOutcome = {
+        integrations: {
+          All: false,
+          GoogleAnalytics: true,
+          Braze: true,
+        },
+        discardPreConsentEvents: true,
+        sendPageEvent: false,
+        trackConsent: false,
+        consentManagement: {
+          allowedConsentIds: ['test1'],
+          deniedConsentIds: ['test2'],
+          enabled: true,
+        },
+      };
+
+      const validOptions = getValidPostConsentOptions(consentOptions);
+      expect(validOptions).toEqual(expectedOutcome);
+    });
+
+    it('should return default integrations object if integrations is not an object literal', () => {
+      state.consents.enabled.value = true;
+
+      const consentOptions = {
+        integrations: [], // not an object literal
+      };
+
+      const expectedOutcome = {
+        integrations: {
+          All: true,
+        },
+        discardPreConsentEvents: false,
+        sendPageEvent: false,
+        trackConsent: false,
+      };
+
+      const validOptions = getValidPostConsentOptions(consentOptions);
+      expect(validOptions).toEqual(expectedOutcome);
+    });
+  });
+
+  describe('getConsentManagementData', () => {
+    it('should return an object with default values if no options are passed', () => {
+      const expectedOutcome = {
+        consentManagerPluginName: undefined,
+        initialized: false,
+        enabled: false,
+        consentsData: {
+          allowedConsentIds: [],
+          deniedConsentIds: [],
+        },
+      };
+      const validOptions = getConsentManagementData();
+      expect(validOptions).toEqual(expectedOutcome);
+    });
+
+    it('should return consent management data based on the options provided', () => {
+      const consentOptions = {
+        enabled: true,
+        provider: 'oneTrust',
+        allowedConsentIds: ['test1'],
+        deniedConsentIds: ['test2'],
+      };
+
+      const expectedOutcome = {
+        consentManagerPluginName: 'OneTrustConsentManager',
+        initialized: true,
+        enabled: true,
+        consentsData: {
+          allowedConsentIds: ['test1'],
+          deniedConsentIds: ['test2'],
+        },
+        provider: 'oneTrust',
+      };
+
+      const validOptions = getConsentManagementData(consentOptions);
+      expect(validOptions).toEqual(expectedOutcome);
+    });
+
+    it('should log an error if the consent provider is not supported', () => {
+      const consentOptions = {
+        enabled: true,
+        provider: 'random',
+      };
+
+      const expectedOutcome = {
+        consentManagerPluginName: undefined,
+        initialized: false,
+        enabled: false,
+        consentsData: {
+          allowedConsentIds: [],
+          deniedConsentIds: [],
+        },
+      };
+
+      const validOptions = getConsentManagementData(consentOptions);
+      expect(validOptions).toEqual(expectedOutcome);
+    });
+  });
+});

package/packages/analytics-js/__tests__/components/utilities/destinations.test.ts

@@ -0,0 +1,201 @@
+import { ConfigResponseDestinationItem } from '../../../src/components/configManager/types';
+import { filterEnabledDestination } from '../../../src/components/utilities/destinations';
+
+const sampleDestinationResponse1: ConfigResponseDestinationItem[] = [
+  {
+    config: {
+      measurementId: 'G-SC6JGSYH6H',
+      capturePageView: 'rs',
+      whitelistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      blacklistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      useNativeSDKToSend: false,
+      eventFilteringOption: 'disable',
+      extendPageViewParams: false,
+      oneTrustCookieCategories: [],
+    },
+    id: '2LoR1TbVG2bcISXvy7DamldfkgO',
+    name: 'GA4 for JS SDK',
+    updatedAt: '2023-03-14T11:34:29.216Z',
+    enabled: true,
+    deleted: false,
+    destinationDefinition: {
+      name: 'GA4',
+      displayName: 'Google Analytics 4 (GA4)',
+      updatedAt: '2023-03-14T11:21:29.656Z',
+    },
+    shouldApplyDeviceModeTransformation: true,
+    propagateEventsUntransformedOnError: false,
+  },
+  {
+    config: {
+      measurementId: 'G-SC6JGSYH6H',
+      capturePageView: 'rs',
+      whitelistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      blacklistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      useNativeSDKToSend: false,
+      eventFilteringOption: 'disable',
+      extendPageViewParams: false,
+      oneTrustCookieCategories: [],
+    },
+    id: '2LoR1TbVG2bcISXvy7Damldfkg1',
+    name: 'Braze for JS SDK',
+    updatedAt: '2023-03-14T11:34:29.216Z',
+    enabled: true,
+    deleted: false,
+    destinationDefinition: {
+      name: 'BRAZE',
+      displayName: 'Braze',
+      updatedAt: '2023-03-14T11:21:29.656Z',
+    },
+    shouldApplyDeviceModeTransformation: false,
+    propagateEventsUntransformedOnError: false,
+  },
+];
+
+const sampleDestinationResponse2: ConfigResponseDestinationItem[] = [
+  {
+    config: {
+      measurementId: 'G-SC6JGSYH6H',
+      capturePageView: 'rs',
+      whitelistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      blacklistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      useNativeSDKToSend: false,
+      eventFilteringOption: 'disable',
+      extendPageViewParams: false,
+      oneTrustCookieCategories: [],
+    },
+    id: '2LoR1TbVG2bcISXvy7DamldfkgO',
+    name: 'GA4 for JS SDK',
+    updatedAt: '2023-03-14T11:34:29.216Z',
+    enabled: true,
+    deleted: true,
+    destinationDefinition: {
+      name: 'GA4',
+      displayName: 'Google Analytics 4 (GA4)',
+      updatedAt: '2023-03-14T11:21:29.656Z',
+    },
+    shouldApplyDeviceModeTransformation: true,
+    propagateEventsUntransformedOnError: false,
+  },
+  {
+    config: {
+      measurementId: 'G-SC6JGSYH6H',
+      capturePageView: 'rs',
+      whitelistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      blacklistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      useNativeSDKToSend: false,
+      eventFilteringOption: 'disable',
+      extendPageViewParams: false,
+      oneTrustCookieCategories: [],
+    },
+    id: '2LoR1TbVG2bcISXvy7Damldfkg1',
+    name: 'Braze for JS SDK',
+    updatedAt: '2023-03-14T11:34:29.216Z',
+    enabled: true,
+    deleted: true,
+    destinationDefinition: {
+      name: 'BRAZE',
+      displayName: 'Braze',
+      updatedAt: '2023-03-14T11:21:29.656Z',
+    },
+    shouldApplyDeviceModeTransformation: false,
+    propagateEventsUntransformedOnError: false,
+  },
+];
+
+const expectedFilteredDestinations = [
+  {
+    id: '2LoR1TbVG2bcISXvy7DamldfkgO',
+    displayName: 'Google Analytics 4 (GA4)',
+    shouldApplyDeviceModeTransformation: true,
+    propagateEventsUntransformedOnError: false,
+    config: {
+      measurementId: 'G-SC6JGSYH6H',
+      capturePageView: 'rs',
+      whitelistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      blacklistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      useNativeSDKToSend: false,
+      eventFilteringOption: 'disable',
+      extendPageViewParams: false,
+      oneTrustCookieCategories: [],
+    },
+    userFriendlyId: 'Google-Analytics-4-(GA4)___2LoR1TbVG2bcISXvy7DamldfkgO',
+  },
+  {
+    id: '2LoR1TbVG2bcISXvy7Damldfkg1',
+    displayName: 'Braze',
+    shouldApplyDeviceModeTransformation: false,
+    propagateEventsUntransformedOnError: false,
+    config: {
+      measurementId: 'G-SC6JGSYH6H',
+      capturePageView: 'rs',
+      whitelistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      blacklistedEvents: [
+        {
+          eventName: '',
+        },
+      ],
+      useNativeSDKToSend: false,
+      eventFilteringOption: 'disable',
+      extendPageViewParams: false,
+      oneTrustCookieCategories: [],
+    },
+    userFriendlyId: 'Braze___2LoR1TbVG2bcISXvy7Damldfkg1',
+  },
+];
+
+describe('Config manager util - filterEnabledDestination', () => {
+  it('should return enabled destinations in specific format', () => {
+    const actualOutcome = filterEnabledDestination(sampleDestinationResponse1);
+    expect(actualOutcome).toStrictEqual(expectedFilteredDestinations);
+  });
+
+  it('should not return deleted destinations', () => {
+    const actualOutcome = filterEnabledDestination(sampleDestinationResponse2);
+    expect(actualOutcome).toStrictEqual([]);
+  });
+});

package/packages/analytics-js/__tests__/components/utilities/event.test.ts

@@ -0,0 +1,8 @@
+import { isEvent } from '../../../src/components/utilities/event';
+
+describe('Common Utils - Event', () => {
+  it('should check if is Event or Error', () => {
+    expect(isEvent(new Event('dummyEvent'))).toBeTruthy();
+    expect(isEvent(new Error('dummyEvent'))).toBeFalsy();
+  });
+});

package/packages/analytics-js/__tests__/components/utilities/globals.test.ts

@@ -0,0 +1,42 @@
+import {
+  createExposedGlobals,
+  getExposedGlobal,
+  setExposedGlobal,
+} from '../../../src/components/utilities/globals';
+
+describe('Common Utils - Globals', () => {
+  afterEach(() => {
+    delete (window as any).RudderStackGlobals;
+  });
+
+  it('should create global object namespace in window', () => {
+    createExposedGlobals();
+    createExposedGlobals('dummyName');
+    expect((window as any).RudderStackGlobals).toStrictEqual({
+      app: {},
+      dummyName: {},
+    });
+  });
+
+  it('should set global object value', () => {
+    expect((window as any).RudderStackGlobals).toBeUndefined();
+
+    setExposedGlobal('dummyName', true);
+    expect((window as any).RudderStackGlobals).toStrictEqual({
+      app: {
+        dummyName: true,
+      },
+    });
+  });
+
+  it('should get global object value', () => {
+    (window as any).RudderStackGlobals = {
+      dummyName: {
+        dummyKeyName: true,
+      },
+    };
+
+    getExposedGlobal('dummyKeyName', 'dummyName');
+    expect((window as any).RudderStackGlobals).toBeTruthy();
+  });
+});