check-working

Author: raju-opti

.github/workflows/javascript.yml

@@ -40,6 +40,31 @@ jobs:
       CI_USER_TOKEN: ${{ secrets.CI_USER_TOKEN }}
       TRAVIS_COM_TOKEN: ${{ secrets.TRAVIS_COM_TOKEN }}
 
+  browser_tests:
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        browser: ['chrome', 'firefox', 'edge', 'safari']
+    env:
+      BROWSERSTACK_USERNAME: ${{ secrets.BROWSERSTACK_USERNAME }}
+      BROWSERSTACK_ACCESS_KEY: ${{ secrets.BROWSERSTACK_ACCESS_KEY }}
+      BROWSERSTACK_LOCAL: 'true'
+      USE_LOCAL_BROWSER: 'false'
+      TEST_BROWSER: ${{ matrix.browser }}
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Node
+      uses: actions/setup-node@v3
+      with:
+        node-version: 20
+        cache: 'npm'
+        cache-dependency-path: ./package-lock.json
+    - name: Browser tests - ${{ matrix.browser }}
+      working-directory: .
+      run: |
+        npm install
+        npm run test-vitest-browser
+
   # crossbrowser_and_umd_unit_tests:
   #   runs-on: ubuntu-latest
   #   env:

lib/event_processor/batch_event_processor.spec.ts

@@ -365,7 +365,7 @@ describe('BatchEventProcessor', async () => {
       expect(eventStore.size()).toEqual(10);
 
       const eventsInStore = Array.from(eventStore.getAll().values())
-        .sort((a, b) => a < b ? -1 : 1).map(e => e.event);
+        .sort((a, b) => a.id < b.id ? -1 : 1).map(e => e.event);
 
       expect(events).toEqual(eventsInStore);
     });

lib/event_processor/event_processor_factory.browser.spec.ts

@@ -15,11 +15,18 @@
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
+// vitest does not handle Class mock well when transpiling to ES6 with { spy: true }.
+// So we provide manual mocks here.
+// Also importOriginal() does not work in browser mode, so we mock every export explicitly.
+
 vi.mock('./default_dispatcher.browser', () => {
   return { default: {} };
 });
 
-vi.mock('./event_processor_factory', async (importOriginal) => {
+vi.mock('./event_processor_factory', () => {
+  // Create a unique symbol for wrapping/unwrapping
+  const eventProcessorSymbol = Symbol('eventProcessor');
+
   const getBatchEventProcessor = vi.fn().mockImplementation(() => {
     return {};
   });
@@ -29,25 +36,54 @@ vi.mock('./event_processor_factory', async (importOriginal) => {
   const getForwardingEventProcessor = vi.fn().mockImplementation(() => {
     return {};
   });
-  const original: any = await importOriginal();
-  return { ...original, getBatchEventProcessor, getOpaqueBatchEventProcessor, getForwardingEventProcessor, FAILED_EVENT_RETRY_INTERVAL: 20000 };
+
+  return {
+    INVALID_EVENT_DISPATCHER: 'Invalid event dispatcher',
+    FAILED_EVENT_RETRY_INTERVAL: 20000,
+    getPrefixEventStore: vi.fn(),
+    validateEventDispatcher: vi.fn(),
+    getBatchEventProcessor,
+    wrapEventProcessor: vi.fn((ep) => ({ [eventProcessorSymbol]: ep })),
+    getOpaqueBatchEventProcessor,
+    extractEventProcessor: vi.fn((ep) => ep?.[eventProcessorSymbol]),
+    getForwardingEventProcessor,
+    __platforms: ['__universal__'],
+  };
 });
 
 vi.mock('../utils/cache/local_storage_cache.browser', () => {
   return { LocalStorageCache: vi.fn() };
 });
 
-vi.mock('./event_store', async (importOriginal) => {
-  const actual: any = await importOriginal()
+vi.mock('./event_store', () => {
   return {
-    ...actual,
+    DEFAULT_MAX_EVENTS_IN_STORE: 500,
+    DEFAULT_STORE_TTL: 10 * 24 * 60 * 60 * 1000,
+    EVENT_STORE_PREFIX: 'optly_event:',
     EventStore: vi.fn(),
-  }
+    __platforms: ['__universal__'],
+  };
 });
 
-vi.mock('../utils/cache/store', async (importOriginal) => {
-  const actual: any = await importOriginal()
-  return { ...actual, SyncPrefixStore: vi.fn(), AsyncPrefixStore: vi.fn() };
+vi.mock('../utils/cache/store', () => {
+  // Create base abstract classes
+  class SyncStoreWithBatchedGet {
+    operation = 'sync' as const;
+  }
+
+  class AsyncStoreWithBatchedGet {
+    operation = 'async' as const;
+  }
+
+  return {
+    SyncStoreWithBatchedGet,
+    AsyncStoreWithBatchedGet,
+    getBatchedSync: vi.fn(),
+    getBatchedAsync: vi.fn(),
+    SyncPrefixStore: vi.fn(),
+    AsyncPrefixStore: vi.fn(),
+    __platforms: ['__universal__'],
+  };
 });
 
 

lib/event_processor/event_processor_factory.react_native.spec.ts

@@ -55,12 +55,15 @@ vi.mock('@react-native-community/netinfo', () => {
 });
 let isAsyncStorageAvailable = true;
 
-await vi.hoisted(async () => {
-  await mockRequireNetInfo();
+// Mock Node.js module loader to simulate missing @react-native-async-storage/async-storage
+vi.hoisted(() => {
+  mockRequireNetInfo();
 });
 
-async function mockRequireNetInfo() {
-  const { Module } = await import('module');
+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;

lib/event_processor/event_processor_factory.spec.ts

@@ -148,7 +148,7 @@ describe('getBatchEventProcessor', () => {
     })).toThrow('Invalid store method getKeys');
   });
 
-  it.only('returns an instane of BatchEventProcessor if no subclass constructor is provided', () => {
+  it('returns an instane of BatchEventProcessor if no subclass constructor is provided', () => {
     const options = {
       eventDispatcher: getMockEventDispatcher(),
       defaultFlushInterval: 1000,

lib/logging/logger_factory.spec.ts

@@ -15,13 +15,47 @@
  */
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 
-vi.mock('./logger', async (importOriginal) => {
-  const actual = await importOriginal()
+// vi.mock('./logger', async (importOriginal) => {
+//   const actual = await importOriginal()
 
+//   const MockLogger = vi.fn();
+//   const MockConsoleLogHandler = vi.fn();
+
+//   return { ...actual as any, OptimizelyLogger: MockLogger, ConsoleLogHandler: MockConsoleLogHandler };
+// });
+
+// vitest does not handle Class mock well when transpiling to ES6 with { spy: true }.
+// So we provide a manual mock here.
+// also importOriginal() does not work here, so we mock every export of the moddule.
+
+vi.mock('./logger', () => {
   const MockLogger = vi.fn();
+
   const MockConsoleLogHandler = vi.fn();
 
-  return { ...actual as any, OptimizelyLogger: MockLogger, ConsoleLogHandler: MockConsoleLogHandler };
+  return {
+    LogLevel: {
+      Debug: 0,
+      Info: 1,
+      Warn: 2,
+      Error: 3,
+    },
+    LogLevelToUpper: {
+      0: 'DEBUG',
+      1: 'INFO',
+      2: 'WARN',
+      3: 'ERROR',
+    },
+    LogLevelToLower: {
+      0: 'debug',
+      1: 'info',
+      2: 'warn',
+      3: 'error',
+    },
+    OptimizelyLogger: MockLogger,
+    ConsoleLogHandler: MockConsoleLogHandler,
+    __platforms: ['__universal__'],
+  };
 });
 
 import { OptimizelyLogger, ConsoleLogHandler, LogLevel } from './logger';
@@ -84,6 +118,8 @@ describe('createLogger', () => {
       logHandler: mockLogHandler,
     }));
 
+    console.log(OptimizelyLogger);
+
     expect(logger).toBe(MockedOptimizelyLogger.mock.instances[0]);
     const { name, level, infoMsgResolver, errorMsgResolver, logHandler } = MockedOptimizelyLogger.mock.calls[0][0];
     expect(name).toBe('Optimizely');

lib/project_config/config_manager_factory.react_native.spec.ts

@@ -16,14 +16,14 @@
 
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 
-await vi.hoisted(async () => {
-  await mockRequireAsyncStorage();
+vi.hoisted(async () => {
+  mockRequireAsyncStorage();
 });
 
 let isAsyncStorageAvailable = true;
 
-async function mockRequireAsyncStorage() {
-  const { Module } = await import('module');
+function mockRequireAsyncStorage() {
+  const { Module } =  require('module');
   const M: any = Module;
 
   M._load_original = M._load;

lib/project_config/project_config_manager.spec.ts

@@ -530,7 +530,8 @@ describe('ProjectConfigManagerImpl', () => {
           await wait(0);
         }
 
-        datafileManagerTerminated.reject();
+        datafileManagerTerminated.reject(new Error('test error'));
+
         await expect(manager.onTerminated()).rejects.toThrow();
         expect(manager.getState()).toBe(ServiceState.Failed);
       });

lib/project_config/project_config_manager.ts

@@ -227,6 +227,8 @@ export class ProjectConfigManagerImpl extends BaseService implements ProjectConf
     }
 
     this.datafileManager.stop();
+    console.log('stopping datafile manager', this.datafileManager.onTerminated);
+
     this.datafileManager.onTerminated().then(() => {
       this.state = ServiceState.Terminated;
       this.stopPromise.resolve();

lib/utils/cache/local_storage_cache.browser.spec.ts

@@ -73,7 +73,7 @@ describe('LocalStorageCache', () => {
     const cache = new LocalStorageCache<string>();
     cache.set('key1', 'value1');
     cache.set('key2', 'value2');
-    expect(cache.getKeys()).toEqual(['key1', 'key2']);
+    expect(cache.getKeys().sort()).toEqual(['key1', 'key2']);
   });
 
   it('should return an array of values for an array of keys when getBatched is called', () => {