@jmruthers/pace-core 0.5.181 → 0.5.182

package/src/providers/UnifiedAuthProvider.smoke.test.tsx

@@ -72,22 +72,122 @@ vi.mock('../../hooks/services/useInactivityService', () => ({
 }));
 
 // Import after mocks so provider uses mocked modules
-import { UnifiedAuthProvider, useUnifiedAuth } from './UnifiedAuthProvider';
+import { UnifiedAuthProvider, useUnifiedAuth } from './services/UnifiedAuthProvider';
 
 // Mock all the child providers with simple implementations
 // Mock service providers actually used by UnifiedAuthProvider
-vi.mock('./services/AuthServiceProvider', () => ({
-  AuthServiceProvider: ({ children }: { children: ReactNode }) => <div data-testid="auth-provider">{children}</div>,
-}));
-vi.mock('./services/OrganisationServiceProvider', () => ({
-  OrganisationServiceProvider: ({ children }: { children: ReactNode }) => <div data-testid="org-provider">{children}</div>,
-}));
-vi.mock('./services/EventServiceProvider', () => ({
-  EventServiceProvider: ({ children }: { children: ReactNode }) => <div data-testid="event-provider">{children}</div>,
-}));
-vi.mock('./services/InactivityServiceProvider', () => ({
-  InactivityServiceProvider: ({ children }: { children: ReactNode }) => <div data-testid="inactivity-provider">{children}</div>,
-}));
+vi.mock('./services/AuthServiceProvider', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('./services/AuthServiceProvider')>();
+  const React = await import('react');
+  const mockAuthService = {
+    getUser: () => null,
+    getSession: () => null,
+    isLoading: () => false,
+    getError: () => null,
+    getSupabaseClient: () => ({}),
+    signIn: vi.fn(),
+    signUp: vi.fn(),
+    signOut: vi.fn(),
+    resetPassword: vi.fn(),
+    updatePassword: vi.fn(),
+    refreshSession: vi.fn(),
+    subscribe: () => () => {},
+    initialize: vi.fn(),
+    cleanup: vi.fn(),
+    getSessionRestorationState: () => ({ isRestoring: false, restorationComplete: false, restorationError: null }),
+  };
+  return {
+    ...actual,
+    AuthServiceProvider: ({ children }: { children: ReactNode }) => (
+      <actual.AuthServiceContext.Provider value={{ authService: mockAuthService, sessionRestoration: { isRestoring: false, restorationComplete: false, restorationError: null } }}>
+        <div data-testid="auth-provider">{children}</div>
+      </actual.AuthServiceContext.Provider>
+    ),
+  };
+});
+vi.mock('./services/OrganisationServiceProvider', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('./services/OrganisationServiceProvider')>();
+  const React = await import('react');
+  const mockOrganisationService = {
+    getSelectedOrganisation: () => null,
+    getOrganisations: () => [],
+    getUserMemberships: () => [],
+    isLoading: () => false,
+    getError: () => null,
+    hasValidOrganisationContext: () => false,
+    isContextReady: () => false,
+    switchOrganisation: vi.fn(),
+    getUserRole: vi.fn(),
+    validateOrganisationAccess: vi.fn(),
+    refreshOrganisations: vi.fn(),
+    ensureOrganisationContext: vi.fn(),
+    isOrganisationSecure: vi.fn(),
+    getPrimaryOrganisation: vi.fn(),
+    subscribe: () => () => {},
+    initialize: vi.fn(),
+    cleanup: vi.fn(),
+  };
+  return {
+    ...actual,
+    OrganisationServiceProvider: ({ children }: { children: ReactNode }) => (
+      <actual.OrganisationServiceContext.Provider value={{ organisationService: mockOrganisationService }}>
+        <div data-testid="org-provider">{children}</div>
+      </actual.OrganisationServiceContext.Provider>
+    ),
+  };
+});
+vi.mock('./services/EventServiceProvider', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('./services/EventServiceProvider')>();
+  const React = await import('react');
+  const mockEventService = {
+    getEvents: () => [],
+    getSelectedEvent: () => null,
+    isLoading: () => false,
+    getError: () => null,
+    setSelectedEvent: vi.fn(),
+    refreshEvents: vi.fn(),
+    subscribe: () => () => {},
+    initialize: vi.fn(),
+    cleanup: vi.fn(),
+  };
+  return {
+    ...actual,
+    EventServiceProvider: ({ children }: { children: ReactNode }) => (
+      <actual.EventServiceContext.Provider value={{ eventService: mockEventService }}>
+        <div data-testid="event-provider">{children}</div>
+      </actual.EventServiceContext.Provider>
+    ),
+  };
+});
+vi.mock('./services/InactivityServiceProvider', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('./services/InactivityServiceProvider')>();
+  const React = await import('react');
+  const mockInactivityService = {
+    getShowInactivityWarning: () => false,
+    getInactivityTimeRemaining: () => 0,
+    isIdle: () => false,
+    getTimeRemaining: () => 30 * 60 * 1000,
+    isWarningShown: () => false,
+    isTracking: () => false,
+    resetActivity: vi.fn(),
+    startTracking: vi.fn(),
+    stopTracking: vi.fn(),
+    handleIdleLogout: vi.fn(),
+    handleStaySignedIn: vi.fn(),
+    handleSignOutNow: vi.fn(),
+    subscribe: () => () => {},
+    initialize: vi.fn(),
+    cleanup: vi.fn(),
+  };
+  return {
+    ...actual,
+    InactivityServiceProvider: ({ children }: { children: ReactNode }) => (
+      <actual.InactivityServiceContext.Provider value={{ inactivityService: mockInactivityService }}>
+        <div data-testid="inactivity-provider">{children}</div>
+      </actual.InactivityServiceContext.Provider>
+    ),
+  };
+});
 
 // No RBAC provider composition in UnifiedAuthProvider now; remove that assertion
 

package/src/providers/__tests__/AuthProvider.test.tsx

@@ -6,7 +6,8 @@
 import React from 'react';
 import { render, screen, fireEvent } from '@testing-library/react';
 import { vi, describe, it, expect, beforeEach } from 'vitest';
-import { AuthServiceProvider as AuthProvider, useAuthService as useAuth } from '../services/AuthServiceProvider';
+import { AuthServiceProvider as AuthProvider } from '../services/AuthServiceProvider';
+import { useAuthService as useAuth } from '../../hooks/services/useAuthService';
 import { TEST_FIXTURES } from '../../__tests__/fixtures/test-data';
 
 // Mock the debug logger

package/src/providers/__tests__/EventProvider.test.tsx

@@ -6,7 +6,8 @@
 import React from 'react';
 import { render, screen, fireEvent } from '@testing-library/react';
 import { vi, describe, it, expect, beforeEach } from 'vitest';
-import { EventProvider, useEvents } from '../EventProvider';
+import { EventServiceProvider } from '../services/EventServiceProvider';
+import { useEvents } from '../../hooks/useEvents';
 import { TEST_FIXTURES } from '../../__tests__/fixtures/test-data';
 
 // Mock the debug logger
@@ -30,14 +31,16 @@ const mockUnifiedAuthState = {
   setSelectedEventId: vi.fn(),
 };
 
-vi.mock('../UnifiedAuthProvider', () => ({
-  useUnifiedAuth: () => ({
-    user: mockUnifiedAuthState.user,
-    session: mockUnifiedAuthState.session,
-    supabase: mockUnifiedAuthState.supabase,
-    appName: mockUnifiedAuthState.appName,
-    setSelectedEventId: mockUnifiedAuthState.setSelectedEventId,
-  }),
+const mockUseUnifiedAuthFn = vi.fn(() => ({
+  user: mockUnifiedAuthState.user,
+  session: mockUnifiedAuthState.session,
+  supabase: mockUnifiedAuthState.supabase,
+  appName: mockUnifiedAuthState.appName,
+  setSelectedEventId: mockUnifiedAuthState.setSelectedEventId,
+}));
+vi.mock('../services/UnifiedAuthProvider', () => ({
+  useUnifiedAuth: () => mockUseUnifiedAuthFn(),
+  UnifiedAuthProvider: ({ children }: { children: React.ReactNode }) => <>{children}</>,
 }));
 
 // Mock OrganisationProvider
@@ -46,7 +49,7 @@ const mockOrganisationState = {
   ensureOrganisationContext: vi.fn(),
 };
 
-vi.mock('../OrganisationProvider', () => ({
+vi.mock('../../hooks/useOrganisations', () => ({
   useOrganisations: () => ({
     selectedOrganisation: mockOrganisationState.selectedOrganisation,
     ensureOrganisationContext: mockOrganisationState.ensureOrganisationContext,
@@ -130,9 +133,16 @@ const TestWrapper = ({
   mockOrganisationState.selectedOrganisation = selectedOrganisation;
 
   return (
-    <EventProvider supabaseClient={supabaseClient}>
+    <EventServiceProvider 
+      supabaseClient={supabaseClient || createMockSupabaseClient()}
+      user={user}
+      session={session}
+      appName={appName}
+      selectedOrganisation={selectedOrganisation}
+      setSelectedEventId={mockUnifiedAuthState.setSelectedEventId}
+    >
       {children}
-    </EventProvider>
+    </EventServiceProvider>
   );
 };
 
@@ -270,9 +280,8 @@ describe('EventProvider', () => {
       };
 
       render(<TestOutsideProvider />);
-      // The hook might not throw an error in this test environment
-      // Just verify the component renders
-      expect(screen.getByTestId('no-error')).toBeInTheDocument();
+      // The hook should throw an error when used outside the provider
+      expect(screen.getByTestId('error')).toHaveTextContent('useEventService must be used within EventServiceProvider');
     });
   });
 

package/src/providers/__tests__/OrganisationProvider.test.tsx

@@ -4,9 +4,10 @@
  */
 
 import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
 import { vi, describe, it, expect, beforeEach } from 'vitest';
-import { OrganisationProvider, useOrganisations } from '../OrganisationProvider';
+import { OrganisationServiceProvider } from '../services/OrganisationServiceProvider';
+import { useOrganisations } from '../../hooks/useOrganisations';
 import { TEST_FIXTURES } from '../../__tests__/fixtures/test-data';
 
 // Mock the debug logger
@@ -16,30 +17,68 @@ vi.mock('../../utils/debugLogger', () => ({
   },
 }));
 
+// Mock setOrganisationContext
+vi.mock('../../utils/context/organisationContext', () => ({
+  setOrganisationContext: vi.fn().mockResolvedValue(undefined),
+}));
+
+// Create mock user and session
+const mockUser = {
+  id: '123e4567-e89b-12d3-a456-426614174001', // Valid UUID format
+  email: 'test@example.com',
+} as any;
+
+const mockSession = {
+  access_token: 'test-token',
+  refresh_token: 'test-refresh-token',
+  user: mockUser,
+  expires_at: Date.now() + 3600000,
+} as any;
+
 // Create mock Supabase client
-const createMockSupabaseClient = () => ({
-  from: vi.fn(() => ({
-    select: vi.fn(() => ({
-      eq: vi.fn(() => ({
-        data: [
-          {
-            organisation_id: 'org-1',
-            organisation_name: 'Test Organisation 1',
-            role: 'admin',
-            is_primary: true,
-          },
-          {
-            organisation_id: 'org-2',
-            organisation_name: 'Test Organisation 2',
-            role: 'user',
-            is_primary: false,
-          },
-        ],
-        error: null,
-      })),
-    })),
-  })),
-});
+const createMockSupabaseClient = () => {
+  const orgId = '123e4567-e89b-12d3-a456-426614174000'; // Valid UUID format
+  const userId = '123e4567-e89b-12d3-a456-426614174001'; // Valid UUID format
+  
+  return {
+    rpc: vi.fn().mockResolvedValue({
+      data: [
+        {
+          user_id: userId,
+          organisation_id: orgId,
+          role: 'org_admin',
+          status: 'active',
+        },
+      ],
+      error: null,
+    }),
+    from: vi.fn((table: string) => {
+      if (table === 'organisations') {
+        return {
+          select: vi.fn().mockResolvedValue({
+            data: [
+              {
+                id: orgId,
+                name: 'Test Organisation 1',
+                display_name: 'Test Organisation 1',
+                subscription_tier: 'basic',
+                settings: {},
+                is_active: true,
+                parent_id: null,
+                created_at: '2023-01-01T00:00:00Z',
+                updated_at: '2023-01-01T00:00:00Z',
+              },
+            ],
+            error: null,
+          }),
+        };
+      }
+      return {
+        select: vi.fn().mockResolvedValue({ data: [], error: null }),
+      };
+    }),
+  };
+};
 
 // Test component that uses the organisation context
 const TestComponent = () => {
@@ -50,7 +89,7 @@ const TestComponent = () => {
       <div data-testid="organisations-count">{org.organisations.length}</div>
       <div data-testid="isLoading">{org.isLoading ? 'true' : 'false'}</div>
       <div data-testid="error">{org.error?.message || 'no-error'}</div>
-      <div data-testid="selectedOrg">{org.selectedOrganisation?.organisation_name || 'no-org'}</div>
+      <div data-testid="selectedOrg">{org.selectedOrganisation?.name || org.selectedOrganisation?.display_name || 'no-org'}</div>
       <div data-testid="hasValidContext">{org.hasValidOrganisationContext ? 'true' : 'false'}</div>
       <div data-testid="hasSetSelectedOrg">{typeof org.setSelectedOrganisation === 'function' ? 'true' : 'false'}</div>
       <div data-testid="hasRefreshOrg">{typeof org.refreshOrganisations === 'function' ? 'true' : 'false'}</div>
@@ -62,8 +101,8 @@ const TestComponent = () => {
 const TestWrapper = ({ 
   children, 
   supabaseClient, 
-  user = null, 
-  session = null 
+  user = mockUser, 
+  session = mockSession 
 }: { 
   children: React.ReactNode; 
   supabaseClient?: any;
@@ -71,9 +110,9 @@ const TestWrapper = ({
   session?: any;
 }) => {
   return (
-    <OrganisationProvider supabaseClient={supabaseClient} user={user} session={session}>
+    <OrganisationServiceProvider supabaseClient={supabaseClient || createMockSupabaseClient()} user={user} session={session}>
       {children}
-    </OrganisationProvider>
+    </OrganisationServiceProvider>
   );
 };
 
@@ -86,7 +125,7 @@ describe('OrganisationProvider', () => {
   });
 
   describe('Rendering', () => {
-    it('renders without crashing', () => {
+    it('renders without crashing', async () => {
       render(
         <TestWrapper supabaseClient={mockSupabaseClient}>
           <TestComponent />
@@ -94,7 +133,12 @@ describe('OrganisationProvider', () => {
       );
 
       expect(screen.getByTestId('test-component')).toBeInTheDocument();
-      expect(screen.getByTestId('organisations-count')).toHaveTextContent('1');
+      
+      // Wait for organisations to load
+      await waitFor(() => {
+        expect(screen.getByTestId('organisations-count')).toHaveTextContent('1');
+      }, { timeout: 3000 });
+      
       expect(screen.getByTestId('isLoading')).toHaveTextContent('false');
       expect(screen.getByTestId('error')).toHaveTextContent('no-error');
     });
@@ -111,18 +155,24 @@ describe('OrganisationProvider', () => {
   });
 
   describe('Context Values', () => {
-    it('provides all required context values', () => {
+    it('provides all required context values', async () => {
       render(
         <TestWrapper supabaseClient={mockSupabaseClient}>
           <TestComponent />
         </TestWrapper>
       );
 
+      // Wait for organisations to load and selected organisation to be set
+      await waitFor(() => {
+        expect(screen.getByTestId('organisations-count')).toHaveTextContent('1');
+        expect(screen.getByTestId('selectedOrg')).not.toHaveTextContent('no-org');
+      }, { timeout: 3000 });
+      
       expect(screen.getByTestId('organisations-count')).toHaveTextContent('1');
       expect(screen.getByTestId('isLoading')).toHaveTextContent('false');
       expect(screen.getByTestId('error')).toHaveTextContent('no-error');
-      expect(screen.getByTestId('selectedOrg')).toHaveTextContent('no-org');
-      expect(screen.getByTestId('hasValidContext')).toHaveTextContent('false');
+      expect(screen.getByTestId('selectedOrg')).not.toHaveTextContent('no-org');
+      expect(screen.getByTestId('hasValidContext')).toHaveTextContent('true');
       expect(screen.getByTestId('hasSetSelectedOrg')).toHaveTextContent('true');
       expect(screen.getByTestId('hasRefreshOrg')).toHaveTextContent('true');
     });
@@ -158,7 +208,8 @@ describe('OrganisationProvider', () => {
       );
 
       expect(screen.getByTestId('test-component')).toBeInTheDocument();
-      expect(screen.getByTestId('organisations-count')).toHaveTextContent('1');
+      // Without supabase client, organisations won't load, so count should be 0
+      expect(screen.getByTestId('organisations-count')).toHaveTextContent('0');
     });
 
     it('handles missing user', () => {

package/src/providers/__tests__/UnifiedAuthProvider.test.tsx

@@ -6,7 +6,7 @@
 import React from 'react';
 import { render, screen, waitFor } from '@testing-library/react';
 import { vi, describe, it, expect } from 'vitest';
-import { UnifiedAuthProvider, useUnifiedAuth } from '../UnifiedAuthProvider';
+import { UnifiedAuthProvider, useUnifiedAuth } from '../services/UnifiedAuthProvider';
 
 // Mock the debug logger
 vi.mock('../../utils/debugLogger', () => ({
@@ -15,11 +15,35 @@ vi.mock('../../utils/debugLogger', () => ({
   },
 }));
 
+// Create mock user and session
+const mockUser = {
+  id: 'test-user-id',
+  email: 'test@example.com',
+  user_metadata: {},
+  app_metadata: {},
+} as any;
+
+const mockSession = {
+  access_token: 'test-token',
+  refresh_token: 'test-refresh-token',
+  user: mockUser,
+  expires_at: Date.now() + 3600000,
+} as any;
+
 // Create mock Supabase client
 const createMockSupabaseClient = () => ({
   auth: {
-    getSession: vi.fn(),
-    onAuthStateChange: vi.fn(),
+    getSession: vi.fn().mockResolvedValue({
+      data: { session: mockSession },
+      error: null
+    }),
+    getUser: vi.fn().mockResolvedValue({
+      data: { user: mockUser },
+      error: null
+    }),
+    onAuthStateChange: vi.fn().mockReturnValue({
+      data: { subscription: { unsubscribe: vi.fn() } }
+    }),
     signInWithPassword: vi.fn(),
     signUp: vi.fn(),
     signOut: vi.fn(),
@@ -47,12 +71,22 @@ const TestComponent = () => {
 };
 
 describe('UnifiedAuthProvider', () => {
-  const mockSupabaseClient = createMockSupabaseClient();
+  let mockSupabaseClient: ReturnType<typeof createMockSupabaseClient>;
+  const defaultProps = {
+    idleTimeoutMs: 30 * 60 * 1000,
+    warnBeforeMs: 60 * 1000,
+    onIdleLogout: vi.fn(),
+  };
+
+  beforeEach(() => {
+    // Create a fresh mock client for each test
+    mockSupabaseClient = createMockSupabaseClient();
+  });
 
   describe('Rendering', () => {
     it('renders without crashing', () => {
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} {...defaultProps}>
           <TestComponent />
         </UnifiedAuthProvider>
       );
@@ -62,7 +96,7 @@ describe('UnifiedAuthProvider', () => {
 
     it('renders with custom app name', () => {
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Custom App">
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Custom App" {...defaultProps}>
           <TestComponent />
         </UnifiedAuthProvider>
       );
@@ -84,15 +118,15 @@ describe('UnifiedAuthProvider', () => {
   describe('Context Values', () => {
     it('provides all required context values', async () => {
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" {...defaultProps}>
           <TestComponent />
         </UnifiedAuthProvider>
       );
 
-      // Wait for services to initialize
+      // Wait for services to initialize and user/session to be loaded
       await waitFor(() => {
-        expect(screen.getByTestId('test-component')).toBeInTheDocument();
-      });
+        expect(screen.getByTestId('hasUser')).toHaveTextContent('true');
+      }, { timeout: 3000 });
 
       expect(screen.getByTestId('hasUser')).toHaveTextContent('true');
       expect(screen.getByTestId('hasSession')).toHaveTextContent('true');
@@ -148,7 +182,7 @@ describe('UnifiedAuthProvider', () => {
 
     it('uses default configuration', () => {
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} {...defaultProps}>
           <TestComponent />
         </UnifiedAuthProvider>
       );
@@ -158,7 +192,7 @@ describe('UnifiedAuthProvider', () => {
   });
 
   describe('[integration] Provider Composition', () => {
-    it('composes with child providers without errors', () => {
+    it('composes with child providers without errors', async () => {
       const TestCompositionComponent = () => {
         const auth = useUnifiedAuth();
         
@@ -173,16 +207,20 @@ describe('UnifiedAuthProvider', () => {
       };
 
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" {...defaultProps}>
           <TestCompositionComponent />
         </UnifiedAuthProvider>
       );
 
       expect(screen.getByTestId('composition-success')).toHaveTextContent('composed');
-      expect(screen.getByTestId('has-all-contexts')).toHaveTextContent('yes');
+      
+      // Wait for user and session to be loaded
+      await waitFor(() => {
+        expect(screen.getByTestId('has-all-contexts')).toHaveTextContent('yes');
+      }, { timeout: 3000 });
     });
 
-    it('provides complete unified context', () => {
+    it('provides complete unified context', async () => {
       const TestCompleteContextComponent = () => {
         const auth = useUnifiedAuth();
         
@@ -198,11 +236,16 @@ describe('UnifiedAuthProvider', () => {
       };
 
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" {...defaultProps}>
           <TestCompleteContextComponent />
         </UnifiedAuthProvider>
       );
 
+      // Wait for user and session to be loaded
+      await waitFor(() => {
+        expect(screen.getByTestId('user-context')).toHaveTextContent('present');
+      }, { timeout: 3000 });
+      
       expect(screen.getByTestId('user-context')).toHaveTextContent('present');
       expect(screen.getByTestId('session-context')).toHaveTextContent('present');
       expect(screen.getByTestId('organisation-context')).toHaveTextContent('missing');
@@ -368,7 +411,7 @@ describe('UnifiedAuthProvider', () => {
   });
 
   describe('[integration] Hook Integration', () => {
-    it('integrates useUnifiedAuth with all contexts', () => {
+    it('integrates useUnifiedAuth with all contexts', async () => {
       const TestHookIntegrationComponent = () => {
         const auth = useUnifiedAuth();
         
@@ -385,11 +428,16 @@ describe('UnifiedAuthProvider', () => {
       };
 
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" {...defaultProps}>
           <TestHookIntegrationComponent />
         </UnifiedAuthProvider>
       );
 
+      // Wait for user and session to be loaded
+      await waitFor(() => {
+        expect(screen.getByTestId('hook-access')).toHaveTextContent('full');
+      }, { timeout: 3000 });
+      
       expect(screen.getByTestId('hook-access')).toHaveTextContent('full');
       expect(screen.getByTestId('hook-methods')).toHaveTextContent('complete');
     });
@@ -427,7 +475,7 @@ describe('UnifiedAuthProvider', () => {
       expect(screen.getByTestId('user-stable')).toHaveTextContent('stable');
     });
 
-    it('handles concurrent hook usage', () => {
+    it('handles concurrent hook usage', async () => {
       const TestConcurrentComponent = () => {
         const auth = useUnifiedAuth();
         
@@ -446,13 +494,17 @@ describe('UnifiedAuthProvider', () => {
       };
 
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" {...defaultProps}>
           <TestConcurrentComponent />
         </UnifiedAuthProvider>
       );
 
       expect(screen.getByTestId('concurrent-safe')).toHaveTextContent('safe');
-      expect(screen.getByTestId('all-reads')).toHaveTextContent('success');
+      
+      // Wait for user and session to be loaded
+      await waitFor(() => {
+        expect(screen.getByTestId('all-reads')).toHaveTextContent('success');
+      }, { timeout: 3000 });
     });
   });
 
@@ -485,7 +537,7 @@ describe('UnifiedAuthProvider', () => {
       expect(screen.getByTestId('app-name-consistent')).toHaveTextContent('consistent');
     });
 
-    it('configures RBAC features when enabled', () => {
+    it('configures RBAC features when enabled', async () => {
       const TestRBACConfigComponent = () => {
         const auth = useUnifiedAuth();
         
@@ -502,12 +554,16 @@ describe('UnifiedAuthProvider', () => {
       };
 
       render(
-        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} enableRBAC={true}>
+        <UnifiedAuthProvider supabaseClient={mockSupabaseClient} appName="Test App" enableRBAC={true} {...defaultProps}>
           <TestRBACConfigComponent />
         </UnifiedAuthProvider>
       );
 
-      expect(screen.getByTestId('rbac-enabled')).toHaveTextContent('enabled');
+      // Wait for user and session to be loaded
+      await waitFor(() => {
+        expect(screen.getByTestId('rbac-enabled')).toHaveTextContent('enabled');
+      }, { timeout: 3000 });
+      
       expect(screen.getByTestId('session-available')).toBeInTheDocument();
     });
 

package/src/providers/index.ts

@@ -12,6 +12,3 @@ export * from './services/EventServiceProvider';
 export * from './services/OrganisationServiceProvider';
 export * from './services/InactivityServiceProvider';
 export * from './services/AuthServiceProvider';
-
-// RBAC Provider - Use @jmruthers/pace-core/rbac instead
-// Note: RBAC functionality has been moved to the dedicated RBAC module