@jmartins-tillster/analytics-react-native 2.21.3

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

@@ -0,0 +1,234 @@
+import {
+  createScreenEvent,
+  createTrackEvent,
+  createIdentifyEvent,
+  createGroupEvent,
+  createAliasEvent,
+} from '../events';
+import { EventType } from '../types';
+
+jest.mock('../uuid', () => ({
+  getUUID: () => 'iDMkR2-I7c2_LCsPPlvwH',
+}));
+
+describe('#createTrackEvent', () => {
+  beforeAll(() => {
+    jest
+      .spyOn(Date.prototype, 'toISOString')
+      .mockReturnValue('2000-01-01T00:00:00.000Z');
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('creates a track event with properties', () => {
+    const event = createTrackEvent({
+      event: 'Awesome event',
+      properties: {
+        foo: 'bar',
+      },
+    });
+
+    expect(event).toEqual({
+      type: EventType.TrackEvent,
+      event: 'Awesome event',
+      properties: {
+        foo: 'bar',
+      },
+    });
+  });
+
+  it('creates a track event without properties', () => {
+    const event = createTrackEvent({
+      event: 'Awesome event',
+    });
+
+    expect(event).toEqual({
+      type: EventType.TrackEvent,
+      event: 'Awesome event',
+      properties: {},
+    });
+  });
+
+  it('adds the user id when it exists', () => {
+    const event = createTrackEvent({
+      event: 'Awesome event',
+    });
+
+    expect(event).toEqual({
+      type: EventType.TrackEvent,
+      event: 'Awesome event',
+      properties: {},
+    });
+  });
+});
+
+describe('#createScreenEvent', () => {
+  beforeAll(() => {
+    jest
+      .spyOn(Date.prototype, 'toISOString')
+      .mockReturnValue('2000-01-01T00:00:00.000Z');
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('creates a screen event with properties', () => {
+    const event = createScreenEvent({
+      name: 'AwesomeScreen',
+      properties: {
+        foo: 'bar',
+      },
+    });
+
+    expect(event).toEqual({
+      type: 'screen',
+      name: 'AwesomeScreen',
+      properties: {
+        foo: 'bar',
+      },
+    });
+  });
+
+  it('creates a screen event without properties', () => {
+    const event = createScreenEvent({
+      name: 'AwesomeScreen',
+    });
+
+    expect(event).toEqual({
+      type: 'screen',
+      name: 'AwesomeScreen',
+      properties: {},
+    });
+  });
+
+  it('adds a user id if it exists', () => {
+    const event = createScreenEvent({
+      name: 'AwesomeScreen',
+    });
+
+    expect(event).toEqual({
+      type: 'screen',
+      name: 'AwesomeScreen',
+      properties: {},
+    });
+  });
+});
+
+describe('#createIdentifyEvent', () => {
+  beforeAll(() => {
+    jest
+      .spyOn(Date.prototype, 'toISOString')
+      .mockReturnValue('2000-01-01T00:00:00.000Z');
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('creates an identify event', () => {
+    const event = createIdentifyEvent({
+      userTraits: {
+        foo: 'bar',
+      },
+    });
+
+    expect(event).toEqual({
+      type: 'identify',
+      traits: {
+        foo: 'bar',
+      },
+    });
+  });
+
+  it('creates an identify event with optional traits', () => {
+    const event = createIdentifyEvent({});
+
+    expect(event).toEqual({
+      type: 'identify',
+      traits: {},
+    });
+  });
+});
+
+describe('#createGroupEvent', () => {
+  beforeAll(() => {
+    jest
+      .spyOn(Date.prototype, 'toISOString')
+      .mockReturnValue('2000-01-01T00:00:00.000Z');
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('creates a group event', () => {
+    const event = createGroupEvent({
+      groupId: 'some-group',
+      groupTraits: {
+        name: 'Segment',
+      },
+    });
+
+    expect(event).toEqual({
+      type: 'group',
+      groupId: 'some-group',
+      traits: {
+        name: 'Segment',
+      },
+    });
+  });
+
+  it('creates an group event with optional traits', () => {
+    const event = createGroupEvent({
+      groupId: 'some-group',
+    });
+
+    expect(event).toEqual({
+      groupId: 'some-group',
+      type: 'group',
+      traits: {},
+    });
+  });
+});
+
+describe('#createAliasEvent', () => {
+  beforeAll(() => {
+    jest
+      .spyOn(Date.prototype, 'toISOString')
+      .mockReturnValue('2000-01-01T00:00:00.000Z');
+  });
+
+  afterAll(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('creates an alias event', () => {
+    const event = createAliasEvent({
+      userId: 'user-123',
+      anonymousId: 'eWpqvL-EHSHLWoiwagN-T',
+      newUserId: 'new-user',
+    });
+
+    expect(event).toEqual({
+      userId: 'new-user',
+      type: 'alias',
+      previousId: 'user-123',
+    });
+  });
+
+  it('uses the anonymous id as previous id when no user id is available', () => {
+    const event = createAliasEvent({
+      anonymousId: 'eWpqvL-EHSHLWoiwagN-T',
+      newUserId: 'new-user',
+    });
+
+    expect(event).toEqual({
+      userId: 'new-user',
+      type: 'alias',
+      previousId: 'eWpqvL-EHSHLWoiwagN-T',
+    });
+  });
+});

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

@@ -0,0 +1,221 @@
+import deepmerge from 'deepmerge';
+
+import { SegmentClient } from '../../analytics';
+import * as context from '../../context';
+import { getMockLogger, MockSegmentStore } from '../../test-helpers';
+import { Context, EventType } from '../../types';
+
+jest.mock('uuid');
+
+jest
+  .spyOn(Date.prototype, 'toISOString')
+  .mockReturnValue('2010-01-01T00:00:00.000Z');
+
+const currentContext = {
+  app: {
+    version: '1.0',
+    build: '1',
+  },
+} as Context;
+
+describe('internal #checkInstalledVersion', () => {
+  const store = new MockSegmentStore();
+  const clientArgs = {
+    config: {
+      writeKey: 'mock-write-key',
+      trackAppLifecycleEvents: false,
+    },
+    logger: getMockLogger(),
+    store: store,
+  };
+  let client: SegmentClient;
+
+  beforeEach(() => {
+    store.reset();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    client.cleanup();
+  });
+
+  it('updates the context with the new value', async () => {
+    client = new SegmentClient(clientArgs);
+    jest.spyOn(context, 'getContext').mockResolvedValueOnce(currentContext);
+    await client.init();
+    expect(store.context.get()).toEqual(currentContext);
+  });
+
+  it('does not send any events when trackAppLifecycleEvents is false', async () => {
+    client = new SegmentClient(clientArgs);
+
+    jest.spyOn(context, 'getContext').mockResolvedValueOnce(currentContext);
+    const processSpy = jest.spyOn(client, 'process');
+
+    await client.init();
+
+    expect(processSpy).not.toHaveBeenCalled();
+  });
+
+  it('calls the application installed and opened events when there is no previous context', async () => {
+    client = new SegmentClient({
+      ...clientArgs,
+      config: {
+        ...clientArgs.config,
+        trackAppLifecycleEvents: true,
+      },
+    });
+
+    jest.spyOn(context, 'getContext').mockResolvedValueOnce(currentContext);
+    const processSpy = jest.spyOn(client, 'process');
+
+    await client.init();
+
+    expect(processSpy).toHaveBeenCalledTimes(2);
+    expect(processSpy).toHaveBeenCalledWith({
+      event: 'Application Installed',
+      properties: {
+        build: '1',
+        version: '1.0',
+      },
+      type: EventType.TrackEvent,
+    });
+    expect(processSpy).toHaveBeenCalledWith({
+      event: 'Application Opened',
+      properties: {
+        build: '1',
+        from_background: false,
+        version: '1.0',
+      },
+      type: EventType.TrackEvent,
+    });
+  });
+
+  it('calls the application updated and opened events when the previous version is different from current', async () => {
+    client = new SegmentClient({
+      ...clientArgs,
+      config: {
+        ...clientArgs.config,
+        trackAppLifecycleEvents: true,
+      },
+      store: new MockSegmentStore({
+        context: {
+          app: {
+            version: '2.0',
+            build: '2',
+          },
+        },
+      }),
+    });
+
+    jest.spyOn(context, 'getContext').mockResolvedValueOnce(currentContext);
+    const processSpy = jest.spyOn(client, 'process');
+
+    await client.init();
+
+    expect(processSpy).toHaveBeenCalledTimes(2);
+    expect(processSpy).toHaveBeenCalledWith({
+      event: 'Application Updated',
+      properties: {
+        build: '1',
+        previous_build: '2',
+        previous_version: '2.0',
+        version: '1.0',
+      },
+      type: EventType.TrackEvent,
+    });
+
+    expect(processSpy).toHaveBeenCalledWith({
+      event: 'Application Opened',
+      properties: {
+        build: '1',
+        from_background: false,
+        version: '1.0',
+      },
+      type: EventType.TrackEvent,
+    });
+  });
+
+  it('only sends the app opened event when the versions match', async () => {
+    client = new SegmentClient({
+      ...clientArgs,
+      config: {
+        ...clientArgs.config,
+        trackAppLifecycleEvents: true,
+      },
+      store: new MockSegmentStore({
+        context: { ...currentContext },
+      }),
+    });
+
+    jest.spyOn(context, 'getContext').mockResolvedValueOnce(currentContext);
+    const processSpy = jest.spyOn(client, 'process');
+
+    await client.init();
+
+    expect(processSpy).toHaveBeenCalledTimes(1);
+    expect(processSpy).toHaveBeenCalledWith({
+      event: 'Application Opened',
+      properties: {
+        from_background: false,
+        version: currentContext.app.version,
+        build: currentContext.app.build,
+      },
+      type: EventType.TrackEvent,
+    });
+  });
+
+  it('merges context and preserves context injected by plugins during configure', async () => {
+    const injectedContextByPlugins = {
+      device: {
+        adTrackingEnabled: true,
+        advertisingId: 'mock-advertising-id',
+      },
+    };
+
+    const store = new MockSegmentStore({
+      context: {
+        ...currentContext,
+        ...injectedContextByPlugins,
+      },
+    });
+
+    client = new SegmentClient({
+      ...clientArgs,
+      store,
+    });
+
+    const newContext = {
+      ...currentContext, // Just adding the full object to prevent TS complaining about missing properties
+      app: {
+        version: '1.5',
+        build: '2',
+        name: 'Test',
+        namespace: 'Test',
+      },
+      device: {
+        manufacturer: 'Apple',
+        model: 'iPhone',
+        name: 'iPhone',
+        type: 'iOS',
+      },
+    };
+    jest.spyOn(context, 'getContext').mockResolvedValueOnce(newContext);
+    await client.init();
+
+    expect(store.context.get()).toEqual(
+      deepmerge(newContext, injectedContextByPlugins)
+    );
+  });
+
+  it('executes callback when client is ready', async () => {
+    client = new SegmentClient(clientArgs);
+    const callback = jest.fn().mockImplementation(() => {
+      expect(store.context.get()).toEqual(currentContext);
+    });
+    client.isReady.onChange(callback);
+    jest.spyOn(context, 'getContext').mockResolvedValueOnce(currentContext);
+    await client.init();
+    expect(callback).toHaveBeenCalled();
+  });
+});