@envive-ai/react-hooks 0.2.10 → 0.2.11

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

@@ -1,21 +1,17 @@
-import React from "react";
-import { render, screen, waitFor, act } from "@testing-library/react";
-import { Provider, useStore } from "jotai";
-import {
-  AmplitudeProvider,
-  useAmplitude,
-  SpiffyMetricsEventName,
-} from "../amplitudeContext";
+import React from 'react';
+import { render, screen, waitFor, act } from '@testing-library/react';
+import { Provider, useStore } from 'jotai';
+import { AmplitudeProvider, useAmplitude, SpiffyMetricsEventName } from '../amplitudeContext';
 import {
   UserIdentityProvider,
   useUserIdentity,
-} 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 { userIdAtom } from "src/atoms/app";
-import Logger from "src/application/logging/logger";
-import { createInstance } from "@amplitude/analytics-browser";
+} 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 { userIdAtom } from 'src/atoms/app';
+import Logger from 'src/application/logging/logger';
+import { createInstance } from '@amplitude/analytics-browser';
 
 // Mock the Logger to avoid console output in tests
 // vi.spyOn(Logger, "logInfo").mockImplementation(() => {});
@@ -28,7 +24,7 @@ const mockTrack = vi.fn();
 const mockInit = vi.fn();
 const mockAdd = vi.fn();
 
-vi.mock("@amplitude/analytics-browser", () => ({
+vi.mock('@amplitude/analytics-browser', () => ({
   createInstance: vi.fn(() => ({
     track: mockTrack,
     init: mockInit,
@@ -37,18 +33,18 @@ vi.mock("@amplitude/analytics-browser", () => ({
 }));
 
 // Mock EventsDispatcher
-vi.mock("src/events", () => ({
+vi.mock('src/events', () => ({
   EventsDispatcher: {
     dispatch: vi.fn(),
   },
   SpiffyEvent: {
-    AMPLITUDE_EVENT: "AMPLITUDE_EVENT",
+    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", {
+Object.defineProperty(global, 'crypto', {
   value: {
     subtle: {
       digest: mockDigest,
@@ -69,7 +65,7 @@ const MockAmplitudeComponent: React.FC = () => {
         onClick={() =>
           amplitude.trackEvent({
             eventName: SpiffyMetricsEventName.ChatUserMessageInput,
-            eventProps: { message: "test message" },
+            eventProps: { message: 'test message' },
           })
         }
       >
@@ -82,7 +78,7 @@ const MockAmplitudeComponent: React.FC = () => {
 // Component that reads userIdAtom to verify it's set
 const AtomReaderComponent: React.FC = () => {
   const store = useStore();
-  const [userId, setUserId] = React.useState<string>("not-set");
+  const [userId, setUserId] = React.useState<string>('not-set');
 
   React.useEffect(() => {
     const unsubscribe = store.sub(userIdAtom, () => {
@@ -123,9 +119,7 @@ const CombinedContextComponent: React.FC = () => {
 
   return (
     <div data-testid="combined-component">
-      <div data-testid="user-id-from-identity">
-        {userIdentity.getUserIdOrDefault()}
-      </div>
+      <div data-testid="user-id-from-identity">{userIdentity.getUserIdOrDefault()}</div>
       <div data-testid="amplitude-ready">{amplitude.isReady.toString()}</div>
     </div>
   );
@@ -137,19 +131,14 @@ const TestWrapper: React.FC<{
   amplitudeApiKey?: string;
   userIdOverride?: string;
   userIdDefault?: string;
-}> = ({
-  children,
-  amplitudeApiKey = "test-amplitude-key",
-  userIdOverride,
-  userIdDefault,
-}) => {
+}> = ({ children, amplitudeApiKey = 'test-amplitude-key', userIdOverride, userIdDefault }) => {
   // Set up localStorage with user IDs if provided
   React.useEffect(() => {
     if (userIdOverride) {
-      localStorage.setItem("v1-spiffy-user-id-override", userIdOverride);
+      localStorage.setItem('v1-spiffy-user-id-override', userIdOverride);
     }
     if (userIdDefault) {
-      localStorage.setItem("v1-spiffy-user-id-default", userIdDefault);
+      localStorage.setItem('v1-spiffy-user-id-default', userIdDefault);
     }
   }, [userIdOverride, userIdDefault]);
 
@@ -176,10 +165,10 @@ const TestWrapper: React.FC<{
   );
 };
 
-describe("AmplitudeProvider with UserIdentityContext", () => {
+describe('AmplitudeProvider with UserIdentityContext', () => {
   beforeEach(() => {
     vi.clearAllMocks();
-    if (typeof localStorage !== "undefined") {
+    if (typeof localStorage !== 'undefined') {
       localStorage.clear();
     }
     // Reset mocks
@@ -189,101 +178,101 @@ describe("AmplitudeProvider with UserIdentityContext", () => {
     mockDigest.mockResolvedValue(new Uint8Array(32).fill(0));
   });
 
-  describe("Integration with UserIdentityContext - userIdAtom", () => {
-    it("should be ready when UserIdentityContext provides a userId", async () => {
+  describe('Integration with UserIdentityContext - userIdAtom', () => {
+    it('should be ready when UserIdentityContext provides a userId', async () => {
       render(
         <TestWrapper>
           <CombinedContextComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        const isReady = screen.getByTestId("amplitude-ready").textContent;
-        expect(isReady).toBe("true");
+        const isReady = screen.getByTestId('amplitude-ready').textContent;
+        expect(isReady).toBe('true');
       });
     });
 
-    it("should use userId from UserIdentityContext in tracking events", async () => {
-      const testUserId = "test-user-id-123";
+    it('should use userId from UserIdentityContext in tracking events', async () => {
+      const testUserId = 'test-user-id-123';
       render(
         <TestWrapper userIdOverride={testUserId}>
           <MockAmplitudeComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-ready").textContent).toBe("true");
+        expect(screen.getByTestId('is-ready').textContent).toBe('true');
       });
 
       await act(async () => {
-        screen.getByTestId("track-event-button").click();
+        screen.getByTestId('track-event-button').click();
       });
 
       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(callArgs[0]).toBe('[Spiffy] Chat User Message Input');
+        expect(callArgs[1]).toHaveProperty('user.id', testUserId);
       });
     });
 
-    it("should use default userId from UserIdentityContext when override is not set", async () => {
-      const testUserId = "default-user-id-456";
+    it('should use default userId from UserIdentityContext when override is not set', async () => {
+      const testUserId = 'default-user-id-456';
       render(
         <TestWrapper userIdDefault={testUserId}>
           <MockAmplitudeComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-ready").textContent).toBe("true");
+        expect(screen.getByTestId('is-ready').textContent).toBe('true');
       });
 
       await act(async () => {
-        screen.getByTestId("track-event-button").click();
+        screen.getByTestId('track-event-button').click();
       });
 
       await waitFor(() => {
         expect(mockTrack).toHaveBeenCalled();
         const callArgs = mockTrack.mock.calls[0];
-        expect(callArgs[1]).toHaveProperty("user.id", testUserId);
+        expect(callArgs[1]).toHaveProperty('user.id', testUserId);
       });
     });
 
-    it("should prioritize override userId over default userId", async () => {
-      const overrideUserId = "override-user-id-789";
-      const defaultUserId = "default-user-id-012";
+    it('should prioritize override userId over default userId', async () => {
+      const overrideUserId = 'override-user-id-789';
+      const defaultUserId = 'default-user-id-012';
       render(
         <TestWrapper
           userIdOverride={overrideUserId}
           userIdDefault={defaultUserId}
         >
           <MockAmplitudeComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-ready").textContent).toBe("true");
+        expect(screen.getByTestId('is-ready').textContent).toBe('true');
       });
 
       await act(async () => {
-        screen.getByTestId("track-event-button").click();
+        screen.getByTestId('track-event-button').click();
       });
 
       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(callArgs[1]).toHaveProperty('user.id', overrideUserId);
+        expect(callArgs[1]).not.toHaveProperty('user.id', defaultUserId);
       });
     });
 
-    it("should initialize Amplitude with userId from UserIdentityContext", async () => {
-      const testUserId = "init-user-id-345";
+    it('should initialize Amplitude with userId from UserIdentityContext', async () => {
+      const testUserId = 'init-user-id-345';
       render(
         <TestWrapper userIdOverride={testUserId}>
           <MockAmplitudeComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
@@ -294,23 +283,21 @@ describe("AmplitudeProvider with UserIdentityContext", () => {
     });
   });
 
-  describe("userIdAtom synchronization", () => {
-    it("should sync userIdAtom with UserIdentityContext userId", async () => {
-      const testUserId = "sync-user-id-678";
+  describe('userIdAtom synchronization', () => {
+    it('should sync userIdAtom with UserIdentityContext userId', async () => {
+      const testUserId = 'sync-user-id-678';
       render(
         <TestWrapper userIdOverride={testUserId}>
           <>
             <CombinedContextComponent />
             <AtomReaderComponent />
           </>
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        const identityUserId = screen.getByTestId(
-          "user-id-from-identity"
-        ).textContent;
-        const atomUserId = screen.getByTestId("atom-reader").textContent;
+        const identityUserId = screen.getByTestId('user-id-from-identity').textContent;
+        const atomUserId = screen.getByTestId('atom-reader').textContent;
         expect(identityUserId).toBe(testUserId);
         expect(atomUserId).toBe(testUserId);
         expect(identityUserId).toBe(atomUserId);
@@ -318,57 +305,57 @@ 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";
+  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>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-ready").textContent).toBe("true");
+        expect(screen.getByTestId('is-ready').textContent).toBe('true');
       });
 
       await act(async () => {
-        screen.getByTestId("track-event-button").click();
+        screen.getByTestId('track-event-button').click();
       });
 
       await waitFor(() => {
         expect(mockTrack).toHaveBeenCalled();
         const callArgs = mockTrack.mock.calls[0];
-        expect(callArgs[1]).toHaveProperty("user.id", testUserId);
+        expect(callArgs[1]).toHaveProperty('user.id', testUserId);
       });
     });
 
-    it("should include user.id in default tracking props", async () => {
-      const testUserId = "default-props-user-id";
+    it('should include user.id in default tracking props', async () => {
+      const testUserId = 'default-props-user-id';
       render(
         <TestWrapper userIdOverride={testUserId}>
           <MockAmplitudeComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-ready").textContent).toBe("true");
+        expect(screen.getByTestId('is-ready').textContent).toBe('true');
       });
 
       await act(async () => {
-        screen.getByTestId("track-event-button").click();
+        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);
+        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";
+    it('should track multiple events with correct userId', async () => {
+      const testUserId = 'multi-event-user-id';
       const MultiEventComponent: React.FC = () => {
         const amplitude = useAmplitude();
 
@@ -384,7 +371,10 @@ describe("AmplitudeProvider with UserIdentityContext", () => {
         };
 
         return (
-          <button data-testid="track-multiple" onClick={trackMultiple}>
+          <button
+            data-testid="track-multiple"
+            onClick={trackMultiple}
+          >
             Track Multiple
           </button>
         );
@@ -393,65 +383,63 @@ describe("AmplitudeProvider with UserIdentityContext", () => {
       render(
         <TestWrapper userIdOverride={testUserId}>
           <MultiEventComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("track-multiple")).toBeInTheDocument();
+        expect(screen.getByTestId('track-multiple')).toBeInTheDocument();
       });
 
       await act(async () => {
-        screen.getByTestId("track-multiple").click();
+        screen.getByTestId('track-multiple').click();
       });
 
       await waitFor(() => {
         expect(mockTrack).toHaveBeenCalledTimes(2);
         mockTrack.mock.calls.forEach((call: any[]) => {
-          expect(call[1]).toHaveProperty("user.id", testUserId);
+          expect(call[1]).toHaveProperty('user.id', testUserId);
         });
       });
     });
   });
 
-  describe("Context readiness and initialization", () => {
-    it("should wait for UserIdentityContext to be ready before becoming ready", async () => {
+  describe('Context readiness and initialization', () => {
+    it('should wait for UserIdentityContext to be ready before becoming ready', async () => {
       render(
         <TestWrapper>
           <CombinedContextComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       // Both contexts should eventually be ready
       await waitFor(() => {
-        const amplitudeReady = screen.getByTestId("amplitude-ready").textContent;
-        expect(amplitudeReady).toBe("true");
+        const amplitudeReady = screen.getByTestId('amplitude-ready').textContent;
+        expect(amplitudeReady).toBe('true');
       });
     });
 
-    it("should initialize Amplitude client with correct userId from UserIdentityContext", async () => {
-      const testUserId = "init-client-user-id";
+    it('should initialize Amplitude client with correct userId from UserIdentityContext', async () => {
+      const testUserId = 'init-client-user-id';
       render(
         <TestWrapper userIdOverride={testUserId}>
           <MockAmplitudeComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
         expect(mockInit).toHaveBeenCalledWith(
-          "test-amplitude-key",
+          'test-amplitude-key',
           testUserId,
           expect.objectContaining({
-            serverZone: "US",
-          })
+            serverZone: 'US',
+          }),
         );
       });
     });
 
-    it("should not render children when not ready", async () => {
+    it('should not render children when not ready', async () => {
       // Create a provider without required dependencies
-      const IncompleteWrapper: React.FC<{ children: React.ReactNode }> = ({
-        children,
-      }) => {
+      const IncompleteWrapper: React.FC<{ children: React.ReactNode }> = ({ children }) => {
         return (
           <Provider>
             <EnviveConfigProvider
@@ -475,51 +463,48 @@ describe("AmplitudeProvider with UserIdentityContext", () => {
       const { container } = render(
         <IncompleteWrapper>
           <div data-testid="should-not-render">Should not render</div>
-        </IncompleteWrapper>
+        </IncompleteWrapper>,
       );
 
       // AmplitudeProvider returns null when not ready, so children should not render
       await waitFor(() => {
-        expect(
-          screen.queryByTestId("should-not-render")
-        ).not.toBeInTheDocument();
+        expect(screen.queryByTestId('should-not-render')).not.toBeInTheDocument();
       });
     });
   });
 
-  describe("Error handling", () => {
-    it("should handle tracking errors gracefully when userId is available", async () => {
-      const testUserId = "error-user-id";
+  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");
+        throw new Error('Tracking error');
       });
 
-      const logErrorSpy = vi.spyOn(Logger, "logError");
+      const logErrorSpy = vi.spyOn(Logger, 'logError');
 
       render(
         <TestWrapper userIdOverride={testUserId}>
           <MockAmplitudeComponent />
-        </TestWrapper>
+        </TestWrapper>,
       );
 
       await waitFor(() => {
-        expect(screen.getByTestId("is-ready").textContent).toBe("true");
+        expect(screen.getByTestId('is-ready').textContent).toBe('true');
       });
 
       await act(async () => {
-        screen.getByTestId("track-event-button").click();
+        screen.getByTestId('track-event-button').click();
       });
 
       await waitFor(() => {
         expect(logErrorSpy).toHaveBeenCalledWith(
-          "[spiffy-ai] Error tracking event",
+          '[spiffy-ai] Error tracking event',
           expect.any(Error),
           expect.objectContaining({
             eventName: SpiffyMetricsEventName.ChatUserMessageInput,
-          })
+          }),
         );
       });
     });
   });
 });
-