test: add unit tests for FlagManager debug override functionality

joker23 · joker23 · commit cfa6df130aa2 · 2025-12-15T13:52:36.000-06:00
diff --git a/packages/shared/sdk-client/__tests__/flag-manager/FlagManager.test.ts b/packages/shared/sdk-client/__tests__/flag-manager/FlagManager.test.ts
@@ -0,0 +1,231 @@
+import { Context, Crypto, Hasher, LDLogger, Platform, Storage } from '@launchdarkly/js-sdk-common';
+
+import DefaultFlagManager from '../../src/flag-manager/FlagManager';
+import { FlagsChangeCallback } from '../../src/flag-manager/FlagUpdater';
+import { ItemDescriptor } from '../../src/flag-manager/ItemDescriptor';
+import { Flag } from '../../src/types';
+
+const TEST_SDK_KEY = 'test-sdk-key';
+const TEST_MAX_CACHED_CONTEXTS = 5;
+
+function makeMockPlatform(storage: Storage, crypto: Crypto): Platform {
+  return {
+    storage,
+    crypto,
+    info: {
+      platformData: jest.fn(),
+      sdkData: jest.fn(),
+    },
+    requests: {
+      fetch: jest.fn(),
+      createEventSource: jest.fn(),
+      getEventSourceCapabilities: jest.fn(),
+    },
+  };
+}
+
+function makeMemoryStorage(): Storage {
+  const data = new Map<string, string>();
+  return {
+    get: async (key: string) => {
+      const value = data.get(key);
+      return value !== undefined ? value : null;
+    },
+    set: async (key: string, value: string) => {
+      data.set(key, value);
+    },
+    clear: async (key: string) => {
+      data.delete(key);
+    },
+  };
+}
+
+function makeMockCrypto() {
+  let counter = 0;
+  let lastInput = '';
+  const hasher: Hasher = {
+    update: jest.fn((input) => {
+      lastInput = input;
+      return hasher;
+    }),
+    digest: jest.fn(() => `${lastInput}Hashed`),
+  };
+
+  return {
+    createHash: jest.fn(() => hasher),
+    createHmac: jest.fn(),
+    randomUUID: jest.fn(() => {
+      counter += 1;
+      return `${counter}`;
+    }),
+  };
+}
+
+function makeMockLogger(): LDLogger {
+  return {
+    error: jest.fn(),
+    warn: jest.fn(),
+    info: jest.fn(),
+    debug: jest.fn(),
+  };
+}
+
+function makeMockFlag(version: number = 1, value: any = 'test-value'): Flag {
+  return {
+    version,
+    flagVersion: version,
+    value,
+    variation: 0,
+    trackEvents: false,
+  };
+}
+
+function makeMockItemDescriptor(version: number = 1, value: any = 'test-value'): ItemDescriptor {
+  return {
+    version,
+    flag: makeMockFlag(version, value),
+  };
+}
+
+describe('FlagManager override tests', () => {
+  let flagManager: DefaultFlagManager;
+  let mockPlatform: Platform;
+  let mockLogger: LDLogger;
+
+  beforeEach(() => {
+    mockLogger = makeMockLogger();
+    mockPlatform = makeMockPlatform(makeMemoryStorage(), makeMockCrypto());
+    flagManager = new DefaultFlagManager(
+      mockPlatform,
+      TEST_SDK_KEY,
+      TEST_MAX_CACHED_CONTEXTS,
+      mockLogger,
+    );
+  });
+
+  it('setOverride takes precedence over flag store value', async () => {
+    const context = Context.fromLDContext({ kind: 'user', key: 'user-key' });
+    const flags = {
+      'test-flag': makeMockItemDescriptor(1, 'store-value'),
+    };
+
+    await flagManager.init(context, flags);
+    expect(flagManager.get('test-flag')?.flag.value).toBe('store-value');
+
+    const debugOverride = flagManager.getDebugOverride();
+    debugOverride?.setOverride('test-flag', 'override-value');
+
+    expect(flagManager.get('test-flag')?.flag.value).toBe('override-value');
+  });
+
+  it('setOverride triggers flag change callback', () => {
+    const mockCallback: FlagsChangeCallback = jest.fn();
+    flagManager.on(mockCallback);
+
+    const debugOverride = flagManager.getDebugOverride();
+    debugOverride?.setOverride('test-flag', 'override-value');
+
+    expect(mockCallback).toHaveBeenCalledTimes(1);
+    expect(mockCallback).toHaveBeenCalledWith(null, ['test-flag'], 'override');
+  });
+
+  it('removeOverride does nothing when override does not exist', () => {
+    const debugOverride = flagManager.getDebugOverride();
+    expect(() => {
+      debugOverride?.removeOverride('non-existent-flag');
+    }).not.toThrow();
+  });
+
+  it('removeOverride reverts to flag store value when override is removed', async () => {
+    const context = Context.fromLDContext({ kind: 'user', key: 'user-key' });
+    const flags = {
+      'test-flag': makeMockItemDescriptor(1, 'store-value'),
+    };
+
+    await flagManager.init(context, flags);
+    const debugOverride = flagManager.getDebugOverride();
+    debugOverride?.setOverride('test-flag', 'override-value');
+    expect(flagManager.get('test-flag')?.flag.value).toBe('override-value');
+
+    debugOverride?.removeOverride('test-flag');
+    expect(flagManager.get('test-flag')?.flag.value).toBe('store-value');
+  });
+
+  it('removeOverride triggers flag change callback', () => {
+    const mockCallback: FlagsChangeCallback = jest.fn();
+    flagManager.on(mockCallback);
+
+    const debugOverride = flagManager.getDebugOverride();
+    debugOverride?.setOverride('test-flag', 'override-value');
+    debugOverride?.removeOverride('test-flag');
+
+    expect(mockCallback).toHaveBeenCalledTimes(2);
+    expect(mockCallback).toHaveBeenNthCalledWith(1, null, ['test-flag'], 'override');
+    expect(mockCallback).toHaveBeenNthCalledWith(2, null, ['test-flag'], 'override');
+  });
+
+  it('clearAllOverrides removes all overrides', () => {
+    const debugOverride = flagManager.getDebugOverride();
+    debugOverride?.setOverride('flag1', 'value1');
+    debugOverride?.setOverride('flag2', 'value2');
+    debugOverride?.setOverride('flag3', 'value3');
+
+    expect(Object.keys(flagManager.getAllOverrides())).toHaveLength(3);
+
+    debugOverride?.clearAllOverrides();
+    expect(Object.keys(flagManager.getAllOverrides())).toHaveLength(0);
+  });
+
+  it('clearAllOverrides triggers flag change callback for all flags', () => {
+    const mockCallback: FlagsChangeCallback = jest.fn();
+    flagManager.on(mockCallback);
+
+    const debugOverride = flagManager.getDebugOverride();
+    debugOverride?.setOverride('flag1', 'value1');
+    debugOverride?.setOverride('flag2', 'value2');
+    (mockCallback as jest.Mock).mockClear();
+
+    debugOverride?.clearAllOverrides();
+    expect(mockCallback).toHaveBeenCalledTimes(1);
+    expect(mockCallback).toHaveBeenCalledWith(null, ['flag1', 'flag2'], 'override');
+  });
+
+  it('getAllOverrides returns all overrides as ItemDescriptors', () => {
+    const debugOverride = flagManager.getDebugOverride();
+    debugOverride?.setOverride('flag1', 'value1');
+    debugOverride?.setOverride('flag2', 42);
+    debugOverride?.setOverride('flag3', true);
+
+    const overrides = debugOverride?.getAllOverrides();
+    expect(overrides).toHaveProperty('flag1');
+    expect(overrides).toHaveProperty('flag2');
+    expect(overrides).toHaveProperty('flag3');
+    expect(overrides?.flag1.flag.value).toBe('value1');
+    expect(overrides?.flag2.flag.value).toBe(42);
+    expect(overrides?.flag3.flag.value).toBe(true);
+    expect(overrides?.flag1.version).toBe(0);
+    expect(overrides?.flag2.version).toBe(0);
+    expect(overrides?.flag3.version).toBe(0);
+  });
+
+  it('getAll merges overrides with flag store values', async () => {
+    const context = Context.fromLDContext({ kind: 'user', key: 'user-key' });
+    const flags = {
+      'store-flag': makeMockItemDescriptor(1, 'store-value'),
+      'shared-flag': makeMockItemDescriptor(1, 'store-value'),
+    };
+
+    await flagManager.init(context, flags);
+    const debugOverride = flagManager.getDebugOverride();
+    debugOverride?.setOverride('shared-flag', 'override-value');
+    debugOverride?.setOverride('override-only-flag', 'override-value');
+
+    const allFlags = flagManager.getAll();
+    expect(allFlags).toHaveProperty('store-flag');
+    expect(allFlags).toHaveProperty('shared-flag');
+    expect(allFlags).toHaveProperty('override-only-flag');
+    expect(allFlags['store-flag'].flag.value).toBe('store-value');
+    expect(allFlags['shared-flag'].flag.value).toBe('override-value');
+    expect(allFlags['override-only-flag'].flag.value).toBe('override-value');
+  });
+});
diff --git a/packages/shared/sdk-client/src/LDClientImpl.ts b/packages/shared/sdk-client/src/LDClientImpl.ts
@@ -41,7 +41,7 @@ import {
 } from './evaluation/evaluationDetail';
 import createEventProcessor from './events/createEventProcessor';
 import EventFactory from './events/EventFactory';
-import DefaultFlagManager, { LDDebugOverride, FlagManager } from './flag-manager/FlagManager';
+import DefaultFlagManager, { FlagManager, LDDebugOverride } from './flag-manager/FlagManager';
 import { FlagChangeType } from './flag-manager/FlagUpdater';
 import HookRunner from './HookRunner';
 import { getInspectorHook } from './inspection/getInspectorHook';
@@ -584,10 +584,10 @@ export default class LDClientImpl implements LDClient, LDClientIdentifyResult {
 
   protected getDebugOverrides(): LDDebugOverride | null {
     if (this._flagManager.getDebugOverride) {
-      return this._flagManager.getDebugOverride()
+      return this._flagManager.getDebugOverride();
     }
 
-    return null
+    return null;
   }
 
   private _handleInspectionChanged(flagKeys: Array<string>, type: FlagChangeType) {
diff --git a/packages/shared/sdk-client/src/api/LDPlugin.ts b/packages/shared/sdk-client/src/api/LDPlugin.ts
@@ -1,8 +1,9 @@
 import { LDPluginBase } from '@launchdarkly/js-sdk-common';
+
 import { LDDebugOverride } from '../flag-manager/FlagManager';
 
 export interface LDPlugin<TClient, THook> extends LDPluginBase<TClient, THook> {
-    /**
+  /**
    * An optional function called if the plugin wants to register debug capabilities.
    * This method allows plugins to receive a debug override interface for
    * temporarily overriding flag values during development and testing.
@@ -12,5 +13,5 @@ export interface LDPlugin<TClient, THook> extends LDPluginBase<TClient, THook> {
    *
    * @param debugOverride The debug override interface instance
    */
-    registerDebug?(debugOverride: LDDebugOverride): void;
+  registerDebug?(debugOverride: LDDebugOverride): void;
 }
diff --git a/packages/shared/sdk-client/src/api/index.ts b/packages/shared/sdk-client/src/api/index.ts
@@ -9,4 +9,4 @@ export { ConnectionMode };
 export * from './LDIdentifyOptions';
 export * from './LDInspection';
 export * from './LDIdentifyResult';
-export * from './LDPlugin';
+export * from './LDPlugin';
diff --git a/packages/shared/sdk-client/src/flag-manager/FlagManager.ts b/packages/shared/sdk-client/src/flag-manager/FlagManager.ts
@@ -67,7 +67,7 @@ export interface FlagManager {
    *
    * @experimental This function is experimental and intended for use by LaunchDarkly tools at this time.
    */
-  getDebugOverride?(): LDDebugOverride
+  getDebugOverride?(): LDDebugOverride;
 }
 
 /**
@@ -173,14 +173,16 @@ export default class DefaultFlagManager implements FlagManager {
     if (this._overrides) {
       return {
         ...this._flagStore.getAll(),
-        ...Object.entries(this._overrides).reduce((acc: {[key: string]: ItemDescriptor}, [key, value]) => {
-          acc[key] = this._convertValueToOverrideDescripter(value);
-          return acc
-        }, {})
-      }
-    } else {
-      return this._flagStore.getAll();
+        ...Object.entries(this._overrides).reduce(
+          (acc: { [key: string]: ItemDescriptor }, [key, value]) => {
+            acc[key] = this._convertValueToOverrideDescripter(value);
+            return acc;
+          },
+          {},
+        ),
+      };
     }
+    return this._flagStore.getAll();
   }
 
   setBootstrap(context: Context, newFlags: { [key: string]: ItemDescriptor }): void {
@@ -212,10 +214,10 @@ export default class DefaultFlagManager implements FlagManager {
   private _convertValueToOverrideDescripter(value: LDFlagValue): ItemDescriptor {
     return {
       flag: {
-        value: value,
-        version: 0
+        value,
+        version: 0,
       },
-      version: 0
+      version: 0,
     };
   }
 
diff --git a/packages/shared/sdk-client/src/index.ts b/packages/shared/sdk-client/src/index.ts
@@ -41,7 +41,7 @@ export type {
 
 export type { DataManager, DataManagerFactory, ConnectionParams } from './DataManager';
 export type { FlagManager, LDDebugOverride } from './flag-manager/FlagManager';
-export {safeRegisterDebugOverridePlugins} from './plugins/safeRegisterDebugOverridePlugins';
+export { safeRegisterDebugOverridePlugins } from './plugins/safeRegisterDebugOverridePlugins';
 export type { Configuration } from './configuration/Configuration';
 
 export type { LDEmitter };
diff --git a/packages/shared/sdk-client/src/plugins/safeRegisterDebugOverridePlugins.ts b/packages/shared/sdk-client/src/plugins/safeRegisterDebugOverridePlugins.ts
@@ -1,6 +1,7 @@
-import { internal, LDLogger } from "@launchdarkly/js-sdk-common";
-import { LDPlugin } from "../api";
-import { LDDebugOverride } from "../flag-manager/FlagManager";
+import { internal, LDLogger } from '@launchdarkly/js-sdk-common';
+
+import { LDPlugin } from '../api';
+import { LDDebugOverride } from '../flag-manager/FlagManager';
 
 /**
  * Safe register debug override plugins.
@@ -12,13 +13,13 @@ import { LDDebugOverride } from "../flag-manager/FlagManager";
 export function safeRegisterDebugOverridePlugins<TClient, THook>(
   logger: LDLogger,
   debugOverride: LDDebugOverride,
-  plugins: LDPlugin<TClient, THook>[]
+  plugins: LDPlugin<TClient, THook>[],
 ): void {
-  plugins.forEach(plugin => {
+  plugins.forEach((plugin) => {
     try {
       plugin.registerDebug?.(debugOverride);
     } catch (error) {
       logger.error(`Exception thrown registering plugin ${internal.safeGetName(logger, plugin)}.`);
     }
   });
-};
+}
