@envive-ai/react-hooks 0.2.10 → 0.3.0

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

@@ -1,33 +1,33 @@
-import React from "react";
-import { render, screen, waitFor, act } from "@testing-library/react";
-import { Provider, useStore } from "jotai";
-import { useAtomValue } from "jotai";
+import React from 'react';
+import { render, screen, waitFor, act } from '@testing-library/react';
+import { Provider, useStore } from 'jotai';
+import { useAtomValue } from 'jotai';
 import {
   UserIdentityProvider,
   useUserIdentity,
   UserIdentityContextType,
-} from "../userIdentityContext";
-import { userIdAtom } from "src/atoms/app";
-import { LocalStorageProvider } from "src/contexts/localStorageContext";
-import Logger from "src/application/logging/logger";
-import CommerceApiClient from "src/application/commerce-api";
-import { v4 as uuid } from "uuid";
+} from '../userIdentityContext';
+import { userIdAtom } from 'src/atoms/app';
+import { LocalStorageProvider } from 'src/contexts/localStorageContext';
+import Logger from 'src/application/logging/logger';
+import CommerceApiClient from 'src/application/commerce-api';
+import { v4 as uuid } from 'uuid';
 
 // 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, 'logInfo').mockImplementation(() => {});
+vi.spyOn(Logger, 'logWarn').mockImplementation(() => {});
+vi.spyOn(Logger, 'logError').mockImplementation(() => {});
 
 // Mock CommerceApiClient
-vi.mock("src/application/commerce-api", () => ({
+vi.mock('src/application/commerce-api', () => ({
   default: {
     identifyUser: vi.fn().mockResolvedValue(undefined),
   },
 }));
 
 // Mock uuid to have predictable values in tests
-vi.mock("uuid", () => ({
-  v4: vi.fn(() => "test-uuid-12345"),
+vi.mock('uuid', () => ({
+  v4: vi.fn(() => 'test-uuid-12345'),
 }));
 
 // Component that uses the useUserIdentity hook
@@ -39,10 +39,10 @@ const MockComponent: React.FC = () => {
       <div data-testid="user-id">{context.getUserIdOrDefault()}</div>
       <div data-testid="is-ready">{context.isReady.toString()}</div>
       <div data-testid="user-id-override">
-        {context.getUserIdOverrideFromLocalStorage() || "none"}
+        {context.getUserIdOverrideFromLocalStorage() || 'none'}
       </div>
       <div data-testid="user-id-default">
-        {context.getUserIdDefaultFromLocalStorage() || "none"}
+        {context.getUserIdDefaultFromLocalStorage() || 'none'}
       </div>
     </div>
   );
@@ -54,7 +54,7 @@ const AtomReaderComponent: React.FC = () => {
   // Use useUserIdentity to ensure the atom is set
   useUserIdentity();
   const store = useStore();
-  const [userId, setUserId] = React.useState<string>("not-set");
+  const [userId, setUserId] = React.useState<string>('not-set');
 
   React.useEffect(() => {
     // Subscribe to atom changes
@@ -103,7 +103,10 @@ const IdentifyUserComponent: React.FC = () => {
 
   return (
     <div>
-      <button data-testid="identify-button" onClick={handleIdentify}>
+      <button
+        data-testid="identify-button"
+        onClick={handleIdentify}
+      >
         Identify
       </button>
       {identifying && <div data-testid="identifying">Identifying...</div>}
@@ -111,11 +114,11 @@ const IdentifyUserComponent: React.FC = () => {
   );
 };
 
-describe("UserIdentityProvider", () => {
+describe('UserIdentityProvider', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     // Clear localStorage before each test
-    if (typeof localStorage !== "undefined") {
+    if (typeof localStorage !== 'undefined') {
       localStorage.clear();
     }
   });
@@ -126,115 +129,111 @@ describe("UserIdentityProvider", () => {
         <LocalStorageProvider>
           <UserIdentityProvider>{children}</UserIdentityProvider>
         </LocalStorageProvider>
-      </Provider>
+      </Provider>,
     );
   };
 
-  describe("Provider Integration with Jotai Store - userIdAtom", () => {
-    it("should set the userIdAtom when provider is mounted and useUserIdentity is called", async () => {
+  describe('Provider Integration with Jotai Store - userIdAtom', () => {
+    it('should set the userIdAtom when provider is mounted and useUserIdentity is called', async () => {
       renderWithProviders(
         <>
           <MockComponent />
           <AtomReaderComponent />
-        </>
+        </>,
       );
 
       // Wait for the atom to be set (useEffect in useUserIdentity runs after render)
       await waitFor(() => {
-        const atomValue = screen.getByTestId("atom-reader").textContent;
-        expect(atomValue).not.toBe("not-set");
-        expect(atomValue).toContain("spiffy-user-id-");
+        const atomValue = screen.getByTestId('atom-reader').textContent;
+        expect(atomValue).not.toBe('not-set');
+        expect(atomValue).toContain('spiffy-user-id-');
       });
 
       // Verify the userId from context matches the atom value
-      const contextUserId = screen.getByTestId("user-id").textContent;
-      const atomUserId = screen.getByTestId("atom-reader").textContent;
+      const contextUserId = screen.getByTestId('user-id').textContent;
+      const atomUserId = screen.getByTestId('atom-reader').textContent;
       expect(contextUserId).toBe(atomUserId);
     });
 
-    it("should set userIdAtom with override value when override exists in localStorage", async () => {
+    it('should set userIdAtom with override value when override exists in localStorage', async () => {
       // Set override before rendering
-      localStorage.setItem("v1-spiffy-user-id-override", "override-user-id-123");
+      localStorage.setItem('v1-spiffy-user-id-override', 'override-user-id-123');
 
       renderWithProviders(
         <>
           <MockComponent />
           <AtomReaderComponent />
-        </>
+        </>,
       );
 
       // Wait for the atom to be set with the override value
       await waitFor(() => {
-        const atomValue = screen.getByTestId("atom-reader").textContent;
-        expect(atomValue).toBe("override-user-id-123");
+        const atomValue = screen.getByTestId('atom-reader').textContent;
+        expect(atomValue).toBe('override-user-id-123');
       });
 
       // Verify the userId from context matches the atom value
-      const contextUserId = screen.getByTestId("user-id").textContent;
-      const atomUserId = screen.getByTestId("atom-reader").textContent;
+      const contextUserId = screen.getByTestId('user-id').textContent;
+      const atomUserId = screen.getByTestId('atom-reader').textContent;
       expect(contextUserId).toBe(atomUserId);
     });
 
-    it("should update userIdAtom when context becomes ready", async () => {
+    it('should update userIdAtom when context becomes ready', async () => {
       // This test verifies that the atom is set even when context starts as not ready
       // We'll test with localStorage available from the start
       renderWithProviders(
         <>
           <MockComponent />
           <AtomReaderComponent />
-        </>
+        </>,
       );
 
       // Wait for context to be ready and atom to be set
       await waitFor(() => {
-        const isReady = screen.getByTestId("is-ready").textContent;
-        expect(isReady).toBe("true");
-        const atomValue = screen.getByTestId("atom-reader").textContent;
-        expect(atomValue).not.toBe("not-set");
+        const isReady = screen.getByTestId('is-ready').textContent;
+        expect(isReady).toBe('true');
+        const atomValue = screen.getByTestId('atom-reader').textContent;
+        expect(atomValue).not.toBe('not-set');
       });
     });
   });
 
-  describe("useUserIdentity Hook Integration", () => {
-    it("should allow components to access context via useUserIdentity hook", async () => {
+  describe('useUserIdentity Hook Integration', () => {
+    it('should allow components to access context via useUserIdentity hook', async () => {
       renderWithProviders(<MockComponent />);
 
       await waitFor(() => {
-        expect(screen.getByTestId("user-id")).toBeInTheDocument();
+        expect(screen.getByTestId('user-id')).toBeInTheDocument();
       });
 
       // Verify all context methods are accessible
-      expect(screen.getByTestId("user-id").textContent).toContain(
-        "spiffy-user-id-"
-      );
-      expect(screen.getByTestId("is-ready").textContent).toBe("true");
+      expect(screen.getByTestId('user-id').textContent).toContain('spiffy-user-id-');
+      expect(screen.getByTestId('is-ready').textContent).toBe('true');
     });
 
-    it("should throw error when used outside of UserIdentityProvider", () => {
+    it('should throw error when used outside of UserIdentityProvider', () => {
       // Suppress console.error for this test
-      const consoleSpy = vi
-        .spyOn(console, "error")
-        .mockImplementation(() => {});
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
 
       expect(() => {
         render(
           <Provider>
             <MockComponent />
-          </Provider>
+          </Provider>,
         );
-      }).toThrow("useUserIdentity must be used within a UserIdentityProvider");
+      }).toThrow('useUserIdentity must be used within a UserIdentityProvider');
 
       consoleSpy.mockRestore();
     });
 
-    it("should set userIdAtom correctly when multiple components use useUserIdentity", async () => {
+    it('should set userIdAtom correctly when multiple components use useUserIdentity', async () => {
       // Component that sets override - the atom will be set by useUserIdentity
       const ComponentWithActions: React.FC = () => {
         const context = useUserIdentity();
 
         React.useEffect(() => {
           // Set override on mount
-          context.setUserIdOverrideInLocalStorage("multi-component-override");
+          context.setUserIdOverrideInLocalStorage('multi-component-override');
         }, [context]);
 
         // Get userId from context instead of atom directly
@@ -251,20 +250,20 @@ describe("UserIdentityProvider", () => {
         <>
           <ComponentWithActions />
           <AtomReaderComponent />
-        </>
+        </>,
       );
 
       // Wait for the atom to be set
       await waitFor(() => {
-        const atomValue = screen.getByTestId("atom-reader").textContent;
-        expect(atomValue).not.toBe("not-set");
+        const atomValue = screen.getByTestId('atom-reader').textContent;
+        expect(atomValue).not.toBe('not-set');
       });
 
       // Both components should see the same atom value
       // Note: The atom is set by useUserIdentity's useEffect, which runs after
       // the override is set in localStorage, so it should reflect the override
       await waitFor(() => {
-        const atomValue = screen.getByTestId("atom-reader").textContent;
+        const atomValue = screen.getByTestId('atom-reader').textContent;
         // The atom should be set to the override value since it was set before
         // the component mounted, or it will be the generated default
         expect(atomValue).toBeTruthy();
@@ -272,84 +271,78 @@ describe("UserIdentityProvider", () => {
     });
   });
 
-  describe("getUserIdOrDefault", () => {
-    it("should return override userId if it exists", async () => {
-      localStorage.setItem("v1-spiffy-user-id-override", "override-123");
+  describe('getUserIdOrDefault', () => {
+    it('should return override userId if it exists', async () => {
+      localStorage.setItem('v1-spiffy-user-id-override', 'override-123');
 
       renderWithProviders(<MockComponent />);
 
       await waitFor(() => {
-        expect(screen.getByTestId("user-id").textContent).toBe("override-123");
+        expect(screen.getByTestId('user-id').textContent).toBe('override-123');
       });
     });
 
-    it("should return default userId if override does not exist", async () => {
-      localStorage.setItem("v1-spiffy-user-id-default", "default-456");
+    it('should return default userId if override does not exist', async () => {
+      localStorage.setItem('v1-spiffy-user-id-default', 'default-456');
 
       renderWithProviders(<MockComponent />);
 
       await waitFor(() => {
-        expect(screen.getByTestId("user-id").textContent).toBe("default-456");
+        expect(screen.getByTestId('user-id').textContent).toBe('default-456');
       });
     });
 
-    it("should generate and store new userId if neither exists", async () => {
+    it('should generate and store new userId if neither exists', async () => {
       renderWithProviders(<MockComponent />);
 
       await waitFor(() => {
-        const userId = screen.getByTestId("user-id").textContent;
-        expect(userId).toContain("spiffy-user-id-");
-        expect(userId).toContain("test-uuid-12345");
+        const userId = screen.getByTestId('user-id').textContent;
+        expect(userId).toContain('spiffy-user-id-');
+        expect(userId).toContain('test-uuid-12345');
       });
 
       // Verify it was stored in localStorage
-      expect(localStorage.getItem("v1-spiffy-user-id-default")).toContain(
-        "spiffy-user-id-"
-      );
+      expect(localStorage.getItem('v1-spiffy-user-id-default')).toContain('spiffy-user-id-');
     });
 
-    it("should prioritize override over default", async () => {
-      localStorage.setItem("v1-spiffy-user-id-override", "override-789");
-      localStorage.setItem("v1-spiffy-user-id-default", "default-012");
+    it('should prioritize override over default', async () => {
+      localStorage.setItem('v1-spiffy-user-id-override', 'override-789');
+      localStorage.setItem('v1-spiffy-user-id-default', 'default-012');
 
       renderWithProviders(<MockComponent />);
 
       await waitFor(() => {
-        expect(screen.getByTestId("user-id").textContent).toBe("override-789");
+        expect(screen.getByTestId('user-id').textContent).toBe('override-789');
       });
     });
   });
 
-  describe("LocalStorage Operations", () => {
-    it("should get userId override from localStorage", async () => {
-      localStorage.setItem("v1-spiffy-user-id-override", "test-override");
+  describe('LocalStorage Operations', () => {
+    it('should get userId override from localStorage', async () => {
+      localStorage.setItem('v1-spiffy-user-id-override', 'test-override');
 
       renderWithProviders(<MockComponent />);
 
       await waitFor(() => {
-        expect(screen.getByTestId("user-id-override").textContent).toBe(
-          "test-override"
-        );
+        expect(screen.getByTestId('user-id-override').textContent).toBe('test-override');
       });
     });
 
-    it("should get userId default from localStorage", async () => {
-      localStorage.setItem("v1-spiffy-user-id-default", "test-default");
+    it('should get userId default from localStorage', async () => {
+      localStorage.setItem('v1-spiffy-user-id-default', 'test-default');
 
       renderWithProviders(<MockComponent />);
 
       await waitFor(() => {
-        expect(screen.getByTestId("user-id-default").textContent).toBe(
-          "test-default"
-        );
+        expect(screen.getByTestId('user-id-default').textContent).toBe('test-default');
       });
     });
 
-    it("should set userId default in localStorage", async () => {
+    it('should set userId default in localStorage', async () => {
       const ComponentWithSet: React.FC = () => {
         const context = useUserIdentity();
         React.useEffect(() => {
-          context.setUserIdDefaultInLocalStorage("new-default-id");
+          context.setUserIdDefaultInLocalStorage('new-default-id');
         }, [context]);
 
         return <div data-testid="set-component">Set</div>;
@@ -358,17 +351,15 @@ describe("UserIdentityProvider", () => {
       renderWithProviders(<ComponentWithSet />);
 
       await waitFor(() => {
-        expect(localStorage.getItem("v1-spiffy-user-id-default")).toBe(
-          "new-default-id"
-        );
+        expect(localStorage.getItem('v1-spiffy-user-id-default')).toBe('new-default-id');
       });
     });
 
-    it("should set userId override in localStorage", async () => {
+    it('should set userId override in localStorage', async () => {
       const ComponentWithSet: React.FC = () => {
         const context = useUserIdentity();
         React.useEffect(() => {
-          context.setUserIdOverrideInLocalStorage("new-override-id");
+          context.setUserIdOverrideInLocalStorage('new-override-id');
         }, [context]);
 
         return <div data-testid="set-component">Set</div>;
@@ -377,14 +368,12 @@ describe("UserIdentityProvider", () => {
       renderWithProviders(<ComponentWithSet />);
 
       await waitFor(() => {
-        expect(localStorage.getItem("v1-spiffy-user-id-override")).toBe(
-          "new-override-id"
-        );
+        expect(localStorage.getItem('v1-spiffy-user-id-override')).toBe('new-override-id');
       });
     });
 
-    it("should clear userId override from localStorage", async () => {
-      localStorage.setItem("v1-spiffy-user-id-override", "existing-override");
+    it('should clear userId override from localStorage', async () => {
+      localStorage.setItem('v1-spiffy-user-id-override', 'existing-override');
 
       const ComponentWithClear: React.FC = () => {
         const context = useUserIdentity();
@@ -398,17 +387,17 @@ describe("UserIdentityProvider", () => {
       renderWithProviders(<ComponentWithClear />);
 
       await waitFor(() => {
-        expect(localStorage.getItem("v1-spiffy-user-id-override")).toBe("");
+        expect(localStorage.getItem('v1-spiffy-user-id-override')).toBe('');
       });
     });
 
-    it("should log info when setting userId default", async () => {
-      const logSpy = vi.spyOn(Logger, "logInfo");
+    it('should log info when setting userId default', async () => {
+      const logSpy = vi.spyOn(Logger, 'logInfo');
 
       const ComponentWithSet: React.FC = () => {
         const context = useUserIdentity();
         React.useEffect(() => {
-          context.setUserIdDefaultInLocalStorage("logged-default-id");
+          context.setUserIdDefaultInLocalStorage('logged-default-id');
         }, [context]);
 
         return <div>Set</div>;
@@ -418,18 +407,18 @@ describe("UserIdentityProvider", () => {
 
       await waitFor(() => {
         expect(logSpy).toHaveBeenCalledWith(
-          "setUserIdDefaultInLocalStorage - Setting user_id=logged-default-id"
+          'setUserIdDefaultInLocalStorage - Setting user_id=logged-default-id',
         );
       });
     });
 
-    it("should log info when setting userId override", async () => {
-      const logSpy = vi.spyOn(Logger, "logInfo");
+    it('should log info when setting userId override', async () => {
+      const logSpy = vi.spyOn(Logger, 'logInfo');
 
       const ComponentWithSet: React.FC = () => {
         const context = useUserIdentity();
         React.useEffect(() => {
-          context.setUserIdOverrideInLocalStorage("logged-override-id");
+          context.setUserIdOverrideInLocalStorage('logged-override-id');
         }, [context]);
 
         return <div>Set</div>;
@@ -439,13 +428,13 @@ describe("UserIdentityProvider", () => {
 
       await waitFor(() => {
         expect(logSpy).toHaveBeenCalledWith(
-          "setUserIdOverrideInLocalStorage - Setting user_id=logged-override-id"
+          'setUserIdOverrideInLocalStorage - Setting user_id=logged-override-id',
         );
       });
     });
 
-    it("should log info when clearing userId override", async () => {
-      const logSpy = vi.spyOn(Logger, "logInfo");
+    it('should log info when clearing userId override', async () => {
+      const logSpy = vi.spyOn(Logger, 'logInfo');
 
       const ComponentWithClear: React.FC = () => {
         const context = useUserIdentity();
@@ -459,43 +448,40 @@ describe("UserIdentityProvider", () => {
       renderWithProviders(<ComponentWithClear />);
 
       await waitFor(() => {
-        expect(logSpy).toHaveBeenCalledWith(
-          "clearUserIdOverrideInLocalStorage - Clearing user_id"
-        );
+        expect(logSpy).toHaveBeenCalledWith('clearUserIdOverrideInLocalStorage - Clearing user_id');
       });
     });
   });
 
-  describe("identifyUser", () => {
-    it("should call CommerceApiClient.identifyUser with correct parameters", async () => {
-      const identifySpy = vi.spyOn(CommerceApiClient, "identifyUser");
+  describe('identifyUser', () => {
+    it('should call CommerceApiClient.identifyUser with correct parameters', async () => {
+      const identifySpy = vi.spyOn(CommerceApiClient, 'identifyUser');
 
       renderWithProviders(<IdentifyUserComponent />);
 
       await waitFor(() => {
-        expect(screen.getByTestId("identify-button")).toBeInTheDocument();
+        expect(screen.getByTestId('identify-button')).toBeInTheDocument();
       });
 
       await act(async () => {
-        screen.getByTestId("identify-button").click();
+        screen.getByTestId('identify-button').click();
       });
 
       await waitFor(
         () => {
           expect(identifySpy).toHaveBeenCalled();
           const callArgs = identifySpy.mock.calls[0];
-          expect(callArgs[0]).toContain("spiffy-user-id-"); // spiffyUserId
-          expect(callArgs[1]).toBe("UNKNOWN_CDP_USER_ID"); // merchantUserId (cdpUserId)
+          expect(callArgs[0]).toContain('spiffy-user-id-'); // spiffyUserId
+          expect(callArgs[1]).toBe('UNKNOWN_CDP_USER_ID'); // merchantUserId (cdpUserId)
           // userAgentDetails - in test environment, some values may be undefined
           expect(callArgs[2]).toBeDefined();
-          expect(typeof callArgs[2]).toBe("object");
+          expect(typeof callArgs[2]).toBe('object');
           // Verify it has the expected structure (values may be undefined in test env)
-          expect(callArgs[2]).toHaveProperty("os");
-          expect(callArgs[2]).toHaveProperty("browser");
+          expect(callArgs[2]).toHaveProperty('os');
+          expect(callArgs[2]).toHaveProperty('browser');
         },
-        { timeout: 3000 }
+        { timeout: 3000 },
       );
     });
   });
 });
-

package/src/contexts/userIdentityContext/index.ts

@@ -1 +1 @@
-export * from "./userIdentityContext";
+export * from './userIdentityContext';