iureiure 1.0.0

package/packages/analytics-js-plugins/__tests__/nativeDestinationQueue/utilities.test.ts

@@ -0,0 +1,98 @@
+import { clone } from 'ramda';
+import { isEventDenyListed } from '../../src/nativeDestinationQueue/utilities';
+
+describe('nativeDestinationQueue Plugin - utilities', () => {
+  describe('isEventDenyListed', () => {
+    const mockDestination = {
+      id: 'sample-destination-id',
+      displayName: 'Destination Display Name',
+      userFriendlyId: 'ID_sample-destination-id',
+      areTransformationsConnected: false,
+      config: {
+        blacklistedEvents: [{ eventName: 'sample track event 2' }],
+        whitelistedEvents: [{ eventName: 'sample track event 1' }],
+        oneTrustCookieCategories: [{ oneTrustCookieCategory: '' }],
+        eventFilteringOption: 'whitelistedEvents',
+      },
+      instance: {
+        name: 'DEST_NAME', // this is same as the definition name
+        destinationId: 'sample-destination-id',
+        areTransformationsConnected: false,
+        analytics: {},
+        isLoaded: () => true,
+      },
+    };
+
+    it('should return false if the event type is not track', () => {
+      const outcome1 = isEventDenyListed('identify', undefined, mockDestination);
+      const outcome2 = isEventDenyListed('page', undefined, mockDestination);
+      const outcome3 = isEventDenyListed('group', undefined, mockDestination);
+      const outcome4 = isEventDenyListed('alias', undefined, mockDestination);
+
+      expect(outcome1).toBeFalsy();
+      expect(outcome2).toBeFalsy();
+      expect(outcome3).toBeFalsy();
+      expect(outcome4).toBeFalsy();
+    });
+
+    it('should return false if deny list is selected and track event does not have event name property', () => {
+      const mockDest = clone(mockDestination);
+      mockDest.config.eventFilteringOption = 'blacklistedEvents';
+
+      const outcome1 = isEventDenyListed('track', undefined, mockDest);
+      expect(outcome1).toBeFalsy();
+    });
+    it('should return false if deny list is selected and track event name is not string', () => {
+      const mockDest = clone(mockDestination);
+      mockDest.config.eventFilteringOption = 'blacklistedEvents';
+
+      const outcome1 = isEventDenyListed('track', true, mockDest);
+      const outcome2 = isEventDenyListed('track', 12345, mockDest);
+      expect(outcome1).toBeFalsy();
+      expect(outcome2).toBeFalsy();
+    });
+    it('should return true if deny list is selected and track event name matches with denylist event name', () => {
+      const mockDest = clone(mockDestination);
+      mockDest.config.eventFilteringOption = 'blacklistedEvents';
+
+      const outcome1 = isEventDenyListed('track', 'sample track event 2', mockDest);
+      expect(outcome1).toBeTruthy();
+    });
+    it('should return false if deny list is selected and track event name does not matches with denylist event name', () => {
+      const mockDest = clone(mockDestination);
+      mockDest.config.eventFilteringOption = 'blacklistedEvents';
+
+      const outcome1 = isEventDenyListed('track', 'sample track event 1234', mockDest);
+      expect(outcome1).toBeFalsy();
+    });
+    it('should return false if deny list is selected and track event name is in different case than with denylist event name', () => {
+      const mockDest = clone(mockDestination);
+      mockDest.config.eventFilteringOption = 'blacklistedEvents';
+
+      const outcome1 = isEventDenyListed('track', 'Sample track event 2', mockDest);
+      expect(outcome1).toBeFalsy();
+    });
+    it('should return true if allow list is selected and track event does not have event name property', () => {
+      const outcome1 = isEventDenyListed('track', undefined, mockDestination);
+      expect(outcome1).toBeTruthy();
+    });
+    it('should return true if allow list is selected and track event name is not string', () => {
+      const outcome1 = isEventDenyListed('track', true, mockDestination);
+      const outcome2 = isEventDenyListed('track', 12345, mockDestination);
+      expect(outcome1).toBeTruthy();
+      expect(outcome2).toBeTruthy();
+    });
+    it('should return false if allow list is selected and track event name matches with allowlist event name', () => {
+      const outcome1 = isEventDenyListed('track', 'sample track event 1', mockDestination);
+      expect(outcome1).toBeFalsy();
+    });
+    it('should return true if allow list is selected and track event name does not matches with allowlist event name', () => {
+      const outcome1 = isEventDenyListed('track', 'sample track event 1234', mockDestination);
+      expect(outcome1).toBeTruthy();
+    });
+    it('should return true if allow list is selected and track event name is in different case than with with allowlist event name', () => {
+      const outcome1 = isEventDenyListed('track', 'Sample track event 1', mockDestination);
+      expect(outcome1).toBeTruthy();
+    });
+  });
+});

package/packages/analytics-js-plugins/__tests__/oneTrustConsentManager/index.test.ts

@@ -0,0 +1,395 @@
+import { state, resetState } from '@rudderstack/analytics-js/state';
+import { OneTrustConsentManager } from '../../src/oneTrustConsentManager';
+
+describe('Plugin - OneTrustConsentManager', () => {
+  beforeEach(() => {
+    resetState();
+    delete (window as any).OneTrust;
+    delete (window as any).OnetrustActiveGroups;
+  });
+
+  const mockLogger = {
+    error: jest.fn(),
+    warn: jest.fn(),
+    log: jest.fn(),
+  };
+
+  const mockErrorHandler = {
+    onError: jest.fn(),
+  };
+
+  it('should add OneTrustConsentManager plugin in the loaded plugin list', () => {
+    OneTrustConsentManager().initialize(state);
+    expect(state.plugins.loadedPlugins.value.includes('OneTrustConsentManager')).toBe(true);
+  });
+
+  it('should update the consent info if OneTrust SDK is already loaded', () => {
+    // Mock the OneTrust data on the window object
+    (window as any).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 as any).OnetrustActiveGroups = ',C0001,C0003,';
+
+    // Initialize the plugin
+    OneTrustConsentManager().consentManager.init(state, mockLogger);
+
+    // Update the consent info from state
+    OneTrustConsentManager().consentManager.updateConsentsInfo(state, undefined, mockLogger);
+
+    expect(state.consents.initialized.value).toBe(true);
+    expect(state.consents.data.value).toStrictEqual({
+      allowedConsentIds: ['C0001', 'C0003'],
+      deniedConsentIds: ['C0002', 'C0004', 'C0005', 'C0006'],
+    });
+  });
+
+  it('should not successfully update consents data the plugin if OneTrust SDK is not loaded', () => {
+    // Initialize the plugin
+    OneTrustConsentManager().consentManager.init(state, mockLogger);
+
+    // Update the consent info from state
+    OneTrustConsentManager().consentManager.updateConsentsInfo(state, undefined, mockLogger);
+
+    expect(state.consents.initialized.value).toStrictEqual(false);
+    expect(mockLogger.error).toHaveBeenCalledWith(
+      `OneTrustConsentManagerPlugin:: Failed to access OneTrust SDK resources. Please ensure that the OneTrust SDK is loaded successfully before RudderStack SDK.`,
+    );
+  });
+
+  it('should return true if destination specific category is consented', () => {
+    state.consents.initialized.value = true;
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      oneTrustCookieCategories: [
+        {
+          oneTrustCookieCategory: 'C0001',
+        },
+        {
+          oneTrustCookieCategory: 'C0003',
+        },
+        {
+          oneTrustCookieCategory: '',
+        },
+      ],
+      key: 'value',
+    };
+
+    const isDestinationConsented = OneTrustConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(true);
+  });
+
+  it('should return true if plugin is not initialized', () => {
+    state.consents.initialized.value = false;
+
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      oneTrustCookieCategories: [
+        {
+          oneTrustCookieCategory: 'C0001',
+        },
+        {
+          oneTrustCookieCategory: '',
+        },
+      ],
+      key: 'value',
+    };
+
+    const isDestinationConsented = OneTrustConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(true);
+  });
+
+  it('should return true if destination config does not have any mapping', () => {
+    state.consents.initialized.value = true;
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      key: 'value',
+    };
+
+    const isDestinationConsented = OneTrustConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(true);
+  });
+
+  it('should return false if destination categories are not consented', () => {
+    state.consents.initialized.value = true;
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      oneTrustCookieCategories: [
+        {
+          oneTrustCookieCategory: 'C0001',
+        },
+        {
+          oneTrustCookieCategory: 'C0004',
+        },
+      ],
+      key: 'value',
+    };
+    const isDestinationConsented = OneTrustConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(false);
+  });
+
+  it('should return true and log error if an exception occurs during destination consent status check', () => {
+    state.consents.initialized.value = true;
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      oneTrustCookieCategories: {}, // Invalid config
+      key: 'value',
+    };
+
+    const isDestinationConsented = OneTrustConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(true);
+    expect(mockErrorHandler.onError).toHaveBeenCalledWith(
+      new TypeError('oneTrustCookieCategories.map is not a function'),
+      'OneTrustConsentManagerPlugin',
+      'Failed to determine the consent status for the destination. Please check the destination configuration and try again.',
+    );
+  });
+
+  it('should return false if the destination categories are not consented in generic consent management config', () => {
+    state.consents.initialized.value = true;
+    state.consents.resolutionStrategy.value = 'and';
+    state.consents.provider.value = 'oneTrust';
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      consentManagement: [
+        {
+          provider: 'oneTrust',
+          consents: [
+            {
+              consent: 'C0001',
+            },
+            {
+              consent: 'C0004',
+            },
+          ],
+        },
+        {
+          provider: 'ketch',
+          consents: [
+            {
+              consent: 'C0003',
+            },
+          ],
+        },
+      ],
+    };
+    const isDestinationConsented = OneTrustConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(false);
+  });
+
+  it("should return true if the active consent provider's configuration data is not present in the destination config", () => {
+    state.consents.initialized.value = true;
+    state.consents.resolutionStrategy.value = 'and';
+    state.consents.provider.value = 'oneTrust';
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      consentManagement: [
+        {
+          provider: 'ketch',
+          consents: [
+            {
+              consent: 'C0003',
+            },
+          ],
+        },
+      ],
+    };
+    const isDestinationConsented = OneTrustConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(true);
+  });
+
+  it('should return true if all the configured consents in generic consent management are consented', () => {
+    state.consents.initialized.value = true;
+    state.consents.provider.value = 'oneTrust';
+    state.consents.resolutionStrategy.value = 'and';
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      consentManagement: [
+        {
+          provider: 'oneTrust',
+          consents: [
+            {
+              consent: 'C0001',
+            },
+            {
+              consent: 'C0003',
+            },
+          ],
+        },
+        {
+          provider: 'ketch',
+          consents: [
+            {
+              consent: 'C0003',
+            },
+          ],
+        },
+      ],
+    };
+    const isDestinationConsented = OneTrustConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(true);
+  });
+
+  it('should return appropriate consent status if the resolution strategy is "or"', () => {
+    state.consents.initialized.value = true;
+    state.consents.provider.value = 'oneTrust';
+    state.consents.resolutionStrategy.value = 'or';
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      consentManagement: [
+        {
+          provider: 'oneTrust',
+          consents: [
+            {
+              consent: 'C0001',
+            },
+            {
+              consent: 'C0004',
+            },
+          ],
+        },
+        {
+          provider: 'ketch',
+          consents: [
+            {
+              consent: 'C0003',
+            },
+          ],
+        },
+      ],
+    };
+    const isDestinationConsented = OneTrustConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(true);
+  });
+
+  it('should return true when the consent values are empty in the generic consent management config and resolution strategy is "or"', () => {
+    state.consents.initialized.value = true;
+    state.consents.provider.value = 'oneTrust';
+    state.consents.resolutionStrategy.value = 'or';
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      consentManagement: [
+        {
+          provider: 'oneTrust',
+          consents: [],
+        },
+        {
+          provider: 'ketch',
+          consents: [
+            {
+              consent: 'C0003',
+            },
+          ],
+        },
+      ],
+    };
+    const isDestinationConsented = OneTrustConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(true);
+  });
+});

package/packages/analytics-js-plugins/__tests__/storageEncryption/index.test.ts

@@ -0,0 +1,37 @@
+import { signal } from '@preact/signals-core';
+import { clone } from 'ramda';
+import { StorageEncryption } from '../../src/storageEncryption';
+
+describe('Plugin - Storage Encryption', () => {
+  const originalState = {
+    plugins: {
+      loadedPlugins: signal([]),
+    },
+  };
+  const storageEncryption = StorageEncryption();
+  let state: any;
+
+  beforeEach(() => {
+    state = clone(originalState);
+  });
+
+  it('should add plugin in the loaded plugin list', () => {
+    storageEncryption.initialize(state);
+    expect(state.plugins.loadedPlugins.value.includes('StorageEncryption')).toBe(true);
+  });
+
+  it('should encrypt the data', () => {
+    const encryptedData = storageEncryption.storage?.encrypt('test-data');
+    expect(encryptedData).toBe('RS_ENC_v3_dGVzdC1kYXRh');
+  });
+
+  it('should decrypt encrypted data', () => {
+    const decryptedData = storageEncryption.storage?.decrypt('RS_ENC_v3_dGVzdC1kYXRh');
+    expect(decryptedData).toBe('test-data');
+  });
+
+  it('should return same data if it is not a supported encryption format', () => {
+    const decryptedData = storageEncryption.storage?.decrypt('test-data');
+    expect(decryptedData).toBe('test-data');
+  });
+});

package/packages/analytics-js-plugins/__tests__/storageEncryptionLegacy/index.test.ts

@@ -0,0 +1,41 @@
+import { signal } from '@preact/signals-core';
+import { clone } from 'ramda';
+import { StorageEncryptionLegacy } from '../../src/storageEncryptionLegacy';
+
+describe('Plugin - Storage Encryption Legacy', () => {
+  const originalState = {
+    plugins: {
+      loadedPlugins: signal([]),
+    },
+  };
+  const storageEncryptionLegacy = StorageEncryptionLegacy();
+  let state: any;
+
+  beforeEach(() => {
+    state = clone(originalState);
+  });
+
+  it('should add plugin in the loaded plugin list', () => {
+    storageEncryptionLegacy.initialize(state);
+    expect(state.plugins.loadedPlugins.value.includes('StorageEncryptionLegacy')).toBe(true);
+  });
+
+  it('should encrypt the data', () => {
+    const srcData = '"1wefk7M3Y1D6EDX4ZpIE00LpKAE"';
+    const encryptedData = storageEncryptionLegacy.storage?.encrypt(srcData);
+    expect(encryptedData.startsWith('RudderEncrypt:')).toBe(true);
+    expect(storageEncryptionLegacy.storage?.decrypt(encryptedData)).toBe(srcData);
+  });
+
+  it('should decrypt encrypted data', () => {
+    const decryptedData = storageEncryptionLegacy.storage?.decrypt(
+      'RudderEncrypt:U2FsdGVkX1+5q5jikppUASe8AdIH6O2iORyF41sYXgxzIGiX9whSeVxxww0OK5h/',
+    );
+    expect(decryptedData).toBe('"1wefk7M3Y1D6EDX4ZpIE00LpKAE"');
+  });
+
+  it('should return same data if it is not a supported encryption format', () => {
+    const decryptedData = storageEncryptionLegacy.storage?.decrypt('test-data');
+    expect(decryptedData).toBe('test-data');
+  });
+});