[fssdk-12294] provider update for hooks

Author: junaed-optimizely

src/hooks/useDecide.spec.tsx

@@ -16,9 +16,10 @@
 
 import { vi, describe, it, expect, beforeEach } from 'vitest';
 import React from 'react';
-import { act } from '@testing-library/react';
+import { act, waitFor } from '@testing-library/react';
 import { renderHook } from '@testing-library/react';
-import { OptimizelyContext, ProviderStateStore } from '../provider/index';
+import { OptimizelyContext, ProviderStateStore, OptimizelyProvider } from '../provider/index';
+import { REACT_CLIENT_META } from '../client/index';
 import { useDecide } from './useDecide';
 import type {
   OptimizelyUserContext,
@@ -68,6 +69,49 @@ function createMockClient(hasConfig = false): Client {
   } as unknown as Client;
 }
 
+/**
+ * Creates a mock client with notification center support and wraps it in OptimizelyProvider.
+ * Used for integration-style tests that need the full Provider lifecycle.
+ */
+function createProviderWrapper(mockUserContext: OptimizelyUserContext) {
+  let configUpdateCallback: (() => void) | undefined;
+
+  const client = {
+    getOptimizelyConfig: vi.fn().mockReturnValue({ revision: '1' }),
+    createUserContext: vi.fn().mockReturnValue(mockUserContext),
+    onReady: vi.fn().mockResolvedValue(undefined),
+    isOdpIntegrated: vi.fn().mockReturnValue(false),
+    notificationCenter: {
+      addNotificationListener: vi.fn().mockImplementation((type: string, cb: () => void) => {
+        if (type === 'OPTIMIZELY_CONFIG_UPDATE') {
+          configUpdateCallback = cb;
+        }
+        return 1;
+      }),
+      removeNotificationListener: vi.fn(),
+    },
+  } as unknown as Client;
+
+  (client as unknown as Record<symbol, unknown>)[REACT_CLIENT_META] = {
+    hasOdpManager: false,
+    hasVuidManager: false,
+  };
+
+  function Wrapper({ children }: { children: React.ReactNode }) {
+    return (
+      <OptimizelyProvider client={client} user={{ id: 'user-1' }}>
+        {children}
+      </OptimizelyProvider>
+    );
+  }
+
+  return {
+    wrapper: Wrapper,
+    client,
+    fireConfigUpdate: () => configUpdateCallback?.(),
+  };
+}
+
 function createWrapper(store: ProviderStateStore, client: Client) {
   const contextValue: OptimizelyContextValue = { store, client };
 
@@ -346,6 +390,38 @@ describe('useDecide', () => {
     expect(result.current.decision).toBe(MOCK_DECISION);
   });
 
+  it('should re-evaluate decision when OPTIMIZELY_CONFIG_UPDATE fires from the client', async () => {
+    const mockUserContext = createMockUserContext();
+    const { wrapper, fireConfigUpdate } = createProviderWrapper(mockUserContext);
+
+    const { result } = renderHook(() => useDecide('flag_1'), { wrapper });
+
+    // Wait for Provider's onReady + UserContextManager + queueMicrotask chain to complete
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.decision).toBe(MOCK_DECISION);
+    const callCountBeforeUpdate = (mockUserContext.decide as ReturnType<typeof vi.fn>).mock.calls.length;
+
+    // Simulate a new datafile with a different decision
+    const updatedDecision: OptimizelyDecision = {
+      ...MOCK_DECISION,
+      variationKey: 'variation_2',
+      variables: { color: 'blue' },
+    };
+    (mockUserContext.decide as ReturnType<typeof vi.fn>).mockReturnValue(updatedDecision);
+
+    // Fire the config update notification (as the SDK would on datafile poll)
+    await act(async () => {
+      fireConfigUpdate();
+    });
+
+    expect(mockUserContext.decide).toHaveBeenCalledTimes(callCountBeforeUpdate + 1);
+    expect(result.current.decision).toBe(updatedDecision);
+    expect(result.current.isLoading).toBe(false);
+  });
+
   describe('forced decision reactivity', () => {
     it('should re-evaluate when setForcedDecision is called for the same flagKey', () => {
       mockClient = createMockClient(true);

src/provider/OptimizelyProvider.spec.tsx

@@ -55,7 +55,10 @@ function createMockClient(
     createUserContext: vi.fn().mockReturnValue(mockUserContext),
     close: vi.fn(),
     getOptimizelyConfig: vi.fn(),
-    notificationCenter: {} as OptimizelyClient['notificationCenter'],
+    notificationCenter: {
+      addNotificationListener: vi.fn().mockReturnValue(1),
+      removeNotificationListener: vi.fn(),
+    } as unknown as OptimizelyClient['notificationCenter'],
     sendOdpEvent: vi.fn(),
     isOdpIntegrated: vi.fn().mockReturnValue(false),
     ...overrides,
@@ -638,6 +641,91 @@ describe('OptimizelyProvider', () => {
     });
   });
 
+  describe('config update subscription', () => {
+    it('should subscribe to OPTIMIZELY_CONFIG_UPDATE on mount', () => {
+      const mockClient = createMockClient();
+
+      render(
+        <OptimizelyProvider client={mockClient}>
+          <div>Child</div>
+        </OptimizelyProvider>
+      );
+
+      expect(mockClient.notificationCenter.addNotificationListener).toHaveBeenCalledWith(
+        'OPTIMIZELY_CONFIG_UPDATE',
+        expect.any(Function)
+      );
+    });
+
+    it('should remove notification listener on unmount', () => {
+      const mockClient = createMockClient();
+
+      const { unmount } = render(
+        <OptimizelyProvider client={mockClient}>
+          <div>Child</div>
+        </OptimizelyProvider>
+      );
+
+      unmount();
+
+      expect(mockClient.notificationCenter.removeNotificationListener).toHaveBeenCalledWith(1);
+    });
+
+    it('should trigger store state change when config update fires', async () => {
+      const mockClient = createMockClient();
+      let capturedContext: OptimizelyContextValue | null = null;
+
+      render(
+        <OptimizelyProvider client={mockClient}>
+          <ContextConsumer onContext={(ctx) => (capturedContext = ctx)} />
+        </OptimizelyProvider>
+      );
+
+      await waitFor(() => {
+        expect(capturedContext).not.toBeNull();
+      });
+
+      const stateBefore = capturedContext!.store.getState();
+
+      // Get the callback that was registered and invoke it
+      const configUpdateCallback = (
+        mockClient.notificationCenter.addNotificationListener as ReturnType<typeof vi.fn>
+      ).mock.calls.find((call: unknown[]) => call[0] === 'OPTIMIZELY_CONFIG_UPDATE')![1];
+
+      await act(() => {
+        configUpdateCallback();
+      });
+
+      const stateAfter = capturedContext!.store.getState();
+
+      // State should be a new reference (triggers useSyncExternalStore subscribers)
+      expect(stateBefore).not.toBe(stateAfter);
+    });
+
+    it('should re-subscribe when client changes', () => {
+      const mockClient1 = createMockClient();
+      const mockClient2 = createMockClient();
+
+      const { rerender } = render(
+        <OptimizelyProvider client={mockClient1}>
+          <div>Child</div>
+        </OptimizelyProvider>
+      );
+
+      expect(mockClient1.notificationCenter.addNotificationListener).toHaveBeenCalledTimes(1);
+
+      rerender(
+        <OptimizelyProvider client={mockClient2}>
+          <div>Child</div>
+        </OptimizelyProvider>
+      );
+
+      // Old listener cleaned up, new one registered
+      expect(mockClient1.notificationCenter.removeNotificationListener).toHaveBeenCalledWith(1);
+      expect(mockClient2.notificationCenter.addNotificationListener).toHaveBeenCalledTimes(1);
+    });
+  });
+
   describe('context reference identity', () => {
     it('should change context value reference when client changes', async () => {
       const mockClient1 = createMockClient();

src/provider/OptimizelyProvider.tsx

@@ -15,6 +15,7 @@
  */
 
 import React, { createContext, useRef, useMemo, useEffect } from 'react';
+import { NOTIFICATION_TYPES } from '@optimizely/optimizely-sdk';
 
 import { ProviderStateStore } from './ProviderStateStore';
 import { UserContextManager } from '../utils/UserContextManager';
@@ -110,6 +111,22 @@ export function OptimizelyProvider({
     };
   }, [client, timeout, store]);
 
+  // Effect: Subscribe to config/datafile updates (e.g., polling)
+  useEffect(() => {
+    if (!client) return;
+
+    const listenerId = client.notificationCenter.addNotificationListener(
+      NOTIFICATION_TYPES.OPTIMIZELY_CONFIG_UPDATE,
+      () => {
+        store.setState({});
+      }
+    );
+
+    return () => {
+      client.notificationCenter.removeNotificationListener(listenerId);
+    };
+  }, [client, store]);
+
   // Cleanup on unmount
   useEffect(() => {
     return () => {