refactor(launchdarkly-provider): Check for context changes on initialization

Signed-off-by: mateo <[email protected]>

Author: Mateoc

libs/providers/launchdarkly-client/src/lib/launchdarkly-client-provider.spec.ts

@@ -9,21 +9,65 @@ const logger: TestLogger = new TestLogger();
 const testFlagKey = 'a-key';
 describe('LaunchDarklyClientProvider', () => {
   let ldClient: LDClient;
+  let ldProvider: LaunchDarklyClientProvider
   let ofClient: Client;
 
   beforeAll(() => {
     ldClient = {
       variationDetail: jest.fn(),
       waitUntilReady: jest.fn().mockResolvedValue({}),
+      getContext: jest.fn().mockReturnValue({}),
     } as any;
-    OpenFeature.setProvider(new LaunchDarklyClientProvider(ldClient, { logger }));
+    ldProvider = new LaunchDarklyClientProvider(ldClient, { logger });
+    OpenFeature.setProvider(ldProvider);
     ofClient = OpenFeature.getClient();
   })
   beforeEach(() => {
     logger.reset();
     jest.clearAllMocks();
   });
 
+  describe('initialize', () => {
+    test('should not update context if it did not change', async () => {
+      const newContext = {kind: 'user', targetingKey: 'test-key'};
+      const oldContext = {kind: 'user', key: 'test-key'};
+      ldClient.getContext = jest.fn().mockReturnValue(oldContext);
+      ldClient.identify = jest.fn().mockResolvedValue(undefined);
+      await ldProvider.initialize(newContext);
+      expect(ldClient.identify).not.toHaveBeenCalled();
+    });
+
+    test('should update context if it changed', async() => {
+      const newContext = {kind: 'organization', targetingKey: 'test-key'};
+      const oldContext = {kind: 'user', key: 'test-key'};
+      ldClient.getContext = jest.fn().mockReturnValue(oldContext);
+      ldClient.identify = jest.fn().mockResolvedValue(undefined);
+      await ldProvider.initialize(newContext);
+      expect(ldClient.identify).toHaveBeenCalledTimes(1);
+      expect(ldClient.identify).toHaveBeenCalledWith(translateContext(logger, newContext));
+    });
+
+    test('should not update context if anonymous and no key', async() => {
+      const newContext = {anonymous: true};
+      const oldContext = {kind: 'user', anonymous: true, key: 'generated-key'};
+      ldClient.getContext = jest.fn().mockReturnValue(oldContext);
+      ldClient.identify = jest.fn().mockResolvedValue(undefined);
+      await ldProvider.initialize(newContext);
+      expect(ldClient.identify).not.toHaveBeenCalled();
+    });
+
+    test('should update context if anonymous and custom key', async() => {
+      const newContext = {anonymous: true, key: 'custom-key'};
+      const oldContext = {kind: 'user', anonymous: true, key: 'generated-key'};
+      ldClient.getContext = jest.fn().mockReturnValue(oldContext);
+      ldClient.identify = jest.fn().mockResolvedValue(undefined);
+      await ldProvider.initialize(newContext);
+      expect(ldClient.identify).toHaveBeenCalledTimes(1);
+      expect(ldClient.identify).toHaveBeenCalledWith(translateContext(logger, newContext));
+    });
+
+  });
+
   describe('resolveBooleanEvaluation', () => {
     it('calls the client correctly for boolean variations', () => {
       // @ts-ignore we don't care about the arguments

libs/providers/launchdarkly-client/src/lib/launchdarkly-client-provider.ts

@@ -8,6 +8,7 @@ import {
 import {
   basicLogger, LDClient
 } from 'launchdarkly-js-client-sdk';
+import isEqual from 'lodash.isequal';
 
 import {LaunchDarklyProviderOptions} from './launchdarkly-provider-options';
 import translateContext from './translate-context';
@@ -43,7 +44,13 @@ export class LaunchDarklyClientProvider implements Provider {
     }
   }
 
-  initialize(context: EvaluationContext): Promise<void> {
+  async initialize(context: EvaluationContext): Promise<void> {
+    const newContext = this.translateContext(context);
+    const oldContext = this.client.getContext();
+    const ignoreAnonymous = newContext.anonymous && oldContext.anonymous && !newContext.key
+    if(!ignoreAnonymous && !isEqual(newContext, oldContext)) {
+       await this.client.identify(newContext);
+    }
     return this.client.waitUntilReady();
   }