event_processor_factory.react_native.spec.ts

/**
 * Copyright 2024-2026, Optimizely
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { vi, describe, it, expect, beforeEach } from 'vitest';

vi.mock('./default_dispatcher.browser', () => {
  return { default: {} };
});


vi.mock('./event_processor_factory', async importOriginal => {
  const getForwardingEventProcessor = vi.fn().mockReturnValue({});
  const getBatchEventProcessor = vi.fn().mockImplementation(() => {
    return {};
  });
  const getOpaqueBatchEventProcessor = vi.fn().mockImplementation(() => {
    return {};
  });
  const original: any = await importOriginal();
  return { ...original, getBatchEventProcessor, getOpaqueBatchEventProcessor, getForwardingEventProcessor };
});

vi.mock('../utils/cache/async_storage_cache.react_native', () => {
  return { AsyncStorageCache: vi.fn() };
});

vi.mock('./event_store', async (importOriginal) => {
  const actual: any = await importOriginal()
  return {
    ...actual,
    EventStore: vi.fn(),
  }
});

vi.mock('../utils/cache/store', async (importOriginal) => {
  const actual: any = await importOriginal()
  return { ...actual, SyncPrefixStore: vi.fn(), AsyncPrefixStore: vi.fn() };
});

vi.mock('@react-native-community/netinfo', () => {
  return { NetInfoState: {}, addEventListener: vi.fn() };
});
let isAsyncStorageAvailable = true;

// Mock Node.js module loader to simulate missing @react-native-async-storage/async-storage
vi.hoisted(() => {
  mockRequireNetInfo();
});

function mockRequireNetInfo() {
  // Dynamically import module synchronously in Node environment
  // eslint-disable-next-line @typescript-eslint/no-var-requires
  const { Module } = require('module');
  const M: any = Module;

  M._load_original = M._load;
  M._load = (uri: string, parent: string) => {
    if (uri === '@react-native-async-storage/async-storage') {
      if (isAsyncStorageAvailable) return {};
      throw new Error("Module not found: @react-native-async-storage/async-storage");
    }
    return M._load_original(uri, parent);
  };
}

import { createForwardingEventProcessor, createBatchEventProcessor } from './event_processor_factory.react_native';
import defaultEventDispatcher from './event_dispatcher/default_dispatcher.browser';
import { extractEventProcessor, getForwardingEventProcessor, FAILED_EVENT_RETRY_INTERVAL } from './event_processor_factory';
import { getOpaqueBatchEventProcessor } from './event_processor_factory';
import { AsyncStore, AsyncPrefixStore, SyncStore, SyncPrefixStore } from '../utils/cache/store';
import { AsyncStorageCache } from '../utils/cache/async_storage_cache.react_native';
import { EVENT_STORE_PREFIX, EventStore } from './event_store';
import { MODULE_NOT_FOUND_REACT_NATIVE_ASYNC_STORAGE } from '../utils/import.react_native/@react-native-async-storage/async-storage';

describe('createForwardingEventProcessor', () => {
  const mockGetForwardingEventProcessor = vi.mocked(getForwardingEventProcessor);

  beforeEach(() => {
    mockGetForwardingEventProcessor.mockClear();
  });

  it('returns forwarding event processor by calling getForwardingEventProcessor with the provided dispatcher', () => {
    const eventDispatcher = {
      dispatchEvent: vi.fn(),
    };

    const processor = extractEventProcessor(createForwardingEventProcessor(eventDispatcher));

    expect(Object.is(processor, mockGetForwardingEventProcessor.mock.results[0].value)).toBe(true);
    expect(mockGetForwardingEventProcessor).toHaveBeenNthCalledWith(1, eventDispatcher);
  });

  it('uses the browser default event dispatcher if none is provided', () => {
    const processor = extractEventProcessor(createForwardingEventProcessor());

    expect(Object.is(processor, mockGetForwardingEventProcessor.mock.results[0].value)).toBe(true);
    expect(mockGetForwardingEventProcessor).toHaveBeenNthCalledWith(1, defaultEventDispatcher);
  });
});

describe('createBatchEventProcessor', () => {
  const mockGetOpaqueBatchEventProcessor = vi.mocked(getOpaqueBatchEventProcessor);
  const MockAsyncStorageCache = vi.mocked(AsyncStorageCache);
  const MockSyncPrefixStore = vi.mocked(SyncPrefixStore);
  const MockAsyncPrefixStore = vi.mocked(AsyncPrefixStore);
  const MockEventStore = vi.mocked(EventStore);

  beforeEach(() => {
    mockGetOpaqueBatchEventProcessor.mockClear();
    MockAsyncStorageCache.mockClear();
    MockSyncPrefixStore.mockClear();
    MockAsyncPrefixStore.mockClear();
    MockEventStore.mockClear();
  });

  it('uses an EventStore instance with AsyncStorageCache and correct options if no eventStore is provided', () => {
    const processor = createBatchEventProcessor({
      storeTtl: 60_000,
    });

    expect(Object.is(processor, mockGetOpaqueBatchEventProcessor.mock.results[0].value)).toBe(true);
    const eventStore = mockGetOpaqueBatchEventProcessor.mock.calls[0][0].eventStore;
    expect(Object.is(eventStore, MockEventStore.mock.instances[0])).toBe(true);

    let { store, ttl, maxSize } = MockEventStore.mock.calls[0][0];
    expect(Object.is(store, MockAsyncStorageCache.mock.instances[0])).toBe(true);

    expect(ttl).toBe(60_000);
    expect(maxSize).toBe(500); // the default max size * 2 < 500

    const processor2 = createBatchEventProcessor({
      storeTtl: 10_000,
      batchSize: 260,
    });

    expect(Object.is(processor2, mockGetOpaqueBatchEventProcessor.mock.results[1].value)).toBe(true);
    const eventStore2 = mockGetOpaqueBatchEventProcessor.mock.calls[1][0].eventStore;
    expect(Object.is(eventStore2, MockEventStore.mock.instances[1])).toBe(true);

    ({ store, ttl, maxSize } = MockEventStore.mock.calls[1][0]);
    expect(Object.is(store, MockAsyncStorageCache.mock.instances[1])).toBe(true);

    expect(ttl).toBe(10_000);
    expect(maxSize).toBe(520); // the provided batch size * 2 > 500
  });

  it('should throw error if @react-native-async-storage/async-storage is not available', async () => {
    isAsyncStorageAvailable = false;
    const { AsyncStorageCache } = await vi.importActual<
      typeof import('../utils/cache/async_storage_cache.react_native')
    >('../utils/cache/async_storage_cache.react_native');

    MockAsyncStorageCache.mockImplementationOnce(() => {
      return new AsyncStorageCache();
    });

    expect(() => createBatchEventProcessor({})).toThrowError(
      MODULE_NOT_FOUND_REACT_NATIVE_ASYNC_STORAGE
    );

    isAsyncStorageAvailable = true;
  });

  it('should not throw error if eventStore is provided and @react-native-async-storage/async-storage is not available', async () => {
    isAsyncStorageAvailable = false;
    const eventStore = {
      operation: 'sync',
    } as SyncStore<string>;
    
    const { AsyncStorageCache } = await vi.importActual<
      typeof import('../utils/cache/async_storage_cache.react_native')
    >('../utils/cache/async_storage_cache.react_native');

    MockAsyncStorageCache.mockImplementationOnce(() => {
      return new AsyncStorageCache();
    });

    expect(() => createBatchEventProcessor({ eventStore })).not.toThrow();

    isAsyncStorageAvailable = true;
  });

  it('wraps the provided eventStore in a SyncPrefixStore if a SyncCache is provided as eventStore', () => {
    const eventStore = {
      operation: 'sync',
    } as SyncStore<string>;

    const processor = createBatchEventProcessor({ eventStore });
    expect(Object.is(processor, mockGetOpaqueBatchEventProcessor.mock.results[0].value)).toBe(true);

    expect(mockGetOpaqueBatchEventProcessor.mock.calls[0][0].eventStore).toBe(MockSyncPrefixStore.mock.results[0].value);
    const [cache, prefix, transformGet, transformSet] = MockSyncPrefixStore.mock.calls[0];

    expect(cache).toBe(eventStore);
    expect(prefix).toBe(EVENT_STORE_PREFIX);

    // transformGet and transformSet should be JSON.parse and JSON.stringify
    expect(transformGet('{"value": 1}')).toEqual({ value: 1 });
    expect(transformSet({ value: 1 })).toBe('{"value":1}');
  });

  it('wraps the provided eventStore in a AsyncPrefixStore if a AsyncCache is provided as eventStore', () => {
    const eventStore = {
      operation: 'async',
    } as AsyncStore<string>;

    const processor = createBatchEventProcessor({ eventStore });
    expect(Object.is(processor, mockGetOpaqueBatchEventProcessor.mock.results[0].value)).toBe(true);

    expect(mockGetOpaqueBatchEventProcessor.mock.calls[0][0].eventStore).toBe(MockAsyncPrefixStore.mock.results[0].value);
    const [cache, prefix, transformGet, transformSet] = MockAsyncPrefixStore.mock.calls[0];

    expect(cache).toBe(eventStore);
    expect(prefix).toBe(EVENT_STORE_PREFIX);

    // transformGet and transformSet should be JSON.parse and JSON.stringify
    expect(transformGet('{"value": 1}')).toEqual({ value: 1 });
    expect(transformSet({ value: 1 })).toBe('{"value":1}');
  });

  it('uses the provided eventDispatcher', () => {
    const eventDispatcher = {
      dispatchEvent: vi.fn(),
    };

    const processor = createBatchEventProcessor({ eventDispatcher });
    expect(Object.is(processor, mockGetOpaqueBatchEventProcessor.mock.results[0].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[0][0].eventDispatcher).toBe(eventDispatcher);
  });

  it('uses the default browser event dispatcher if none is provided', () => {
    const processor = createBatchEventProcessor({});
    expect(Object.is(processor, mockGetOpaqueBatchEventProcessor.mock.results[0].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[0][0].eventDispatcher).toBe(defaultEventDispatcher);
  });

  it('uses the provided closingEventDispatcher', () => {
    const closingEventDispatcher = {
      dispatchEvent: vi.fn(),
    };

    const processor = createBatchEventProcessor({ closingEventDispatcher });
    expect(Object.is(processor, mockGetOpaqueBatchEventProcessor.mock.results[0].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[0][0].closingEventDispatcher).toBe(closingEventDispatcher);

    const processor2 = createBatchEventProcessor({});
    expect(Object.is(processor2, mockGetOpaqueBatchEventProcessor.mock.results[1].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[1][0].closingEventDispatcher).toBe(undefined);
  });

  it('uses the provided flushInterval', () => {
    const processor1 = createBatchEventProcessor({ flushInterval: 2000 });
    expect(Object.is(processor1, mockGetOpaqueBatchEventProcessor.mock.results[0].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[0][0].flushInterval).toBe(2000);

    const processor2 = createBatchEventProcessor({});
    expect(Object.is(processor2, mockGetOpaqueBatchEventProcessor.mock.results[1].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[1][0].flushInterval).toBe(undefined);
  });

  it('uses the provided batchSize', () => {
    const processor1 = createBatchEventProcessor({ batchSize: 20 });
    expect(Object.is(processor1, mockGetOpaqueBatchEventProcessor.mock.results[0].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[0][0].batchSize).toBe(20);

    const processor2 = createBatchEventProcessor({});
    expect(Object.is(processor2, mockGetOpaqueBatchEventProcessor.mock.results[1].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[1][0].batchSize).toBe(undefined);
  });

  it('uses maxRetries value of 2 by default', () => {
    const processor = createBatchEventProcessor({});
    expect(Object.is(processor, mockGetOpaqueBatchEventProcessor.mock.results[0].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[0][0].retryOptions?.maxRetries).toBe(2);
  });

  it('uses the provided maxRetries value', () => {
    const processor1 = createBatchEventProcessor({ maxRetries: 3 });
    expect(Object.is(processor1, mockGetOpaqueBatchEventProcessor.mock.results[0].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[0][0].retryOptions?.maxRetries).toBe(3);

    const processor2 = createBatchEventProcessor({ maxRetries: 10 });
    expect(Object.is(processor2, mockGetOpaqueBatchEventProcessor.mock.results[1].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[1][0].retryOptions?.maxRetries).toBe(10);
  });

  it('uses the default failedEventRetryInterval', () => {
    const processor = createBatchEventProcessor({});
    expect(Object.is(processor, mockGetOpaqueBatchEventProcessor.mock.results[0].value)).toBe(true);
    expect(mockGetOpaqueBatchEventProcessor.mock.calls[0][0].failedEventRetryInterval).toBe(FAILED_EVENT_RETRY_INTERVAL);
  });
});