fix: lint and tests fix

Author: jesusbalderramawgu

src/common-components/tests/FormField.test.jsx

@@ -12,7 +12,7 @@ import FormGroup from '../FormGroup';
 import PasswordField from '../PasswordField';
 
 // Mock the useFieldValidations hook
-jest.mock('../../register/data/api.hook', () => ({
+jest.mock('../../register/data/apiHook', () => ({
   useFieldValidations: jest.fn(),
 }));
 

src/login/data/apiHook.test.ts

@@ -95,12 +95,18 @@ describe('useLogin', () => {
       password: 'password123',
     };
     const mockErrorResponse = {
-      email_or_username: ['This field is required'],
-      password: ['Password is too weak'],
+      errorCode: INVALID_FORM,
+      context: {
+        email_or_username: ['This field is required'],
+        password: ['Password is too weak'],
+      },
     };
     const mockCamelCasedResponse = {
-      emailOrUsername: ['This field is required'],
-      password: ['Password is too weak'],
+      errorCode: INVALID_FORM,
+      context: {
+        emailOrUsername: ['This field is required'],
+        password: ['Password is too weak'],
+      },
     };
 
     const mockError = {
@@ -110,10 +116,16 @@ describe('useLogin', () => {
       },
     };
 
+    // Mock onError callback to test formatted error
+    const mockOnError = jest.fn();
+
     mockLogin.mockRejectedValueOnce(mockError);
-    mockCamelCaseObject.mockReturnValueOnce(mockCamelCasedResponse);
+    mockCamelCaseObject.mockReturnValueOnce({
+      status: 400,
+      data: mockCamelCasedResponse,
+    });
 
-    const { result } = renderHook(() => useLogin(), {
+    const { result } = renderHook(() => useLogin({ onError: mockOnError }), {
       wrapper: createWrapper(),
     });
 
@@ -124,11 +136,18 @@ describe('useLogin', () => {
     });
 
     expect(mockLogin).toHaveBeenCalledWith(mockLoginData);
-    expect(mockCamelCaseObject).toHaveBeenCalledWith(mockErrorResponse);
+    expect(mockCamelCaseObject).toHaveBeenCalledWith({
+      status: 400,
+      data: mockErrorResponse,
+    });
     expect(mockLogInfo).toHaveBeenCalledWith('Login failed with validation error', mockError);
-    expect(result.current.error).toEqual({
-      errorCode: INVALID_FORM,
-      context: mockCamelCasedResponse,
+    expect(mockOnError).toHaveBeenCalledWith({
+      type: INVALID_FORM,
+      context: {
+        emailOrUsername: ['This field is required'],
+        password: ['Password is too weak'], 
+      },
+      count: 0,
     });
   });
 
@@ -141,9 +160,12 @@ describe('useLogin', () => {
     const timeoutError = new Error('Request timeout');
     timeoutError.name = 'TimeoutError';
 
+    // Mock onError callback to test formatted error
+    const mockOnError = jest.fn();
+
     mockLogin.mockRejectedValueOnce(timeoutError);
 
-    const { result } = renderHook(() => useLogin(), {
+    const { result } = renderHook(() => useLogin({ onError: mockOnError }), {
       wrapper: createWrapper(),
     });
 
@@ -153,10 +175,11 @@ describe('useLogin', () => {
       expect(result.current.isError).toBe(true);
     });
 
-    expect(mockLogError).toHaveBeenCalledWith('Login failed with network error', timeoutError);
-    expect(result.current.error).toEqual({
-      errorCode: INTERNAL_SERVER_ERROR,
+    expect(mockLogError).toHaveBeenCalledWith('Login failed', timeoutError);
+    expect(mockOnError).toHaveBeenCalledWith({
+      type: INTERNAL_SERVER_ERROR,
       context: {},
+      count: 0,
     });
   });
 

src/login/tests/LoginPage.test.jsx

@@ -79,17 +79,43 @@ describe('LoginPage', () => {
 
     // Mock the login hook
     mockLoginMutate = jest.fn();
-    useLogin.mockReturnValue({
+    mockLoginMutate.mockRejected = false; // Reset flag
+    const loginMutation = {
       mutate: mockLoginMutate,
       isPending: false,
-    });
+    };
+    useLogin.mockImplementation((options) => ({
+      ...loginMutation,
+      mutate: jest.fn().mockImplementation((data) => {
+        // Call the mocked function for testing assertions
+        mockLoginMutate(data);
+        // Simulate can call success or error based on test needs
+        if (options?.onSuccess && !mockLoginMutate.mockRejected) {
+          options.onSuccess({ redirectUrl: 'https://test.com/dashboard' });
+        }
+      }),
+    }));
 
     // Mock the third party auth hook
     mockThirdPartyAuthMutate = jest.fn();
-    useThirdPartyAuthHook.mockReturnValue({
+    const thirdPartyAuthMutation = {
       mutate: mockThirdPartyAuthMutate,
       isPending: false,
-    });
+    };
+    useThirdPartyAuthHook.mockImplementation((options) => ({
+      ...thirdPartyAuthMutation,
+      mutate: jest.fn().mockImplementation((data) => {
+        mockThirdPartyAuthMutate(data);
+        if (options?.onSuccess) {
+          // Simulate successful third party auth response
+          options.onSuccess({
+            thirdPartyAuthContext: {},
+            fieldDescriptions: {},
+            optionalFields: { fields: {}, extended_profile: [] },
+          });
+        }
+      }),
+    }));
 
     // Mock the third party auth context
     mockThirdPartyAuthContext = {
@@ -128,7 +154,7 @@ describe('LoginPage', () => {
 
     fireEvent.click(screen.getByRole('button', { name: /sign in/i }));
 
-    expect(mockLoginMutate).toHaveBeenCalledWith({ email_or_username: 'test', password: 'test-password' }, expect.any(Object));
+    expect(mockLoginMutate).toHaveBeenCalledWith({ email_or_username: 'test', password: 'test-password' });
   });
 
   it('should not call login mutation on empty form submission', () => {
@@ -373,10 +399,17 @@ describe('LoginPage', () => {
   // Login error handling is now managed by React Query hooks and context
   // We'll test that error messages appear when login fails
   it('should show error message when login fails', async () => {
-    // Mock the login hook to return an error
-    mockLoginMutate.mockImplementation((payload, { onError }) => {
-      onError({ errorCode: INTERNAL_SERVER_ERROR, context: {} });
-    });
+    // Mock the login hook to simulate error
+    mockLoginMutate.mockRejected = true;
+    useLogin.mockImplementation((options) => ({
+      mutate: jest.fn().mockImplementation((data) => {
+        mockLoginMutate(data);
+        if (options?.onError) {
+          options.onError({ type: INTERNAL_SERVER_ERROR, context: {}, count: 0 });
+        }
+      }),
+      isPending: false,
+    }));
 
     useLogin.mockReturnValue({
       mutate: mockLoginMutate,
@@ -449,9 +482,15 @@ describe('LoginPage', () => {
   // Login success and redirection is now handled by React Query hooks
   it('should handle successful login', () => {
     // Mock successful login
-    mockLoginMutate.mockImplementation((payload, { onSuccess }) => {
-      onSuccess({ success: true, redirectUrl: 'https://test.com/testing-dashboard/' });
-    });
+    useLogin.mockImplementation((options) => ({
+      mutate: jest.fn().mockImplementation((data) => {
+        mockLoginMutate(data);
+        if (options?.onSuccess) {
+          options.onSuccess({ success: true, redirectUrl: 'https://test.com/testing-dashboard/' });
+        }
+      }),
+      isPending: false,
+    }));
 
     useLogin.mockReturnValue({
       mutate: mockLoginMutate,

src/progressive-profiling/data/apiHook.test.ts

@@ -36,13 +36,11 @@ const createWrapper = () => {
 };
 
 describe('useSaveUserProfile', () => {
-  const mockSetLoading = jest.fn();
   const mockSetShowError = jest.fn();
   const mockSetSuccess = jest.fn();
   const mockSetSubmitState = jest.fn();
 
   const mockContextValue = {
-    setLoading: mockSetLoading,
     setShowError: mockSetShowError,
     setSuccess: mockSetSuccess,
     setSubmitState: mockSetSubmitState,
@@ -88,17 +86,12 @@ describe('useSaveUserProfile', () => {
       expect(result.current.isSuccess).toBe(true);
     });
 
-    // Check loading state was set during mutation
-    expect(mockSetLoading).toHaveBeenCalledWith(true);
-
     // Check API was called correctly
     expect(mockPatchAccount).toHaveBeenCalledWith(mockPayload.username, mockPayload.data);
 
     // Check success state is set
-    expect(mockSetLoading).toHaveBeenCalledWith(false);
     expect(mockSetSuccess).toHaveBeenCalledWith(true);
     expect(mockSetSubmitState).toHaveBeenCalledWith(COMPLETE_STATE);
-    expect(result.current.data).toEqual(mockResponse);
   });
 
   it('should handle API error and set error state', async () => {
@@ -120,14 +113,10 @@ describe('useSaveUserProfile', () => {
       expect(result.current.isError).toBe(true);
     });
 
-    // Check loading state was set during mutation
-    expect(mockSetLoading).toHaveBeenCalledWith(true);
-
     // Check API was called
     expect(mockPatchAccount).toHaveBeenCalledWith(mockPayload.username, mockPayload.data);
 
     // Check error state is set
-    expect(mockSetLoading).toHaveBeenCalledWith(false);
     expect(mockSetSubmitState).toHaveBeenCalledWith(DEFAULT_STATE);
     expect(result.current.error).toEqual(mockError);
   });
@@ -152,7 +141,6 @@ describe('useSaveUserProfile', () => {
     });
 
     // Check error state is set
-    expect(mockSetLoading).toHaveBeenCalledWith(false);
     expect(mockSetSubmitState).toHaveBeenCalledWith(DEFAULT_STATE);
   });
 
@@ -183,7 +171,6 @@ describe('useSaveUserProfile', () => {
 
     expect(mockPatchAccount).toHaveBeenCalledWith(mockPayload.username, mockPayload.data);
     expect(mockSetSuccess).toHaveBeenCalledWith(true);
-    expect(result.current.data).toEqual(mockResponse);
   });
 
   it('should handle network errors gracefully', async () => {
@@ -206,7 +193,6 @@ describe('useSaveUserProfile', () => {
       expect(result.current.isError).toBe(true);
     });
 
-    expect(mockSetLoading).toHaveBeenCalledWith(false);
     expect(mockSetSubmitState).toHaveBeenCalledWith(DEFAULT_STATE);
   });
 
@@ -229,7 +215,7 @@ describe('useSaveUserProfile', () => {
       expect(result.current.isSuccess).toBe(true);
     });
 
-    expect(mockSetLoading).toHaveBeenCalledWith(true);
+    expect(mockSetSuccess).toHaveBeenCalledWith(true);
 
     jest.clearAllMocks();
     mockPatchAccount.mockResolvedValueOnce({ success: true });
@@ -241,9 +227,6 @@ describe('useSaveUserProfile', () => {
       expect(result.current.isSuccess).toBe(true);
     });
 
-    expect(mockSetLoading).toHaveBeenCalledWith(true);
-
-    expect(mockSetLoading).toHaveBeenCalledWith(false);
     expect(mockSetSuccess).toHaveBeenCalledWith(true);
   });
 });