iureiure 1.0.0

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

@@ -0,0 +1,498 @@
+import { state, resetState } from '@rudderstack/analytics-js/state';
+import { defaultPluginEngine } from '@rudderstack/analytics-js/services/PluginEngine';
+import { PluginsManager } from '@rudderstack/analytics-js/components/pluginsManager';
+import { StoreManager } from '@rudderstack/analytics-js/services/StoreManager/StoreManager';
+import { KetchConsentManager } from '../../src/ketchConsentManager';
+
+describe('Plugin - KetchConsentManager', () => {
+  beforeEach(() => {
+    resetState();
+    (window as any).ketchConsent = undefined;
+    (window as any).getKetchUserConsentedPurposes = undefined;
+    (window as any).getKetchUserDeniedPurposes = undefined;
+    // delete all cookies
+    document.cookie.split(';').forEach(function (c) {
+      document.cookie = c
+        .replace(/^ +/, '')
+        .replace(/=.*/, '=;expires=' + new Date().toUTCString() + ';path=/');
+    });
+  });
+
+  const mockLogger = {
+    error: jest.fn(),
+    warn: jest.fn(),
+    log: jest.fn(),
+  };
+
+  const mockErrorHandler = {
+    onError: jest.fn(),
+  };
+
+  it('should add KetchConsentManager plugin in the loaded plugin list', () => {
+    KetchConsentManager().initialize(state);
+    expect(state.plugins.loadedPlugins.value.includes('KetchConsentManager')).toBe(true);
+  });
+
+  it('should initialize the plugin if ketch consent data is already available on the window object', () => {
+    // Initialize the plugin
+    KetchConsentManager().consentManager.init(state, mockLogger);
+
+    expect((window as any).getKetchUserConsentedPurposes).toEqual(expect.any(Function));
+    expect((window as any).getKetchUserDeniedPurposes).toEqual(expect.any(Function));
+    expect((window as any).updateKetchConsent).toEqual(expect.any(Function));
+  });
+
+  it('should update state with consents data from ketch window resources', () => {
+    // Mock the ketch data on the window object
+    (window as any).ketchConsent = {
+      purpose1: true,
+      purpose2: false,
+      purpose3: true,
+      purpose4: false,
+      purpose5: true,
+    };
+
+    // Initialize the plugin
+    KetchConsentManager().consentManager.init(state, mockLogger);
+
+    // Update the state with the consent data
+    KetchConsentManager().consentManager.updateConsentsInfo(state, undefined, mockLogger);
+
+    expect(state.consents.initialized.value).toBe(true);
+    expect(state.consents.data.value).toStrictEqual({
+      allowedConsentIds: ['purpose1', 'purpose3', 'purpose5'],
+      deniedConsentIds: ['purpose2', 'purpose4'],
+    });
+
+    expect((window as any).getKetchUserConsentedPurposes()).toStrictEqual([
+      'purpose1',
+      'purpose3',
+      'purpose5',
+    ]);
+    expect((window as any).getKetchUserDeniedPurposes()).toStrictEqual(['purpose2', 'purpose4']);
+  });
+
+  it('should return undefined values when the window callbacks are invoked and there is no data in the state', () => {
+    // Initialize the plugin
+    KetchConsentManager().consentManager.init(state, mockLogger);
+
+    expect((window as any).getKetchUserConsentedPurposes()).toStrictEqual(undefined);
+    expect((window as any).getKetchUserDeniedPurposes()).toStrictEqual(undefined);
+  });
+
+  it('should define a callback function on window to update consent data', () => {
+    // Mock the ketch data on the window object
+    (window as any).ketchConsent = {
+      purpose1: true,
+      purpose2: false,
+      purpose3: true,
+      purpose4: false,
+      purpose5: true,
+    };
+
+    // Initialize the plugin
+    KetchConsentManager().consentManager.init(state, mockLogger);
+
+    // Call the callback function
+    (window as any).updateKetchConsent({
+      purpose1: false,
+      purpose2: true,
+      purpose3: false,
+      purpose4: true,
+      purpose5: false,
+    });
+
+    expect(state.consents.data.value).toStrictEqual({
+      allowedConsentIds: ['purpose2', 'purpose4'],
+      deniedConsentIds: ['purpose1', 'purpose3', 'purpose5'],
+    });
+
+    expect((window as any).getKetchUserConsentedPurposes()).toStrictEqual(['purpose2', 'purpose4']);
+    expect((window as any).getKetchUserDeniedPurposes()).toStrictEqual([
+      'purpose1',
+      'purpose3',
+      'purpose5',
+    ]);
+  });
+
+  it('should get consent data from ketch cookies if ketch consent data is not available on the window object', () => {
+    const ketchRawConsentData = {
+      purpose1: {
+        status: 'granted',
+      },
+      purpose2: {
+        status: 'denied',
+      },
+      purpose3: {
+        status: 'granted',
+      },
+      purpose4: {
+        status: 'denied',
+      },
+      purpose5: {
+        status: 'granted',
+      },
+    };
+    const ketchConsentString = JSON.stringify(ketchRawConsentData);
+
+    // Mock the ketch cookies
+    document.cookie = `_ketch_consent_v1_=${window.btoa(ketchConsentString)};`;
+
+    const pluginsManager = new PluginsManager(defaultPluginEngine, undefined, mockLogger);
+    const storeManager = new StoreManager(pluginsManager, undefined, mockLogger);
+
+    // Initialize the plugin
+    KetchConsentManager().consentManager.init(state, mockLogger);
+
+    // Update the state with the consent data
+    KetchConsentManager().consentManager.updateConsentsInfo(state, storeManager, mockLogger);
+
+    expect(state.consents.initialized.value).toBe(true);
+    expect(state.consents.data.value).toStrictEqual({
+      allowedConsentIds: ['purpose1', 'purpose3', 'purpose5'],
+      deniedConsentIds: ['purpose2', 'purpose4'],
+    });
+
+    expect((window as any).getKetchUserConsentedPurposes()).toStrictEqual([
+      'purpose1',
+      'purpose3',
+      'purpose5',
+    ]);
+    expect((window as any).getKetchUserDeniedPurposes()).toStrictEqual(['purpose2', 'purpose4']);
+  });
+
+  it('should return true if the consent manager is not initialized', () => {
+    expect(
+      KetchConsentManager().consentManager.isDestinationConsented(
+        state,
+        undefined,
+        mockErrorHandler,
+        mockLogger,
+      ),
+    ).toBe(true);
+  });
+
+  it('should return true if the destination config does not contain ketch consent purposes data', () => {
+    state.consents.initialized.value = true;
+    state.consents.data.value = {
+      allowedConsentIds: ['purpose1', 'purpose3', 'purpose5'],
+      deniedConsentIds: ['purpose2', 'purpose4'],
+    };
+
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+    };
+
+    expect(
+      KetchConsentManager().consentManager.isDestinationConsented(
+        state,
+        destConfig,
+        mockErrorHandler,
+        mockLogger,
+      ),
+    ).toBe(true);
+  });
+
+  it('should return true if the ketch consent purposes data is empty in the destination config', () => {
+    state.consents.initialized.value = true;
+    state.consents.data.value = {
+      allowedConsentIds: ['purpose1', 'purpose3', 'purpose5'],
+      deniedConsentIds: ['purpose2', 'purpose4'],
+    };
+
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      ketchConsentPurposes: [],
+    };
+
+    expect(
+      KetchConsentManager().consentManager.isDestinationConsented(
+        state,
+        destConfig,
+        mockErrorHandler,
+        mockLogger,
+      ),
+    ).toBe(true);
+  });
+
+  it('should return true if at least one of the ketch consent purposes in the destination config is allowed', () => {
+    state.consents.initialized.value = true;
+    state.consents.data.value = {
+      allowedConsentIds: ['purpose1', 'purpose3', 'purpose5'],
+      deniedConsentIds: ['purpose2', 'purpose4'],
+    };
+
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      ketchConsentPurposes: [
+        {
+          purpose: 'purpose1',
+        },
+        {
+          purpose: 'purpose2',
+        },
+      ],
+    };
+
+    expect(
+      KetchConsentManager().consentManager.isDestinationConsented(
+        state,
+        destConfig,
+        mockErrorHandler,
+        mockLogger,
+      ),
+    ).toBe(true);
+  });
+
+  it('should return false if none of the ketch consent purposes in the destination config is allowed', () => {
+    state.consents.initialized.value = true;
+    state.consents.data.value = {
+      allowedConsentIds: ['purpose1', 'purpose3', 'purpose5'],
+      deniedConsentIds: ['purpose2', 'purpose4'],
+    };
+
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      ketchConsentPurposes: [
+        {
+          purpose: 'purpose2',
+        },
+        {
+          purpose: 'purpose4',
+        },
+      ],
+    };
+
+    expect(
+      KetchConsentManager().consentManager.isDestinationConsented(
+        state,
+        destConfig,
+        mockErrorHandler,
+        mockLogger,
+      ),
+    ).toBe(false);
+  });
+
+  it('should return true and log an error if any exception is thrown while checking if the destination is consented', () => {
+    state.consents.initialized.value = true;
+    state.consents.data.value = {
+      allowedConsentIds: null, // This will throw an exception
+      deniedConsentIds: ['purpose2', 'purpose4'],
+    };
+
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      ketchConsentPurposes: [
+        {
+          purpose: 'purpose2',
+        },
+        {
+          purpose: 'purpose4',
+        },
+      ],
+    };
+
+    expect(
+      KetchConsentManager().consentManager.isDestinationConsented(
+        state,
+        destConfig,
+        mockErrorHandler,
+        mockLogger,
+      ),
+    ).toBe(true);
+    expect(mockErrorHandler.onError).toHaveBeenCalledWith(
+      new TypeError("Cannot read properties of null (reading 'includes')"),
+      'KetchConsentManagerPlugin',
+      '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 = 'or';
+    state.consents.provider.value = 'ketch';
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      consentManagement: [
+        {
+          provider: 'oneTrust',
+          consents: [
+            {
+              consent: 'Functional Cookies',
+            },
+            {
+              consent: 'C0004',
+            },
+          ],
+        },
+        {
+          provider: 'ketch',
+          consents: [
+            {
+              consent: 'C0004',
+            },
+          ],
+        },
+      ],
+    };
+    const isDestinationConsented = KetchConsentManager().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 = 'or';
+    state.consents.provider.value = 'ketch';
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      consentManagement: [
+        {
+          provider: 'oneTrust',
+          consents: [
+            {
+              consent: 'Functional Cookies',
+            },
+          ],
+        },
+      ],
+    };
+    const isDestinationConsented = KetchConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(true);
+  });
+
+  it('should return true if at least one of the configured consents in generic consent management are consented', () => {
+    state.consents.initialized.value = true;
+    state.consents.provider.value = 'ketch';
+    state.consents.resolutionStrategy.value = 'or';
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0003'],
+    };
+    const destConfig = {
+      blacklistedEvents: [],
+      whitelistedEvents: [],
+      eventFilteringOption: 'disable',
+      consentManagement: [
+        {
+          provider: 'oneTrust',
+          consents: [
+            {
+              consent: 'Functional Cookies',
+            },
+            {
+              consent: 'C0003',
+            },
+          ],
+        },
+        {
+          provider: 'ketch',
+          consents: [
+            {
+              consent: 'C0003',
+            },
+          ],
+        },
+      ],
+    };
+    const isDestinationConsented = KetchConsentManager().consentManager.isDestinationConsented(
+      state,
+      destConfig,
+      mockErrorHandler,
+      mockLogger,
+    );
+    expect(isDestinationConsented).toBe(true);
+  });
+
+  it('should return appropriate value when the resolution strategy is set to "and"', () => {
+    state.consents.initialized.value = true;
+    state.consents.provider.value = 'ketch';
+    state.consents.resolutionStrategy.value = 'and';
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0002', 'C0003'],
+    };
+    const destConfig = {
+      consentManagement: [
+        {
+          provider: 'ketch',
+          consents: [
+            {
+              consent: 'C0001',
+            },
+            {
+              consent: 'C0002',
+            },
+          ],
+        },
+      ],
+    };
+    expect(
+      KetchConsentManager().consentManager.isDestinationConsented(
+        state,
+        destConfig,
+        mockErrorHandler,
+        mockLogger,
+      ),
+    ).toBe(true);
+  });
+
+  it('should return appropriate value when the resolution strategy not set', () => {
+    state.consents.initialized.value = true;
+    state.consents.provider.value = 'ketch';
+    state.consents.resolutionStrategy.value = null;
+    state.consents.data.value = {
+      allowedConsentIds: ['C0001', 'C0002', 'C0003'],
+    };
+    const destConfig = {
+      consentManagement: [
+        {
+          provider: 'ketch',
+          consents: [
+            {
+              consent: 'C0001',
+            },
+            {
+              consent: 'C0002',
+            },
+          ],
+        },
+      ],
+    };
+    expect(
+      KetchConsentManager().consentManager.isDestinationConsented(
+        state,
+        destConfig,
+        mockErrorHandler,
+        mockLogger,
+      ),
+    ).toBe(true);
+  });
+});

package/packages/analytics-js-plugins/__tests__/ketchConsentManager/utils.test.ts

@@ -0,0 +1,189 @@
+import { state, resetState } from '@rudderstack/analytics-js/state';
+import { defaultPluginEngine } from '@rudderstack/analytics-js/services/PluginEngine';
+import { PluginsManager } from '@rudderstack/analytics-js/components/pluginsManager';
+import { StoreManager } from '@rudderstack/analytics-js/services/StoreManager/StoreManager';
+import {
+  updateConsentStateFromData,
+  getConsentData,
+  getKetchConsentData,
+} from '../../src/ketchConsentManager/utils';
+
+describe('KetchConsentManager - Utils', () => {
+  const mockLogger = {
+    error: jest.fn(),
+    warn: jest.fn(),
+    log: jest.fn(),
+  };
+
+  beforeEach(() => {
+    resetState();
+
+    // delete all cookies
+    document.cookie.split(';').forEach(function (c) {
+      document.cookie = c
+        .replace(/^ +/, '')
+        .replace(/=.*/, '=;expires=' + new Date().toUTCString() + ';path=/');
+    });
+  });
+
+  describe('updateConsentStateFromData', () => {
+    it('should update the consent state from the ketch data', () => {
+      const ketchConsentData = {
+        purpose1: true,
+        purpose2: false,
+        purpose3: true,
+        purpose4: false,
+        purpose5: true,
+      };
+
+      // Initialize the plugin
+      updateConsentStateFromData(state, ketchConsentData);
+
+      expect(state.consents.data.value).toStrictEqual({
+        allowedConsentIds: ['purpose1', 'purpose3', 'purpose5'],
+        deniedConsentIds: ['purpose2', 'purpose4'],
+      });
+    });
+  });
+
+  describe('getConsentData', () => {
+    it('should get consent data from ketch consent data', () => {
+      const ketchConsentData = {
+        purpose1: true,
+        purpose2: false,
+        purpose3: true,
+        purpose4: false,
+        purpose5: true,
+      };
+
+      const consentData = getConsentData(ketchConsentData);
+
+      expect(consentData).toStrictEqual({
+        allowedConsentIds: ['purpose1', 'purpose3', 'purpose5'],
+        deniedConsentIds: ['purpose2', 'purpose4'],
+      });
+    });
+
+    it('should get consent data if the ketch consent data is not provided', () => {
+      const consentData = getConsentData();
+
+      expect(consentData).toStrictEqual({
+        allowedConsentIds: [],
+        deniedConsentIds: [],
+      });
+    });
+  });
+
+  describe('getKetchConsentData', () => {
+    const pluginsManager = new PluginsManager(defaultPluginEngine, undefined, mockLogger);
+    const storeManager = new StoreManager(pluginsManager, undefined, mockLogger);
+
+    it('should get the ketch consent data from cookies', () => {
+      // Mock the ketch data in the cookies
+      const ketchRawConsentData = {
+        purpose1: {
+          status: 'granted',
+        },
+        purpose2: {
+          status: 'denied',
+        },
+        purpose3: {
+          status: 'granted',
+        },
+        purpose4: {
+          status: 'denied',
+        },
+        purpose5: {
+          status: 'granted',
+        },
+      };
+      const ketchConsentString = JSON.stringify(ketchRawConsentData);
+
+      // Mock the ketch cookies
+      document.cookie = `_ketch_consent_v1_=${window.btoa(ketchConsentString)};`;
+
+      const ketchConsentData = getKetchConsentData(storeManager, mockLogger);
+
+      expect(ketchConsentData).toStrictEqual({
+        purpose1: true,
+        purpose2: false,
+        purpose3: true,
+        purpose4: false,
+        purpose5: true,
+      });
+    });
+
+    it('should return undefined if ketch consent cookie could not be read', () => {
+      // mock store manager to intentionally throw error
+      const mockStoreManager = {
+        setStore: () => {
+          return {
+            engine: null,
+          };
+        },
+      };
+
+      const ketchConsentData = getKetchConsentData(mockStoreManager, mockLogger);
+
+      expect(ketchConsentData).toBeUndefined();
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        'KetchConsentManagerPlugin:: Failed to read the consent cookie.',
+        new TypeError("Cannot read properties of null (reading 'getItem')"),
+      );
+    });
+
+    it('should return undefined if ketch consent cookie is not present', () => {
+      const ketchConsentData = getKetchConsentData(storeManager, mockLogger);
+
+      expect(ketchConsentData).toBeUndefined();
+    });
+
+    it('should return undefined if ketch consent cookie data is not properly encoded', () => {
+      // Mock the ketch cookie
+      // The value is not Base64 encoded
+      document.cookie = `_ketch_consent_v1_=abc;`;
+
+      const ketchConsentData = getKetchConsentData(storeManager, mockLogger);
+
+      expect(ketchConsentData).toBeUndefined();
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        'KetchConsentManagerPlugin:: Failed to parse the consent cookie.',
+        new SyntaxError('Unexpected token \'i\', "i�" is not valid JSON'),
+      );
+    });
+
+    it('should return undefined if ketch consent cookie data is not JSON string', () => {
+      // Mock the ketch cookie
+      // The value is not JSON stringified
+      document.cookie = `_ketch_consent_v1_=YWJjZGU=;`;
+
+      const ketchConsentData = getKetchConsentData(storeManager, mockLogger);
+
+      expect(ketchConsentData).toBeUndefined();
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        'KetchConsentManagerPlugin:: Failed to parse the consent cookie.',
+        new SyntaxError('Unexpected token \'a\', "abcde" is not valid JSON'),
+      );
+    });
+
+    it('should return undefined if ketch consent data inside the cookie is null', () => {
+      // Mock the ketch cookie
+      // The value is inside is null
+      document.cookie = `_ketch_consent_v1_=bnVsbA==;`;
+
+      const ketchConsentData = getKetchConsentData(storeManager, mockLogger);
+
+      expect(ketchConsentData).toBeUndefined();
+    });
+
+    it('should return undefined if ketch consent data inside the cookie is an empty string', () => {
+      // Mock the ketch cookie
+      // The value is inside is empty string
+      document.cookie = `_ketch_consent_v1_=IiI=;`;
+
+      const ketchConsentData = getKetchConsentData(storeManager, mockLogger);
+
+      expect(ketchConsentData).toBeUndefined();
+    });
+  });
+});