More tests

Author: kinyoklion

packages/sdk/browser/__tests__/BrowserClient.test.ts

@@ -4,14 +4,14 @@ import {
   AutoEnvAttributes,
   EventSourceCapabilities,
   EventSourceInitDict,
-  Hasher,
   LDLogger,
   PlatformData,
   Requests,
   SdkData,
 } from '@launchdarkly/js-client-sdk-common';
 
 import { BrowserClient } from '../src/BrowserClient';
+import { MockHasher } from './MockHasher';
 
 function mockResponse(value: string, statusCode: number) {
   const response: Response = {
@@ -79,18 +79,6 @@ function makeRequests(): Requests {
   };
 }
 
-class MockHasher implements Hasher {
-  update(_data: string): Hasher {
-    return this;
-  }
-  digest?(_encoding: string): string {
-    return 'hashed';
-  }
-  async asyncDigest?(_encoding: string): Promise<string> {
-    return 'hashed';
-  }
-}
-
 describe('given a mock platform for a BrowserClient', () => {
   const logger: LDLogger = {
     debug: jest.fn(),

packages/sdk/browser/__tests__/BrowserDataManager.test.ts

@@ -1,7 +1,12 @@
+import { jest } from '@jest/globals';
+import { TextEncoder } from 'node:util';
+
 import {
   ApplicationTags,
+  base64UrlEncode,
   Configuration,
   Context,
+  Encoding,
   FlagManager,
   internal,
   LDEmitter,
@@ -14,15 +19,26 @@ import {
 } from '@launchdarkly/js-client-sdk-common';
 
 import BrowserDataManager from '../src/BrowserDataManager';
-import { ValidatedOptions } from '../src/options';
+import validateOptions, { ValidatedOptions } from '../src/options';
+import BrowserEncoding from '../src/platform/BrowserEncoding';
+import BrowserInfo from '../src/platform/BrowserInfo';
+import LocalStorage from '../src/platform/LocalStorage';
+import { MockHasher } from './MockHasher';
+
+global.TextEncoder = TextEncoder;
 
 function mockResponse(value: string, statusCode: number) {
   const response: Response = {
     headers: {
+      // @ts-ignore
       get: jest.fn(),
+      // @ts-ignore
       keys: jest.fn(),
+      // @ts-ignore
       values: jest.fn(),
+      // @ts-ignore
       entries: jest.fn(),
+      // @ts-ignore
       has: jest.fn(),
     },
     status: statusCode,
@@ -32,8 +48,14 @@ function mockResponse(value: string, statusCode: number) {
   return Promise.resolve(response);
 }
 
+/**
+ * Mocks fetch. Returns the fetch jest.Mock object.
+ * @param remoteJson
+ * @param statusCode
+ */
 function mockFetch(value: string, statusCode: number = 200) {
   const f = jest.fn();
+  // @ts-ignore
   f.mockResolvedValue(mockResponse(value, statusCode));
   return f;
 }
@@ -46,9 +68,8 @@ describe('given a BrowserDataManager with mocked dependencies', () => {
   let baseHeaders: LDHeaders;
   let emitter: jest.Mocked<LDEmitter>;
   let diagnosticsManager: jest.Mocked<internal.DiagnosticsManager>;
-  let browserDataManager: BrowserDataManager;
+  let dataManager: BrowserDataManager;
   let logger: LDLogger;
-
   beforeEach(() => {
     logger = {
       error: jest.fn(),
@@ -79,40 +100,67 @@ describe('given a BrowserDataManager with mocked dependencies', () => {
       pollInterval: 1000,
       userAgentHeaderName: 'user-agent',
       trackEventModifier: (event) => event,
-    }
+    };
     const mockedFetch = mockFetch('{"flagA": true}', 200);
     platform = {
+      crypto: {
+        createHash: () => new MockHasher(),
+        randomUUID: () => '123',
+      },
+      info: new BrowserInfo(),
       requests: {
+        createEventSource: jest.fn((streamUri: string = '', options: any = {}) => ({
+          streamUri,
+          options,
+          onclose: jest.fn(),
+          addEventListener: jest.fn(),
+          close: jest.fn(),
+        })),
         fetch: mockedFetch,
-        createEventSource: jest.fn(),
         getEventSourceCapabilities: jest.fn(),
       },
+      storage: new LocalStorage(config.logger),
+      encoding: new BrowserEncoding(),
     } as unknown as jest.Mocked<Platform>;
 
     flagManager = {
       loadCached: jest.fn(),
+      get: jest.fn(),
+      getAll: jest.fn(),
+      init: jest.fn(),
+      upsert: jest.fn(),
+      on: jest.fn(),
+      off: jest.fn(),
     } as unknown as jest.Mocked<FlagManager>;
 
-    browserConfig = { stream: true } as ValidatedOptions;
+    browserConfig = validateOptions({ stream: false }, logger);
     baseHeaders = {};
     emitter = {
       emit: jest.fn(),
     } as unknown as jest.Mocked<LDEmitter>;
     diagnosticsManager = {} as unknown as jest.Mocked<internal.DiagnosticsManager>;
 
-    browserDataManager = new BrowserDataManager(
+    dataManager = new BrowserDataManager(
       platform,
       flagManager,
       'test-credential',
       config,
       browserConfig,
       () => ({
-        pathGet: jest.fn(),
-        pathReport: jest.fn(),
+        pathGet(encoding: Encoding, _plainContextString: string): string {
+          return `/msdk/evalx/contexts/${base64UrlEncode(_plainContextString, encoding)}`;
+        },
+        pathReport(_encoding: Encoding, _plainContextString: string): string {
+          return `/msdk/evalx/context`;
+        },
       }),
       () => ({
-        pathGet: jest.fn(),
-        pathReport: jest.fn(),
+        pathGet(encoding: Encoding, _plainContextString: string): string {
+          return `/meval/${base64UrlEncode(_plainContextString, encoding)}`;
+        },
+        pathReport(_encoding: Encoding, _plainContextString: string): string {
+          return `/meval`;
+        },
       }),
       baseHeaders,
       emitter,
@@ -124,71 +172,130 @@ describe('given a BrowserDataManager with mocked dependencies', () => {
     jest.resetAllMocks();
   });
 
-  it('should load cached flags and continue to initialize via a poll', async () => {
+  it('creates an event source when stream is true', async () => {
+    dataManager = new BrowserDataManager(
+      platform,
+      flagManager,
+      'test-credential',
+      config,
+      validateOptions({ stream: true }, logger),
+      () => ({
+        pathGet(encoding: Encoding, _plainContextString: string): string {
+          return `/msdk/evalx/contexts/${base64UrlEncode(_plainContextString, encoding)}`;
+        },
+        pathReport(_encoding: Encoding, _plainContextString: string): string {
+          return `/msdk/evalx/context`;
+        },
+      }),
+      () => ({
+        pathGet(encoding: Encoding, _plainContextString: string): string {
+          return `/meval/${base64UrlEncode(_plainContextString, encoding)}`;
+        },
+        pathReport(_encoding: Encoding, _plainContextString: string): string {
+          return `/meval`;
+        },
+      }),
+      baseHeaders,
+      emitter,
+      diagnosticsManager,
+    );
+
+    const context = Context.fromLDContext({ kind: 'user', key: 'test-user' });
+    const identifyOptions: LDIdentifyOptions = { waitForNetworkResults: false };
+    const identifyResolve = jest.fn();
+    const identifyReject = jest.fn();
+
+    await dataManager.identify(identifyResolve, identifyReject, context, identifyOptions);
+
+    expect(platform.requests.createEventSource).toHaveBeenCalled();
+  });
+
+  it('should load cached flags and continue to poll to complete identify', async () => {
     const context = Context.fromLDContext({ kind: 'user', key: 'test-user' });
-    const identifyOptions: LDIdentifyOptions = {};
+    const identifyOptions: LDIdentifyOptions = { waitForNetworkResults: false };
     const identifyResolve = jest.fn();
     const identifyReject = jest.fn();
 
     flagManager.loadCached.mockResolvedValue(true);
 
-    await browserDataManager.identify(identifyResolve, identifyReject, context, identifyOptions);
+    await dataManager.identify(identifyResolve, identifyReject, context, identifyOptions);
 
     expect(logger.debug).toHaveBeenCalledWith(
-      'Identify - Flags loaded from cache. Continuing to initialize via a poll.',
+      '[BrowserDataManager] Identify - Flags loaded from cache. Continuing to initialize via a poll.',
     );
+
     expect(flagManager.loadCached).toHaveBeenCalledWith(context);
-    expect(platform.requests.fetch).toHaveBeenCalled();
+    expect(identifyResolve).toHaveBeenCalled();
+    expect(flagManager.init).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ flagA: { flag: true, version: undefined } }),
+    );
+    expect(platform.requests.createEventSource).not.toHaveBeenCalled();
   });
 
-  it('should set up streaming connection if stream is enabled', async () => {
+  it('should identify from polling when there are no cached flags', async () => {
     const context = Context.fromLDContext({ kind: 'user', key: 'test-user' });
-    const identifyOptions: LDIdentifyOptions = {};
+    const identifyOptions: LDIdentifyOptions = { waitForNetworkResults: false };
     const identifyResolve = jest.fn();
     const identifyReject = jest.fn();
 
-    await browserDataManager.identify(identifyResolve, identifyReject, context, identifyOptions);
+    flagManager.loadCached.mockResolvedValue(false);
 
-    expect(platform.requests.createEventSource).toHaveBeenCalled();
+    await dataManager.identify(identifyResolve, identifyReject, context, identifyOptions);
+
+    expect(logger.debug).not.toHaveBeenCalledWith(
+      'Identify - Flags loaded from cache. Continuing to initialize via a poll.',
+    );
+
+    expect(flagManager.loadCached).toHaveBeenCalledWith(context);
+    expect(identifyResolve).toHaveBeenCalled();
+    expect(flagManager.init).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ flagA: { flag: true, version: undefined } }),
+    );
+    expect(platform.requests.createEventSource).not.toHaveBeenCalled();
   });
 
-  it('should not set up streaming connection if stream is disabled', async () => {
-    browserConfig.stream = false;
+  it('creates a stream when streaming is enabled after construction', async () => {
     const context = Context.fromLDContext({ kind: 'user', key: 'test-user' });
-    const identifyOptions: LDIdentifyOptions = {};
+    const identifyOptions: LDIdentifyOptions = { waitForNetworkResults: false };
     const identifyResolve = jest.fn();
     const identifyReject = jest.fn();
 
-    await browserDataManager.identify(identifyResolve, identifyReject, context, identifyOptions);
+    flagManager.loadCached.mockResolvedValue(false);
+
+    await dataManager.identify(identifyResolve, identifyReject, context, identifyOptions);
 
     expect(platform.requests.createEventSource).not.toHaveBeenCalled();
+    dataManager.startDataSource();
+    expect(platform.requests.createEventSource).toHaveBeenCalled();
   });
 
-  // it('should stop the data source', () => {
-  //   const mockClose = jest.fn();
-  //   browserDataManager.updateProcessor = { close: mockClose } as any;
-
-  //   browserDataManager.stopDataSource();
-
-  //   expect(mockClose).toHaveBeenCalled();
-  //   expect(browserDataManager.updateProcessor).toBeUndefined();
-  // });
-
-  // it('should start the data source if context exists', () => {
-  //   const mockSetupConnection = jest.spyOn(browserDataManager as any, 'setupConnection');
-  //   browserDataManager.context = Context.fromLDContext({ kind: 'user', key: 'test-user' });
-
-  //   browserDataManager.startDataSource();
+  it('does not re-create the stream if it already running', async () => {
+    const context = Context.fromLDContext({ kind: 'user', key: 'test-user' });
+    const identifyOptions: LDIdentifyOptions = { waitForNetworkResults: false };
+    const identifyResolve = jest.fn();
+    const identifyReject = jest.fn();
 
-  //   expect(mockSetupConnection).toHaveBeenCalled();
-  // });
+    flagManager.loadCached.mockResolvedValue(false);
 
-  // it('should not start the data source if context does not exist', () => {
-  //   const mockSetupConnection = jest.spyOn(browserDataManager as any, 'setupConnection');
-  //   browserDataManager.context = undefined;
+    await dataManager.identify(identifyResolve, identifyReject, context, identifyOptions);
 
-  //   browserDataManager.startDataSource();
+    expect(platform.requests.createEventSource).not.toHaveBeenCalled();
+    dataManager.startDataSource();
+    dataManager.startDataSource();
+    expect(platform.requests.createEventSource).toHaveBeenCalledTimes(1);
+    expect(logger.debug).toHaveBeenCalledWith(
+      '[BrowserDataManager] Update processor already active. Not changing state.',
+    );
+  });
 
-  //   expect(mockSetupConnection).not.toHaveBeenCalled();
-  // });
+  it('does not start a stream if identify has not been called', async () => {
+    expect(platform.requests.createEventSource).not.toHaveBeenCalled();
+    dataManager.startDataSource();
+    expect(platform.requests.createEventSource).not.toHaveBeenCalledTimes(1);
+    expect(logger.debug).toHaveBeenCalledWith(
+      '[BrowserDataManager] Context not set, not starting update processor.',
+    );
+  });
 });

packages/sdk/browser/__tests__/MockHasher.ts

@@ -0,0 +1,13 @@
+import { Hasher } from '@launchdarkly/js-client-sdk-common';
+
+export class MockHasher implements Hasher {
+  update(_data: string): Hasher {
+    return this;
+  }
+  digest?(_encoding: string): string {
+    return 'hashed';
+  }
+  async asyncDigest?(_encoding: string): Promise<string> {
+    return 'hashed';
+  }
+}