@jmruthers/pace-core 0.6.9 → 0.6.11

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

@@ -1,615 +0,0 @@
-/**
- * @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 { useOrganisationService } from '../services/useOrganisationService';
-import { useEventService } from '../services/useEventService';
-import { useInactivityService } from '../services/useInactivityService';
-import { useAuth } from '../services/useAuth';
-import { useCurrentOrganisation } from '../services/useCurrentOrganisation';
-import { useCurrentEvent } from '../services/useCurrentEvent';
-
-// Mock usePermissions hook for service hooks tests
-vi.mock('../../rbac/hooks/usePermissions', () => ({
-  usePermissions: vi.fn(() => ({
-    permissions: { 'events:read': true },
-    roles: ['admin'],
-    accessLevel: 'ADMIN',
-    rbacLoading: false,
-    rbacError: null,
-    selectedEventId: 'event-1',
-    userEventAccess: [],
-    eventAccessLoading: false,
-    selectedOrganisationId: 'org-1',
-    appConfig: { name: 'test' },
-    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(),
-    getUserEventAccess: vi.fn(),
-    requireOrganisationContext: vi.fn(() => 'org-1'),
-  }))
-}));
-
-import { usePermissions } from '../../rbac/hooks/usePermissions';
-
-// 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 }) => (
-        <section>{children}</section>
-      );
-
-      // 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 }) => (
-        <section>{children}</section>
-      );
-
-      // 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 }) => (
-        <section>{children}</section>
-      );
-
-      mockUseContext.mockReturnValue({ authService: mockService });
-
-      renderHook(() => useAuthService(), { wrapper });
-
-      expect(mockService.subscribe).toHaveBeenCalled();
-    });
-  });
-
-  describe('useOrganisationService', () => {
-    it('should return OrganisationService from context', () => {
-      const mockService = createMockService('organisation');
-      const wrapper = ({ children }: { children: React.ReactNode }) => (
-        <section>{children}</section>
-      );
-
-      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 }) => (
-        <section>{children}</section>
-      );
-
-      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 }) => (
-        <section>{children}</section>
-      );
-
-      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 }) => (
-        <section>{children}</section>
-      );
-
-      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 }) => (
-        <section>{children}</section>
-      );
-
-      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 }) => (
-        <section>{children}</section>
-      );
-
-      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 }) => (
-        <section>{children}</section>
-      );
-
-      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 }) => (
-        <section>{children}</section>
-      );
-
-      mockUseContext.mockReturnValue({ rbacService: mockService });
-
-      const { result } = renderHook(() => usePermissions('user-1', 'org-1', 'event-1', 'test-app'), { 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 }) => (
-        <section>{children}</section>
-      );
-
-      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 }) => (
-        <section>{children}</section>
-      );
-
-      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 }) => (
-        <section>{children}</section>
-      );
-
-      // Test individual hooks
-      mockUseContext.mockReturnValue({ authService: mockAuthService });
-      const { result: authResult } = renderHook(() => useAuth(), { wrapper });
-
-      mockUseContext.mockReturnValue({ rbacService: mockRBACService });
-      const { result: permissionsResult } = renderHook(() => usePermissions('user-1', 'org-1', 'event-1', 'test-app'), { 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 }) => (
-        <section>{children}</section>
-      );
-
-      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 }) => (
-        <section>{children}</section>
-      );
-
-      mockUseContext.mockReturnValue({ authService: mockService });
-
-      // Should not throw error
-      expect(() => {
-        const { result } = renderHook(() => useAuth(), { wrapper });
-        expect(result.current).toBeDefined();
-      }).not.toThrow();
-    });
-  });
-});