new test

Author: raju-opti

lib/event_processor/event_processor_factory.browser.ts

@@ -17,12 +17,15 @@
 import { getForwardingEventProcessor } from './forwarding_event_processor';
 import { EventDispatcher } from './eventDispatcher';
 import { EventProcessor } from './eventProcessor';
-import { BatchEventProcessor, BatchEventProcessorConfig } from './batch_event_processor';
-import { getQueuingEventProcessor, QueueingEventProcessorOptions } from './event_processor_factory';
+import { BatchEventProcessor, BatchEventProcessorConfig, EventWithId } from './batch_event_processor';
+import { getBatchEventProcessor, QueueingEventProcessorOptions } from './event_processor_factory';
 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 } from '../utils/cache/cache';
 
 export const FAILED_EVENT_RETRY_INTERVAL = 20 * 1000; 
+export const EVENT_STORE_PREFIX = 'fs_optly_pending_events';
 
 export const createForwardingEventProcessor = (
   eventDispatcher: EventDispatcher = defaultEventDispatcher,
@@ -33,14 +36,23 @@ export const createForwardingEventProcessor = (
 export const createQueueingEventProcessor = (
   options: QueueingEventProcessorOptions
 ): EventProcessor => {
-  return getQueuingEventProcessor({
+  const localStorageCache = new LocalStorageCache<string>();
+  const eventStore = new SyncPrefixCache<string, EventWithId>(
+    localStorageCache, EVENT_STORE_PREFIX,
+    JSON.parse,
+    JSON.stringify
+  );
+
+  return getBatchEventProcessor({
     eventDispatcher: options.eventDispatcher || defaultEventDispatcher,
     closingEventDispatcher: options.closingEventDispatcher || 
       (options.eventDispatcher ? options.eventDispatcher : sendBeaconEventDispatcher),
     flushInterval: options.flushInterval,
     batchSize: options.batchSize,
-    retryOptions: {},
+    retryOptions: {
+      maxRetries: 5,
+    },
     failedEventRetryInterval: FAILED_EVENT_RETRY_INTERVAL,
+    eventStore,
   });
 };
-

lib/event_processor/event_processor_factory.spec.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, vi, MockInstance } from 'vitest';
+import { DEFAULT_MAX_BACKOFF, DEFAULT_MIN_BACKOFF, getBatchEventProcessor } from './event_processor_factory';
+import { BatchEventProcessor, BatchEventProcessorConfig } from './batch_event_processor';
+import { ExponentialBackoff, IntervalRepeater } from '../utils/repeater/repeater';
+
+vi.mock('./batch_event_processor');
+vi.mock('../utils/repeater/repeater');
+
+type BatchEventProcessorConstructor = typeof BatchEventProcessor;
+
+const getMockEventDispatcher = () => {
+  return {
+    dispatchEvent: vi.fn(),
+  }
+};
+
+describe('getBatchEventProcessor', () => {
+  const MockBatchEventProcessor = vi.mocked(BatchEventProcessor);
+  const MockExponentialBackoff = vi.mocked(ExponentialBackoff);
+  
+  beforeEach(() => {
+    MockBatchEventProcessor.mockReset();
+    MockExponentialBackoff.mockReset();
+  });
+
+  it('returns an instane of BatchEventProcessor if no subclass constructor is provided', () => {
+    const options = {
+      eventDispatcher: getMockEventDispatcher(),
+    };
+
+    const processor = getBatchEventProcessor(options);
+
+    expect(processor instanceof BatchEventProcessor).toBe(true);
+  });
+
+  it('returns an instane of the provided subclass constructor', () => {
+    class CustomEventProcessor extends BatchEventProcessor {
+      constructor(opts: BatchEventProcessorConfig) {
+        super(opts);
+      }
+    }
+
+    const options = {
+      eventDispatcher: getMockEventDispatcher(),
+    };
+
+    const processor = getBatchEventProcessor(options, CustomEventProcessor);
+
+    expect(processor instanceof CustomEventProcessor).toBe(true);
+  });
+
+  it('does not use retry if retryOptions is not provided', () => {
+    const options = {
+      eventDispatcher: getMockEventDispatcher(),
+    };
+
+    const processor = getBatchEventProcessor(options);
+    expect(MockBatchEventProcessor.mock.calls[0][0].retryConfig).toBe(undefined);
+  });
+
+  it('uses retry when retryOptions is provided', () => {
+    const options = {
+      eventDispatcher: getMockEventDispatcher(),
+      retryOptions: {},
+    };
+
+    let processor = getBatchEventProcessor(options);
+
+    const usedRetryConfig = MockBatchEventProcessor.mock.calls[0][0].retryConfig;
+    expect(usedRetryConfig).not.toBe(undefined);
+    expect(usedRetryConfig?.backoffProvider).not.toBe(undefined);
+  });
+
+  it('uses the correct maxRetries value when retryOptions is provided', () => {
+    const options1 = {
+      eventDispatcher: getMockEventDispatcher(),
+      retryOptions: {
+        maxRetries: 10,
+      },
+    };
+
+    let processor1 = getBatchEventProcessor(options1);
+    expect(MockBatchEventProcessor.mock.calls[0][0].retryConfig?.maxRetries).toBe(10);
+
+    const options2 = {
+      eventDispatcher: getMockEventDispatcher(),
+      retryOptions: {},
+    };
+
+    let processor2 = getBatchEventProcessor(options2);
+    expect(MockBatchEventProcessor.mock.calls[0][0].retryConfig).not.toBe(undefined);
+    expect(MockBatchEventProcessor.mock.calls[1][0].retryConfig?.maxRetries).toBe(undefined);
+  });
+
+  it('uses exponential backoff with default parameters when retryOptions is provided without backoff values', () => {
+    const options = {
+      eventDispatcher: getMockEventDispatcher(),
+      retryOptions: {},
+    };
+
+    let processor = getBatchEventProcessor(options);
+    const backoffProvider = MockBatchEventProcessor.mock.calls[0][0].retryConfig?.backoffProvider;
+
+    expect(backoffProvider).not.toBe(undefined);
+    const backoff = backoffProvider?.();
+    expect(Object.is(backoff, MockExponentialBackoff.mock.instances[0])).toBe(true);
+    expect(MockExponentialBackoff).toHaveBeenNthCalledWith(1, DEFAULT_MIN_BACKOFF, DEFAULT_MAX_BACKOFF, 500);
+  });
+
+  it('uses exponential backoff with provided backoff values in retryOptions', () => {
+    const options = {
+      eventDispatcher: getMockEventDispatcher(),
+      retryOptions: { minBackoff: 1000, maxBackoff: 2000 },
+    };
+
+    let processor = getBatchEventProcessor(options);
+    const backoffProvider = MockBatchEventProcessor.mock.calls[0][0].retryConfig?.backoffProvider;
+
+    expect(backoffProvider).not.toBe(undefined);
+    const backoff = backoffProvider?.();
+    expect(Object.is(backoff, MockExponentialBackoff.mock.instances[0])).toBe(true);
+    expect(MockExponentialBackoff).toHaveBeenNthCalledWith(1, 1000, 2000, 500);
+  });
+});

lib/event_processor/event_processor_factory.ts

@@ -3,7 +3,8 @@ import { StartupLog } from "../service";
 import { ExponentialBackoff, IntervalRepeater } from "../utils/repeater/repeater";
 import { EventDispatcher } from "./eventDispatcher";
 import { EventProcessor } from "./eventProcessor";
-import { BatchEventProcessor, RetryConfig } from "./batch_event_processor";
+import { BatchEventProcessor, EventWithId, RetryConfig } from "./batch_event_processor";
+import { Cache } from "../utils/cache/cache";
 
 export const DEFAULT_EVENT_BATCH_SIZE = 10;
 export const DEFAULT_EVENT_FLUSH_INTERVAL = 1000;
@@ -21,18 +22,19 @@ export type QueueingEventProcessorOptions = {
 export type QueueingEventProcessorFactoryOptions = Omit<QueueingEventProcessorOptions, 'eventDispatcher'> & {
   eventDispatcher: EventDispatcher;
   failedEventRetryInterval?: number;
+  eventStore?: Cache<EventWithId>;
   retryOptions?: {
     maxRetries?: number;
     minBackoff?: number;
     maxBackoff?: number;
   };
 }
 
-export const getQueuingEventProcessor = (
+export const getBatchEventProcessor = (
     options: QueueingEventProcessorFactoryOptions,
     EventProcessorConstructor: typeof BatchEventProcessor = BatchEventProcessor
   ): EventProcessor => {
-  const { eventDispatcher, closingEventDispatcher, retryOptions } = options;
+  const { eventDispatcher, closingEventDispatcher, retryOptions, eventStore } = options;
 
   const retryConfig: RetryConfig | undefined = retryOptions ? {
     maxRetries: retryOptions.maxRetries,
@@ -78,6 +80,7 @@ export const getQueuingEventProcessor = (
     failedEventRepeater,
     retryConfig,
     batchSize,
-    startupLogs
+    eventStore,
+    startupLogs,
   });
 };

lib/event_processor/index.ts

@@ -17,6 +17,4 @@
 export * from './events'
 export * from './eventProcessor'
 export * from './eventDispatcher'
-export * from './pendingEventsDispatcher'
 export * from './v1/buildEventV1'
-export * from './v1/v1EventProcessor'