test

Author: raju-opti

lib/event_processor/event_processor_factory.browser.spec.ts

@@ -20,16 +20,33 @@ vi.mock('./default_dispatcher.browser', () => {
 });
 
 vi.mock('./forwarding_event_processor', () => {
-  const getForwardingEventProcessor = vi.fn().mockReturnValue({});
+  const getForwardingEventProcessor = vi.fn().mockImplementation(() => {
+    return {};
+  });
   return { getForwardingEventProcessor };
 });
 
 vi.mock('./event_processor_factory', () => {
-  const getBatchEventProcessor = vi.fn().mockReturnValue({});
+  const getBatchEventProcessor = vi.fn().mockImplementation(() => {
+    return {};
+  });
   return { getBatchEventProcessor };
 });
 
-import { createForwardingEventProcessor, createBatchEventProcessor } from './event_processor_factory.browser';
+vi.mock('../utils/cache/local_storage_cache.browser', () => {
+  return { LocalStorageCache: vi.fn() };
+});
+
+vi.mock('../utils/cache/cache', () => {
+  return { SyncPrefixCache: vi.fn() };
+});
+
+
+import defaultEventDispatcher from './default_dispatcher.browser';
+import { LocalStorageCache } from '../utils/cache/local_storage_cache.browser';
+import { SyncPrefixCache } from '../utils/cache/cache';
+import { createForwardingEventProcessor, createBatchEventProcessor, EVENT_STORE_PREFIX, FAILED_EVENT_RETRY_INTERVAL } from './event_processor_factory.browser';
+import sendBeaconEventDispatcher from '../plugins/event_dispatcher/send_beacon_dispatcher';
 import { getForwardingEventProcessor } from './forwarding_event_processor';
 import browserDefaultEventDispatcher from './default_dispatcher.browser';
 import { getBatchEventProcessor } from './event_processor_factory';
@@ -60,12 +77,15 @@ describe('createForwardingEventProcessor', () => {
   });
 });
 
-
 describe('createBatchEventProcessor', () => {
   const mockGetBatchEventProcessor = vi.mocked(getBatchEventProcessor);
+  const MockLocalStorageCache = vi.mocked(LocalStorageCache);
+  const MockSyncPrefixCache = vi.mocked(SyncPrefixCache);
 
   beforeEach(() => {
     mockGetBatchEventProcessor.mockClear();
+    MockLocalStorageCache.mockClear();
+    MockSyncPrefixCache.mockClear();
   });
 
   it('uses localStorageCache and SyncPrefixCache to create eventStore', () => {
@@ -80,6 +100,88 @@ describe('createBatchEventProcessor', () => {
     const processor = createBatchEventProcessor(options);
     expect(Object.is(processor, mockGetBatchEventProcessor.mock.results[0].value)).toBe(true);
     const eventStore = mockGetBatchEventProcessor.mock.calls[0][0].eventStore;
-    expect
+    expect(Object.is(eventStore, MockSyncPrefixCache.mock.results[0].value)).toBe(true);
+
+    const [cache, prefix, transformGet, transformSet] = MockSyncPrefixCache.mock.calls[0];
+    expect(Object.is(cache, MockLocalStorageCache.mock.results[0].value)).toBe(true);
+    expect(prefix).toBe(EVENT_STORE_PREFIX);
+
+    // transformGet and transformSet should be identity functions
+    expect(transformGet('value')).toBe('value');
+    expect(transformSet('value')).toBe('value');
+  });
+
+  it('uses the provided eventDispatcher', () => {
+    const eventDispatcher = {
+      dispatchEvent: vi.fn(),
+    };
+
+    const processor = createBatchEventProcessor({ eventDispatcher });
+    expect(Object.is(processor, mockGetBatchEventProcessor.mock.results[0].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.mock.calls[0][0].eventDispatcher).toBe(eventDispatcher);
+  });
+
+  it('uses the default broser event dispatcher if none is provided', () => {
+    const processor = createBatchEventProcessor({ });
+    expect(Object.is(processor, mockGetBatchEventProcessor.mock.results[0].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.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, mockGetBatchEventProcessor.mock.results[0].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.mock.calls[0][0].closingEventDispatcher).toBe(closingEventDispatcher);
+  });
+
+  it('does not use any closingEventDispatcher if eventDispatcher is provided but closingEventDispatcher is not', () => {
+    const eventDispatcher = {
+      dispatchEvent: vi.fn(),
+    };
+
+    const processor = createBatchEventProcessor({ eventDispatcher });
+    expect(Object.is(processor, mockGetBatchEventProcessor.mock.results[0].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.mock.calls[0][0].closingEventDispatcher).toBe(undefined);
+  });
+
+  it('uses the default sendBeacon event dispatcher if neither eventDispatcher nor closingEventDispatcher is provided', () => {
+    const processor = createBatchEventProcessor({ });
+    expect(Object.is(processor, mockGetBatchEventProcessor.mock.results[0].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.mock.calls[0][0].closingEventDispatcher).toBe(sendBeaconEventDispatcher);
+  });
+
+  it('uses the provided flushInterval', () => {
+    const processor1 = createBatchEventProcessor({ flushInterval: 2000 });
+    expect(Object.is(processor1, mockGetBatchEventProcessor.mock.results[0].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.mock.calls[0][0].flushInterval).toBe(2000);
+
+    const processor2 = createBatchEventProcessor({ });
+    expect(Object.is(processor2, mockGetBatchEventProcessor.mock.results[1].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.mock.calls[1][0].flushInterval).toBe(undefined);
+  });
+
+  it('uses the provided batchSize', () => {
+    const processor1 = createBatchEventProcessor({ batchSize: 20 });
+    expect(Object.is(processor1, mockGetBatchEventProcessor.mock.results[0].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.mock.calls[0][0].batchSize).toBe(20);
+
+    const processor2 = createBatchEventProcessor({ });
+    expect(Object.is(processor2, mockGetBatchEventProcessor.mock.results[1].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.mock.calls[1][0].batchSize).toBe(undefined);
+  });
+
+  it('uses maxRetries value of 5', () => {
+    const processor = createBatchEventProcessor({ });
+    expect(Object.is(processor, mockGetBatchEventProcessor.mock.results[0].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.mock.calls[0][0].retryOptions?.maxRetries).toBe(5);
+  });
+
+  it('uses the default failedEventRetryInterval', () => {
+    const processor = createBatchEventProcessor({ });
+    expect(Object.is(processor, mockGetBatchEventProcessor.mock.results[0].value)).toBe(true);
+    expect(mockGetBatchEventProcessor.mock.calls[0][0].failedEventRetryInterval).toBe(FAILED_EVENT_RETRY_INTERVAL);
   });
 });

lib/event_processor/event_processor_factory.browser.ts

@@ -22,10 +22,10 @@ import { getBatchEventProcessor, BatchEventProcessorOptions } from './event_proc
 import defaultEventDispatcher from './default_dispatcher.browser';
 import sendBeaconEventDispatcher from '../plugins/event_dispatcher/send_beacon_dispatcher';
 import { LocalStorageCache } from '../utils/cache/local_storage_cache.browser';
-import { SyncPrefixCache, AsyncPrefixCache, Cache } from '../utils/cache/cache';
+import { SyncPrefixCache } from '../utils/cache/cache';
 
 export const FAILED_EVENT_RETRY_INTERVAL = 20 * 1000; 
-export const EVENT_STORE_PREFIX = 'fs_optly_pending_events';
+export const EVENT_STORE_PREFIX = 'optly_event:';
 
 export const createForwardingEventProcessor = (
   eventDispatcher: EventDispatcher = defaultEventDispatcher,
@@ -48,7 +48,7 @@ export const createBatchEventProcessor = (
   return getBatchEventProcessor({
     eventDispatcher: options.eventDispatcher || defaultEventDispatcher,
     closingEventDispatcher: options.closingEventDispatcher || 
-      (options.eventDispatcher ? options.eventDispatcher : sendBeaconEventDispatcher),
+      (options.eventDispatcher ? undefined : sendBeaconEventDispatcher),
     flushInterval: options.flushInterval,
     batchSize: options.batchSize,
     retryOptions: {