@digitaldefiance/express-suite-react-components 5.0.0 → 5.0.2

package/src/contexts/AuthProvider.spec.tsx

@@ -0,0 +1,1284 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  jest,
+} from '@jest/globals';
+import { ReactNode } from 'react';
+
+// Mock PasswordLoginService
+const mockPasswordLoginService = {
+  getWalletAndMnemonicFromLocalStorageBundle: jest.fn() as jest.Mock,
+  setupPasswordLoginLocalStorageBundle: jest.fn() as jest.Mock,
+};
+
+const mockNavigate = jest.fn();
+
+// Create shared mock instance
+const mockAuthService = {
+  verifyToken: jest.fn() as jest.Mock,
+  directLogin: jest.fn() as jest.Mock,
+  emailChallengeLogin: jest.fn() as jest.Mock,
+  refreshToken: jest.fn() as jest.Mock,
+  register: jest.fn() as jest.Mock,
+  requestEmailLogin: jest.fn() as jest.Mock,
+  backupCodeLogin: jest.fn() as jest.Mock,
+  changePassword: jest.fn() as jest.Mock,
+};
+
+// Mock dependencies - must be before imports
+jest.mock('../services/authService', () => ({
+  mockAuthService,
+  createAuthService: jest.fn(() => mockAuthService),
+}));
+jest.mock('../services/authenticatedApi', () => ({
+  createAuthenticatedApiClient: jest.fn(() => ({
+    post: jest.fn(),
+    get: jest.fn(),
+  })),
+}));
+
+jest.mock('@digitaldefiance/i18n-lib', () => {
+  const actual = jest.requireActual('@digitaldefiance/i18n-lib');
+  const mockI18nEngineInstance = {
+    t: jest.fn((key: string) => key),
+    translate: jest.fn((componentId: string, key: string) => key),
+    setLanguage: jest.fn(),
+  };
+  return {
+    ...actual,
+    DefaultCurrencyCode: 'USD',
+    CurrencyCode: class MockCurrencyCode {
+      constructor(public value: string = 'USD') {}
+    },
+    I18nEngine: {
+      getInstance: () => mockI18nEngineInstance,
+    },
+    ECIESService: jest.fn(),
+    t: jest.fn((key) => key),
+  };
+});
+
+jest.mock('@digitaldefiance/ecies-lib', () => {
+  const actual = jest.requireActual('@digitaldefiance/ecies-lib');
+
+  // Mock ECIESService to avoid ID provider validation issues in tests
+  const mockECIESService = jest.fn().mockImplementation(() => ({
+    generateNewMnemonic: jest.fn(),
+    mnemonicToSimpleKeyPair: jest.fn(),
+    getPublicKey: jest.fn(),
+    encryptSimpleOrSingle: jest.fn(),
+    decryptSimpleOrSingleWithHeader: jest.fn(),
+    signMessage: jest.fn(),
+    verifyMessage: jest.fn(),
+    config: {},
+    constants: actual.Constants,
+    idProvider: actual.Constants.idProvider,
+  }));
+
+  return {
+    ...actual,
+    ECIESService: mockECIESService,
+    PasswordLoginService: Object.assign(
+      jest.fn().mockImplementation(() => mockPasswordLoginService),
+      {
+        privateKeyStorageKey: 'encryptedPrivateKey',
+        saltStorageKey: 'passwordLoginSalt',
+        encryptedMnemonicStorageKey: 'encryptedMnemonic',
+        profileStorageKey: 'pbkdf2Profile',
+      }
+    ),
+  };
+});
+
+jest.mock('./I18nProvider', () => {
+  const React = require('react');
+  const I18nProvider = ({ children }: { children: any }) => {
+    return React.createElement(React.Fragment, null, children);
+  };
+  I18nProvider.displayName = 'MockI18nProvider';
+
+  return {
+    I18nProvider,
+    useI18n: () => ({
+      t: (key: string) => key,
+      tComponent: (componentId: string, key: string) => key,
+      changeLanguage: jest.fn(),
+      currentLanguage: 'en-US',
+    }),
+  };
+});
+
+jest.mock('@ethereumjs/wallet', () => ({
+  Wallet: {
+    generate: jest.fn(() => ({
+      getPrivateKey: jest.fn(() => Buffer.from('test')),
+      getPublicKey: jest.fn(() => Buffer.from('test')),
+      getAddress: jest.fn(() => Buffer.from('test')),
+    })),
+  },
+}));
+
+// Now import after mocks
+import {
+  ECIES as ECIESConstants,
+  SecureString,
+} from '@digitaldefiance/ecies-lib';
+import { Constants } from '@digitaldefiance/suite-core-lib';
+import { Wallet } from '@ethereumjs/wallet';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { localStorageMock } from '../../tests/setup';
+import { AuthProvider, useAuth } from './AuthProvider';
+import { I18nProvider } from './I18nProvider';
+import { AppThemeProvider } from './ThemeProvider';
+
+// Mock localStorage is imported from test-setup
+
+// Mock console methods
+const consoleMock = {
+  error: jest.fn(),
+  log: jest.fn(),
+};
+Object.defineProperty(console, 'error', { value: consoleMock.error });
+
+// Test wrapper component
+const TestWrapper = ({ children }: { children: ReactNode }) => (
+  <I18nProvider i18nEngine={null as any} onLanguageChange={async () => {}}>
+    <AppThemeProvider>
+      <AuthProvider
+        baseUrl="http://localhost:3000"
+        constants={Constants}
+        eciesConfig={ECIESConstants}
+        onLogout={mockNavigate}
+      >
+        {children}
+      </AuthProvider>
+    </AppThemeProvider>
+  </I18nProvider>
+);
+
+// Helper to create mock user
+const createMockUser = (admin = false) => ({
+  id: '1',
+  username: admin ? 'admin' : 'testuser',
+  email: admin ? 'admin@example.com' : 'test@example.com',
+  roles: [
+    {
+      id: 'role1',
+      _id: 'role1',
+      name: admin ? 'admin' : 'user',
+      member: true,
+      child: false,
+      system: false,
+      admin,
+      createdAt: '2023-01-01T00:00:00.000Z',
+      updatedAt: '2023-01-01T00:00:00.000Z',
+      deletedAt: undefined,
+      createdBy: 'system',
+      updatedBy: 'system',
+    },
+  ],
+  siteLanguage: 'en-US',
+  timezone: 'UTC',
+  currency: 'USD',
+  darkMode: false,
+  directChallenge: false,
+  emailVerified: true,
+});
+
+describe('AuthProvider', () => {
+  beforeEach(() => {
+    localStorageMock.getItem.mockReturnValue(null);
+    localStorageMock.setItem.mockClear();
+    localStorageMock.removeItem.mockClear();
+    mockPasswordLoginService.getWalletAndMnemonicFromLocalStorageBundle.mockClear();
+    mockPasswordLoginService.setupPasswordLoginLocalStorageBundle.mockClear();
+    mockAuthService.verifyToken.mockClear();
+    mockAuthService.directLogin.mockClear();
+    mockAuthService.emailChallengeLogin.mockClear();
+    mockAuthService.refreshToken.mockClear();
+    mockAuthService.register.mockClear();
+    mockAuthService.requestEmailLogin.mockClear();
+    mockAuthService.backupCodeLogin.mockClear();
+  });
+
+  afterEach(() => {
+    jest.clearAllTimers();
+  });
+
+  describe('Initial State', () => {
+    it('should initialize with default values', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.isAuthenticated).toBe(false);
+        expect(result.current.user).toBe(null);
+        expect(result.current.userData).toBe(null);
+        expect(result.current.token).toBe(null);
+        expect(result.current.mnemonic).toBeUndefined();
+        expect(result.current.wallet).toBeUndefined();
+        expect(result.current.admin).toBe(false);
+      });
+    });
+
+    it('should initialize expiration seconds from localStorage', async () => {
+      localStorageMock.getItem.mockImplementation((key) => {
+        if (key === 'mnemonicExpirationSeconds') return '300';
+        if (key === 'walletExpirationSeconds') return '600';
+        return null;
+      });
+
+      renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(localStorageMock.getItem).toHaveBeenCalledWith(
+          'mnemonicExpirationSeconds'
+        );
+        expect(localStorageMock.getItem).toHaveBeenCalledWith(
+          'walletExpirationSeconds'
+        );
+      });
+    });
+  });
+
+  describe('checkAuth', () => {
+    it('should clear auth state when no token exists', async () => {
+      localStorageMock.getItem.mockReturnValue(null);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+        expect(result.current.isCheckingAuth).toBe(false);
+        expect(result.current.isAuthenticated).toBe(false);
+      });
+    });
+
+    it('should verify token and set user when token exists', async () => {
+      const mockUser = createMockUser();
+      mockAuthService.verifyToken.mockResolvedValue(mockUser);
+
+      localStorageMock.getItem.mockImplementation((key) =>
+        key === 'authToken' ? 'valid-token' : null
+      );
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(
+        () => {
+          expect(result.current.loading).toBe(false);
+          expect(result.current.isCheckingAuth).toBe(false);
+          expect(result.current.isAuthenticated).toBe(true);
+        },
+        { timeout: 5000 }
+      );
+
+      expect(result.current.userData).toEqual(mockUser);
+      expect(result.current.token).toBe('valid-token');
+    });
+
+    it('should handle token verification failure', async () => {
+      localStorageMock.getItem.mockImplementation((key) => {
+        if (key === 'authToken') return 'invalid-token';
+        return null;
+      });
+      mockAuthService.verifyToken.mockRejectedValue(new Error('Token invalid'));
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.isAuthenticated).toBe(false);
+        expect(result.current.userData).toBe(null);
+        expect(result.current.loading).toBe(false);
+        expect(result.current.isCheckingAuth).toBe(false);
+        expect(localStorageMock.removeItem).toHaveBeenCalledWith('authToken');
+      });
+    });
+
+    it('should set admin flag for admin users', async () => {
+      const mockAdminUser = createMockUser(true);
+      mockAuthService.verifyToken.mockResolvedValue(mockAdminUser);
+
+      localStorageMock.getItem.mockImplementation((key) =>
+        key === 'authToken' ? 'admin-token' : null
+      );
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(
+        () => {
+          expect(result.current.loading).toBe(false);
+          expect(result.current.admin).toBe(true);
+        },
+        { timeout: 5000 }
+      );
+    });
+
+    it('should propagate displayName from verifyToken into user state', async () => {
+      const mockUser = { ...createMockUser(), displayName: 'Verified User' };
+      mockAuthService.verifyToken.mockResolvedValue(mockUser);
+
+      localStorageMock.getItem.mockImplementation((key) =>
+        key === 'authToken' ? 'valid-token' : null
+      );
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(
+        () => {
+          expect(result.current.loading).toBe(false);
+          expect(result.current.isAuthenticated).toBe(true);
+        },
+        { timeout: 5000 }
+      );
+
+      expect(result.current.userData).toEqual(
+        expect.objectContaining({ displayName: 'Verified User' })
+      );
+    });
+  });
+
+  describe('directLogin', () => {
+    it('should perform successful direct login', async () => {
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockWallet = Wallet.generate();
+      const mockUser = createMockUser();
+      const mockLoginResult = {
+        token: 'new-token',
+        user: mockUser,
+        wallet: mockWallet,
+        message: 'Login successful',
+      };
+
+      mockAuthService.directLogin.mockResolvedValue(mockLoginResult);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.directLogin).toBeDefined();
+      });
+
+      let loginResult;
+      await act(async () => {
+        loginResult = await result.current.directLogin(
+          mockMnemonic,
+          'testuser'
+        );
+      });
+
+      expect(mockAuthService.directLogin).toHaveBeenCalled();
+      expect(loginResult).toEqual(mockLoginResult);
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'authToken',
+        'new-token'
+      );
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'user',
+        JSON.stringify(mockUser)
+      );
+    });
+
+    it('should perform successful direct login with custom expiration seconds', async () => {
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockWallet = Wallet.generate();
+      const mockUser = createMockUser();
+      const mockLoginResult = {
+        token: 'new-token',
+        user: mockUser,
+        wallet: mockWallet,
+        message: 'Login successful',
+      };
+
+      mockAuthService.directLogin.mockResolvedValue(mockLoginResult);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      let loginResult;
+      await act(async () => {
+        loginResult = await result.current.directLogin(
+          mockMnemonic,
+          'testuser',
+          undefined,
+          600, // mnemonicExpirationSeconds
+          1200 // walletExpirationSeconds
+        );
+      });
+
+      expect(loginResult).toEqual(mockLoginResult);
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'authToken',
+        'new-token'
+      );
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'user',
+        JSON.stringify(mockUser)
+      );
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'mnemonicExpirationSeconds',
+        '600'
+      );
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'walletExpirationSeconds',
+        '1200'
+      );
+    });
+
+    it('should handle direct login failure', async () => {
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockError = { error: 'Login failed' };
+
+      mockAuthService.directLogin.mockResolvedValue(mockError);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await act(async () => {
+        await result.current.directLogin(mockMnemonic, 'testuser');
+      });
+      expect(result.current.isAuthenticated).toBe(false);
+    });
+
+    it('should propagate displayName from directLogin into user state', async () => {
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockWallet = Wallet.generate();
+      const mockUser = { ...createMockUser(), displayName: 'Direct User' };
+      const mockLoginResult = {
+        token: 'new-token',
+        user: mockUser,
+        wallet: mockWallet,
+        message: 'Login successful',
+      };
+
+      mockAuthService.directLogin.mockResolvedValue(mockLoginResult);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.directLogin).toBeDefined();
+      });
+
+      await act(async () => {
+        await result.current.directLogin(mockMnemonic, 'testuser');
+      });
+
+      expect(result.current.userData).toEqual(
+        expect.objectContaining({ displayName: 'Direct User' })
+      );
+    });
+  });
+
+  describe('emailChallengeLogin', () => {
+    it('should perform successful email challenge login', async () => {
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockWallet = Wallet.generate();
+      const mockUser = createMockUser();
+      const mockLoginResult = {
+        token: 'new-token',
+        user: mockUser,
+        wallet: mockWallet,
+        message: 'Login successful',
+      };
+
+      mockAuthService.emailChallengeLogin.mockResolvedValue(mockLoginResult);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      let loginResult;
+      await act(async () => {
+        loginResult = await result.current.emailChallengeLogin(
+          mockMnemonic,
+          'challenge-token',
+          'testuser'
+        );
+      });
+
+      expect(loginResult).toEqual(mockLoginResult);
+    });
+
+    it('should perform successful email challenge login with custom expiration seconds', async () => {
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockWallet = Wallet.generate();
+      const mockUser = createMockUser();
+      const mockLoginResult = {
+        token: 'new-token',
+        user: mockUser,
+        wallet: mockWallet,
+        message: 'Login successful',
+      };
+
+      mockAuthService.emailChallengeLogin.mockResolvedValue(mockLoginResult);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      let loginResult;
+      await act(async () => {
+        loginResult = await result.current.emailChallengeLogin(
+          mockMnemonic,
+          'challenge-token',
+          'testuser',
+          undefined,
+          300, // mnemonicExpirationSeconds
+          900 // walletExpirationSeconds
+        );
+      });
+
+      expect(loginResult).toEqual(mockLoginResult);
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'mnemonicExpirationSeconds',
+        '300'
+      );
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'walletExpirationSeconds',
+        '900'
+      );
+    });
+  });
+
+  describe('refreshToken', () => {
+    it('should refresh token successfully', async () => {
+      const mockUser = createMockUser();
+      const mockRefreshResult = {
+        token: 'refreshed-token',
+        user: mockUser,
+      };
+
+      mockAuthService.refreshToken.mockResolvedValue(mockRefreshResult);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.refreshToken).toBeDefined();
+      });
+
+      let refreshResult;
+      await act(async () => {
+        refreshResult = await result.current.refreshToken();
+      });
+
+      expect(refreshResult).toEqual(mockRefreshResult);
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'authToken',
+        'refreshed-token'
+      );
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'user',
+        JSON.stringify(mockUser)
+      );
+    });
+
+    it('should handle refresh token failure', async () => {
+      mockAuthService.refreshToken.mockRejectedValue(
+        new Error('Refresh failed')
+      );
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.refreshToken).toBeDefined();
+      });
+
+      await expect(
+        act(async () => {
+          await result.current.refreshToken();
+        })
+      ).rejects.toThrow('Refresh failed');
+
+      expect(localStorageMock.removeItem).toHaveBeenCalledWith('authToken');
+      expect(localStorageMock.removeItem).toHaveBeenCalledWith('user');
+    });
+  });
+
+  describe('register', () => {
+    it('should register user successfully', async () => {
+      const mockRegisterResult = {
+        success: true,
+        message: 'Registration successful',
+        mnemonic: 'test mnemonic',
+      };
+
+      mockAuthService.register.mockResolvedValue(mockRegisterResult);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await act(async () => {
+        await result.current.register(
+          'testuser',
+          'test@example.com',
+          'UTC',
+          'password'
+        );
+      });
+    });
+
+    it('should pass displayName to authService.register', async () => {
+      const mockRegisterResult = {
+        success: true,
+        message: 'Registration successful',
+        mnemonic: 'test mnemonic',
+      };
+
+      mockAuthService.register.mockResolvedValue(mockRegisterResult);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await act(async () => {
+        await result.current.register(
+          'testuser',
+          'test@example.com',
+          'UTC',
+          'password',
+          undefined,
+          'My Display Name'
+        );
+      });
+
+      expect(mockAuthService.register).toHaveBeenCalledWith(
+        'testuser',
+        'test@example.com',
+        'UTC',
+        'password',
+        undefined,
+        'My Display Name',
+        undefined
+      );
+    });
+  });
+
+  describe('requestEmailLogin', () => {
+    it('should request email login successfully', async () => {
+      const mockMessage = 'Email sent successfully';
+      mockAuthService.requestEmailLogin.mockResolvedValue(mockMessage);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await act(async () => {
+        await result.current.requestEmailLogin('testuser');
+      });
+    });
+  });
+
+  describe('backupCodeLogin', () => {
+    it('should perform backup code login successfully', async () => {
+      const mockUser = createMockUser();
+      const mockLoginResult = {
+        token: 'backup-token',
+        user: mockUser,
+        codeCount: 5,
+        mnemonic: 'recovered mnemonic',
+        message: 'Login successful',
+      };
+
+      mockAuthService.backupCodeLogin.mockResolvedValue(mockLoginResult);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      let loginResult;
+      await act(async () => {
+        loginResult = await result.current.backupCodeLogin(
+          'testuser',
+          'backup-code',
+          false,
+          true
+        );
+      });
+
+      expect(loginResult).toEqual({
+        token: 'backup-token',
+        codeCount: 5,
+        mnemonic: 'recovered mnemonic',
+        message: 'Login successful',
+      });
+    });
+  });
+
+  describe('logout', () => {
+    it('should logout user and clear all data', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await act(async () => {
+        await result.current.logout();
+      });
+
+      expect(localStorageMock.removeItem).toHaveBeenCalledWith('user');
+      expect(localStorageMock.removeItem).toHaveBeenCalledWith('authToken');
+      expect(result.current.isAuthenticated).toBe(false);
+      expect(result.current.userData).toBe(null);
+      expect(result.current.mnemonic).toBeUndefined();
+      expect(result.current.wallet).toBeUndefined();
+      expect(mockNavigate).toHaveBeenCalled();
+    });
+  });
+
+  describe('verifyToken', () => {
+    it('should verify token successfully', async () => {
+      const mockUser = createMockUser();
+      mockAuthService.verifyToken.mockResolvedValue(mockUser);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      let verifyResult;
+      await act(async () => {
+        verifyResult = await result.current.verifyToken('test-token');
+      });
+
+      expect(verifyResult).toBe(true);
+      expect(mockAuthService.verifyToken).toHaveBeenCalledWith('test-token');
+    });
+
+    it('should handle token verification failure', async () => {
+      mockAuthService.verifyToken.mockResolvedValue({ error: 'Invalid token' });
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      let verifyResult;
+      await act(async () => {
+        verifyResult = await result.current.verifyToken('invalid-token');
+      });
+
+      expect(verifyResult).toBe(false);
+      expect(mockAuthService.verifyToken).toHaveBeenCalledWith('invalid-token');
+    });
+  });
+
+  describe('changePassword', () => {
+    it('should change password successfully', async () => {
+      // Mock localStorage to have encrypted password (password login available)
+      localStorageMock.getItem.mockImplementation((key) => {
+        if (key === 'encryptedPassword') return 'mock-encrypted-password';
+        return null;
+      });
+
+      // Mock successful password login service operations
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockWallet = Wallet.generate();
+      mockPasswordLoginService.getWalletAndMnemonicFromLocalStorageBundle.mockResolvedValue(
+        {
+          mnemonic: mockMnemonic,
+          wallet: mockWallet,
+        }
+      );
+      mockPasswordLoginService.setupPasswordLoginLocalStorageBundle.mockResolvedValue(
+        mockWallet
+      );
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await act(async () => {
+        await result.current.changePassword('oldpass', 'newpass');
+      });
+    });
+
+    it('should handle password change failure', async () => {
+      // Mock localStorage to not have encrypted password (password login not available)
+      localStorageMock.getItem.mockReturnValue(null);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      let changeResult;
+      await act(async () => {
+        changeResult = await result.current.changePassword(
+          'oldpass',
+          'newpass'
+        );
+      });
+
+      expect(changeResult).toEqual({
+        error: 'error_login_passwordLoginNotSetup',
+        errorType: 'PasswordLoginNotSetup',
+      });
+    });
+  });
+
+  describe('Mnemonic Management', () => {
+    it('should set and clear mnemonic', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+      const mockMnemonic = new SecureString('test mnemonic');
+
+      await waitFor(() => {
+        expect(result.current.setMnemonic).toBeDefined();
+      });
+
+      act(() => {
+        result.current.setMnemonic(mockMnemonic, 10);
+      });
+
+      expect(result.current.mnemonic).toEqual(mockMnemonic);
+
+      act(() => {
+        result.current.clearMnemonic();
+      });
+
+      expect(result.current.mnemonic).toBeUndefined();
+    });
+
+    it('should store mnemonic expiration seconds to localStorage when provided', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+      const mockMnemonic = new SecureString('test mnemonic');
+
+      await waitFor(() => {
+        expect(result.current.setMnemonic).toBeDefined();
+      });
+
+      act(() => {
+        result.current.setMnemonic(mockMnemonic, 300);
+      });
+
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'mnemonicExpirationSeconds',
+        '300'
+      );
+      expect(result.current.mnemonic).toEqual(mockMnemonic);
+    });
+
+    it('should use stored expiration seconds when duration not provided', async () => {
+      localStorageMock.getItem.mockImplementation((key) =>
+        key === 'mnemonicExpirationSeconds' ? '600' : null
+      );
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+      const mockMnemonic = new SecureString('test mnemonic');
+
+      await waitFor(() => {
+        expect(result.current.setMnemonic).toBeDefined();
+      });
+
+      act(() => {
+        result.current.setMnemonic(mockMnemonic);
+      });
+
+      expect(result.current.mnemonic).toEqual(mockMnemonic);
+      // Should not call setItem when no duration provided
+      expect(localStorageMock.setItem).not.toHaveBeenCalledWith(
+        'mnemonicExpirationSeconds',
+        expect.any(String)
+      );
+    });
+  });
+
+  describe('Wallet Management', () => {
+    it('should set and clear wallet', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+      const mockWallet = Wallet.generate();
+
+      await waitFor(() => {
+        expect(result.current.setWallet).toBeDefined();
+      });
+
+      act(() => {
+        result.current.setWallet(mockWallet, 10);
+      });
+
+      expect(result.current.wallet).toEqual(mockWallet);
+
+      act(() => {
+        result.current.clearWallet();
+      });
+
+      expect(result.current.wallet).toBeUndefined();
+    });
+
+    it('should store wallet expiration seconds to localStorage when provided', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+      const mockWallet = Wallet.generate();
+
+      await waitFor(() => {
+        expect(result.current.setWallet).toBeDefined();
+      });
+
+      act(() => {
+        result.current.setWallet(mockWallet, 900);
+      });
+
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'walletExpirationSeconds',
+        '900'
+      );
+      expect(result.current.wallet).toEqual(mockWallet);
+    });
+
+    it('should use stored expiration seconds when duration not provided', async () => {
+      localStorageMock.getItem.mockImplementation((key) =>
+        key === 'walletExpirationSeconds' ? '1200' : null
+      );
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+      const mockWallet = Wallet.generate();
+
+      await waitFor(() => {
+        expect(result.current.setWallet).toBeDefined();
+      });
+
+      act(() => {
+        result.current.setWallet(mockWallet);
+      });
+
+      expect(result.current.wallet).toEqual(mockWallet);
+      // Should not call setItem when no duration provided
+      expect(localStorageMock.setItem).not.toHaveBeenCalledWith(
+        'walletExpirationSeconds',
+        expect.any(String)
+      );
+    });
+  });
+
+  describe('Expiration Settings Management', () => {
+    it('should set mnemonic expiration seconds and update localStorage', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.setMnemonicExpirationSeconds).toBeDefined();
+      });
+
+      act(() => {
+        result.current.setMnemonicExpirationSeconds(1800);
+      });
+
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'mnemonicExpirationSeconds',
+        '1800'
+      );
+    });
+
+    it('should set wallet expiration seconds and update localStorage', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.setWalletExpirationSeconds).toBeDefined();
+      });
+
+      act(() => {
+        result.current.setWalletExpirationSeconds(3600);
+      });
+
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'walletExpirationSeconds',
+        '3600'
+      );
+    });
+
+    it('should use updated expiration seconds after setting them', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockWallet = Wallet.generate();
+
+      await waitFor(() => {
+        expect(result.current.setMnemonicExpirationSeconds).toBeDefined();
+        expect(result.current.setWalletExpirationSeconds).toBeDefined();
+      });
+
+      // Set new expiration times
+      act(() => {
+        result.current.setMnemonicExpirationSeconds(2400);
+        result.current.setWalletExpirationSeconds(4800);
+      });
+
+      // Clear the setItem calls from setting expiration times
+      localStorageMock.setItem.mockClear();
+
+      // Now set mnemonic and wallet without duration - should use the stored values
+      act(() => {
+        result.current.setMnemonic(mockMnemonic);
+      });
+
+      act(() => {
+        result.current.setWallet(mockWallet);
+      });
+
+      expect(result.current.mnemonic).toEqual(mockMnemonic);
+      expect(result.current.wallet).toEqual(mockWallet);
+      // Should not call setItem again since we're using stored defaults
+      expect(localStorageMock.setItem).not.toHaveBeenCalledWith(
+        'mnemonicExpirationSeconds',
+        expect.any(String)
+      );
+      expect(localStorageMock.setItem).not.toHaveBeenCalledWith(
+        'walletExpirationSeconds',
+        expect.any(String)
+      );
+    });
+  });
+
+  describe('Timeout Management', () => {
+    it('should set expiration times and use them for timeouts', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockWallet = Wallet.generate();
+
+      await waitFor(() => {
+        expect(result.current.setMnemonicExpirationSeconds).toBeDefined();
+        expect(result.current.setWalletExpirationSeconds).toBeDefined();
+      });
+
+      // Set custom expiration times
+      act(() => {
+        result.current.setMnemonicExpirationSeconds(120); // 2 minutes
+        result.current.setWalletExpirationSeconds(180); // 3 minutes
+      });
+
+      // Verify localStorage was updated
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'mnemonicExpirationSeconds',
+        '120'
+      );
+      expect(localStorageMock.setItem).toHaveBeenCalledWith(
+        'walletExpirationSeconds',
+        '180'
+      );
+
+      // Set mnemonic and wallet without explicit duration - should use the custom times
+      act(() => {
+        result.current.setMnemonic(mockMnemonic);
+        result.current.setWallet(mockWallet);
+      });
+
+      expect(result.current.mnemonic).toEqual(mockMnemonic);
+      expect(result.current.wallet).toEqual(mockWallet);
+
+      // Verify timeout functions are set up (they should be active but we won't test timing)
+      expect(result.current.mnemonic).toBeDefined();
+      expect(result.current.wallet).toBeDefined();
+    });
+  });
+
+  describe('passwordLogin', () => {
+    it('should perform successful password login', async () => {
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockWallet = Wallet.generate();
+      const mockUser = createMockUser();
+      const mockLoginResult = {
+        token: 'password-token',
+        message: 'Login successful',
+        user: mockUser,
+        wallet: mockWallet,
+      };
+
+      localStorageMock.getItem.mockImplementation((key) => {
+        if (key === 'passwordLoginSalt') return '0'.repeat(64);
+        if (key === 'encryptedPrivateKey') return '0'.repeat(128);
+        if (key === 'encryptedMnemonic') return '0'.repeat(128);
+        if (key === 'pbkdf2Profile') return 'BROWSER_PASSWORD';
+        return null;
+      });
+
+      mockPasswordLoginService.getWalletAndMnemonicFromLocalStorageBundle.mockResolvedValue(
+        {
+          mnemonic: mockMnemonic,
+          wallet: mockWallet,
+        }
+      );
+      mockAuthService.directLogin.mockResolvedValue(mockLoginResult);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      let loginResult;
+      await act(async () => {
+        loginResult = await result.current.passwordLogin(
+          new SecureString('password')
+        );
+      });
+
+      expect(loginResult).toEqual(mockLoginResult);
+      expect(
+        mockPasswordLoginService.getWalletAndMnemonicFromLocalStorageBundle
+      ).toHaveBeenCalled();
+    });
+
+    it('should handle password login when not available', async () => {
+      localStorageMock.getItem.mockReturnValue(null);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      let loginResult;
+      await act(async () => {
+        loginResult = await result.current.passwordLogin(
+          new SecureString('password')
+        );
+      });
+
+      expect(loginResult).toEqual({
+        error: 'error_login_passwordLoginNotSetup',
+        errorType: 'PasswordLoginNotSetup',
+      });
+    });
+  });
+
+  describe('setUpBrowserPasswordLogin', () => {
+    it('should set up password login successfully', async () => {
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockWallet = Wallet.generate();
+
+      mockPasswordLoginService.setupPasswordLoginLocalStorageBundle.mockResolvedValue(
+        mockWallet
+      );
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      let setupResult;
+      await act(async () => {
+        setupResult = await result.current.setUpBrowserPasswordLogin(
+          mockMnemonic,
+          new SecureString('password')
+        );
+      });
+
+      expect(setupResult).toEqual({
+        success: true,
+        message: expect.any(String),
+      });
+      expect(
+        mockPasswordLoginService.setupPasswordLoginLocalStorageBundle
+      ).toHaveBeenCalled();
+    });
+
+    it('should handle password setup failure', async () => {
+      const mockMnemonic = new SecureString('test mnemonic');
+      mockPasswordLoginService.setupPasswordLoginLocalStorageBundle.mockRejectedValue(
+        new Error('Setup failed')
+      );
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      let setupResult;
+      await act(async () => {
+        setupResult = await result.current.setUpBrowserPasswordLogin(
+          mockMnemonic,
+          new SecureString('password')
+        );
+      });
+
+      expect(setupResult).toEqual({
+        success: false,
+        message: 'passwordLogin_setup_failure',
+      });
+    });
+  });
+
+  describe('isBrowserPasswordLoginAvailable', () => {
+    it('should return true when encrypted password exists', async () => {
+      localStorageMock.getItem.mockImplementation((key) =>
+        key === 'encryptedPrivateKey' ? 'mock-encrypted-private-key' : null
+      );
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.isBrowserPasswordLoginAvailable?.()).toBe(true);
+      });
+    });
+
+    it('should return false when no encrypted password exists', async () => {
+      localStorageMock.getItem.mockReturnValue(null);
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.isBrowserPasswordLoginAvailable?.()).toBe(false);
+      });
+    });
+  });
+
+  describe('Timeout Setup', () => {
+    it('should set up timeouts when setting mnemonic and wallet', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+      const mockMnemonic = new SecureString('test mnemonic');
+      const mockWallet = Wallet.generate();
+
+      await waitFor(() => {
+        expect(result.current.setMnemonic).toBeDefined();
+        expect(result.current.setWallet).toBeDefined();
+      });
+
+      act(() => {
+        result.current.setMnemonic(mockMnemonic, 300);
+        result.current.setWallet(mockWallet, 600);
+      });
+
+      expect(result.current.mnemonic).toEqual(mockMnemonic);
+      expect(result.current.wallet).toEqual(mockWallet);
+    });
+  });
+
+  describe('State Exposure', () => {
+    it('should expose mnemonicExpirationSeconds and walletExpirationSeconds', async () => {
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(typeof result.current.mnemonicExpirationSeconds).toBe('number');
+        expect(typeof result.current.walletExpirationSeconds).toBe('number');
+      });
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle invalid localStorage values gracefully', async () => {
+      localStorageMock.getItem.mockImplementation((key) => {
+        if (key === 'mnemonicExpirationSeconds') return 'invalid';
+        if (key === 'walletExpirationSeconds') return 'invalid';
+        return null;
+      });
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(typeof result.current.mnemonicExpirationSeconds).toBe('number');
+        expect(typeof result.current.walletExpirationSeconds).toBe('number');
+      });
+    });
+
+    it('should handle checkAuth with error response from verifyToken', async () => {
+      localStorageMock.getItem.mockImplementation((key) => {
+        if (key === 'authToken') return 'token-with-error';
+        return null;
+      });
+      mockAuthService.verifyToken.mockResolvedValue({ error: 'Token expired' });
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.isAuthenticated).toBe(false);
+        expect(result.current.token).toBe(null);
+      });
+    });
+
+    it('should handle changePassword with invalid current password', async () => {
+      localStorageMock.getItem.mockImplementation((key) => {
+        if (key === 'encryptedPassword') return 'mock-encrypted-password';
+        return null;
+      });
+
+      mockPasswordLoginService.getWalletAndMnemonicFromLocalStorageBundle.mockResolvedValue(
+        {
+          mnemonic: null, // Invalid mnemonic
+          wallet: Wallet.generate(),
+        }
+      );
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await act(async () => {
+        await result.current.changePassword('wrongpass', 'newpass');
+      });
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle console errors gracefully', async () => {
+      localStorageMock.getItem.mockImplementation((key) => {
+        if (key === 'authToken') return 'invalid-token';
+        return null;
+      });
+      mockAuthService.verifyToken.mockRejectedValue(new Error('Network error'));
+
+      const { result } = renderHook(() => useAuth(), { wrapper: TestWrapper });
+
+      await waitFor(() => {
+        expect(result.current.isAuthenticated).toBe(false);
+        expect(consoleMock.error).toHaveBeenCalledWith(
+          'Token verification failed:',
+          expect.any(Error)
+        );
+      });
+    });
+  });
+});