@jmartins-tillster/analytics-react-native 2.21.3

package/packages/core/src/plugins/__tests__/QueueFlushingPlugin.test.ts

@@ -0,0 +1,143 @@
+import { createStore } from '@segment/sovran-react-native';
+
+import { MockEventStore } from '../../test-helpers';
+import { EventType, SegmentEvent } from '../../types';
+import { QueueFlushingPlugin } from '../QueueFlushingPlugin';
+
+import type { SegmentClient } from '../../analytics';
+jest.mock('@segment/sovran-react-native');
+
+describe('QueueFlushingPlugin', () => {
+  function setupQueuePlugin(
+    onFlush: (events: SegmentEvent[]) => Promise<void>,
+    flushAt: number
+  ) {
+    const queuePlugin = new QueueFlushingPlugin(onFlush);
+    // We override the createStore before the queue plugin is initialized to use our own mocked event store
+    (createStore as jest.Mock).mockReturnValue(new MockEventStore());
+    queuePlugin.configure({
+      getConfig: () => ({
+        writeKey: 'SEGMENT_KEY',
+        flushAt,
+      }),
+    } as unknown as SegmentClient);
+
+    // Mock the create store just before the queue plugin creates its store
+    return queuePlugin;
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetModules();
+  });
+
+  it('should queue events when executed in the timeline', async () => {
+    const onFlush = jest.fn();
+    const queuePlugin = setupQueuePlugin(onFlush, 10);
+
+    const result = await queuePlugin.execute({
+      type: EventType.TrackEvent,
+      event: 'test1',
+      properties: {
+        test: 'test1',
+      },
+    } as SegmentEvent);
+
+    expect(result).not.toBeUndefined();
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect(queuePlugin.queueStore?.getState().events).toHaveLength(1);
+
+    // No flush called yet
+    expect(onFlush).not.toHaveBeenCalled();
+  });
+
+  it('should dequeue events on demand', async () => {
+    const onFlush = jest.fn().mockResolvedValue(undefined);
+    const queuePlugin = setupQueuePlugin(onFlush, 10);
+
+    const event: SegmentEvent = {
+      type: EventType.TrackEvent,
+      event: 'test2',
+      properties: {
+        test: 'test2',
+      },
+    };
+
+    const result = await queuePlugin.execute(event);
+
+    expect(result).not.toBeUndefined();
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect(queuePlugin.queueStore?.getState().events).toHaveLength(1);
+    await queuePlugin.dequeue(event);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect(queuePlugin.queueStore?.getState().events).toHaveLength(0);
+  });
+  it('should clear all events from the queue', async () => {
+    const onFlush = jest.fn().mockResolvedValue(undefined);
+    const queuePlugin = setupQueuePlugin(onFlush, 10);
+    const event1: SegmentEvent = {
+      type: EventType.TrackEvent,
+      event: 'test1',
+      properties: {
+        test: 'test1',
+      },
+    };
+    const event2: SegmentEvent = {
+      type: EventType.TrackEvent,
+      event: 'test2',
+      properties: {
+        test: 'test2',
+      },
+    };
+    await queuePlugin.execute(event1);
+    await queuePlugin.execute(event2);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect(queuePlugin.queueStore?.getState().events).toHaveLength(2);
+    await queuePlugin.dequeueEvents();
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    expect(queuePlugin.queueStore?.getState().events).toHaveLength(0);
+  });
+  it('should return the count of items in the queue', async () => {
+    const onFlush = jest.fn().mockResolvedValue(undefined);
+    const queuePlugin = setupQueuePlugin(onFlush, 10);
+
+    const event1: SegmentEvent = {
+      type: EventType.TrackEvent,
+      event: 'test1',
+      properties: {
+        test: 'test1',
+      },
+    };
+
+    const event2: SegmentEvent = {
+      type: EventType.TrackEvent,
+      event: 'test2',
+      properties: {
+        test: 'test2',
+      },
+    };
+
+    await queuePlugin.execute(event1);
+    await queuePlugin.execute(event2);
+
+    let eventsCount = await queuePlugin.pendingEvents();
+    expect(eventsCount).toBe(2);
+
+    await queuePlugin.dequeue(event1);
+
+    eventsCount = await queuePlugin.pendingEvents();
+    expect(eventsCount).toBe(1);
+
+    await queuePlugin.dequeueEvents();
+
+    eventsCount = await queuePlugin.pendingEvents();
+    expect(eventsCount).toBe(0);
+  });
+});

package/packages/core/src/plugins/__tests__/SegmentDestination.test.ts

@@ -0,0 +1,549 @@
+import { SegmentClient } from '../../analytics';
+import * as api from '../../api';
+import { defaultApiHost } from '../../constants';
+import {
+  createMockStoreGetter,
+  getMockLogger,
+  MockSegmentStore,
+} from '../../test-helpers';
+import {
+  Config,
+  EventType,
+  SegmentAPIIntegration,
+  SegmentEvent,
+  TrackEventType,
+  UpdateType,
+} from '../../types';
+import {
+  SEGMENT_DESTINATION_KEY,
+  SegmentDestination,
+} from '../SegmentDestination';
+import { getURL } from '../../util';
+
+jest.mock('uuid');
+
+describe('SegmentDestination', () => {
+  const store = new MockSegmentStore();
+  const clientArgs = {
+    logger: getMockLogger(),
+    config: {
+      writeKey: '123-456',
+      maxBatchSize: 2,
+      flushInterval: 0,
+    },
+    store,
+  };
+
+  beforeEach(() => {
+    store.reset();
+    jest.clearAllMocks();
+  });
+
+  it('executes', async () => {
+    const plugin = new SegmentDestination();
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    plugin.analytics = new SegmentClient(clientArgs);
+    const event: TrackEventType = {
+      anonymousId: '3534a492-e975-4efa-a18b-3c70c562fec2',
+      event: 'Awesome event',
+      type: EventType.TrackEvent,
+      properties: {},
+      timestamp: '2000-01-01T00:00:00.000Z',
+      messageId: '1d1744bf-5beb-41ac-ad7a-943eac33babc',
+      context: { app: { name: 'TestApp' } },
+      integrations: {
+        Firebase: false,
+      },
+    };
+    const result = await plugin.execute(event);
+    expect(result).toEqual(event);
+  });
+
+  it('disables device mode plugins to prevent dups', async () => {
+    const plugin = new SegmentDestination();
+    const analytics = new SegmentClient({
+      ...clientArgs,
+      store: new MockSegmentStore({
+        settings: {
+          firebase: {
+            someConfig: 'someValue',
+          },
+          [SEGMENT_DESTINATION_KEY]: {},
+        },
+      }),
+    });
+    plugin.configure(analytics);
+
+    plugin.analytics!.getPlugins = jest.fn().mockReturnValue([
+      {
+        key: 'firebase',
+        type: 'destination',
+      },
+    ]);
+
+    const event: TrackEventType = {
+      anonymousId: '3534a492-e975-4efa-a18b-3c70c562fec2',
+      event: 'Awesome event',
+      type: EventType.TrackEvent,
+      properties: {},
+      timestamp: '2000-01-01T00:00:00.000Z',
+      messageId: '1d1744bf-5beb-41ac-ad7a-943eac33babc',
+      context: { app: { name: 'TestApp' } },
+      integrations: {},
+    };
+
+    const result = await plugin.execute(event);
+    expect(result).toEqual({
+      ...event,
+      _metadata: {
+        bundled: ['firebase'],
+        unbundled: [],
+        bundledIds: [],
+      },
+    });
+  });
+
+  it('marks unbundled plugins where the cloud mode is disabled', async () => {
+    const plugin = new SegmentDestination();
+    const analytics = new SegmentClient({
+      ...clientArgs,
+      store: new MockSegmentStore({
+        settings: {
+          [SEGMENT_DESTINATION_KEY]: {
+            unbundledIntegrations: ['firebase'],
+            maybeBundledConfigIds: {},
+          },
+        },
+      }),
+    });
+    plugin.configure(analytics);
+
+    plugin.analytics!.getPlugins = jest.fn().mockReturnValue([
+      {
+        key: 'firebase',
+        type: 'destination',
+      },
+    ]);
+
+    const event: TrackEventType = {
+      anonymousId: '3534a492-e975-4efa-a18b-3c70c562fec2',
+      event: 'Awesome event',
+      type: EventType.TrackEvent,
+      properties: {},
+      timestamp: '2000-01-01T00:00:00.000Z',
+      messageId: '1d1744bf-5beb-41ac-ad7a-943eac33babc',
+      context: { app: { name: 'TestApp' } },
+      integrations: {},
+    };
+
+    const result = await plugin.execute(event);
+    expect(result).toEqual({
+      ...event,
+      _metadata: {
+        bundled: [],
+        unbundled: ['firebase'],
+        bundledIds: [],
+      },
+    });
+  });
+
+  it('marks active integrations as unbundled if plugin is not bundled', async () => {
+    const plugin = new SegmentDestination();
+    const analytics = new SegmentClient({
+      ...clientArgs,
+      store: new MockSegmentStore({
+        settings: {
+          [SEGMENT_DESTINATION_KEY]: {
+            unbundledIntegrations: ['Amplitude'],
+          },
+          Mixpanel: {}, // Mixpanel is active but not bundled
+        },
+      }),
+    });
+    plugin.configure(analytics);
+
+    const event: TrackEventType = {
+      anonymousId: '3534a492-e975-4efa-a18b-3c70c562fec2',
+      event: 'Awesome event',
+      type: EventType.TrackEvent,
+      properties: {},
+      timestamp: '2000-01-01T00:00:00.000Z',
+      messageId: '1d1744bf-5beb-41ac-ad7a-943eac33babc',
+      context: { app: { name: 'TestApp' } },
+      integrations: {},
+    };
+
+    const result = await plugin.execute(event);
+    expect(result).toEqual({
+      ...event,
+      _metadata: {
+        bundled: [],
+        unbundled: ['Mixpanel', 'Amplitude'],
+        bundledIds: [],
+      },
+    });
+  });
+
+  it('lets plugins/events override destination settings', async () => {
+    const plugin = new SegmentDestination();
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    plugin.analytics = new SegmentClient({
+      ...clientArgs,
+      store: new MockSegmentStore({
+        settings: {
+          firebase: {
+            someConfig: 'someValue',
+          },
+          [SEGMENT_DESTINATION_KEY]: {},
+        },
+      }),
+    });
+
+    plugin.analytics.getPlugins = jest.fn().mockReturnValue([
+      {
+        key: 'firebase',
+        type: 'destination',
+      },
+    ]);
+
+    const event: TrackEventType = {
+      anonymousId: '3534a492-e975-4efa-a18b-3c70c562fec2',
+      event: 'Awesome event',
+      type: EventType.TrackEvent,
+      properties: {},
+      timestamp: '2000-01-01T00:00:00.000Z',
+      messageId: '1d1744bf-5beb-41ac-ad7a-943eac33babc',
+      context: { app: { name: 'TestApp' } },
+      integrations: {
+        firebase: true,
+      },
+    };
+
+    const result = await plugin.execute(event);
+    expect(result).toEqual(event);
+  });
+
+  it('lets plugins/events disable destinations individually', async () => {
+    const plugin = new SegmentDestination();
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    plugin.analytics = new SegmentClient({
+      ...clientArgs,
+      store: new MockSegmentStore({
+        settings: {
+          [SEGMENT_DESTINATION_KEY]: {},
+        },
+      }),
+    });
+
+    const event: TrackEventType = {
+      anonymousId: '3534a492-e975-4efa-a18b-3c70c562fec2',
+      event: 'Awesome event',
+      type: EventType.TrackEvent,
+      properties: {},
+      timestamp: '2000-01-01T00:00:00.000Z',
+      messageId: '1d1744bf-5beb-41ac-ad7a-943eac33babc',
+      context: { app: { name: 'TestApp' } },
+      integrations: {
+        [SEGMENT_DESTINATION_KEY]: false,
+      },
+    };
+
+    const result = await plugin.execute(event);
+    expect(result).toEqual(undefined);
+  });
+
+  describe('uploads', () => {
+    const createTestWith = ({
+      config,
+      settings,
+      events,
+    }: {
+      config?: Config;
+      settings?: SegmentAPIIntegration;
+      events: SegmentEvent[];
+    }) => {
+      const plugin = new SegmentDestination();
+
+      const analytics = new SegmentClient({
+        ...clientArgs,
+        config: config ?? clientArgs.config,
+        store: new MockSegmentStore({
+          settings: {
+            [SEGMENT_DESTINATION_KEY]: {},
+          },
+        }),
+      });
+
+      plugin.configure(analytics);
+      // The settings store won't match but that's ok, the plugin should rely only on the settings it receives during update
+      plugin.update(
+        {
+          integrations: {
+            [SEGMENT_DESTINATION_KEY]: settings ?? {},
+          },
+        },
+        UpdateType.initial
+      );
+
+      jest
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        .spyOn(plugin.queuePlugin.queueStore!, 'getState')
+        .mockImplementation(createMockStoreGetter(() => ({ events })));
+
+      const sendEventsSpy = jest
+        .spyOn(api, 'uploadEvents')
+        .mockResolvedValue({ ok: true } as Response);
+
+      return {
+        plugin,
+        sendEventsSpy,
+      };
+    };
+
+    it('chunks the events correctly', async () => {
+      const events = [
+        { messageId: 'message-1' },
+        { messageId: 'message-2' },
+        { messageId: 'message-3' },
+        { messageId: 'message-4' },
+      ] as SegmentEvent[];
+
+      const { plugin, sendEventsSpy } = createTestWith({
+        events: events,
+      });
+
+      await plugin.flush();
+
+      expect(sendEventsSpy).toHaveBeenCalledTimes(2);
+      expect(sendEventsSpy).toHaveBeenCalledWith({
+        url: getURL(defaultApiHost, ''), // default api already appended with '/b'
+        writeKey: '123-456',
+        events: events.slice(0, 2).map((e) => ({
+          ...e,
+        })),
+      });
+      expect(sendEventsSpy).toHaveBeenCalledWith({
+        url: getURL(defaultApiHost, ''), // default api already appended with '/b'
+        writeKey: '123-456',
+        events: events.slice(2, 4).map((e) => ({
+          ...e,
+        })),
+      });
+    });
+
+    it('uses segment settings apiHost for uploading events', async () => {
+      const customEndpoint = 'events.eu1.segmentapis.com';
+      const events = [
+        { messageId: 'message-1' },
+        { messageId: 'message-2' },
+      ] as SegmentEvent[];
+
+      const { plugin, sendEventsSpy } = createTestWith({
+        events: events,
+        settings: {
+          apiKey: '',
+          apiHost: customEndpoint,
+        },
+      });
+
+      await plugin.flush();
+
+      expect(sendEventsSpy).toHaveBeenCalledTimes(1);
+      expect(sendEventsSpy).toHaveBeenCalledWith({
+        url: getURL(customEndpoint, '/b'),
+        writeKey: '123-456',
+        events: events.slice(0, 2).map((e) => ({
+          ...e,
+        })),
+      });
+    });
+
+    it.each([
+      [false, false], // No proxy, No segment endpoint
+      [false, true], // No proxy, Yes segment endpoint
+      [true, false], // Yes proxy, No segment endpoint
+      [true, true], // Yes proxy, Yes segment endpoint
+    ])(
+      'lets user override apiHost with proxy when hasProxy is %s and useSegmentEndpoints is %s',
+      async (hasProxy, useSegmentEndpoints) => {
+        const customEndpoint = 'https://customproxy.com/batchEvents';
+        const events = [
+          { messageId: 'message-1' },
+          { messageId: 'message-2' },
+        ] as SegmentEvent[];
+
+        const { plugin, sendEventsSpy } = createTestWith({
+          events,
+          settings: {
+            apiKey: '',
+            apiHost: 'events.eu1.segmentapis.com',
+          },
+          config: {
+            ...clientArgs.config,
+            proxy: hasProxy ? customEndpoint : undefined, // Only set proxy when true
+            useSegmentEndpoints, // Pass the flag dynamically
+          },
+        });
+
+        // Determine expected URL logic
+        let expectedUrl: string;
+        if (hasProxy) {
+          if (useSegmentEndpoints) {
+            expectedUrl = getURL(customEndpoint, '/b');
+          } else {
+            expectedUrl = getURL(customEndpoint, '');
+          }
+        } else {
+          expectedUrl = getURL('events.eu1.segmentapis.com', '/b');
+        }
+
+        await plugin.flush();
+
+        expect(sendEventsSpy).toHaveBeenCalledTimes(1);
+        expect(sendEventsSpy).toHaveBeenCalledWith({
+          url: expectedUrl,
+          writeKey: '123-456',
+          events: events.map((e) => ({
+            ...e,
+          })),
+        });
+      }
+    );
+  });
+  describe('getEndpoint', () => {
+    it.each([
+      ['example.com/v1/', 'https://example.com/v1/'],
+      ['https://example.com/v1/', 'https://example.com/v1/'],
+      ['http://example.com/v1/', 'http://example.com/v1/'],
+    ])(
+      'should append b if proxy end with / and useSegmentEndpoint is true',
+      (proxy, expectedBaseURL) => {
+        const plugin = new SegmentDestination();
+        const config = {
+          ...clientArgs.config,
+          useSegmentEndpoints: true,
+          proxy: proxy,
+        };
+        plugin.analytics = new SegmentClient({
+          ...clientArgs,
+          config,
+        });
+        const spy = jest.spyOn(Object.getPrototypeOf(plugin), 'getEndpoint');
+        expect(plugin['getEndpoint']()).toBe(`${expectedBaseURL}b`);
+        expect(spy).toHaveBeenCalled();
+      }
+    );
+    it.each([
+      ['example.com/v1/b/', 'https://example.com/v1/b/'],
+      ['https://example.com/v1/b/', 'https://example.com/v1/b/'],
+      ['http://example.com/v1/b/', 'http://example.com/v1/b/'],
+    ])(
+      'should append b if proxy ends with b/ and useSegmentEndpoint is true',
+      (proxy, expectedBaseURL) => {
+        const plugin = new SegmentDestination();
+        const config = {
+          ...clientArgs.config,
+          useSegmentEndpoints: true,
+          proxy: proxy,
+        };
+        plugin.analytics = new SegmentClient({
+          ...clientArgs,
+          config,
+        });
+
+        const spy = jest.spyOn(Object.getPrototypeOf(plugin), 'getEndpoint');
+        expect(plugin['getEndpoint']()).toBe(`${expectedBaseURL}b`);
+        expect(spy).toHaveBeenCalled();
+      }
+    );
+    it.each([
+      ['example.com/v1/b', 'https://example.com/v1/b'],
+      ['https://example.com/v1/b', 'https://example.com/v1/b'],
+      ['http://example.com/v1/b', 'http://example.com/v1/b'],
+    ])(
+      'should append /b if proxy ends with /b and useSegmentEndpoint is true',
+      (proxy, expectedBaseURL) => {
+        const plugin = new SegmentDestination();
+        const config = {
+          ...clientArgs.config,
+          useSegmentEndpoints: true,
+          proxy: proxy,
+        };
+        plugin.analytics = new SegmentClient({
+          ...clientArgs,
+          config,
+        });
+
+        const spy = jest.spyOn(Object.getPrototypeOf(plugin), 'getEndpoint');
+        expect(plugin['getEndpoint']()).toBe(`${expectedBaseURL}/b`);
+        expect(spy).toHaveBeenCalled();
+      }
+    );
+    it.each([
+      ['example.com/v1?params=xx'],
+      ['https://example.com/v1?params=xx'],
+      ['http://example.com/v1?params=xx'],
+    ])(
+      'should throw an error if proxy comes with query params and useSegmentEndpoint is true',
+      (proxy) => {
+        const plugin = new SegmentDestination();
+        const config = {
+          ...clientArgs.config,
+          useSegmentEndpoints: true,
+          proxy: proxy,
+        };
+        plugin.analytics = new SegmentClient({
+          ...clientArgs,
+          config,
+        });
+
+        const spy = jest.spyOn(Object.getPrototypeOf(plugin), 'getEndpoint');
+        // Expect the private method to throw an error
+        expect(plugin['getEndpoint']()).toBe(defaultApiHost);
+        expect(spy).toHaveBeenCalled();
+      }
+    );
+    it.each([
+      ['example.com/v1/', false],
+      ['example.com/b/', false],
+      ['example.com/b', false],
+      ['example.com/v1?params=xx', false],
+    ])(
+      'should always return identical result if proxy is provided and useSegmentEndpoints is false',
+      (proxy, useSegmentEndpoints) => {
+        const plugin = new SegmentDestination();
+        const config = {
+          ...clientArgs.config,
+          useSegmentEndpoints: useSegmentEndpoints,
+          proxy: proxy,
+        };
+        plugin.analytics = new SegmentClient({
+          ...clientArgs,
+          config,
+        });
+        const spy = jest.spyOn(Object.getPrototypeOf(plugin), 'getEndpoint');
+        const expected = `https://${proxy}`;
+        expect(plugin['getEndpoint']()).toBe(expected);
+        expect(spy).toHaveBeenCalled();
+      }
+    );
+    it('No proxy provided, should return default API host', () => {
+      const plugin = new SegmentDestination();
+      const config = {
+        ...clientArgs.config,
+        useSegmentEndpoints: true, // No matter in this case
+      };
+      plugin.analytics = new SegmentClient({
+        ...clientArgs,
+        config,
+      });
+      const spy = jest.spyOn(Object.getPrototypeOf(plugin), 'getEndpoint');
+      expect(plugin['getEndpoint']()).toBe(defaultApiHost);
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+});