@jmartins-tillster/analytics-react-native 2.21.3

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

@@ -0,0 +1,162 @@
+import { SegmentClient } from '../../analytics';
+import { getMockLogger, MockSegmentStore } from '../../test-helpers';
+import { EventType, SegmentEvent } from '../../types';
+
+jest.mock('uuid');
+
+jest
+  .spyOn(Date.prototype, 'toISOString')
+  .mockReturnValue('2010-01-01T00:00:00.000Z');
+
+describe('process', () => {
+  const store = new MockSegmentStore({
+    userInfo: {
+      userId: 'current-user-id',
+      anonymousId: 'very-anonymous',
+    },
+    context: {
+      library: {
+        name: 'test',
+        version: '1.0',
+      },
+    },
+  });
+
+  const clientArgs = {
+    config: {
+      writeKey: 'mock-write-key',
+      flushInterval: 0,
+    },
+    logger: getMockLogger(),
+    store: store,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('stamps basic data: timestamp and messageId for pending events when not ready', async () => {
+    const client = new SegmentClient(clientArgs);
+    jest.spyOn(client.isReady, 'value', 'get').mockReturnValue(false);
+    // @ts-ignore
+    const timeline = client.timeline;
+    jest.spyOn(timeline, 'process');
+
+    await client.track('Some Event', { id: 1 });
+
+    let expectedEvent: Record<string, unknown> = {
+      event: 'Some Event',
+      properties: {
+        id: 1,
+      },
+      type: EventType.TrackEvent,
+    };
+
+    // While not ready only timestamp and messageId should be defined
+    // @ts-ignore
+    const pendingEvents = client.store.pendingEvents.get();
+    expect(pendingEvents.length).toBe(1);
+    const pendingEvent = pendingEvents[0];
+    expect(pendingEvent).toMatchObject(expectedEvent);
+    expect(pendingEvent.messageId).not.toBeUndefined();
+    expect(pendingEvent.timestamp).not.toBeUndefined();
+
+    // Not yet processed
+    expect(timeline.process).not.toHaveBeenCalled();
+
+    // When ready it replays events
+    jest.spyOn(client.isReady, 'value', 'get').mockReturnValue(true);
+    // @ts-ignore
+    await client.onReady();
+    // @ts-ignore
+    await client.processPendingEvents();
+    expectedEvent = {
+      ...expectedEvent,
+      context: { ...store.context.get() },
+      userId: store.userInfo.get().userId,
+      anonymousId: store.userInfo.get().anonymousId,
+    };
+
+    // @ts-ignore
+    expect(client.store.pendingEvents.get().length).toBe(0);
+
+    expect(timeline.process).toHaveBeenCalledWith(
+      expect.objectContaining(expectedEvent)
+    );
+  });
+
+  it('stamps all context and userInfo data for events when ready', async () => {
+    const client = new SegmentClient(clientArgs);
+    jest.spyOn(client.isReady, 'value', 'get').mockReturnValue(true);
+
+    // @ts-ignore
+    const timeline = client.timeline;
+    jest.spyOn(timeline, 'process');
+
+    await client.track('Some Event', { id: 1 });
+
+    const expectedEvent = {
+      event: 'Some Event',
+      properties: {
+        id: 1,
+      },
+      type: EventType.TrackEvent,
+      context: { ...store.context.get() },
+      userId: store.userInfo.get().userId,
+      anonymousId: store.userInfo.get().anonymousId,
+    } as SegmentEvent;
+
+    // @ts-ignore
+    const pendingEvents = client.store.pendingEvents.get();
+    expect(pendingEvents.length).toBe(0);
+
+    expect(timeline.process).toHaveBeenCalledWith(
+      expect.objectContaining(expectedEvent)
+    );
+  });
+
+  it('enrichment closure gets applied', async () => {
+    const client = new SegmentClient(clientArgs);
+    jest.spyOn(client.isReady, 'value', 'get').mockReturnValue(true);
+
+    // @ts-ignore
+    const timeline = client.timeline;
+    jest.spyOn(timeline, 'process');
+
+    await client.track('Some Event', { id: 1 }, (event) => {
+      if (event.context == null) {
+        event.context = {};
+      }
+      event.context.__eventOrigin = {
+        type: 'signals',
+      };
+      event.anonymousId = 'foo';
+
+      return event;
+    });
+
+    const expectedEvent = {
+      event: 'Some Event',
+      properties: {
+        id: 1,
+      },
+      type: EventType.TrackEvent,
+      context: {
+        __eventOrigin: {
+          type: 'signals',
+        },
+        ...store.context.get(),
+      },
+      userId: store.userInfo.get().userId,
+      anonymousId: 'foo',
+    } as SegmentEvent;
+
+    // @ts-ignore
+    const pendingEvents = client.store.pendingEvents.get();
+    expect(pendingEvents.length).toBe(0);
+
+    expect(timeline.process).toHaveBeenCalledWith(
+      expect.objectContaining(expectedEvent)
+    );
+  });
+});

package/packages/core/src/__tests__/methods/screen.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 #screen', () => {
+  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 screen event correctly', async () => {
+    const client = new SegmentClient(clientArgs);
+    jest.spyOn(client, 'process');
+
+    await client.screen('Home Screen', { id: 1 });
+
+    const expectedEvent = {
+      name: 'Home Screen',
+      properties: {
+        id: 1,
+      },
+      type: 'screen',
+    };
+
+    expect(client.process).toHaveBeenCalledTimes(1);
+    expect(client.process).toHaveBeenCalledWith(expectedEvent, undefined);
+  });
+});

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

@@ -0,0 +1,49 @@
+import { SegmentClient } from '../../analytics';
+import { getMockLogger, MockSegmentStore } from '../../test-helpers';
+import { EventType } from '../../types';
+
+jest.mock('uuid');
+
+jest
+  .spyOn(Date.prototype, 'toISOString')
+  .mockReturnValue('2010-01-01T00:00:00.000Z');
+
+describe('methods #track', () => {
+  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 track event correctly', async () => {
+    const client = new SegmentClient(clientArgs);
+    jest.spyOn(client, 'process');
+
+    await client.track('Some Event', { id: 1 });
+
+    const expectedEvent = {
+      event: 'Some Event',
+      properties: {
+        id: 1,
+      },
+      type: EventType.TrackEvent,
+    };
+
+    expect(client.process).toHaveBeenCalledTimes(1);
+    expect(client.process).toHaveBeenCalledWith(expectedEvent, undefined);
+  });
+});

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

@@ -0,0 +1,130 @@
+import { SegmentClient } from '../analytics';
+import { Plugin } from '../plugin';
+import { getMockLogger, MockSegmentStore } from '../test-helpers';
+import { Timeline } from '../timeline';
+import { EventType, PluginType, SegmentEvent, TrackEventType } from '../types';
+
+jest.mock('uuid');
+
+jest
+  .spyOn(Date.prototype, 'toISOString')
+  .mockReturnValue('2010-01-01T00:00:00.000Z');
+
+describe('timeline', () => {
+  const initialUserInfo = {
+    traits: {
+      name: 'Stacy',
+      age: 30,
+    },
+    userId: 'current-user-id',
+    anonymousId: 'very-anonymous',
+  };
+
+  const store = new MockSegmentStore({
+    userInfo: initialUserInfo,
+    settings: {
+      '1': true,
+      '2': true,
+    },
+  });
+
+  const clientArgs = {
+    config: {
+      writeKey: 'mock-write-key',
+      flushInterval: 0,
+    },
+    logger: getMockLogger(),
+    store: store,
+  };
+
+  const client = new SegmentClient(clientArgs);
+
+  class MockPlugin extends Plugin {
+    constructor(
+      private readonly executeFunc: (
+        event: SegmentEvent
+      ) => SegmentEvent | undefined,
+      type: PluginType
+    ) {
+      super();
+      this.type = type;
+      this.analytics = client;
+    }
+
+    execute(event: SegmentEvent) {
+      return this.executeFunc(event);
+    }
+  }
+
+  it('processes each destination independently', async () => {
+    const timeline = new Timeline();
+
+    const goodPlugin = jest.fn().mockImplementation((e: SegmentEvent) => e);
+    const badPlugin = jest.fn().mockImplementation(() => undefined);
+    timeline.add(new MockPlugin(badPlugin, PluginType.destination));
+    timeline.add(new MockPlugin(goodPlugin, PluginType.destination));
+
+    const expectedEvent: TrackEventType = {
+      type: EventType.TrackEvent,
+      event: 'test',
+      properties: {
+        test: 'sample',
+      },
+    };
+
+    const result = await timeline.process(expectedEvent);
+
+    expect(result).toEqual(expectedEvent);
+    expect(goodPlugin).toHaveBeenCalled();
+    expect(badPlugin).toHaveBeenCalled();
+  });
+
+  it('handles errors from plugins execution', async () => {
+    const timeline = new Timeline();
+
+    const goodPlugin = jest.fn().mockImplementation((e: SegmentEvent) => e);
+    const badPlugin = jest.fn().mockImplementation(() => {
+      throw 'ERROR';
+    });
+    timeline.add(new MockPlugin(badPlugin, PluginType.before));
+    timeline.add(new MockPlugin(goodPlugin, PluginType.before));
+
+    const expectedEvent: TrackEventType = {
+      type: EventType.TrackEvent,
+      event: 'test',
+      properties: {
+        test: 'sample',
+      },
+    };
+
+    const result = await timeline.process(expectedEvent);
+
+    expect(result).toEqual(expectedEvent);
+    expect(goodPlugin).toHaveBeenCalled();
+    expect(badPlugin).toHaveBeenCalled();
+  });
+
+  it('shortcircuits plugin execution if a plugin return undefined', async () => {
+    const timeline = new Timeline();
+
+    const goodPlugin = jest.fn().mockImplementation((e: SegmentEvent) => e);
+    const badPlugin = jest.fn().mockImplementation(() => undefined);
+    timeline.add(new MockPlugin(badPlugin, PluginType.before));
+    timeline.add(new MockPlugin(goodPlugin, PluginType.before));
+    timeline.add(new MockPlugin(goodPlugin, PluginType.destination));
+
+    const expectedEvent: TrackEventType = {
+      type: EventType.TrackEvent,
+      event: 'test',
+      properties: {
+        test: 'sample',
+      },
+    };
+
+    const result = await timeline.process(expectedEvent);
+
+    expect(result).toEqual(undefined);
+    expect(goodPlugin).not.toHaveBeenCalled();
+    expect(badPlugin).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,200 @@
+import { UserTraits } from '../types';
+import { chunk, allSettled, deepCompare, getURL } from '../util';
+
+describe('#chunk', () => {
+  it('handles empty array', () => {
+    expect(chunk([], 5)).toEqual([]);
+  });
+
+  it('handles chunk to 1', () => {
+    expect(chunk([1, 2, 3, 4], 1)).toEqual([[1], [2], [3], [4]]);
+  });
+
+  it('handles chunk to 2', () => {
+    expect(chunk([1, 2, 3, 4], 2)).toEqual([
+      [1, 2],
+      [3, 4],
+    ]);
+  });
+
+  it('handles remainders', () => {
+    expect(chunk([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);
+  });
+
+  it('handles max kb', () => {
+    const almost1KBString =
+      'heisxxohwswnetphtpnwyhluoeariblrgbksynoricexcoylnpmkymrgxmtuslveckeoulxqfwmemyxqvgyjnnclrmzcsacxkpdwzdthtudexkphsshjhlplvgryuqbqecgpbyussbgwuearvcmmrnkghcmcmynzxcswkghgrkhumeswvmhnhvymohluqooxmlbqdtxmeyikacyxvdkntrlwggoyrldmeaezowghoyukeeuaulxohknbbpyxpotonrtwfhoevysrfonevjtpjfywpptklmshzobtyklrahpkqnjifqtnxbeleeqxjacnphcomsdplxqmkcvnpxwbbmnmmzqvxmvpdrqaytlybmyghuckxnqlkgzptowgycanrenlgsgtwwbyudctiqmlszpzczfoglfoeuvdkublajngfmgstufgaroktarkeydqpmrgspuhbsqxqebzhycttsxkfcbgdqgctjgkrahoubqrvscdowafwfbysqerxqmzmakqibepyrjxjgcsnabjmovsgothxcawjsqzprxdnolyyhjfujgcxvniupmffqkhzknkzglazjflnnloazwslomxpegluqywyuvalysliziukrunfprejkojyihjjfcqdgsundoinipuzoxkqthslqgminkwcqglrjuhbqcirmuowdvizfsyubnllxxtjxqrctlzqmbfunxwzzbovogpvgrzeunvucaniqmqhwzcwqwzqvjaaeuajxgdhgitsekkowqejuouhaguudfkbyyivkayzsyoiymvavbabvtrgwmoadkvxxvgenttbohzngbzqiguficxkqvbxlrvkpycotawgalfdpmnmcfligffhivuzjtuxrwjjmzqcvbaocxfdmhnrcwhdmnpccikjvrskojxwnoiskacbivzfmbwyqfrhzjtdsjomzifswvaqdlorszbasmskosoullyyzpzjjzzkuvgoqwrzasqiroyaomrrxyqgzdigcwde';
+    expect(
+      chunk([almost1KBString, almost1KBString, almost1KBString], 5, 1)
+    ).toEqual([[almost1KBString], [almost1KBString], [almost1KBString]]);
+  });
+
+  it('handles max kb and count at the same time', () => {
+    const about500bString =
+      'jfywukefmafvjroiisrqxudmmkqibiwaknaywfberhhtiymwrzcyoitzemqhwqamkccbgccsinagjddhhnijndpqyejfaztdbmcunmdaewraamfzssfwyzddttjkdpwehphowxrbpohntfohxvmufgoyovfguxlghvoisbmtufpyxqgqylufzhvavjylkhavobvmzyqbojniyjhkgssmnujyicucskiaenpeutaqbxsnzuinhnvfqbkmmoxzxhangjxhnuhskmldksucmridbyacvhycxpdgkkibypdphhwrkpmwivtgbvnfkilxmwvxbxuxklqstjltilksgaaxqmhdtmublkwzobrcoofiyygahosrmbmgftybdmdpyptsrntukfyczdusqlfgyexyojcfuloyyuepgkyhivmiqruqxbvixfotvwzjbamrqopsjiyftiuwmhbcfsvkrmjpmwthpwwszgjarargfpmxxkuwaofahreb';
+    expect(
+      chunk([about500bString, about500bString, about500bString], 2, 1)
+    ).toEqual([[about500bString, about500bString], [about500bString]]);
+  });
+});
+
+describe('allSettled', () => {
+  it('handles all resolved and rejected promises properly', async () => {
+    const promises: (Promise<number> | number)[] = [];
+    promises.push(Promise.resolve(1));
+    promises.push(2);
+    promises.push(Promise.reject(3));
+
+    const results = await allSettled(promises);
+
+    expect(results).toEqual([
+      {
+        status: 'fulfilled',
+        value: 1,
+      },
+      {
+        status: 'fulfilled',
+        value: 2,
+      },
+      {
+        status: 'rejected',
+        reason: 3,
+      },
+    ]);
+  });
+});
+
+describe('deepCompare', () => {
+  const base: UserTraits = {
+    age: 30,
+    address: {
+      city: 'San Francisco',
+      country: 'USA',
+    },
+    company: {
+      name: 'Twilio',
+    },
+    deepNested: {
+      level1: {
+        level2: {
+          level3: true,
+        },
+      },
+    },
+  };
+
+  it('shallow compare, same object should return true', () => {
+    const a: UserTraits = { ...base };
+    const b: UserTraits = a;
+    expect(deepCompare(a, b)).toBe(true);
+  });
+
+  it('deep compare, object copy should return true', () => {
+    const a: UserTraits = { ...base };
+    const b: UserTraits = { ...base };
+    expect(deepCompare(a, b)).toBe(true);
+  });
+
+  it('deep compare, different key objects should return false', () => {
+    const a: UserTraits = { ...base };
+    const b: UserTraits = {
+      age: 20,
+      deepNested: {
+        level1: {
+          level2: {
+            level3: false,
+          },
+        },
+      },
+    };
+    expect(deepCompare(a, b)).toBe(false);
+  });
+
+  it('deep compare, modified objects should return false', () => {
+    const a: UserTraits = { ...base };
+    const b: UserTraits = {
+      ...base,
+      age: 20,
+      deepNested: {
+        level1: {
+          level2: {
+            level3: false,
+          },
+        },
+      },
+    };
+    expect(deepCompare(a, b)).toBe(false);
+  });
+
+  it('deep compare, different nested objects should return false', () => {
+    const a: UserTraits = { ...base };
+    const b: UserTraits = {
+      ...base,
+      age: 20,
+      deepNested: {
+        level1: {
+          level2: {
+            level3: true,
+          },
+          anotherLevel2: {
+            level3: true,
+          },
+        },
+      },
+    };
+    expect(deepCompare(a, b)).toBe(false);
+  });
+
+  it('deep compare, mistmatching nested object type should return false', () => {
+    const a: UserTraits = { ...base };
+    const b: UserTraits = {
+      ...base,
+      age: 20,
+      deepNested: {
+        level1: {
+          level2: 1,
+        },
+      },
+    };
+    expect(deepCompare(a, b)).toBe(false);
+  });
+});
+
+describe('getURL function', () => {
+  // Positive Test Cases
+  it('should return correct URL for valid host and path', () => {
+    expect(getURL('www.example.com', '/home')).toBe(
+      'https://www.example.com/home'
+    );
+    expect(getURL('blog.example.com', '/posts')).toBe(
+      'https://blog.example.com/posts'
+    );
+  });
+
+  it('should return the root URL when the path is empty', () => {
+    expect(getURL('www.example.com', '')).toBe('https://www.example.com');
+  });
+
+  it('should handle query parameters correctly in the URL path', () => {
+    expect(getURL('www.example.com', '/search?q=test')).toBe(
+      'https://www.example.com/search?q=test'
+    );
+  });
+
+  it('should handle special characters in the URL path', () => {
+    expect(getURL('www.example.com', '/about#section1')).toBe(
+      'https://www.example.com/about#section1'
+    );
+  });
+
+  // Negative Test Cases
+  it('should throw an error for empty host', () => {
+    expect(() => getURL('', '/home')).toThrow('Invalid URL has been passed');
+  });
+
+  it('should throw an error for invalid characters in the host', () => {
+    expect(() => getURL('invalid host.com', '/path')).toThrow(
+      'Invalid URL has been passed'
+    );
+  });
+});