@envive-ai/react-hooks 0.3.3 → 0.3.5

package/src/contexts/amplitudeContext/__tests__/amplitudeContext.test.tsx

@@ -7,49 +7,44 @@ import {
 } from 'src/contexts/userIdentityContext/userIdentityContext';
 import { LocalStorageProvider } from 'src/contexts/localStorageContext';
 import { EnviveConfigProvider } from 'src/contexts/enviveConfigContext/enviveConfigContext';
-import { FeatureFlagServiceProvider } from 'src/contexts/featureFlagServiceContext/featureFlagServiceContext';
+import {
+  FeatureFlagService,
+  FeatureFlagServiceProvider,
+} from 'src/contexts/featureFlagServiceContext/featureFlagServiceContext';
 import { userIdAtom } from 'src/atoms/app';
-import Logger from 'src/application/logging/logger';
+import { AmplitudeService } from 'src/services/amplitudeService/amplitudeService';
 import { AmplitudeProvider, SpiffyMetricsEventName, useAmplitude } from '../amplitudeContext';
 
-// Mock the Logger to avoid console output in tests
-// vi.spyOn(Logger, "logInfo").mockImplementation(() => {});
-// vi.spyOn(Logger, "logWarn").mockImplementation(() => {});
-// vi.spyOn(Logger, "logError").mockImplementation(() => {});
-// vi.spyOn(Logger, "logDebug").mockImplementation(() => {});
-
-// Mock Amplitude
-const mockTrack = vi.fn();
-const mockInit = vi.fn();
-const mockAdd = vi.fn();
-
-vi.mock('@amplitude/analytics-browser', () => ({
-  createInstance: vi.fn(() => ({
-    track: mockTrack,
-    init: mockInit,
-    add: mockAdd,
-  })),
-}));
-
-// Mock EventsDispatcher
-vi.mock('src/events', () => ({
-  EventsDispatcher: {
-    dispatch: vi.fn(),
-  },
-  SpiffyEvent: {
-    AMPLITUDE_EVENT: 'AMPLITUDE_EVENT',
-  },
-}));
-
-// Mock crypto.subtle.digest for insert_id generation
-const mockDigest = vi.fn().mockResolvedValue(new Uint8Array(32).fill(0));
-Object.defineProperty(global, 'crypto', {
-  value: {
-    subtle: {
-      digest: mockDigest,
-    },
-  },
-  writable: true,
+// Mock AmplitudeService
+const mockTrackEvent = vi.fn().mockResolvedValue(undefined);
+const mockSetSupplementalDefaultProps = vi.fn();
+const mockIsReady = vi.fn().mockReturnValue(true);
+
+vi.mock('src/services/amplitudeService/amplitudeService', async () => {
+  const actual = await vi.importActual<
+    typeof import('src/services/amplitudeService/amplitudeService')
+  >('src/services/amplitudeService/amplitudeService');
+
+  class MockAmplitudeService {
+    trackEvent = mockTrackEvent;
+
+    setSupplementalDefaultProps = mockSetSupplementalDefaultProps;
+
+    get isReady(): boolean {
+      return mockIsReady();
+    }
+  }
+
+  function MockAmplitudeServiceConstructor() {
+    return new MockAmplitudeService();
+  }
+  MockAmplitudeServiceConstructor.prototype = MockAmplitudeService.prototype;
+  const mockAmplitudeServiceConstructor = vi.fn(MockAmplitudeServiceConstructor);
+
+  return {
+    ...actual,
+    AmplitudeService: mockAmplitudeServiceConstructor,
+  };
 });
 
 // Component that uses the useAmplitude hook
@@ -125,13 +120,23 @@ const CombinedContextComponent: React.FC = () => {
   );
 };
 
+// FeatureFlagService
+const testFeatureFlagService = new FeatureFlagService([]);
+
 // Wrapper component with all required providers
 const TestWrapper: React.FC<{
   children: React.ReactNode;
   amplitudeApiKey?: string;
   userIdOverride?: string;
   userIdDefault?: string;
-}> = ({ children, amplitudeApiKey = 'test-amplitude-key', userIdOverride, userIdDefault }) => {
+  externalAmplitudeService?: AmplitudeService;
+}> = ({
+  children,
+  amplitudeApiKey = 'test-amplitude-key',
+  userIdOverride,
+  userIdDefault,
+  externalAmplitudeService,
+}) => {
   // Set up localStorage with user IDs if provided
   React.useEffect(() => {
     if (userIdOverride) {
@@ -155,8 +160,10 @@ const TestWrapper: React.FC<{
       >
         <LocalStorageProvider>
           <UserIdentityProvider>
-            <FeatureFlagServiceProvider featureGates={[]}>
-              <AmplitudeProvider>{children}</AmplitudeProvider>
+            <FeatureFlagServiceProvider featureFlagService={testFeatureFlagService}>
+              <AmplitudeProvider externalAmplitudeService={externalAmplitudeService}>
+                {children}
+              </AmplitudeProvider>
             </FeatureFlagServiceProvider>
           </UserIdentityProvider>
         </LocalStorageProvider>
@@ -165,17 +172,19 @@ const TestWrapper: React.FC<{
   );
 };
 
-describe('AmplitudeProvider with UserIdentityContext', () => {
+describe('AmplitudeProvider - React Context Integration', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     if (typeof localStorage !== 'undefined') {
       localStorage.clear();
     }
     // Reset mocks
-    mockTrack.mockClear();
-    mockInit.mockClear();
-    mockAdd.mockClear();
-    mockDigest.mockResolvedValue(new Uint8Array(32).fill(0));
+    mockTrackEvent.mockClear();
+    mockSetSupplementalDefaultProps.mockClear();
+    mockIsReady.mockReturnValue(true);
+    if (AmplitudeService && typeof AmplitudeService === 'function') {
+      (AmplitudeService as unknown as ReturnType<typeof vi.fn>).mockClear();
+    }
   });
 
   describe('Integration with UserIdentityContext - userIdAtom', () => {
@@ -209,10 +218,12 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
       });
 
       await waitFor(() => {
-        expect(mockTrack).toHaveBeenCalled();
-        const callArgs = mockTrack.mock.calls[0];
-        expect(callArgs[0]).toBe('[Spiffy] Chat User Message Input');
-        expect(callArgs[1]).toHaveProperty('user.id', testUserId);
+        expect(mockTrackEvent).toHaveBeenCalled();
+        const callArgs = mockTrackEvent.mock.calls[0];
+        expect(callArgs[0]).toEqual({
+          eventName: SpiffyMetricsEventName.ChatUserMessageInput,
+          eventProps: { message: 'test message' },
+        });
       });
     });
 
@@ -233,9 +244,12 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
       });
 
       await waitFor(() => {
-        expect(mockTrack).toHaveBeenCalled();
-        const callArgs = mockTrack.mock.calls[0];
-        expect(callArgs[1]).toHaveProperty('user.id', testUserId);
+        expect(mockTrackEvent).toHaveBeenCalled();
+        const callArgs = mockTrackEvent.mock.calls[0];
+        expect(callArgs[0]).toEqual({
+          eventName: SpiffyMetricsEventName.ChatUserMessageInput,
+          eventProps: { message: 'test message' },
+        });
       });
     });
 
@@ -260,14 +274,16 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
       });
 
       await waitFor(() => {
-        expect(mockTrack).toHaveBeenCalled();
-        const callArgs = mockTrack.mock.calls[0];
-        expect(callArgs[1]).toHaveProperty('user.id', overrideUserId);
-        expect(callArgs[1]).not.toHaveProperty('user.id', defaultUserId);
+        expect(mockTrackEvent).toHaveBeenCalled();
+        const callArgs = mockTrackEvent.mock.calls[0];
+        expect(callArgs[0]).toEqual({
+          eventName: SpiffyMetricsEventName.ChatUserMessageInput,
+          eventProps: { message: 'test message' },
+        });
       });
     });
 
-    it('should initialize Amplitude with userId from UserIdentityContext', async () => {
+    it('should initialize AmplitudeService with userId from UserIdentityContext', async () => {
       const testUserId = 'init-user-id-345';
       render(
         <TestWrapper userIdOverride={testUserId}>
@@ -276,9 +292,10 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
       );
 
       await waitFor(() => {
-        expect(mockInit).toHaveBeenCalled();
-        const initArgs = mockInit.mock.calls[0];
-        expect(initArgs[1]).toBe(testUserId);
+        expect(AmplitudeService).toHaveBeenCalled();
+        const serviceCallArgs = (AmplitudeService as unknown as ReturnType<typeof vi.fn>).mock
+          .calls[0];
+        expect(serviceCallArgs[0]).toHaveProperty('userId', testUserId);
       });
     });
   });
@@ -305,105 +322,6 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
     });
   });
 
-  describe('Event tracking with UserIdentityContext userId', () => {
-    it('should include user.id in all tracked events', async () => {
-      const testUserId = 'event-user-id-901';
-      render(
-        <TestWrapper userIdOverride={testUserId}>
-          <MockAmplitudeComponent />
-        </TestWrapper>,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('is-ready').textContent).toBe('true');
-      });
-
-      await act(async () => {
-        screen.getByTestId('track-event-button').click();
-      });
-
-      await waitFor(() => {
-        expect(mockTrack).toHaveBeenCalled();
-        const callArgs = mockTrack.mock.calls[0];
-        expect(callArgs[1]).toHaveProperty('user.id', testUserId);
-      });
-    });
-
-    it('should include user.id in default tracking props', async () => {
-      const testUserId = 'default-props-user-id';
-      render(
-        <TestWrapper userIdOverride={testUserId}>
-          <MockAmplitudeComponent />
-        </TestWrapper>,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('is-ready').textContent).toBe('true');
-      });
-
-      await act(async () => {
-        screen.getByTestId('track-event-button').click();
-      });
-
-      await waitFor(() => {
-        expect(mockTrack).toHaveBeenCalled();
-        const callArgs = mockTrack.mock.calls[0];
-        const eventProps = callArgs[1];
-        expect(eventProps['user.id']).toBe(testUserId);
-        expect(eventProps['cdp.user_id']).toBe(null);
-      });
-    });
-
-    it('should track multiple events with correct userId', async () => {
-      const testUserId = 'multi-event-user-id';
-      const MultiEventComponent: React.FC = () => {
-        const amplitude = useAmplitude();
-
-        const trackMultiple = () => {
-          amplitude.trackEvent({
-            eventName: SpiffyMetricsEventName.ChatUserMessageInput,
-            eventProps: { event1: true },
-          });
-          amplitude.trackEvent({
-            eventName: SpiffyMetricsEventName.ChatSuggestionClicked,
-            eventProps: { event2: true },
-          });
-        };
-
-        return (
-          <button
-            data-testid="track-multiple"
-            type="button"
-            onClick={trackMultiple}
-          >
-            Track Multiple
-          </button>
-        );
-      };
-
-      render(
-        <TestWrapper userIdOverride={testUserId}>
-          <MultiEventComponent />
-        </TestWrapper>,
-      );
-
-      await waitFor(() => {
-        expect(screen.getByTestId('track-multiple')).toBeInTheDocument();
-      });
-
-      await act(async () => {
-        screen.getByTestId('track-multiple').click();
-      });
-
-      await waitFor(() => {
-        expect(mockTrack).toHaveBeenCalledTimes(2);
-        mockTrack.mock.calls.forEach((call: any[]) => {
-          expect(call[1]).toHaveProperty('user.id', testUserId);
-        });
-      });
-    });
-  });
-
   describe('Context readiness and initialization', () => {
     it('should wait for UserIdentityContext to be ready before becoming ready', async () => {
       render(
@@ -419,7 +337,7 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
       });
     });
 
-    it('should initialize Amplitude client with correct userId from UserIdentityContext', async () => {
+    it('should initialize AmplitudeService with correct config from UserIdentityContext', async () => {
       const testUserId = 'init-client-user-id';
       render(
         <TestWrapper userIdOverride={testUserId}>
@@ -428,13 +346,14 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
       );
 
       await waitFor(() => {
-        expect(mockInit).toHaveBeenCalledWith(
-          'test-amplitude-key',
-          testUserId,
-          expect.objectContaining({
-            serverZone: 'US',
-          }),
-        );
+        expect(AmplitudeService).toHaveBeenCalled();
+        const serviceCallArgs = (AmplitudeService as unknown as ReturnType<typeof vi.fn>).mock
+          .calls[0];
+        expect(serviceCallArgs[0]).toMatchObject({
+          userId: testUserId,
+          amplitudeApiKey: 'test-amplitude-key',
+          dataResidency: 'US',
+        });
       });
     });
 
@@ -451,7 +370,7 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
             >
               <LocalStorageProvider>
                 <UserIdentityProvider>
-                  <FeatureFlagServiceProvider featureGates={[]}>
+                  <FeatureFlagServiceProvider featureFlagService={testFeatureFlagService}>
                     <AmplitudeProvider>{children}</AmplitudeProvider>
                   </FeatureFlagServiceProvider>
                 </UserIdentityProvider>
@@ -461,7 +380,7 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
         );
       };
 
-      const { container } = render(
+      render(
         <IncompleteWrapper>
           <div data-testid="should-not-render">Should not render</div>
         </IncompleteWrapper>,
@@ -474,17 +393,20 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
     });
   });
 
-  describe('Error handling', () => {
-    it('should handle tracking errors gracefully when userId is available', async () => {
-      const testUserId = 'error-user-id';
-      mockTrack.mockImplementationOnce(() => {
-        throw new Error('Tracking error');
+  describe('External service injection', () => {
+    it('should use external AmplitudeService when provided', async () => {
+      const externalService = new AmplitudeService({
+        userId: 'external-user-id',
+        amplitudeApiKey: 'external-api-key',
+        dataResidency: 'EU',
+        featureFlagService: new FeatureFlagService([]),
+        env: 'test', // Provide required fields to match AmplitudeServiceConfig
+        contextSource: 'test-source',
+        orgShortName: 'test-org',
       });
 
-      const logErrorSpy = vi.spyOn(Logger, 'logError');
-
       render(
-        <TestWrapper userIdOverride={testUserId}>
+        <TestWrapper externalAmplitudeService={externalService}>
           <MockAmplitudeComponent />
         </TestWrapper>,
       );
@@ -498,13 +420,100 @@ describe('AmplitudeProvider with UserIdentityContext', () => {
       });
 
       await waitFor(() => {
-        expect(logErrorSpy).toHaveBeenCalledWith(
-          '[spiffy-ai] Error tracking event',
-          expect.any(Error),
-          expect.objectContaining({
-            eventName: SpiffyMetricsEventName.ChatUserMessageInput,
-          }),
-        );
+        expect(mockTrackEvent).toHaveBeenCalled();
+        const callArgs = mockTrackEvent.mock.calls[0];
+        expect(callArgs[0]).toEqual({
+          eventName: SpiffyMetricsEventName.ChatUserMessageInput,
+          eventProps: { message: 'test message' },
+        });
+      });
+    });
+
+    it('should not create new service when external service is provided', async () => {
+      // Provide all required fields to match AmplitudeServiceConfig
+      const externalService = new AmplitudeService({
+        userId: 'external-user-id',
+        amplitudeApiKey: 'external-api-key',
+        dataResidency: 'EU',
+        featureFlagService: new FeatureFlagService([]),
+        env: 'test',
+        contextSource: 'test-source',
+        orgShortName: 'test-org',
+      });
+
+      const serviceCallCountBefore = (AmplitudeService as unknown as ReturnType<typeof vi.fn>).mock
+        .calls.length;
+
+      render(
+        <TestWrapper externalAmplitudeService={externalService}>
+          <MockAmplitudeComponent />
+        </TestWrapper>,
+      );
+
+      await waitFor(() => {
+        expect(screen.getByTestId('is-ready').textContent).toBe('true');
+      });
+
+      // Should not have created an additional service instance
+      // The provider should use the external service directly
+      const serviceCallCountAfter = (AmplitudeService as unknown as ReturnType<typeof vi.fn>).mock
+        .calls.length;
+      expect(serviceCallCountAfter).toBe(serviceCallCountBefore);
+    });
+  });
+
+  describe('useAmplitude hook', () => {
+    it('should throw error when used outside provider', () => {
+      // Suppress console.error for this test
+      const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      expect(() => {
+        render(<MockAmplitudeComponent />);
+      }).toThrow('useAmplitude must be used within AmplitudeProvider');
+
+      consoleError.mockRestore();
+    });
+
+    it('should provide amplitude context when used within provider', async () => {
+      render(
+        <TestWrapper>
+          <MockAmplitudeComponent />
+        </TestWrapper>,
+      );
+
+      await waitFor(() => {
+        expect(screen.getByTestId('amplitude-component')).toBeInTheDocument();
+        expect(screen.getByTestId('is-ready')).toBeInTheDocument();
+      });
+    });
+  });
+
+  describe('Service instance management', () => {
+    it('should update service when dependencies change', async () => {
+      const { rerender } = render(
+        <TestWrapper amplitudeApiKey="initial-key">
+          <MockAmplitudeComponent />
+        </TestWrapper>,
+      );
+
+      await waitFor(() => {
+        expect(screen.getByTestId('is-ready').textContent).toBe('true');
+      });
+
+      const initialServiceCalls = (AmplitudeService as unknown as ReturnType<typeof vi.fn>).mock
+        .calls.length;
+
+      rerender(
+        <TestWrapper amplitudeApiKey="updated-key">
+          <MockAmplitudeComponent />
+        </TestWrapper>,
+      );
+
+      // Service should be recreated with new config
+      await waitFor(() => {
+        const serviceCallCount = (AmplitudeService as unknown as ReturnType<typeof vi.fn>).mock
+          .calls.length;
+        expect(serviceCallCount).toBeGreaterThan(initialServiceCalls);
       });
     });
   });