@jmartins-tillster/analytics-react-native 2.21.3

package/packages/core/src/test-helpers/mockLogger.ts

@@ -0,0 +1,10 @@
+import { Logger } from '../logger';
+
+export const getMockLogger = () => {
+  const logger = new Logger();
+  logger.disable();
+  logger.info = jest.fn();
+  logger.warn = jest.fn();
+  logger.error = jest.fn();
+  return logger;
+};

package/packages/core/src/test-helpers/mockSegmentStore.ts

@@ -0,0 +1,266 @@
+import { SEGMENT_DESTINATION_KEY } from '../plugins/SegmentDestination';
+import type {
+  DeepLinkData,
+  Dictionary,
+  Queue,
+  Settable,
+  Storage,
+  Watchable,
+} from '../storage';
+import type {
+  Context,
+  DeepPartial,
+  DestinationFilters,
+  EdgeFunctionSettings,
+  IntegrationSettings,
+  RoutingRule,
+  SegmentAPIConsentSettings,
+  SegmentAPIIntegrations,
+  SegmentEvent,
+  UserInfoState,
+} from '../types';
+import { createCallbackManager } from './utils';
+import { createGetter } from '../storage/helpers';
+
+export type StoreData = {
+  isReady: boolean;
+  enabled: boolean;
+  context?: DeepPartial<Context>;
+  settings: SegmentAPIIntegrations;
+  consentSettings?: SegmentAPIConsentSettings;
+  edgeFunctionSettings?: EdgeFunctionSettings;
+  filters: DestinationFilters;
+  userInfo: UserInfoState;
+  deepLinkData: DeepLinkData;
+  pendingEvents: SegmentEvent[];
+};
+
+const INITIAL_VALUES: StoreData = {
+  isReady: true,
+  enabled: true,
+  context: undefined,
+  settings: {
+    [SEGMENT_DESTINATION_KEY]: {},
+  },
+  consentSettings: undefined,
+  filters: {},
+  userInfo: {
+    anonymousId: 'anonymousId',
+    userId: undefined,
+    traits: undefined,
+  },
+  deepLinkData: {
+    referring_application: '',
+    url: '',
+  },
+  pendingEvents: [],
+};
+
+export function createMockStoreGetter<T>(fn: () => T) {
+  return createGetter(fn, () => {
+    return new Promise((resolve) => {
+      resolve(fn());
+    });
+  });
+}
+
+export class MockSegmentStore implements Storage {
+  private data: StoreData;
+  private initialData: StoreData;
+
+  reset = () => {
+    this.data = JSON.parse(JSON.stringify(this.initialData)) as StoreData;
+  };
+
+  constructor(initialData?: Partial<StoreData>) {
+    this.data = { ...INITIAL_VALUES, ...initialData };
+    this.initialData = JSON.parse(
+      JSON.stringify({ ...INITIAL_VALUES, ...initialData })
+    ) as StoreData;
+  }
+
+  private callbacks = {
+    context: createCallbackManager<DeepPartial<Context> | undefined>(),
+    settings: createCallbackManager<SegmentAPIIntegrations>(),
+    consentSettings: createCallbackManager<
+      SegmentAPIConsentSettings | undefined
+    >(),
+    edgeFunctionSettings: createCallbackManager<
+      EdgeFunctionSettings | undefined
+    >(),
+    filters: createCallbackManager<DestinationFilters>(),
+    userInfo: createCallbackManager<UserInfoState>(),
+    deepLinkData: createCallbackManager<DeepLinkData>(),
+    pendingEvents: createCallbackManager<SegmentEvent[]>(),
+    enabled: createCallbackManager<boolean>(),
+  };
+
+  readonly isReady = {
+    get: createMockStoreGetter(() => {
+      return this.data.isReady;
+    }),
+    onChange: (_callback: (value: boolean) => void) => {
+      return () => {
+        return;
+      };
+    },
+  };
+
+  readonly enabled = {
+    get: createMockStoreGetter(() => {
+      return this.data.enabled;
+    }),
+    onChange: (_callback: (value: boolean) => void) => {
+      return () => {
+        return;
+      };
+    },
+    set: async (value: boolean | ((prev: boolean) => boolean)) => {
+      this.data.enabled =
+        value instanceof Function ? value(this.data.enabled ?? true) : value;
+      this.callbacks.enabled.run(this.data.enabled);
+      return this.data.enabled;
+    },
+  };
+
+  readonly context: Watchable<DeepPartial<Context> | undefined> &
+    Settable<DeepPartial<Context>> = {
+    get: createMockStoreGetter(() => ({ ...this.data.context })),
+    onChange: (callback: (value?: DeepPartial<Context>) => void) =>
+      this.callbacks.context.register(callback),
+    set: (value) => {
+      this.data.context =
+        value instanceof Function
+          ? value(this.data.context ?? {})
+          : { ...value };
+      this.callbacks.context.run(this.data.context);
+      return this.data.context;
+    },
+  };
+
+  readonly settings: Watchable<SegmentAPIIntegrations | undefined> &
+    Settable<SegmentAPIIntegrations> &
+    Dictionary<string, IntegrationSettings, SegmentAPIIntegrations> = {
+    get: createMockStoreGetter(() => this.data.settings),
+    onChange: (callback: (value?: SegmentAPIIntegrations) => void) =>
+      this.callbacks.settings.register(callback),
+    set: (value) => {
+      this.data.settings =
+        value instanceof Function
+          ? value(this.data.settings ?? {})
+          : { ...value };
+      this.callbacks.settings.run(this.data.settings);
+      return this.data.settings;
+    },
+    add: (key: string, value: IntegrationSettings) => {
+      this.data.settings[key] = value;
+      this.callbacks.settings.run(this.data.settings);
+      return Promise.resolve(this.data.settings);
+    },
+  };
+
+  readonly consentSettings: Watchable<SegmentAPIConsentSettings | undefined> &
+    Settable<SegmentAPIConsentSettings | undefined> = {
+    get: createMockStoreGetter(() => this.data.consentSettings),
+    onChange: (callback: (value?: SegmentAPIConsentSettings) => void) =>
+      this.callbacks.consentSettings.register(callback),
+    set: (value) => {
+      this.data.consentSettings =
+        value instanceof Function ? value(this.data.consentSettings) : value;
+      this.callbacks.consentSettings.run(this.data.consentSettings);
+      return this.data.consentSettings;
+    },
+  };
+
+  readonly edgeFunctionSettings: Watchable<EdgeFunctionSettings | undefined> &
+    Settable<EdgeFunctionSettings | undefined> = {
+    get: createMockStoreGetter(() => this.data.edgeFunctionSettings),
+    onChange: (callback: (value?: EdgeFunctionSettings) => void) =>
+      this.callbacks.edgeFunctionSettings.register(callback),
+    set: (value) => {
+      this.data.edgeFunctionSettings =
+        value instanceof Function
+          ? value(this.data.edgeFunctionSettings)
+          : value;
+      this.callbacks.edgeFunctionSettings.run(this.data.edgeFunctionSettings);
+      return this.data.edgeFunctionSettings;
+    },
+  };
+
+  readonly filters: Watchable<DestinationFilters | undefined> &
+    Settable<DestinationFilters> &
+    Dictionary<string, RoutingRule, DestinationFilters> = {
+    get: createMockStoreGetter(() => this.data.filters),
+    onChange: (callback: (value?: DestinationFilters) => void) =>
+      this.callbacks.filters.register(callback),
+    set: (value) => {
+      this.data.filters =
+        value instanceof Function
+          ? value(this.data.filters ?? {})
+          : { ...value };
+      this.callbacks.filters.run(this.data.filters);
+      return this.data.filters;
+    },
+    add: (key: string, value: RoutingRule) => {
+      this.data.filters[key] = value;
+      this.callbacks.filters.run(this.data.filters);
+      return Promise.resolve(this.data.filters);
+    },
+  };
+
+  readonly userInfo: Watchable<UserInfoState> & Settable<UserInfoState> = {
+    get: createMockStoreGetter(() => this.data.userInfo),
+    onChange: (callback: (value: UserInfoState) => void) =>
+      this.callbacks.userInfo.register(callback),
+    set: (value) => {
+      this.data.userInfo =
+        value instanceof Function
+          ? value(this.data.userInfo ?? {})
+          : { ...value };
+      this.callbacks.userInfo.run(this.data.userInfo);
+      return this.data.userInfo;
+    },
+  };
+
+  readonly deepLinkData = {
+    get: createMockStoreGetter(() => {
+      return this.data.deepLinkData;
+    }),
+    set: (value: DeepLinkData) => {
+      this.data.deepLinkData = value;
+      this.callbacks.deepLinkData.run(value);
+    },
+    onChange: (callback: (value: DeepLinkData) => void) =>
+      this.callbacks.deepLinkData.register(callback),
+  };
+
+  readonly pendingEvents: Watchable<SegmentEvent[]> &
+    Settable<SegmentEvent[]> &
+    Queue<SegmentEvent, SegmentEvent[]> = {
+    get: createMockStoreGetter(() => {
+      return this.data.pendingEvents;
+    }),
+    set: (value) => {
+      this.data.pendingEvents =
+        value instanceof Function
+          ? value(this.data.pendingEvents ?? [])
+          : [...value];
+      this.callbacks.pendingEvents.run(this.data.pendingEvents);
+      return this.data.pendingEvents;
+    },
+    add: (value: SegmentEvent) => {
+      this.data.pendingEvents.push(value);
+      this.callbacks.pendingEvents.run(this.data.pendingEvents);
+      return Promise.resolve(this.data.pendingEvents);
+    },
+    remove: (value: SegmentEvent) => {
+      this.data.pendingEvents = this.data.pendingEvents.filter(
+        (e) => e.messageId != value.messageId
+      );
+      this.callbacks.pendingEvents.run(this.data.pendingEvents);
+      return Promise.resolve(this.data.pendingEvents);
+    },
+    onChange: (callback: (value: SegmentEvent[]) => void) =>
+      this.callbacks.pendingEvents.register(callback),
+  };
+}

package/packages/core/src/test-helpers/mockTimeline.ts

@@ -0,0 +1,9 @@
+import { Timeline } from '../timeline';
+import { getMockDestinationPlugin } from './mockDestinationPlugin';
+
+export const getMockTimeline = () => {
+  const timeline = new Timeline();
+  const destinationPlugin = getMockDestinationPlugin();
+  timeline.add(destinationPlugin);
+  return timeline;
+};

package/packages/core/src/test-helpers/setupSegmentClient.ts

@@ -0,0 +1,59 @@
+import { SegmentClient } from '../analytics';
+import { UtilityPlugin } from '../plugin';
+import { Config, PluginType, SegmentEvent } from '../types';
+import { getMockLogger } from './mockLogger';
+import { MockSegmentStore, StoreData } from './mockSegmentStore';
+
+jest
+  .spyOn(Date.prototype, 'toISOString')
+  .mockReturnValue('2010-01-01T00:00:00.000Z');
+
+export const createTestClient = (
+  storeData?: Partial<StoreData>,
+  config?: Partial<Config>
+) => {
+  const store = new MockSegmentStore({
+    isReady: true,
+    enabled: true,
+    ...storeData,
+  });
+
+  const clientArgs = {
+    config: {
+      writeKey: 'mock-write-key',
+      autoAddSegmentDestination: false,
+      flushInterval: 0,
+      ...config,
+    },
+    logger: getMockLogger(),
+    store: store,
+  };
+
+  const client = new SegmentClient(clientArgs);
+  class ObservablePlugin extends UtilityPlugin {
+    type = PluginType.after;
+
+    execute = async (
+      event: SegmentEvent
+    ): Promise<SegmentEvent | undefined> => {
+      await super.execute(event);
+      return event;
+    };
+  }
+
+  const mockPlugin = new ObservablePlugin();
+  jest.spyOn(mockPlugin, 'execute');
+
+  client.add({ plugin: mockPlugin });
+
+  return {
+    client,
+    store,
+    plugin: mockPlugin as UtilityPlugin,
+    expectEvent: (event: Partial<SegmentEvent>) => {
+      return expect(mockPlugin.execute).toHaveBeenCalledWith(
+        expect.objectContaining(event)
+      );
+    },
+  };
+};

package/packages/core/src/test-helpers/utils.ts

@@ -0,0 +1,23 @@
+export const createCallbackManager = <V, R = void>() => {
+  type Callback = (value: V) => R;
+  const callbacks: Callback[] = [];
+
+  const deregister = (callback: Callback) => {
+    callbacks.splice(callbacks.indexOf(callback), 1);
+  };
+
+  const register = (callback: Callback) => {
+    callbacks.push(callback);
+    return () => {
+      deregister(callback);
+    };
+  };
+
+  const run = (value: V) => {
+    for (const callback of [...callbacks]) {
+      callback(value);
+    }
+  };
+
+  return { register, deregister, run };
+};

package/packages/core/src/timeline.ts

@@ -0,0 +1,136 @@
+import { PluginType, SegmentEvent, UpdateType } from './types';
+import type { DestinationPlugin, Plugin } from './plugin';
+import { getAllPlugins } from './util';
+import { ErrorType, SegmentError } from './errors';
+
+type TimelinePlugins = {
+  [key in PluginType]?: Plugin[];
+};
+
+const PLUGIN_ORDER = [
+  PluginType.before,
+  PluginType.enrichment,
+  PluginType.destination,
+  PluginType.after,
+];
+
+export class Timeline {
+  plugins: TimelinePlugins = {
+    before: [],
+    enrichment: [],
+    destination: [],
+    after: [],
+  };
+
+  add(plugin: Plugin) {
+    const { type } = plugin;
+    if (this.plugins[type]) {
+      this.plugins[type]?.push(plugin);
+    } else {
+      this.plugins[type] = [plugin];
+    }
+    const settings = plugin.analytics?.settings.get();
+    let hasInitialSettings = false;
+    if (settings !== undefined) {
+      plugin.update({ integrations: settings }, UpdateType.initial);
+      hasInitialSettings = true;
+    }
+
+    plugin.analytics?.settings.onChange((newSettings) => {
+      if (newSettings !== undefined) {
+        plugin.update(
+          { integrations: newSettings },
+          hasInitialSettings ? UpdateType.refresh : UpdateType.initial
+        );
+        hasInitialSettings = true;
+      }
+    });
+  }
+
+  remove(plugin: Plugin) {
+    const plugins = this.plugins[plugin.type];
+    if (plugins) {
+      const index = plugins.findIndex((f) => f === plugin);
+      if (index > -1) {
+        plugins.splice(index, 1);
+      }
+    }
+  }
+
+  apply(closure: (plugin: Plugin) => void) {
+    getAllPlugins(this).forEach((plugin) => closure(plugin));
+  }
+
+  async process(
+    incomingEvent: SegmentEvent
+  ): Promise<SegmentEvent | undefined> {
+    let result: SegmentEvent | undefined = incomingEvent;
+
+    for (const key of PLUGIN_ORDER) {
+      const pluginResult: SegmentEvent | undefined = await this.applyPlugins({
+        type: key,
+        event: result!,
+      });
+
+      if (key !== PluginType.destination) {
+        if (result === undefined) {
+          return;
+        } else if (
+          key === PluginType.enrichment &&
+          pluginResult?.enrichment &&
+          typeof pluginResult.enrichment === 'function'
+        ) {
+          result = pluginResult.enrichment(pluginResult);
+        } else {
+          result = pluginResult;
+        }
+      }
+    }
+
+    return result;
+  }
+
+  async applyPlugins({
+    type,
+    event,
+  }: {
+    type: PluginType;
+    event: SegmentEvent;
+  }): Promise<SegmentEvent | undefined> {
+    let result: SegmentEvent | undefined = event;
+
+    const plugins = this.plugins[type];
+    if (plugins) {
+      for (const plugin of plugins) {
+        if (result) {
+          try {
+            const pluginResult = plugin.execute(result);
+            // Each destination is independent from each other, so we don't roll over changes caused internally in each one of their processing
+            if (type !== PluginType.destination) {
+              result = await pluginResult;
+              if (result === undefined) {
+                break;
+              }
+            } else {
+              await pluginResult;
+            }
+          } catch (error) {
+            plugin.analytics?.reportInternalError(
+              new SegmentError(
+                ErrorType.PluginError,
+                JSON.stringify(error),
+                error
+              )
+            );
+            plugin.analytics?.logger.warn(
+              `Destination ${
+                (plugin as DestinationPlugin).key
+              } failed to execute: ${JSON.stringify(error)}`
+            );
+          }
+        }
+      }
+    }
+    return result;
+  }
+}