@jmartins-tillster/analytics-react-native 2.21.3

package/packages/core/src/__tests__/internal/trackDeepLinks.test.ts

@@ -0,0 +1,121 @@
+import * as ReactNative from 'react-native';
+
+import { SegmentClient } from '../../analytics';
+import {
+  createMockStoreGetter,
+  getMockLogger,
+  MockSegmentStore,
+} from '../../test-helpers';
+import { EventType } from '../../types';
+
+jest.mock('uuid');
+
+jest
+  .spyOn(Date.prototype, 'toISOString')
+  .mockReturnValue('2000-01-01T00:00:00.000Z');
+
+describe('#trackDeepLinks', () => {
+  const store = new MockSegmentStore({
+    context: {
+      app: {
+        name: 'test',
+        version: '1.0',
+        build: '1',
+      },
+    },
+  });
+  const clientArgs = {
+    config: {
+      writeKey: 'mock-write-key',
+      trackDeepLinks: true,
+      trackAppLifecycleEvents: false,
+    },
+    logger: getMockLogger(),
+    store: store,
+  };
+
+  beforeEach(() => {
+    return;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    store.reset();
+  });
+
+  it('sends a track event when trackDeepLinks is enabled and the app was opened from a link', async () => {
+    const deepLinkData = {
+      url: 'myapp://open',
+      referring_application: 'Safari',
+    };
+    jest
+      .spyOn(store.deepLinkData, 'get')
+      .mockImplementation(createMockStoreGetter(() => deepLinkData));
+    const client = new SegmentClient(clientArgs);
+    jest.spyOn(client, 'process');
+
+    await client.init();
+
+    expect(client.process).toHaveBeenCalledTimes(1);
+    expect(client.process).toHaveBeenCalledWith({
+      event: 'Deep Link Opened',
+      properties: deepLinkData,
+      type: EventType.TrackEvent,
+    });
+    client.cleanup();
+  });
+
+  it('sends a track event when trackDeepLinks is enabled and the app was launched from a link from background', async () => {
+    const deepLinkData = {
+      url: 'myapp://open',
+      referring_application: 'Safari',
+    };
+
+    const client = new SegmentClient(clientArgs);
+    jest.spyOn(client, 'process');
+
+    await client.init();
+    store.deepLinkData.set(deepLinkData);
+    await new Promise(process.nextTick);
+
+    expect(client.process).toHaveBeenCalledTimes(1);
+    expect(client.process).toHaveBeenCalledWith({
+      event: 'Deep Link Opened',
+      properties: deepLinkData,
+      type: EventType.TrackEvent,
+    });
+    client.cleanup();
+  });
+
+  it('does not send a track event when trackDeepLinks is not enabled', async () => {
+    const client = new SegmentClient({
+      ...clientArgs,
+      config: {
+        writeKey: 'mock-write-key',
+        trackDeepLinks: false,
+      },
+    });
+    jest.spyOn(client, 'process');
+
+    jest
+      .spyOn(ReactNative.Linking, 'getInitialURL')
+      .mockResolvedValueOnce('myapp://open');
+
+    await client.init();
+
+    expect(client.process).not.toHaveBeenCalled();
+
+    client.cleanup();
+  });
+
+  it('does not send a track event when trackDeepLinks is enabled, but the app was not opened via deep link', async () => {
+    const client = new SegmentClient(clientArgs);
+    jest.spyOn(client, 'process');
+
+    await client.init();
+
+    expect(client.process).not.toHaveBeenCalled();
+
+    client.cleanup();
+  });
+});

package/packages/core/src/__tests__/logger.test.ts

@@ -0,0 +1,83 @@
+import { createLogger, Logger } from '../logger';
+
+describe('#createLogger', () => {
+  it('create a new logger', () => {
+    const logger = createLogger();
+    expect(logger).toBeInstanceOf(Logger);
+  });
+});
+
+describe('Logger', () => {
+  it('create a new logger instance', () => {
+    const logger = new Logger();
+
+    expect(logger.isDisabled).toBeFalsy();
+  });
+
+  it('create a new logger instance in production', () => {
+    const previousNodeEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'production';
+
+    const logger = new Logger();
+
+    expect(logger.isDisabled).toBe(true);
+
+    process.env.NODE_ENV = previousNodeEnv;
+  });
+
+  it('enables the logger', () => {
+    const logger = new Logger(true);
+    expect(logger.isDisabled).toBe(true);
+    logger.enable();
+    expect(logger.isDisabled).toBeFalsy();
+  });
+
+  it('disables the logger', () => {
+    const logger = new Logger();
+    expect(logger.isDisabled).toBeFalsy();
+    logger.disable();
+    expect(logger.isDisabled).toBe(true);
+  });
+
+  it('logs an info message - enabled logger', () => {
+    jest.spyOn(global.console, 'info').mockImplementationOnce(jest.fn());
+    const logger = new Logger(false);
+    logger.info('Hello world');
+    expect(console.info).toHaveBeenCalledWith('Hello world');
+  });
+
+  it('logs an info message - disabled logger', () => {
+    jest.spyOn(global.console, 'info').mockImplementationOnce(jest.fn());
+    const logger = new Logger(true);
+    logger.info('Hello world');
+    expect(console.info).not.toHaveBeenCalledWith();
+  });
+
+  it('logs a warn message - enabled logger', () => {
+    jest.spyOn(global.console, 'warn').mockImplementationOnce(jest.fn());
+    const logger = new Logger(false);
+    logger.warn('Hello world');
+    expect(console.warn).toHaveBeenCalledWith('Hello world');
+  });
+
+  it('logs a warn message - disabled logger', () => {
+    jest.spyOn(global.console, 'warn').mockImplementationOnce(jest.fn());
+    const logger = new Logger(true);
+    logger.warn('Hello world');
+    expect(console.warn).not.toHaveBeenCalledWith();
+  });
+
+  it('logs an error message - enabled logger', () => {
+    jest.spyOn(global.console, 'error').mockImplementationOnce(jest.fn());
+    const logger = new Logger(false);
+    logger.error('Hello world');
+    expect(console.error).toHaveBeenCalledWith('Hello world');
+  });
+
+  it('logs an error message - disabled logger', () => {
+    jest.spyOn(global.console, 'error').mockImplementationOnce(jest.fn());
+    const logger = new Logger(true);
+    logger.error('Hello world');
+    expect(console.error).not.toHaveBeenCalledWith();
+  });
+});

package/packages/core/src/__tests__/mapTransform.test.ts

@@ -0,0 +1,63 @@
+import { generateMapTransform } from '../mapTransform';
+import { isString } from '../util';
+
+describe('mapTransform', () => {
+  const keyMap: { [key: string]: string } = {
+    oldId: 'newId',
+    veryOldKey: 'muchNewerKey',
+    oldArray: 'newArray',
+  };
+
+  const transformMap: { [key: string]: (value: unknown) => unknown } = {
+    muchNewerKey: (value: unknown) => {
+      if (isString(value)) {
+        return value.slice(0, 3);
+      }
+      return value;
+    },
+    newArray: (value: unknown) => {
+      if (Array.isArray(value)) {
+        return value.slice(0, 1) as unknown[];
+      }
+      return value;
+    },
+  };
+
+  const testMapTransform = generateMapTransform(keyMap, transformMap);
+
+  it('maps keys to new values', () => {
+    const oldObject = {
+      oldId: 1,
+      veryOldKey: '123456',
+      nestedObject: {
+        veryOldKey: '123456',
+        nestedObject: {
+          veryOldKey: '123456',
+        },
+      },
+      oldArray: [
+        {
+          veryOldKey: '123456',
+          doNotTransform: 'nope',
+        },
+        {
+          veryOldKey: '123456',
+          doNotTransform: 'nope',
+        },
+        {
+          veryOldKey: '123456',
+          doNotTransform: 'nope',
+        },
+      ],
+    };
+
+    const clone = JSON.parse(JSON.stringify(oldObject)) as object;
+
+    const newObject = testMapTransform(oldObject);
+
+    // Original object shouldn't have mutated
+    expect(oldObject).toMatchObject(clone);
+    // New object should have new keys and values transformed
+    expect(newObject).toMatchSnapshot();
+  });
+});

package/packages/core/src/__tests__/methods/alias.test.ts

@@ -0,0 +1,89 @@
+import { createTestClient } from '../../test-helpers';
+import { EventType, SegmentEvent } from '../../types';
+
+jest.mock('uuid');
+
+jest
+  .spyOn(Date.prototype, 'toISOString')
+  .mockReturnValue('2010-01-01T00:00:00.000Z');
+
+describe('methods #alias', () => {
+  const initialUserInfo = {
+    anonymousId: 'anonymousId',
+    userId: 'current-user-id',
+  };
+
+  const { store, client, expectEvent } = createTestClient({
+    userInfo: initialUserInfo,
+  });
+
+  beforeEach(async () => {
+    store.reset();
+    jest.clearAllMocks();
+    await client.init();
+  });
+
+  it('adds the alias event correctly', async () => {
+    await client.alias('new-user-id');
+
+    const expectedEvent = {
+      previousId: 'current-user-id',
+      type: EventType.AliasEvent,
+      userId: 'new-user-id',
+    };
+
+    expectEvent(expectedEvent);
+
+    const info = await client.userInfo.get(true);
+    expect(info).toEqual({
+      anonymousId: 'anonymousId',
+      userId: 'new-user-id',
+      traits: undefined,
+    });
+  });
+
+  it('uses anonymousId in event if no userId in store', async () => {
+    await client.init();
+
+    await store.userInfo.set({
+      anonymousId: 'anonymousId',
+      userId: undefined,
+    });
+
+    await client.alias('new-user-id');
+
+    const expectedEvent = {
+      previousId: 'anonymousId',
+      type: EventType.AliasEvent,
+      userId: 'new-user-id',
+    };
+
+    expectEvent(expectedEvent);
+
+    expect(client.userInfo.get()).toEqual({
+      anonymousId: 'anonymousId',
+      userId: 'new-user-id',
+      traits: undefined,
+    });
+  });
+
+  it('is concurrency safe', async () => {
+    // We trigger an alias and do not await it, we do a track immediately and await.
+    // The track call should have the correct values injected into it.
+    void client.alias('new-user-id');
+    await client.track('something');
+
+    const expectedTrackEvent: Partial<SegmentEvent> = {
+      event: 'something',
+      userId: 'new-user-id',
+      type: EventType.TrackEvent,
+    };
+
+    expectEvent(expectedTrackEvent);
+
+    expect(client.userInfo.get()).toEqual({
+      ...initialUserInfo,
+      userId: 'new-user-id',
+    });
+  });
+});

package/packages/core/src/__tests__/methods/flush.test.ts

@@ -0,0 +1,120 @@
+import { SegmentClient } from '../../analytics';
+import {
+  getMockLogger,
+  getMockTimeline,
+  MockSegmentStore,
+} from '../../test-helpers';
+import { PluginType } from '../../types';
+
+import type { DestinationPlugin } from '../../plugin';
+jest.mock('react-native');
+jest.mock('uuid');
+
+describe('methods #flush', () => {
+  const store = new MockSegmentStore();
+
+  const clientArgs = {
+    config: {
+      writeKey: '123-456',
+      autoAddSegmentDestination: false,
+      trackAppLifecycleEvents: false,
+      flushInterval: 0,
+    },
+    logger: getMockLogger(),
+    store: store,
+  };
+
+  beforeEach(() => {
+    jest.useFakeTimers({ legacyFakeTimers: true });
+  });
+
+  afterEach(() => {
+    store.reset();
+    jest.clearAllMocks();
+  });
+
+  it('does not flush plugins when the client is destroyed', async () => {
+    const client = new SegmentClient(clientArgs);
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    client.timeline = getMockTimeline();
+    client.cleanup();
+
+    await client.flush();
+
+    const destinations = client.getPlugins(PluginType.destination);
+    const mockDestinationPlugin = destinations[0] as DestinationPlugin;
+    expect(mockDestinationPlugin.flush).not.toHaveBeenCalled();
+  });
+
+  it('calls flush on the plugins correctly', async () => {
+    const client = new SegmentClient({
+      ...clientArgs,
+      store: new MockSegmentStore({
+        userInfo: {
+          anonymousId: '123-456',
+          traits: {
+            name: 'Mary',
+          },
+        },
+      }),
+    });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    client.timeline = getMockTimeline();
+
+    const destinations = client.getPlugins(PluginType.destination);
+    const mockDestinationPlugin = destinations[0] as DestinationPlugin;
+
+    await client.flush();
+
+    expect(mockDestinationPlugin.flush).toHaveBeenCalledTimes(1);
+  });
+
+  // it('handles errors in posting an event', async () => {
+  //   const state = {
+  //     events: [
+  //       { messageId: 'message-1' },
+  //       { messageId: 'message-2' },
+  //     ] as SegmentEvent[],
+  //     eventsToRetry: [] as SegmentEvent[],
+  //     userTraits: {
+  //       name: 'Mary',
+  //     },
+  //   };
+  //   const clientContext = {
+  //     key: 'segment-key',
+  //     config: { maxBatchSize: 2 },
+  //     secondsElapsed: 10,
+  //     logger: getMockLogger(),
+  //     store: {
+  //       dispatch: jest.fn() as jest.MockedFunction<any>,
+  //       getState: () => state,
+  //     },
+  //     actions: {
+  //       deleteEventsByMessageId: jest.fn() as jest.MockedFunction<any>,
+  //       addEventsToRetry: jest.fn() as jest.MockedFunction<any>,
+  //     },
+  //     timeline: getMockTimeline(),
+  //   } as SegmentClientContext;
+
+  //   const sendEventsSpy = jest.spyOn(api, 'sendEvents').mockRejectedValue(null);
+
+  //   await flush.bind(clientContext)();
+
+  //   expect(sendEventsSpy).toHaveBeenCalledTimes(1);
+  //   expect(clientContext.store.dispatch).toHaveBeenCalledTimes(2);
+  //   expect(clientContext.actions.main.deleteEventsByMessageId).toHaveBeenCalledTimes(
+  //     1
+  //   );
+  //   expect(clientContext.actions.main.deleteEventsByMessageId).toHaveBeenCalledWith({
+  //     ids: ['message-1', 'message-2'],
+  //   });
+  //   expect(clientContext.actions.main.addEventsToRetry).toHaveBeenCalledTimes(1);
+  //   expect(clientContext.actions.main.addEventsToRetry).toHaveBeenCalledWith({
+  //     events: state.events,
+  //     config: clientContext.config,
+  //   });
+  // });
+});

package/packages/core/src/__tests__/methods/group.test.ts

@@ -0,0 +1,48 @@
+import { SegmentClient } from '../../analytics';
+import { getMockLogger, MockSegmentStore } from '../../test-helpers';
+
+jest.mock('uuid');
+
+jest
+  .spyOn(Date.prototype, 'toISOString')
+  .mockReturnValue('2010-01-01T00:00:00.000Z');
+
+describe('methods #group', () => {
+  const store = new MockSegmentStore({
+    userInfo: {
+      userId: 'current-user-id',
+      anonymousId: 'very-anonymous',
+    },
+  });
+
+  const clientArgs = {
+    config: {
+      writeKey: 'mock-write-key',
+      flushInterval: 0,
+    },
+    logger: getMockLogger(),
+    store: store,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('adds the alias event correctly', async () => {
+    const client = new SegmentClient(clientArgs);
+    jest.spyOn(client, 'process');
+
+    await client.group('new-group-id', { name: 'Best Group Ever' });
+
+    const expectedEvent = {
+      groupId: 'new-group-id',
+      type: 'group',
+      traits: {
+        name: 'Best Group Ever',
+      },
+    };
+
+    expect(client.process).toHaveBeenCalledTimes(1);
+    expect(client.process).toHaveBeenCalledWith(expectedEvent, undefined);
+  });
+});

package/packages/core/src/__tests__/methods/identify.test.ts

@@ -0,0 +1,132 @@
+import { createTestClient } from '../../test-helpers';
+import { EventType, SegmentEvent } from '../../types';
+
+describe('methods #identify', () => {
+  const initialUserInfo = {
+    traits: {
+      name: 'Stacy',
+      age: 30,
+    },
+    userId: 'current-user-id',
+    anonymousId: 'very-anonymous',
+  };
+  const { store, client, expectEvent } = createTestClient({
+    userInfo: initialUserInfo,
+  });
+
+  beforeEach(async () => {
+    store.reset();
+    jest.clearAllMocks();
+    await client.init();
+  });
+
+  it('adds the identify event correctly', async () => {
+    await client.identify('new-user-id', { name: 'Mary', age: 30 });
+
+    const expectedEvent: Partial<SegmentEvent> = {
+      traits: {
+        name: 'Mary',
+        age: 30,
+      },
+      userId: 'new-user-id',
+      type: EventType.IdentifyEvent,
+    };
+
+    expectEvent(expectedEvent);
+
+    expect(client.userInfo.get()).toEqual({
+      ...initialUserInfo,
+      userId: 'new-user-id',
+      traits: expectedEvent.traits,
+    });
+  });
+
+  it('does not update user traits when there are no new ones provided', async () => {
+    await client.identify('new-user-id');
+
+    const expectedEvent = {
+      traits: initialUserInfo.traits,
+      userId: 'new-user-id',
+      type: EventType.IdentifyEvent,
+    };
+
+    expectEvent(expectedEvent);
+
+    expect(client.userInfo.get()).toEqual({
+      ...initialUserInfo,
+      userId: 'new-user-id',
+    });
+  });
+
+  it('does not update userId when userId is undefined', async () => {
+    await client.identify(undefined, { name: 'Mary' });
+
+    const expectedEvent = {
+      traits: { name: 'Mary', age: 30 },
+      userId: 'current-user-id',
+      type: EventType.IdentifyEvent,
+    };
+
+    expectEvent(expectedEvent);
+    expect(client.userInfo.get()).toEqual({
+      ...initialUserInfo,
+      traits: {
+        age: 30,
+        name: 'Mary',
+      },
+    });
+  });
+
+  it('does not persist identity traits accross events', async () => {
+    await client.identify('new-user-id', { name: 'Mary', age: 30 });
+
+    const expectedEvent: Partial<SegmentEvent> = {
+      traits: {
+        name: 'Mary',
+        age: 30,
+      },
+      userId: 'new-user-id',
+      type: EventType.IdentifyEvent,
+    };
+    expectEvent(expectedEvent);
+
+    expect(client.userInfo.get()).toEqual({
+      ...initialUserInfo,
+      userId: 'new-user-id',
+      traits: expectedEvent.traits,
+    });
+
+    await client.track('track event');
+
+    expectEvent({
+      anonymousId: 'very-anonymous',
+      event: 'track event',
+      integrations: {},
+      messageId: 'mocked-uuid',
+      properties: {},
+      timestamp: '2010-01-01T00:00:00.000Z',
+      type: EventType.TrackEvent,
+      userId: 'new-user-id',
+    });
+  });
+
+  it('adds userInfo to next events, concurrency safe', async () => {
+    // We trigger an identify and do not await it, we do a track immediately and await.
+    // The track call should have the correct values injected into it.
+    void client.identify('new-user-id');
+    await client.track('something');
+
+    const expectedTrackEvent: Partial<SegmentEvent> = {
+      event: 'something',
+      userId: 'new-user-id',
+      type: EventType.TrackEvent,
+    };
+
+    expectEvent(expectedTrackEvent);
+
+    expect(client.userInfo.get()).toEqual({
+      ...initialUserInfo,
+      userId: 'new-user-id',
+    });
+  });
+});