@jmartins-tillster/analytics-react-native 2.21.3

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

@@ -0,0 +1,252 @@
+import type { AppStateStatus } from 'react-native';
+import { AppState } from 'react-native';
+import { SegmentClient } from '../analytics';
+import { ErrorType, SegmentError } from '../errors';
+import { CountFlushPolicy, TimerFlushPolicy } from '../flushPolicies';
+import { getMockLogger, MockSegmentStore } from '../test-helpers';
+
+jest.mock('../api');
+
+describe('SegmentClient', () => {
+  const store = new MockSegmentStore();
+  const clientArgs = {
+    config: {
+      writeKey: 'SEGMENT_KEY',
+      flushAt: 10,
+      trackAppLifecycleEvents: true,
+    },
+    logger: getMockLogger(),
+    store: store,
+  };
+
+  let client: SegmentClient;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    client.cleanup();
+  });
+
+  describe('when initializing a new client', () => {
+    it('creates the client with default values', () => {
+      client = new SegmentClient(clientArgs);
+      expect(client.getConfig()).toEqual(clientArgs.config);
+    });
+  });
+
+  describe('#setupInterval', () => {
+    beforeEach(() => {
+      // Using the legacy timers of jest to track calls
+      jest.useFakeTimers({ legacyFakeTimers: true });
+    });
+
+    afterEach(() => {
+      jest.clearAllTimers();
+    });
+
+    it('resets the interval and creates a new one when initialised', async () => {
+      client = new SegmentClient({
+        ...clientArgs,
+        config: { ...clientArgs.config, flushInterval: 10 },
+      });
+      await client.init();
+
+      const flush = jest.spyOn(client, 'flush');
+
+      // Wait 10 secs for the flush interval to happen
+      jest.advanceTimersByTime(10 * 1000);
+
+      // Flush should have been called at flushInterval
+      expect(flush).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('#setupLifecycleEvents', () => {
+    it('subscribes to the app state update events', async () => {
+      let updateCallback = (_val: AppStateStatus) => {
+        return;
+      };
+
+      const addSpy = jest
+        .spyOn(AppState, 'addEventListener')
+        .mockImplementation((_action, callback) => {
+          updateCallback = callback;
+          return { remove: jest.fn() };
+        });
+
+      client = new SegmentClient(clientArgs);
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      jest.spyOn(client, 'handleAppStateChange');
+      await client.init();
+
+      expect(addSpy).toHaveBeenCalledTimes(1);
+      expect(addSpy).toHaveBeenCalledWith('change', expect.any(Function));
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      expect(client.handleAppStateChange).not.toHaveBeenCalled();
+
+      updateCallback('active');
+
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      expect(client.handleAppStateChange).toHaveBeenCalledTimes(1);
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      expect(client.handleAppStateChange).toHaveBeenCalledWith('active');
+    });
+  });
+
+  describe('#cleanup', () => {
+    it('clears all subscriptions and timers', async () => {
+      const segmentClient = new SegmentClient(clientArgs);
+      await segmentClient.init();
+
+      jest.spyOn(
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        segmentClient.appStateSubscription,
+        'remove'
+      );
+
+      segmentClient.cleanup();
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      expect(segmentClient.destroyed).toBe(true);
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      expect(segmentClient.appStateSubscription?.remove).toHaveBeenCalledTimes(
+        1
+      );
+    });
+  });
+
+  describe('#reset', () => {
+    it('resets all userInfo except anonymousId', async () => {
+      client = new SegmentClient(clientArgs);
+      const setUserInfo = jest.spyOn(store.userInfo, 'set');
+      await client.reset(false);
+
+      expect(setUserInfo).toHaveBeenCalledWith({
+        anonymousId: 'anonymousId',
+        userId: undefined,
+        traits: undefined,
+      });
+    });
+
+    it('resets user data, identity, traits', async () => {
+      client = new SegmentClient(clientArgs);
+      const setUserInfo = jest.spyOn(store.userInfo, 'set');
+      await client.reset();
+
+      expect(setUserInfo).toHaveBeenCalledWith({
+        anonymousId: 'mocked-uuid',
+        userId: undefined,
+        traits: undefined,
+      });
+    });
+  });
+
+  describe('Error Handler', () => {
+    it('calls the error handler when reportErrorInternal is called', () => {
+      const errorHandler = jest.fn();
+      client = new SegmentClient({
+        ...clientArgs,
+        config: { ...clientArgs.config, errorHandler: errorHandler },
+      });
+
+      const error = new SegmentError(
+        ErrorType.NetworkUnknown,
+        'Some weird error'
+      );
+      client.reportInternalError(error);
+
+      expect(errorHandler).toHaveBeenCalledWith(error);
+    });
+  });
+
+  describe('Flush Policies', () => {
+    it('creates the default flush policies when config is empty', async () => {
+      client = new SegmentClient({
+        ...clientArgs,
+        config: {
+          ...clientArgs.config,
+          flushAt: undefined,
+          flushInterval: undefined,
+        },
+      });
+      await client.init();
+      const flushPolicies = client.getFlushPolicies();
+      expect(flushPolicies.length).toBe(2);
+    });
+
+    it('setting flush policies is mutually exclusive with flushAt/Interval', async () => {
+      client = new SegmentClient({
+        ...clientArgs,
+        config: {
+          ...clientArgs.config,
+          flushAt: 5,
+          flushInterval: 30,
+          flushPolicies: [new CountFlushPolicy(1)],
+        },
+      });
+      await client.init();
+      const flushPolicies = client.getFlushPolicies();
+      expect(flushPolicies.length).toBe(1);
+    });
+
+    it('setting flushAt/Interval to 0 should make the client have no uploads', async () => {
+      client = new SegmentClient({
+        ...clientArgs,
+        config: {
+          ...clientArgs.config,
+          flushAt: 0,
+          flushInterval: 0,
+        },
+      });
+      await client.init();
+      const flushPolicies = client.getFlushPolicies();
+      expect(flushPolicies.length).toBe(0);
+    });
+
+    it('setting an empty array of policies should make the client have no uploads', async () => {
+      client = new SegmentClient({
+        ...clientArgs,
+        config: {
+          ...clientArgs.config,
+          flushAt: undefined,
+          flushInterval: undefined,
+          flushPolicies: [],
+        },
+      });
+      await client.init();
+      const flushPolicies = client.getFlushPolicies();
+      expect(flushPolicies.length).toBe(0);
+    });
+
+    it('can add and remove policies, does not mutate original array', async () => {
+      const policies = [new CountFlushPolicy(1), new TimerFlushPolicy(200)];
+      client = new SegmentClient({
+        ...clientArgs,
+        config: {
+          ...clientArgs.config,
+          flushAt: undefined,
+          flushInterval: undefined,
+          flushPolicies: policies,
+        },
+      });
+      await client.init();
+      expect(client.getFlushPolicies().length).toBe(policies.length);
+
+      client.removeFlushPolicy(...policies);
+      expect(client.getFlushPolicies().length).toBe(0);
+
+      client.addFlushPolicy(...policies);
+      expect(client.getFlushPolicies().length).toBe(policies.length);
+    });
+  });
+});

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

@@ -0,0 +1,91 @@
+import {
+  Context,
+  EventType,
+  SegmentAPIIntegrations,
+  TrackEventType,
+  UserTraits,
+} from '../types';
+import { uploadEvents } from '../api';
+import * as context from '../context';
+
+describe('#sendEvents', () => {
+  beforeEach(() => {
+    jest
+      .spyOn(context, 'getContext')
+      .mockImplementationOnce(
+        async (userTraits?: UserTraits): Promise<Context> => {
+          return {
+            traits: userTraits ?? {},
+          } as Context;
+        }
+      );
+
+    jest
+      .spyOn(Date.prototype, 'toISOString')
+      .mockReturnValue('2001-01-01T00:00:00.000Z');
+  });
+
+  async function sendAnEventPer(writeKey: string, toUrl: string) {
+    const mockResponse = Promise.resolve('MANOS');
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    global.fetch = jest.fn(() => Promise.resolve(mockResponse));
+
+    const serializedEventProperties: 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 and Integration exist on SegmentEvents but are transmitted separately to avoid duplication
+    const additionalEventProperties: {
+      context: Context;
+      integrations: SegmentAPIIntegrations;
+    } = {
+      context: await context.getContext({ name: 'Hello' }),
+      integrations: {
+        Firebase: false,
+      },
+    };
+
+    const event = {
+      ...serializedEventProperties,
+      ...additionalEventProperties,
+    };
+
+    await uploadEvents({
+      writeKey: writeKey,
+      url: toUrl,
+      events: [event],
+    });
+
+    expect(fetch).toHaveBeenCalledWith(toUrl, {
+      method: 'POST',
+      body: JSON.stringify({
+        batch: [event],
+        sentAt: '2001-01-01T00:00:00.000Z',
+        writeKey: 'SEGMENT_KEY',
+      }),
+      headers: {
+        'Content-Type': 'application/json; charset=utf-8',
+      },
+    });
+  }
+
+  it('sends an event', async () => {
+    const toSegmentBatchApi = 'https://api.segment.io/v1.b';
+    const writeKey = 'SEGMENT_KEY';
+
+    await sendAnEventPer(writeKey, toSegmentBatchApi);
+  });
+
+  it('sends an event to proxy', async () => {
+    const toProxyUrl = 'https://myprox.io/b';
+    const writeKey = 'SEGMENT_KEY';
+
+    await sendAnEventPer(writeKey, toProxyUrl);
+  });
+});

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

@@ -0,0 +1,27 @@
+import type { SegmentClient } from '../analytics';
+import { createClient } from '../client';
+import { getMockLogger } from '../test-helpers';
+
+jest.mock('uuid');
+
+describe('#createClient', () => {
+  const config = {
+    writeKey: 'SEGMENT_KEY',
+    logger: getMockLogger(),
+  };
+
+  let client: SegmentClient;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    client.cleanup();
+  });
+
+  it('creates the client with the provided logger', () => {
+    client = createClient(config);
+    expect(client.logger).toBe(config.logger);
+  });
+});

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

@@ -0,0 +1,122 @@
+import { NativeModules } from 'react-native';
+import type { Context, NativeContextInfo, UserTraits } from '../types';
+
+import packageJson from '../../package.json';
+
+import { getContext } from '../context';
+import type { AnalyticsReactNativeModule } from '../types';
+
+const UUID = 'uuid-uuid-very-unique';
+
+jest.mock('../uuid', () => ({
+  getUUID: () => UUID,
+}));
+
+describe('#getContext', () => {
+  const mockNativeContext: NativeContextInfo = {
+    appName: 'Segment Example',
+    appVersion: '1.0',
+    buildNumber: '1',
+    bundleId: 'com.segment.example.analytics',
+    locale: 'en_US',
+    networkType: 'wifi',
+    osName: 'iOS',
+    osVersion: '14.1',
+    screenHeight: 800,
+    screenWidth: 600,
+    screenDensity: 2.625,
+    timezone: 'Europe/London',
+    manufacturer: 'Apple',
+    model: 'x86_64',
+    deviceName: 'iPhone',
+    deviceId: '123-456-789',
+    deviceType: 'phone',
+  };
+
+  const contextResult: Context = {
+    app: {
+      build: '1',
+      name: 'Segment Example',
+      namespace: 'com.segment.example.analytics',
+      version: '1.0',
+    },
+    device: {
+      id: '123-456-789',
+      manufacturer: 'Apple',
+      model: 'x86_64',
+      name: 'iPhone',
+      type: 'phone',
+    },
+    library: {
+      name: 'analytics-react-native',
+      version: packageJson.version,
+    },
+    locale: 'en_US',
+    network: {
+      cellular: false,
+      wifi: true,
+    },
+    os: {
+      name: 'iOS',
+      version: '14.1',
+    },
+    screen: {
+      density: 2.625,
+      height: 800,
+      width: 600,
+    },
+    timezone: 'Europe/London',
+    traits: {},
+    instanceId: UUID,
+  };
+
+  beforeEach(() => {
+    NativeModules.AnalyticsReactNative = {
+      getContextInfo: jest.fn().mockResolvedValue(mockNativeContext),
+    };
+  });
+
+  it('gets the context', async () => {
+    const { AnalyticsReactNative } = NativeModules;
+
+    const context = await getContext(undefined);
+
+    expect(
+      (AnalyticsReactNative as AnalyticsReactNativeModule).getContextInfo
+    ).toHaveBeenCalledTimes(1);
+    expect(context).toEqual(contextResult);
+  });
+
+  it('gets the context with Traits', async () => {
+    const { AnalyticsReactNative } = NativeModules;
+    const userTraits: UserTraits = {
+      firstName: 'John',
+      lastName: 'Doe',
+    };
+
+    const context = await getContext(userTraits);
+
+    expect(
+      (AnalyticsReactNative as AnalyticsReactNativeModule).getContextInfo
+    ).toHaveBeenCalledTimes(1);
+    expect(context).toEqual({ ...contextResult, traits: userTraits });
+  });
+
+  it('strip non-required config from native calls', async () => {
+    const { AnalyticsReactNative } = NativeModules;
+    await getContext(undefined, {
+      writeKey: 'notRequiredInNative',
+      collectDeviceId: true,
+      flushPolicies: [], // Shouldn't get to native as this is RN specific
+    });
+
+    expect(
+      (AnalyticsReactNative as AnalyticsReactNativeModule).getContextInfo
+    ).toHaveBeenCalledTimes(1);
+    expect(
+      (AnalyticsReactNative as AnalyticsReactNativeModule).getContextInfo
+    ).toHaveBeenCalledWith({
+      collectDeviceId: true,
+    });
+  });
+});