fix: retry queue

packages/analytics-js-common/__mocks__/BufferQueue.ts

@@ -0,0 +1,10 @@
+class BufferQueue<T> {
+  items: T[];
+  enqueue = jest.fn();
+  dequeue = jest.fn();
+  isEmpty = jest.fn();
+  size = jest.fn();
+  clear = jest.fn();
+}
+
+export { BufferQueue };

packages/analytics-js-common/__mocks__/ErrorHandler.ts

@@ -0,0 +1,16 @@
+import { PreLoadErrorData, type IErrorHandler } from '../src/types/ErrorHandler';
+import { BufferQueue } from './BufferQueue';
+
+// Mock all the methods of the ErrorHandler class
+class ErrorHandler implements IErrorHandler {
+  onError = jest.fn();
+  leaveBreadcrumb = jest.fn();
+  notifyError = jest.fn();
+  init = jest.fn();
+  attachErrorListeners = jest.fn();
+  errorBuffer = new BufferQueue<PreLoadErrorData>();
+}
+
+const defaultErrorHandler = new ErrorHandler();
+
+export { ErrorHandler, defaultErrorHandler };

packages/analytics-js-common/__mocks__/Logger.ts

@@ -0,0 +1,18 @@
+import type { ILogger } from '../src/types/Logger';
+
+class Logger implements ILogger {
+  warn = jest.fn();
+  log = jest.fn();
+  error = jest.fn();
+  info = jest.fn();
+  debug = jest.fn();
+  minLogLevel = 0;
+  scope = 'test scope';
+  setMinLogLevel = jest.fn();
+  setScope = jest.fn();
+  logProvider = console;
+}
+
+const defaultLogger = new Logger();
+
+export { Logger, defaultLogger };

packages/analytics-js-common/__mocks__/Storage.ts

@@ -0,0 +1,76 @@
+import store from 'storejs';
+import type { IInMemoryStorageOptions, IStorage } from '../src/types/Store';
+import { Nullable } from '../src/types/Nullable';
+
+class LocalStorage implements IStorage {
+  keys = () => {
+    return store.keys();
+  };
+  isEnabled = true;
+  getItem = (key: string) => {
+    return store.get(key) ?? null;
+  };
+  setItem = (key: string, value: any) => {
+    store.set(key, value);
+  };
+  removeItem = (key: string) => store.remove(key);
+  clear = () => {
+    store.clear();
+  };
+  length = store.len();
+  key = (idx: number): Nullable<string> => {
+    return this.keys()[idx] ?? null;
+  };
+}
+
+/**
+ * A storage utility to retain values in memory via Storage interface
+ */
+class InMemoryStorage implements IStorage {
+  isEnabled = true;
+  length = 0;
+  data: Record<string, any> = {};
+
+  setItem(key: string, value: any): any {
+    this.data[key] = value;
+    this.length = Object.keys(this.data).length;
+    return value;
+  }
+
+  getItem(key: string): any {
+    if (key in this.data) {
+      return this.data[key];
+    }
+    return null;
+  }
+
+  removeItem(key: string) {
+    if (key in this.data) {
+      delete this.data[key];
+    }
+    this.length = Object.keys(this.data).length;
+    return null;
+  }
+
+  clear() {
+    this.data = {};
+    this.length = 0;
+  }
+
+  key(index: number): Nullable<string> {
+    const curKeys = this.keys();
+    return curKeys[index] ?? null;
+  }
+
+  keys(): string[] {
+    return Object.keys(this.data);
+  }
+}
+
+const defaultInMemoryStorage = new InMemoryStorage();
+
+export { InMemoryStorage, defaultInMemoryStorage };
+
+const defaultLocalStorage = new LocalStorage();
+
+export { LocalStorage, defaultLocalStorage };

packages/analytics-js-common/__mocks__/Store.ts

@@ -0,0 +1,54 @@
+import type { IStore, IStoreConfig } from '../src/types/Store';
+import { defaultInMemoryStorage, defaultLocalStorage } from './Storage';
+
+// Mock all the methods of the Store class
+
+class Store implements IStore {
+  constructor(config: IStoreConfig, engine?: any) {
+    this.id = config.id;
+    this.name = config.name;
+    this.isEncrypted = config.isEncrypted ?? false;
+    this.validKeys = config.validKeys ?? {};
+    this.engine = engine ?? defaultLocalStorage;
+    this.originalEngine = this.engine;
+  }
+  id = 'test';
+  name = 'test';
+  isEncrypted = false;
+  validKeys = {};
+  engine = defaultLocalStorage;
+  originalEngine = defaultLocalStorage;
+  createValidKey = (key: string) => {
+    return [this.name, this.id, key].join('.');
+  };
+  swapQueueStoreToInMemoryEngine = () => {
+    this.engine.keys().forEach(key => {
+      const value = this.engine.getItem(key);
+      defaultInMemoryStorage.setItem(key, value);
+    });
+
+    this.engine = defaultInMemoryStorage;
+  };
+  set = (key: string, value) => {
+    const validKey = this.createValidKey(key);
+    this.engine.setItem(validKey, value);
+  };
+  get = (key: string) => {
+    const validKey = this.createValidKey(key);
+    return this.engine.getItem(validKey);
+  };
+  remove = (key: string) => {
+    const validKey = this.createValidKey(key);
+    this.engine.removeItem(validKey);
+  };
+  clear = this.engine.clear;
+  onError = jest.fn();
+  crypto = jest.fn();
+  encrypt = jest.fn();
+  decrypt = jest.fn();
+  getOriginalEngine = () => this.originalEngine;
+}
+
+const defaultStore = new Store({ id: 'test', name: 'test' });
+
+export { Store, defaultStore };

packages/analytics-js-common/__mocks__/StoreManager.ts

@@ -0,0 +1,17 @@
+import type { IStoreConfig, IStoreManager } from '../src/types/Store';
+import { defaultStore, Store } from './Store';
+
+// Mock all the methods of the StoreManager class
+
+class StoreManager implements IStoreManager {
+  init = jest.fn();
+  setStore = (config: IStoreConfig) => {
+    return new Store(config);
+  };
+  getStore = jest.fn(() => defaultStore);
+  initializeStorageState = jest.fn();
+}
+
+const defaultStoreManager = new StoreManager();
+
+export { StoreManager, defaultStoreManager };