iureiure 1.0.0

package/packages/analytics-js/__fixtures__/msw.handlers.ts

@@ -0,0 +1,82 @@
+import { http, HttpResponse } from 'msw';
+import { dummyDataplaneHost, dummySourceConfigResponse } from './fixtures';
+
+const handlers = [
+  http.get(`${dummyDataplaneHost}/rawSample`, () => {
+    return new HttpResponse('{"raw": "sample"}', {
+      status: 200,
+    });
+  }),
+  http.get(`${dummyDataplaneHost}/brokenJsonSample`, () => {
+    return new HttpResponse('{raw: sample}', {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json; charset=utf-8',
+      },
+    });
+  }),
+  http.get(`${dummyDataplaneHost}/emptyJsonSample`, () => {
+    return new HttpResponse('', {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json; charset=utf-8',
+      },
+    });
+  }),
+  http.get(`${dummyDataplaneHost}/jsonSample`, () => {
+    return new HttpResponse(JSON.stringify({ json: 'sample' }), {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json; charset=utf-8',
+      },
+    });
+  }),
+  http.get(`${dummyDataplaneHost}/404ErrorSample`, () => {
+    return new HttpResponse(null, {
+      status: 404,
+    });
+  }),
+  http.get(`${dummyDataplaneHost}/429ErrorSample`, () => {
+    return new HttpResponse(null, {
+      status: 429,
+    });
+  }),
+  http.get(`${dummyDataplaneHost}/500ErrorSample`, () => {
+    return new HttpResponse(null, {
+      status: 500,
+    });
+  }),
+  http.get(`${dummyDataplaneHost}/noConnectionSample`, () => {
+    return HttpResponse.error();
+  }),
+  http.get(`${dummyDataplaneHost}/jsFileSample`, () => {
+    const fileContents = 'console.log("jsFileSample script executed")';
+    return new HttpResponse(fileContents, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/javascript',
+        'Content-Length': fileContents.length.toString(),
+      },
+    });
+  }),
+  http.get(`${dummyDataplaneHost}/jsFileEmpty`, () => {
+    const fileContents = '';
+    return new HttpResponse(fileContents, {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/javascript',
+        'Content-Length': fileContents.length.toString(),
+      },
+    });
+  }),
+  http.get(`${dummyDataplaneHost}/sourceConfig`, () => {
+    return new HttpResponse(JSON.stringify(dummySourceConfigResponse), {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json; charset=utf-8',
+      },
+    });
+  }),
+];
+
+export { handlers };

package/packages/analytics-js/__fixtures__/msw.server.ts

@@ -0,0 +1,6 @@
+import { setupServer } from 'msw/node';
+import { handlers } from './msw.handlers';
+
+const server = setupServer(...handlers);
+
+export { server };

package/packages/analytics-js/__mocks__/remotePlugins/BeaconQueue.ts

@@ -0,0 +1,9 @@
+const BeaconQueue = () => ({
+  name: 'BeaconQueue',
+  dataplaneEventsQueue: {
+    init: jest.fn(() => {}),
+    enqueue: jest.fn(() => {}),
+  },
+});
+
+export default BeaconQueue;

package/packages/analytics-js/__mocks__/remotePlugins/Bugsnag.ts

@@ -0,0 +1,10 @@
+const Bugsnag = () => ({
+  name: 'Bugsnag',
+  errorReportingProvider: {
+    init: jest.fn(() => {}),
+    notify: jest.fn(() => {}),
+    breadcrumb: jest.fn(() => {}),
+  },
+});
+
+export default Bugsnag;

package/packages/analytics-js/__mocks__/remotePlugins/CustomConsentManager.ts

@@ -0,0 +1,10 @@
+const CustomConsentManager = () => ({
+  name: 'CustomConsentManager',
+  consentManager: {
+    init: jest.fn(() => {}),
+    updateConsentsInfo: jest.fn(() => {}),
+    isDestinationConsented: jest.fn(() => {}),
+  },
+});
+
+export default CustomConsentManager;

package/packages/analytics-js/__mocks__/remotePlugins/DeviceModeDestinations.ts

@@ -0,0 +1,9 @@
+const DeviceModeDestinations = () => ({
+  name: 'DeviceModeDestinations',
+  nativeDestinations: {
+    setActiveDestinations: jest.fn(() => {}),
+    load: jest.fn(() => {}),
+  },
+});
+
+export default DeviceModeDestinations;

package/packages/analytics-js/__mocks__/remotePlugins/DeviceModeTransformation.ts

@@ -0,0 +1,9 @@
+const DeviceModeTransformation = () => ({
+  name: 'DeviceModeTransformation',
+  transformEvent: {
+    init: jest.fn(() => {}),
+    enqueue: jest.fn(() => {}),
+  },
+});
+
+export default DeviceModeTransformation;

package/packages/analytics-js/__mocks__/remotePlugins/ErrorReporting.ts

@@ -0,0 +1,10 @@
+const ErrorReporting = () => ({
+  name: 'ErrorReporting',
+  errorReporting: {
+    init: jest.fn(() => {}),
+    notify: jest.fn(() => {}),
+    breadcrumb: jest.fn(() => {}),
+  },
+});
+
+export default ErrorReporting;

package/packages/analytics-js/__mocks__/remotePlugins/ExternalAnonymousId.ts

@@ -0,0 +1,10 @@
+const ExternalAnonymousId = () => ({
+  name: 'ExternalAnonymousId',
+  storage: {
+    getAnonymousId: jest.fn(() => {
+      return 'dummy-anonymousId-12345678';
+    }),
+  },
+});
+
+export default ExternalAnonymousId;

package/packages/analytics-js/__mocks__/remotePlugins/GoogleLinker.ts

@@ -0,0 +1,8 @@
+const GoogleLinker = () => ({
+  name: 'GoogleLinker',
+  userSession: {
+    anonymousIdGoogleLinker: jest.fn((value: any) => value),
+  },
+});
+
+export default GoogleLinker;

package/packages/analytics-js/__mocks__/remotePlugins/KetchConsentManager.ts

@@ -0,0 +1,10 @@
+const KetchConsentManager = () => ({
+  name: 'KetchConsentManager',
+  consentManager: {
+    init: jest.fn(() => {}),
+    updateConsentsInfo: jest.fn(() => {}),
+    isDestinationConsented: jest.fn(() => {}),
+  },
+});
+
+export default KetchConsentManager;

package/packages/analytics-js/__mocks__/remotePlugins/NativeDestinationQueue.ts

@@ -0,0 +1,10 @@
+const NativeDestinationQueue = () => ({
+  name: 'NativeDestinationQueue',
+  destinationsEventsQueue: {
+    init: jest.fn(() => {}),
+    enqueue: jest.fn(() => {}),
+    enqueueEventToDestination: jest.fn(() => {}),
+  },
+});
+
+export default NativeDestinationQueue;

package/packages/analytics-js/__mocks__/remotePlugins/OneTrustConsentManager.ts

@@ -0,0 +1,10 @@
+const OneTrustConsentManager = () => ({
+  name: 'OneTrustConsentManager',
+  consentManager: {
+    init: jest.fn(() => {}),
+    updateConsentsInfo: jest.fn(() => {}),
+    isDestinationConsented: jest.fn(() => {}),
+  },
+});
+
+export default OneTrustConsentManager;

package/packages/analytics-js/__mocks__/remotePlugins/StorageEncryption.ts

@@ -0,0 +1,9 @@
+const StorageEncryption = () => ({
+  name: 'StorageEncryption',
+  storage: {
+    encrypt: jest.fn((value: any) => value),
+    decrypt: jest.fn((value: any) => value),
+  },
+});
+
+export default StorageEncryption;

package/packages/analytics-js/__mocks__/remotePlugins/StorageEncryptionLegacy.ts

@@ -0,0 +1,9 @@
+const StorageEncryptionLegacy = () => ({
+  name: 'StorageEncryptionLegacy',
+  storage: {
+    encrypt: jest.fn((value: any) => value),
+    decrypt: jest.fn((value: any) => value),
+  },
+});
+
+export default StorageEncryptionLegacy;

package/packages/analytics-js/__mocks__/remotePlugins/StorageMigrator.ts

@@ -0,0 +1,8 @@
+const StorageMigrator = () => ({
+  name: 'StorageMigrator',
+  storage: {
+    migrate: jest.fn((key: any, storageEngine: any, errorHandler?: any, logger?: any) => key),
+  },
+});
+
+export default StorageMigrator;

package/packages/analytics-js/__mocks__/remotePlugins/XhrQueue.ts

@@ -0,0 +1,9 @@
+const XhrQueue = () => ({
+  name: 'XhrQueue',
+  dataplaneEventsQueue: {
+    init: jest.fn(() => {}),
+    enqueue: jest.fn(() => {}),
+  },
+});
+
+export default XhrQueue;

package/packages/analytics-js/__tests__/app/RudderAnalytics.test.ts

@@ -0,0 +1,286 @@
+import type { LoadOptions } from '@rudderstack/analytics-js-common/types/LoadOptions';
+import { RudderAnalytics } from '../../src/app/RudderAnalytics';
+import { Analytics } from '../../src/components/core/Analytics';
+
+jest.mock('../../src/components/core/Analytics');
+
+describe('Core - Rudder Analytics Facade', () => {
+  let analyticsInstanceMock: Analytics;
+  let rudderAnalytics: RudderAnalytics;
+  const mockLoadOptions = {
+    integrations: {
+      All: false,
+    },
+  } as LoadOptions;
+
+  beforeEach(() => {
+    Analytics.mockClear();
+    analyticsInstanceMock = new Analytics() as jest.Mocked<Analytics>;
+    (window as any).rudderanalytics = [
+      ['track'],
+      ['consent', { sendPageEvent: true }],
+      ['load', { option1: true }],
+      ['consent', { sendPageEvent: false }],
+      ['track'],
+    ];
+    rudderAnalytics = new RudderAnalytics();
+    (rudderAnalytics as any).analyticsInstances = { writeKey: analyticsInstanceMock };
+    (rudderAnalytics as any).defaultAnalyticsKey = 'writeKey';
+  });
+
+  afterEach(() => {
+    (rudderAnalytics as any).globalSingleton = null;
+    jest.resetAllMocks();
+  });
+
+  it('should return the global singleton from "rudderanalytics" global object', done => {
+    const expectedPreloadedEvents = [
+      ['consent', { sendPageEvent: true }],
+      ['consent', { sendPageEvent: false }],
+      ['track'],
+      ['track'],
+    ];
+    const globalSingleton = rudderAnalytics;
+
+    expect(window.RudderStackGlobals?.app?.preloadedEventsBuffer).toEqual(expectedPreloadedEvents);
+    expect(window.rudderanalytics).toEqual(globalSingleton);
+    done();
+  });
+
+  it('should return the global singleton if it exists', () => {
+    const globalSingleton = rudderAnalytics;
+    rudderAnalytics = new RudderAnalytics();
+
+    expect(rudderAnalytics).toEqual(globalSingleton);
+  });
+
+  it('should auto set the default analytics key if no analytics instances exist', () => {
+    (rudderAnalytics as any).analyticsInstances = {};
+    (rudderAnalytics as any).defaultAnalyticsKey = '';
+    rudderAnalytics.setDefaultInstanceKey('writeKey');
+
+    expect(rudderAnalytics.defaultAnalyticsKey).toEqual('writeKey');
+  });
+
+  it('should auto set the default analytics key if analytics instances exist', () => {
+    rudderAnalytics.setDefaultInstanceKey('writeKey2');
+
+    expect(rudderAnalytics.defaultAnalyticsKey).toEqual('writeKey2');
+  });
+
+  it('should return an existing analytics instance', () => {
+    expect(rudderAnalytics.getAnalyticsInstance('writeKey')).toStrictEqual(analyticsInstanceMock);
+  });
+
+  it('should create a new analytics instance if none exists', () => {
+    (rudderAnalytics as any).analyticsInstances = {};
+    (rudderAnalytics as any).defaultAnalyticsKey = '';
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance('writeKey');
+
+    expect(analyticsInstance).toBeInstanceOf(Analytics);
+  });
+
+  it('should create a new analytics instance with the default key if none is provided', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+
+    expect(analyticsInstance).toBeInstanceOf(Analytics);
+    expect(rudderAnalytics.analyticsInstances).toHaveProperty('writeKey', analyticsInstance);
+  });
+
+  it('should not create a new analytics instance if one already exists for the write key', () => {
+    const analyticsInstance = analyticsInstanceMock;
+    rudderAnalytics.analyticsInstances = { writeKey: analyticsInstance };
+    rudderAnalytics.load('writeKey', 'data-plane-url');
+
+    expect(rudderAnalytics.getAnalyticsInstance('writeKey')).toStrictEqual(analyticsInstance);
+  });
+
+  it('should set the default analytics key if none has been set', () => {
+    rudderAnalytics.load('writeKey', 'data-plane-url');
+
+    expect(rudderAnalytics.defaultAnalyticsKey).toEqual('writeKey');
+  });
+
+  it('should create a new analytics instance with the write key on load and trigger its load method', () => {
+    rudderAnalytics.analyticsInstances = {};
+    rudderAnalytics.defaultAnalyticsKey = '';
+    rudderAnalytics.load('writeKey', 'data-plane-url', mockLoadOptions);
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance('writeKey');
+    const loadSpy = jest.spyOn(analyticsInstance, 'load');
+
+    expect(rudderAnalytics.analyticsInstances).toHaveProperty('writeKey', analyticsInstance);
+    expect(loadSpy).toHaveBeenCalledWith('writeKey', 'data-plane-url', mockLoadOptions);
+  });
+
+  it('should process ready arguments and forwards to ready call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const readySpy = jest.spyOn(analyticsInstance, 'ready');
+
+    const callback = () => console.log('Ready!');
+
+    rudderAnalytics.ready(callback);
+    expect(readySpy).toHaveBeenCalledWith(expect.any(Function));
+  });
+
+  it('should process page arguments and forwards to page call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const pageSpy = jest.spyOn(analyticsInstance, 'page');
+
+    rudderAnalytics.page('category');
+    expect(pageSpy).toHaveBeenCalledWith({
+      name: 'category',
+      properties: { category: null, name: 'category' },
+    });
+  });
+
+  it('should process track arguments and forwards to track call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const trackSpy = jest.spyOn(analyticsInstance, 'track');
+
+    rudderAnalytics.track('event');
+    expect(trackSpy).toHaveBeenCalledWith({ name: 'event', properties: {} });
+  });
+
+  it('should process identify arguments and forwards to identify call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const identifySpy = jest.spyOn(analyticsInstance, 'identify');
+
+    rudderAnalytics.identify(1234);
+    expect(identifySpy).toHaveBeenCalledWith({ userId: '1234' });
+  });
+
+  it('should process alias arguments and forwards to alias call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const aliasSpy = jest.spyOn(analyticsInstance, 'alias');
+
+    rudderAnalytics.alias('1234');
+    expect(aliasSpy).toHaveBeenCalledWith({ to: '1234' });
+  });
+
+  it('should process group arguments and forwards to group call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const groupSpy = jest.spyOn(analyticsInstance, 'group');
+
+    rudderAnalytics.group(1234);
+    expect(groupSpy).toHaveBeenCalledWith({ groupId: '1234', traits: {} });
+  });
+
+  it('should process reset arguments and forwards to reset call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const resetSpy = jest.spyOn(analyticsInstance, 'reset');
+
+    rudderAnalytics.reset(true);
+    expect(resetSpy).toHaveBeenCalledWith(true);
+  });
+
+  it('should process getAnonymousId arguments and forwards to getAnonymousId call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const getAnonymousIdSpy = jest.spyOn(analyticsInstance, 'getAnonymousId');
+
+    rudderAnalytics.getAnonymousId({
+      autoCapture: {
+        enabled: true,
+      },
+    });
+    expect(getAnonymousIdSpy).toHaveBeenCalledWith({ autoCapture: { enabled: true } });
+  });
+
+  it('should process setAnonymousId arguments and forwards to setAnonymousId call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const setAnonymousIdSpy = jest.spyOn(analyticsInstance, 'setAnonymousId');
+
+    rudderAnalytics.setAnonymousId('id', 'param');
+    expect(setAnonymousIdSpy).toHaveBeenCalledWith('id', 'param');
+  });
+
+  it('should process getUserId arguments and forwards to getUserId call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const getUserIdSpy = jest.spyOn(analyticsInstance, 'getUserId');
+
+    rudderAnalytics.getUserId();
+    expect(getUserIdSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should process getUserTraits arguments and forwards to getUserTraits call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const getUserTraitsSpy = jest.spyOn(analyticsInstance, 'getUserTraits');
+
+    rudderAnalytics.getUserTraits();
+    expect(getUserTraitsSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should process getGroupId arguments and forwards to getGroupId call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const getGroupIdSpy = jest.spyOn(analyticsInstance, 'getGroupId');
+
+    rudderAnalytics.getGroupId();
+    expect(getGroupIdSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should process getGroupTraits arguments and forwards to getGroupTraits call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const getGroupTraitsSpy = jest.spyOn(analyticsInstance, 'getGroupTraits');
+
+    rudderAnalytics.getGroupTraits();
+    expect(getGroupTraitsSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should process startSession arguments and forwards to startSession call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const startSessionSpy = jest.spyOn(analyticsInstance, 'startSession');
+
+    rudderAnalytics.startSession(1234);
+    expect(startSessionSpy).toHaveBeenCalledWith(1234);
+  });
+
+  it('should process endSession arguments and forwards to endSession call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const endSessionSpy = jest.spyOn(analyticsInstance, 'endSession');
+
+    rudderAnalytics.endSession();
+    expect(endSessionSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should process getSessionId arguments and forwards to getSessionId call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const getSessionIdSpy = jest.spyOn(analyticsInstance, 'getSessionId');
+
+    rudderAnalytics.getSessionId();
+    expect(getSessionIdSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should retrieve all preloaded events and set to global', () => {
+    expect((window as any).RudderStackGlobals.app.preloadedEventsBuffer).toEqual([
+      ['consent', { sendPageEvent: true }],
+      ['consent', { sendPageEvent: false }],
+      ['track'],
+      ['track'],
+    ]);
+  });
+
+  it('should process setAuthToken arguments and forwards to setAuthToken call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const setAuthTokenSpy = jest.spyOn(analyticsInstance, 'setAuthToken');
+
+    rudderAnalytics.setAuthToken('token');
+    expect(setAuthTokenSpy).toHaveBeenCalledWith('token');
+  });
+
+  it('should process consent arguments and forwards to consent call', () => {
+    const analyticsInstance = rudderAnalytics.getAnalyticsInstance();
+    const consentSpy = jest.spyOn(analyticsInstance, 'consent');
+
+    rudderAnalytics.consent({
+      consentManagement: {
+        allowedConsentIds: ['1'],
+        deniedConsentIds: ['2'],
+      },
+    });
+    expect(consentSpy).toHaveBeenCalledWith({
+      consentManagement: {
+        allowedConsentIds: ['1'],
+        deniedConsentIds: ['2'],
+      },
+    });
+  });
+});

package/packages/analytics-js/__tests__/components/capabilitiesManager/detection/adBlockers.test.ts

@@ -0,0 +1,78 @@
+import { effect } from '@preact/signals-core';
+import { detectAdBlockers } from '../../../../src/components/capabilitiesManager/detection/adBlockers';
+import { state, resetState } from '../../../../src/state';
+
+let errObj;
+let xhrObj;
+
+jest.mock('../../../../src/services/HttpClient/HttpClient', () => {
+  const originalModule = jest.requireActual('../../../../src/services/HttpClient/HttpClient');
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    HttpClient: jest.fn().mockImplementation(() => ({
+      setAuthHeader: jest.fn(),
+      getAsyncData: jest.fn().mockImplementation(({ url, callback }) => {
+        callback(undefined, {
+          error: errObj,
+          xhr: xhrObj,
+        });
+      }),
+    })),
+  };
+});
+
+describe('detectAdBlockers', () => {
+  beforeEach(() => {
+    resetState();
+  });
+
+  it('should detect adBlockers if the request is blocked', done => {
+    state.lifecycle.sourceConfigUrl.value = 'https://example.com/some/path/';
+
+    errObj = new Error('Request blocked');
+    xhrObj = {
+      responseURL: 'https://example.com/some/path/?view=ad',
+    };
+
+    detectAdBlockers();
+
+    effect(() => {
+      expect(state.capabilities.isAdBlocked.value).toBe(true);
+      done();
+    });
+  });
+
+  it('should detect adBlockers if the request internally redirected', done => {
+    state.lifecycle.sourceConfigUrl.value = 'https://example.com/some/path/';
+
+    errObj = undefined;
+    xhrObj = {
+      responseURL: 'data:text/css;charset=UTF-8;base64,dGVtcA==',
+    };
+
+    detectAdBlockers();
+
+    effect(() => {
+      expect(state.capabilities.isAdBlocked.value).toBe(true);
+      done();
+    });
+  });
+
+  it('should not detect adBlockers if the request is not blocked', done => {
+    state.lifecycle.sourceConfigUrl.value = 'https://example.com/some/path/';
+
+    errObj = undefined;
+    xhrObj = {
+      responseURL: 'https://example.com/some/path/?view=ad',
+    };
+
+    detectAdBlockers();
+
+    effect(() => {
+      expect(state.capabilities.isAdBlocked.value).toBe(false);
+      done();
+    });
+  });
+});

package/packages/analytics-js/__tests__/components/capabilitiesManager/detection/browser.test.ts

@@ -0,0 +1,24 @@
+import {
+  hasCrypto,
+  isBrowser,
+  isNode,
+  hasUAClientHints,
+} from '../../../../src/components/capabilitiesManager/detection/browser';
+
+describe('Capabilities Detection - Browser', () => {
+  it('should detect browser', () => {
+    expect(isBrowser()).toBeTruthy();
+  });
+
+  it('should detect node', () => {
+    expect(isNode()).toBeTruthy();
+  });
+
+  it('should detect hasCrypto', () => {
+    expect(hasCrypto()).toBeTruthy();
+  });
+
+  it('should detect Client Hints', () => {
+    expect(hasUAClientHints()).toBeFalsy();
+  });
+});