@jmruthers/pace-core 0.5.67 → 0.5.69

package/src/hooks/__tests__/ServiceHooks.test.tsx

@@ -0,0 +1,613 @@
+/**
+ * @file Service Hooks Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/__tests__
+ * @since 0.1.0
+ *
+ * Unit tests for service hooks.
+ * Tests React hooks that provide access to services.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import * as React from 'react';
+import { useAuthService } from '../services/useAuthService';
+import { useRBACService } from '../services/useRBACService';
+import { useOrganisationService } from '../services/useOrganisationService';
+import { useEventService } from '../services/useEventService';
+import { useInactivityService } from '../services/useInactivityService';
+import { useAuth } from '../services/useAuth';
+import { usePermissions } from '../services/usePermissions';
+import { useCurrentOrganisation } from '../services/useCurrentOrganisation';
+import { useCurrentEvent } from '../services/useCurrentEvent';
+
+// Create a mock for useContext that can be controlled
+const mockUseContext = vi.fn();
+
+// Mock React module
+vi.mock('react', async () => {
+  const actual = await vi.importActual('react');
+  return {
+    ...actual,
+    useContext: (...args: any[]) => mockUseContext(...args),
+  };
+});
+
+// Mock the provider contexts
+vi.mock('../../providers/services/AuthServiceProvider', () => ({
+  AuthServiceContext: { _currentValue: null },
+}));
+
+vi.mock('../../providers/services/RBACServiceProvider', () => ({
+  RBACServiceContext: { _currentValue: null },
+}));
+
+vi.mock('../../providers/services/OrganisationServiceProvider', () => ({
+  OrganisationServiceContext: { _currentValue: null },
+}));
+
+vi.mock('../../providers/services/EventServiceProvider', () => ({
+  EventServiceContext: { _currentValue: null },
+}));
+
+vi.mock('../../providers/services/InactivityServiceProvider', () => ({
+  InactivityServiceContext: { _currentValue: null },
+}));
+
+// Mock Supabase client
+const createMockSupabaseClient = () => ({
+  auth: {
+    getSession: vi.fn(),
+    getUser: vi.fn(),
+    onAuthStateChange: vi.fn(() => ({ data: { subscription: { unsubscribe: vi.fn() } } })),
+    signInWithPassword: vi.fn(),
+    signUp: vi.fn(),
+    signOut: vi.fn(),
+    resetPasswordForEmail: vi.fn(),
+    updateUser: vi.fn(),
+    refreshSession: vi.fn()
+  },
+  rpc: vi.fn(),
+  from: vi.fn()
+});
+
+// Mock user and session
+const mockUser = {
+  id: 'user-1',
+  email: 'test@example.com'
+};
+
+const mockSession = {
+  access_token: 'token',
+  user: mockUser
+};
+
+const mockOrganisation = {
+  id: 'org-1',
+  display_name: 'Test Organisation'
+};
+
+// Mock service classes
+const createMockService = (name: string) => ({
+  subscribe: vi.fn(() => vi.fn()), // Return unsubscribe function
+  cleanup: vi.fn(),
+  // Add service-specific methods as needed
+  [name]: vi.fn()
+});
+
+describe('Service Hooks', () => {
+  let mockSupabase: ReturnType<typeof createMockSupabaseClient>;
+
+  beforeEach(() => {
+    mockSupabase = createMockSupabaseClient();
+    // Reset the mock before each test
+    mockUseContext.mockReset();
+  });
+
+  describe('useAuthService', () => {
+    it('should return AuthService from context', () => {
+      const mockService = createMockService('auth');
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      // Mock the context with proper structure
+      mockUseContext.mockReturnValue({ authService: mockService });
+
+      const { result } = renderHook(() => useAuthService(), { wrapper });
+
+      expect(result.current).toBe(mockService);
+    });
+
+    it('should throw error when used outside provider', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      // Mock the context to return null
+      mockUseContext.mockReturnValue(null);
+
+      expect(() => {
+        renderHook(() => useAuthService(), { wrapper });
+      }).toThrow('useAuthService must be used within AuthServiceProvider');
+    });
+
+    it('should subscribe to service changes', () => {
+      const mockService = createMockService('auth');
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ authService: mockService });
+
+      renderHook(() => useAuthService(), { wrapper });
+
+      expect(mockService.subscribe).toHaveBeenCalled();
+    });
+  });
+
+  describe('useRBACService', () => {
+    it('should return RBACService from context', () => {
+      const mockService = createMockService('rbac');
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ rbacService: mockService });
+
+      const { result } = renderHook(() => useRBACService(), { wrapper });
+
+      expect(result.current).toBe(mockService);
+    });
+
+    it('should throw error when used outside provider', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue(null);
+
+      expect(() => {
+        renderHook(() => useRBACService(), { wrapper });
+      }).toThrow('useRBACService must be used within RBACServiceProvider');
+    });
+  });
+
+  describe('useOrganisationService', () => {
+    it('should return OrganisationService from context', () => {
+      const mockService = createMockService('organisation');
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ organisationService: mockService });
+
+      const { result } = renderHook(() => useOrganisationService(), { wrapper });
+
+      expect(result.current).toBe(mockService);
+    });
+
+    it('should throw error when used outside provider', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue(null);
+
+      expect(() => {
+        renderHook(() => useOrganisationService(), { wrapper });
+      }).toThrow('useOrganisationService must be used within OrganisationServiceProvider');
+    });
+  });
+
+  describe('useEventService', () => {
+    it('should return EventService from context', () => {
+      const mockService = createMockService('event');
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ eventService: mockService });
+
+      const { result } = renderHook(() => useEventService(), { wrapper });
+
+      expect(result.current).toBe(mockService);
+    });
+
+    it('should throw error when used outside provider', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue(null);
+
+      expect(() => {
+        renderHook(() => useEventService(), { wrapper });
+      }).toThrow('useEventService must be used within EventServiceProvider');
+    });
+  });
+
+  describe('useInactivityService', () => {
+    it('should return InactivityService from context', () => {
+      const mockService = createMockService('inactivity');
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      vi.spyOn(React, 'useContext').mockReturnValue({ inactivityService: mockService });
+
+      const { result } = renderHook(() => useInactivityService(), { wrapper });
+
+      expect(result.current).toBe(mockService);
+    });
+
+    it('should throw error when used outside provider', () => {
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue(null);
+
+      expect(() => {
+        renderHook(() => useInactivityService(), { wrapper });
+      }).toThrow('useInactivityService must be used within InactivityServiceProvider');
+    });
+  });
+
+  describe('useAuth', () => {
+    it('should return auth service properties and methods', () => {
+      const mockService = {
+        getUser: vi.fn(() => mockUser),
+        getSession: vi.fn(() => mockSession),
+        isAuthenticated: vi.fn(() => true),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        getSupabaseClient: vi.fn(() => mockSupabase),
+        signIn: vi.fn(),
+        signUp: vi.fn(),
+        signOut: vi.fn(),
+        resetPassword: vi.fn(),
+        updatePassword: vi.fn(),
+        refreshSession: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ authService: mockService });
+
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      expect(result.current.user).toBe(mockUser);
+      expect(result.current.session).toBe(mockSession);
+      expect(result.current.isAuthenticated).toBe(true);
+      expect(result.current.authLoading).toBe(false);
+      expect(result.current.authError).toBeNull();
+      expect(typeof result.current.signIn).toBe('function');
+      expect(typeof result.current.signUp).toBe('function');
+      expect(typeof result.current.signOut).toBe('function');
+      expect(typeof result.current.resetPassword).toBe('function');
+      expect(typeof result.current.updatePassword).toBe('function');
+      expect(typeof result.current.refreshSession).toBe('function');
+    });
+  });
+
+  describe('usePermissions', () => {
+    it('should return RBAC service properties and methods', () => {
+      const mockService = {
+        getPermissions: vi.fn(() => ({ 'events:read': true })),
+        getRoles: vi.fn(() => ['admin']),
+        getAccessLevel: vi.fn(() => 'ADMIN'),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        getSelectedEventId: vi.fn(() => 'event-1'),
+        getAppConfig: vi.fn(() => ({ name: 'test' })),
+        getUserEventAccess: vi.fn(() => []),
+        isEventAccessLoading: vi.fn(() => false),
+        getSelectedOrganisationId: vi.fn(() => 'org-1'),
+        hasPermission: vi.fn(),
+        hasAnyPermission: vi.fn(),
+        hasAllPermissions: vi.fn(),
+        hasRole: vi.fn(),
+        hasAccessLevel: vi.fn(),
+        canAccess: vi.fn(),
+        validatePermission: vi.fn(),
+        validateAccess: vi.fn(),
+        refreshPermissions: vi.fn(),
+        setSelectedEventId: vi.fn(),
+        loadUserEventAccess: vi.fn(),
+        requireOrganisationContext: vi.fn(() => 'org-1'),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ rbacService: mockService });
+
+      const { result } = renderHook(() => usePermissions(), { wrapper });
+
+      expect(result.current.permissions).toEqual({ 'events:read': true });
+      expect(result.current.roles).toEqual(['admin']);
+      expect(result.current.accessLevel).toBe('ADMIN');
+      expect(result.current.rbacLoading).toBe(false);
+      expect(result.current.rbacError).toBeNull();
+      expect(result.current.selectedEventId).toBe('event-1');
+      expect(result.current.userEventAccess).toEqual([]);
+      expect(result.current.eventAccessLoading).toBe(false);
+      expect(result.current.selectedOrganisationId).toBe('org-1');
+      expect(result.current.appConfig).toEqual({ name: 'test' });
+      expect(typeof result.current.hasPermission).toBe('function');
+      expect(typeof result.current.hasAnyPermission).toBe('function');
+      expect(typeof result.current.hasAllPermissions).toBe('function');
+      expect(typeof result.current.hasRole).toBe('function');
+      expect(typeof result.current.hasAccessLevel).toBe('function');
+      expect(typeof result.current.canAccess).toBe('function');
+      expect(typeof result.current.validatePermission).toBe('function');
+      expect(typeof result.current.validateAccess).toBe('function');
+      expect(typeof result.current.refreshPermissions).toBe('function');
+      expect(typeof result.current.setSelectedEventId).toBe('function');
+      expect(typeof result.current.loadUserEventAccess).toBe('function');
+      expect(typeof result.current.getUserEventAccess).toBe('function');
+      expect(typeof result.current.requireOrganisationContext).toBe('function');
+    });
+  });
+
+  describe('useCurrentOrganisation', () => {
+    it('should return organisation service properties and methods', () => {
+      const mockService = {
+        getSelectedOrganisation: vi.fn(() => mockOrganisation),
+        getOrganisations: vi.fn(() => [mockOrganisation]),
+        getUserMemberships: vi.fn(() => []),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        hasValidOrganisationContext: vi.fn(() => true),
+        isContextReady: vi.fn(() => true),
+        switchOrganisation: vi.fn(),
+        getUserRole: vi.fn(),
+        validateOrganisationAccess: vi.fn(),
+        refreshOrganisations: vi.fn(),
+        ensureOrganisationContext: vi.fn(() => mockOrganisation),
+        isOrganisationSecure: vi.fn(() => true),
+        getPrimaryOrganisation: vi.fn(() => mockOrganisation),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ organisationService: mockService });
+
+      const { result } = renderHook(() => useCurrentOrganisation(), { wrapper });
+
+      expect(result.current.selectedOrganisation).toBe(mockOrganisation);
+      expect(result.current.organisations).toEqual([mockOrganisation]);
+      expect(result.current.userMemberships).toEqual([]);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+      expect(result.current.hasValidOrganisationContext).toBe(true);
+      expect(typeof result.current.switchOrganisation).toBe('function');
+      expect(typeof result.current.getUserRole).toBe('function');
+      expect(typeof result.current.validateOrganisationAccess).toBe('function');
+      expect(typeof result.current.refreshOrganisations).toBe('function');
+      expect(typeof result.current.ensureOrganisationContext).toBe('function');
+      expect(typeof result.current.isOrganisationSecure).toBe('function');
+      expect(typeof result.current.getPrimaryOrganisation).toBe('function');
+    });
+  });
+
+  describe('useCurrentEvent', () => {
+    it('should return event service properties and methods', () => {
+      const mockEvent = {
+        id: 'event-1',
+        event_id: 'event-1',
+        event_name: 'Test Event',
+        event_date: '2024-01-01T00:00:00Z',
+        event_venue: 'Test Venue',
+        event_participants: 100,
+        event_colours: '#FF0000',
+        event_logo: '',
+        organisation_id: 'org-1',
+        is_visible: true,
+        name: 'Test Event',
+        start_date: '2024-01-01T00:00:00Z'
+      };
+
+      const mockService = {
+        getEvents: vi.fn(() => [mockEvent]),
+        getSelectedEvent: vi.fn(() => mockEvent),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        setSelectedEvent: vi.fn(),
+        refreshEvents: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ eventService: mockService });
+
+      const { result } = renderHook(() => useCurrentEvent(), { wrapper });
+
+      expect(result.current.events).toEqual([mockEvent]);
+      expect(result.current.selectedEvent).toBe(mockEvent);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+      expect(typeof result.current.setSelectedEvent).toBe('function');
+      expect(typeof result.current.refreshEvents).toBe('function');
+    });
+  });
+
+  describe('Hook Integration', () => {
+    it('should work with multiple hooks simultaneously', () => {
+      const mockAuthService = {
+        getUser: vi.fn(() => mockUser),
+        getSession: vi.fn(() => mockSession),
+        isAuthenticated: vi.fn(() => true),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        getSupabaseClient: vi.fn(() => mockSupabase),
+        signIn: vi.fn(),
+        signUp: vi.fn(),
+        signOut: vi.fn(),
+        resetPassword: vi.fn(),
+        updatePassword: vi.fn(),
+        refreshSession: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+      
+      const mockRBACService = {
+        getPermissions: vi.fn(() => ({})),
+        getRoles: vi.fn(() => []),
+        getAccessLevel: vi.fn(() => 'VIEWER'),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        getSelectedEventId: vi.fn(() => null),
+        getAppConfig: vi.fn(() => null),
+        getUserEventAccess: vi.fn(() => []),
+        isEventAccessLoading: vi.fn(() => false),
+        getSelectedOrganisationId: vi.fn(() => null),
+        hasPermission: vi.fn(),
+        hasAnyPermission: vi.fn(),
+        hasAllPermissions: vi.fn(),
+        hasRole: vi.fn(),
+        hasAccessLevel: vi.fn(),
+        canAccess: vi.fn(),
+        validatePermission: vi.fn(),
+        validateAccess: vi.fn(),
+        refreshPermissions: vi.fn(),
+        setSelectedEventId: vi.fn(),
+        loadUserEventAccess: vi.fn(),
+        requireOrganisationContext: vi.fn(() => 'org-1'),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+      
+      const mockOrganisationService = {
+        getSelectedOrganisation: vi.fn(() => mockOrganisation),
+        getOrganisations: vi.fn(() => [mockOrganisation]),
+        getUserMemberships: vi.fn(() => []),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        hasValidOrganisationContext: vi.fn(() => true),
+        isContextReady: vi.fn(() => true),
+        switchOrganisation: vi.fn(),
+        getUserRole: vi.fn(),
+        validateOrganisationAccess: vi.fn(),
+        refreshOrganisations: vi.fn(),
+        ensureOrganisationContext: vi.fn(() => mockOrganisation),
+        isOrganisationSecure: vi.fn(() => true),
+        getPrimaryOrganisation: vi.fn(() => mockOrganisation),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+      
+      const mockEventService = {
+        getEvents: vi.fn(() => []),
+        getSelectedEvent: vi.fn(() => null),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => null),
+        setSelectedEvent: vi.fn(),
+        refreshEvents: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      // Test individual hooks
+      mockUseContext.mockReturnValue({ authService: mockAuthService });
+      const { result: authResult } = renderHook(() => useAuth(), { wrapper });
+
+      mockUseContext.mockReturnValue({ rbacService: mockRBACService });
+      const { result: permissionsResult } = renderHook(() => usePermissions(), { wrapper });
+
+      mockUseContext.mockReturnValue({ organisationService: mockOrganisationService });
+      const { result: organisationResult } = renderHook(() => useCurrentOrganisation(), { wrapper });
+
+      mockUseContext.mockReturnValue({ eventService: mockEventService });
+      const { result: eventResult } = renderHook(() => useCurrentEvent(), { wrapper });
+
+      expect(authResult.current).toBeDefined();
+      expect(permissionsResult.current).toBeDefined();
+      expect(organisationResult.current).toBeDefined();
+      expect(eventResult.current).toBeDefined();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle service errors gracefully', () => {
+      const mockService = {
+        getUser: vi.fn(() => null),
+        getSession: vi.fn(() => null),
+        isAuthenticated: vi.fn(() => false),
+        isLoading: vi.fn(() => false),
+        getError: vi.fn(() => new Error('Service error')),
+        getSupabaseClient: vi.fn(() => null),
+        signIn: vi.fn(),
+        signUp: vi.fn(),
+        signOut: vi.fn(),
+        resetPassword: vi.fn(),
+        updatePassword: vi.fn(),
+        refreshSession: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ authService: mockService });
+
+      const { result } = renderHook(() => useAuth(), { wrapper });
+
+      expect(result.current.authError).toBeDefined();
+      expect(result.current.authError?.message).toBe('Service error');
+    });
+
+    it('should handle missing service methods gracefully', () => {
+      const mockService = {
+        getUser: vi.fn(),
+        getSession: vi.fn(),
+        isAuthenticated: vi.fn(),
+        isLoading: vi.fn(),
+        getError: vi.fn(() => null),
+        getSupabaseClient: vi.fn(),
+        signIn: vi.fn(),
+        signUp: vi.fn(),
+        signOut: vi.fn(),
+        resetPassword: vi.fn(),
+        updatePassword: vi.fn(),
+        refreshSession: vi.fn(),
+        subscribe: vi.fn(() => vi.fn()),
+        cleanup: vi.fn()
+      };
+
+      const wrapper = ({ children }: { children: React.ReactNode }) => (
+        <div>{children}</div>
+      );
+
+      mockUseContext.mockReturnValue({ authService: mockService });
+
+      // Should not throw error
+      expect(() => {
+        const { result } = renderHook(() => useAuth(), { wrapper });
+        expect(result.current).toBeDefined();
+      }).not.toThrow();
+    });
+  });
+});

package/src/hooks/__tests__/hooks.integration.test.tsx

@@ -275,16 +275,7 @@ const DataTableStateComponent = () => {
 };
 
 describe('Hooks Integration', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockPerformance.now.mockReturnValue(0);
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('useDebounce Integration', () => {
+    describe('useDebounce Integration', () => {
     it('debounces search input with component integration', async () => {
       renderWithProviders(<DebouncedSearch />);
 

package/src/hooks/__tests__/useApiFetch.unit.test.ts

@@ -38,15 +38,8 @@ function useApiFetch(url: string) {
 }
 
 describe('useApiFetch', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('fetches data on mount', async () => {
+    describe('Data Fetching', () => {
+    it('fetches data on mount', async () => {
     const mockData = { id: 1, name: 'Test' };
     mockFetch.mockResolvedValueOnce({
       ok: true,
@@ -64,9 +57,9 @@ describe('useApiFetch', () => {
 
     expect(result.current.data).toEqual(mockData);
     expect(mockFetch).toHaveBeenCalledWith('/api/test');
-  });
+    });
 
-  it('sets loading state', async () => {
+    it('sets loading state', async () => {
     const mockData = { id: 1, name: 'Test' };
     mockFetch.mockResolvedValueOnce({
       ok: true,
@@ -81,9 +74,9 @@ describe('useApiFetch', () => {
     await waitFor(() => {
       expect(result.current.loading).toBe(false);
     });
-  });
+    });
 
-  it('returns data', async () => {
+    it('returns data', async () => {
     const mockData = { id: 1, name: 'Test Data' };
     mockFetch.mockResolvedValueOnce({
       ok: true,
@@ -97,9 +90,11 @@ describe('useApiFetch', () => {
     });
 
     expect(result.current.error).toBe(null);
+    });
   });
 
-  it('handles errors gracefully', async () => {
+  describe('Error Handling', () => {
+    it('handles errors gracefully', async () => {
     const errorMessage = 'Network error';
     mockFetch.mockRejectedValueOnce(new Error(errorMessage));
 
@@ -111,5 +106,6 @@ describe('useApiFetch', () => {
 
     expect(result.current.error).toBe(errorMessage);
     expect(result.current.data).toBe(null);
+    });
   });
 });