@jmruthers/pace-core 0.5.189 → 0.5.190

package/src/rbac/hooks/useRBAC.simple.test.ts

@@ -1,95 +0,0 @@
-/**
- * @file useRBAC Hook Simple Tests
- * @package @jmruthers/pace-core
- * @module RBAC/Hooks/useRBAC
- * @since 0.3.0
- * 
- * Simple tests for the useRBAC hook to verify basic functionality.
- */
-
-import { renderHook } from '@testing-library/react';
-import { vi, describe, it, expect, beforeEach } from 'vitest';
-
-// Mock the providers with simple mocks
-vi.mock('../../providers/UnifiedAuthProvider', () => ({
-  useUnifiedAuth: vi.fn(() => ({
-    user: { id: 'user-123' },
-    session: { access_token: 'mock-token' },
-    supabase: {
-      // Ensure realtime init is skipped
-      channel: undefined,
-      from: vi.fn(() => ({
-        select: vi.fn(() => ({
-          eq: vi.fn(() => ({
-            eq: vi.fn(() => ({
-              single: vi.fn().mockResolvedValue({
-                data: { global_role: 'user' },
-                error: null
-              })
-            }))
-          }))
-        }))
-      }))
-    },
-    appName: 'test-app'
-  }))
-}));
-
-vi.mock('../../providers/OrganisationProvider', () => ({
-  useOrganisations: vi.fn(() => ({
-    selectedOrganisation: { id: 'org-123', name: 'Test Org' }
-  }))
-}));
-
-vi.mock('../../providers/EventProvider', () => ({
-  useEvents: vi.fn(() => ({
-    selectedEvent: { event_id: 'event-123', name: 'Test Event' }
-  }))
-}));
-
-// Import after mocking
-vi.mock('./useRBAC', () => ({
-  useRBAC: () => ({
-    isLoading: false,
-    isAuthenticated: true,
-    globalRole: 'user',
-    organisationRole: 'member',
-    eventAppRole: 'participant',
-    isSuperAdmin: false,
-    isOrgAdmin: false,
-    hasGlobalPermission: () => true,
-    error: null,
-  }),
-}));
-import { useRBAC } from './useRBAC';
-
-describe('useRBAC Hook - Simple Tests', () => {
-    it('renders without crashing', () => {
-    const { result } = renderHook(() => useRBAC());
-    
-    expect(result.current).toBeDefined();
-    expect(result.current.globalRole).toBeDefined();
-    expect(result.current.organisationRole).toBeDefined();
-    expect(result.current.eventAppRole).toBeDefined();
-  });
-
-  it('has required properties', () => {
-    const { result } = renderHook(() => useRBAC());
-    
-    expect(result.current).toHaveProperty('globalRole');
-    expect(result.current).toHaveProperty('organisationRole');
-    expect(result.current).toHaveProperty('eventAppRole');
-    expect(result.current).toHaveProperty('hasGlobalPermission');
-    expect(result.current).toHaveProperty('isSuperAdmin');
-    expect(result.current).toHaveProperty('isOrgAdmin');
-    expect(result.current).toHaveProperty('isLoading');
-    expect(result.current).toHaveProperty('error');
-    // Note: hasPermission was removed - use useCan() hook instead
-  });
-
-  it('hasGlobalPermission is a function', () => {
-    const { result } = renderHook(() => useRBAC());
-    
-    expect(typeof result.current.hasGlobalPermission).toBe('function');
-  });
-});

package/src/rbac/utils/__tests__/eventContext.unit.test.ts

@@ -1,428 +0,0 @@
-/**
- * @file Event Context Utilities Tests
- * @package @jmruthers/pace-core
- * @module RBAC/EventContext/Tests
- * @since 1.0.0
- * 
- * Comprehensive tests for event context utilities in the RBAC system.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { SupabaseClient } from '@supabase/supabase-js';
-import { Database } from '../../../types/database';
-import { UUID, Scope } from '../../types';
-import {
-  getOrganisationFromEvent,
-  createScopeFromEvent,
-  isEventBasedScope,
-  isValidEventBasedScope
-} from '../eventContext';
-
-// Mock Supabase client
-const createMockSupabaseClient = () => {
-  const mockQuery = {
-    select: vi.fn().mockReturnThis(),
-    eq: vi.fn().mockReturnThis(),
-    single: vi.fn()
-  };
-
-  return {
-    from: vi.fn().mockReturnValue(mockQuery),
-    query: mockQuery
-  } as unknown as SupabaseClient<Database>;
-};
-
-describe('Event Context Utilities', () => {
-  let mockSupabase: SupabaseClient<Database>;
-  let mockQuery: any;
-
-  beforeEach(() => {
-    mockSupabase = createMockSupabaseClient();
-    mockQuery = mockSupabase.from('event');
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('getOrganisationFromEvent', () => {
-    it('should return organisation ID when event exists', async () => {
-      const eventId = 'event-123';
-      const organisationId = 'org-456';
-      
-      mockQuery.single.mockResolvedValue({
-        data: { organisation_id: organisationId },
-        error: null
-      });
-
-      const result = await getOrganisationFromEvent(mockSupabase, eventId);
-
-      expect(result).toBe(organisationId);
-      expect(mockSupabase.from).toHaveBeenCalledWith('event');
-      expect(mockQuery.select).toHaveBeenCalledWith('organisation_id');
-      expect(mockQuery.eq).toHaveBeenCalledWith('event_id', eventId);
-      expect(mockQuery.single).toHaveBeenCalled();
-    });
-
-    it('should return null when event does not exist', async () => {
-      const eventId = 'nonexistent-event';
-      
-      mockQuery.single.mockResolvedValue({
-        data: null,
-        error: { message: 'Event not found' }
-      });
-
-      const result = await getOrganisationFromEvent(mockSupabase, eventId);
-
-      expect(result).toBeNull();
-    });
-
-    it('should return null when data is null', async () => {
-      const eventId = 'event-123';
-      
-      mockQuery.single.mockResolvedValue({
-        data: null,
-        error: null
-      });
-
-      const result = await getOrganisationFromEvent(mockSupabase, eventId);
-
-      expect(result).toBeNull();
-    });
-
-    it('should handle database errors gracefully', async () => {
-      const eventId = 'event-123';
-      const dbError = new Error('Database connection failed');
-      
-      mockQuery.single.mockRejectedValue(dbError);
-
-      await expect(getOrganisationFromEvent(mockSupabase, eventId))
-        .rejects.toThrow('Database connection failed');
-    });
-
-    it('should handle empty organisation_id', async () => {
-      const eventId = 'event-123';
-      
-      mockQuery.single.mockResolvedValue({
-        data: { organisation_id: null },
-        error: null
-      });
-
-      const result = await getOrganisationFromEvent(mockSupabase, eventId);
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('createScopeFromEvent', () => {
-    it('should create complete scope when event exists', async () => {
-      const eventId = 'event-123';
-      const organisationId = 'org-456';
-      const appId = 'app-789';
-      
-      mockQuery.single.mockResolvedValue({
-        data: { organisation_id: organisationId },
-        error: null
-      });
-
-      const result = await createScopeFromEvent(mockSupabase, eventId, appId);
-
-      expect(result).toEqual({
-        organisationId,
-        eventId,
-        appId
-      });
-    });
-
-    it('should create scope without appId when not provided', async () => {
-      const eventId = 'event-123';
-      const organisationId = 'org-456';
-      
-      mockQuery.single.mockResolvedValue({
-        data: { organisation_id: organisationId },
-        error: null
-      });
-
-      const result = await createScopeFromEvent(mockSupabase, eventId);
-
-      expect(result).toEqual({
-        organisationId,
-        eventId,
-        appId: undefined
-      });
-    });
-
-    it('should return null when event does not exist', async () => {
-      const eventId = 'nonexistent-event';
-      
-      mockQuery.single.mockResolvedValue({
-        data: null,
-        error: { message: 'Event not found' }
-      });
-
-      const result = await createScopeFromEvent(mockSupabase, eventId);
-
-      expect(result).toBeNull();
-    });
-
-    it('should return null when organisation lookup fails', async () => {
-      const eventId = 'event-123';
-      
-      mockQuery.single.mockResolvedValue({
-        data: { organisation_id: null },
-        error: null
-      });
-
-      const result = await createScopeFromEvent(mockSupabase, eventId);
-
-      expect(result).toBeNull();
-    });
-
-    it('should handle database errors gracefully', async () => {
-      const eventId = 'event-123';
-      const dbError = new Error('Database connection failed');
-      
-      mockQuery.single.mockRejectedValue(dbError);
-
-      await expect(createScopeFromEvent(mockSupabase, eventId))
-        .rejects.toThrow('Database connection failed');
-    });
-  });
-
-  describe('isEventBasedScope', () => {
-    it('should return true for event-based scope (no organisationId, has eventId)', () => {
-      const scope: Scope = {
-        eventId: 'event-123',
-        appId: 'app-456'
-      };
-
-      expect(isEventBasedScope(scope)).toBe(true);
-    });
-
-    it('should return false when organisationId is present', () => {
-      const scope: Scope = {
-        organisationId: 'org-123',
-        eventId: 'event-123',
-        appId: 'app-456'
-      };
-
-      expect(isEventBasedScope(scope)).toBe(false);
-    });
-
-    it('should return false when eventId is missing', () => {
-      const scope: Scope = {
-        appId: 'app-456'
-      };
-
-      expect(isEventBasedScope(scope)).toBe(false);
-    });
-
-    it('should return false when both organisationId and eventId are missing', () => {
-      const scope: Scope = {
-        appId: 'app-456'
-      };
-
-      expect(isEventBasedScope(scope)).toBe(false);
-    });
-
-    it('should return false when eventId is null', () => {
-      const scope: Scope = {
-        eventId: null,
-        appId: 'app-456'
-      };
-
-      expect(isEventBasedScope(scope)).toBe(false);
-    });
-
-    it('should return false when eventId is undefined', () => {
-      const scope: Scope = {
-        eventId: undefined,
-        appId: 'app-456'
-      };
-
-      expect(isEventBasedScope(scope)).toBe(false);
-    });
-  });
-
-  describe('isValidEventBasedScope', () => {
-    it('should return true for valid event-based scope', () => {
-      const scope: Scope = {
-        eventId: 'event-123',
-        appId: 'app-456'
-      };
-
-      expect(isValidEventBasedScope(scope)).toBe(true);
-    });
-
-    it('should return false when eventId is missing', () => {
-      const scope: Scope = {
-        appId: 'app-456'
-      };
-
-      expect(isValidEventBasedScope(scope)).toBe(false);
-    });
-
-    it('should return false when eventId is null', () => {
-      const scope: Scope = {
-        eventId: null,
-        appId: 'app-456'
-      };
-
-      expect(isValidEventBasedScope(scope)).toBe(false);
-    });
-
-    it('should return false when eventId is undefined', () => {
-      const scope: Scope = {
-        eventId: undefined,
-        appId: 'app-456'
-      };
-
-      expect(isValidEventBasedScope(scope)).toBe(false);
-    });
-
-    it('should return false when organisationId is present (not event-based)', () => {
-      const scope: Scope = {
-        organisationId: 'org-123',
-        eventId: 'event-123',
-        appId: 'app-456'
-      };
-
-      expect(isValidEventBasedScope(scope)).toBe(false);
-    });
-
-    it('should return true for event-based scope without appId', () => {
-      const scope: Scope = {
-        eventId: 'event-123'
-      };
-
-      expect(isValidEventBasedScope(scope)).toBe(true);
-    });
-  });
-
-  describe('Edge Cases and Error Handling', () => {
-    it('should handle malformed event IDs', async () => {
-      const malformedEventId = '';
-      
-      mockQuery.single.mockResolvedValue({
-        data: null,
-        error: { message: 'Invalid event ID' }
-      });
-
-      const result = await getOrganisationFromEvent(mockSupabase, malformedEventId);
-
-      expect(result).toBeNull();
-    });
-
-    it('should handle very long event IDs', async () => {
-      const longEventId = 'a'.repeat(1000);
-      const organisationId = 'org-456';
-      
-      mockQuery.single.mockResolvedValue({
-        data: { organisation_id: organisationId },
-        error: null
-      });
-
-      const result = await getOrganisationFromEvent(mockSupabase, longEventId);
-
-      expect(result).toBe(organisationId);
-      expect(mockQuery.eq).toHaveBeenCalledWith('event_id', longEventId);
-    });
-
-    it('should handle special characters in event IDs', async () => {
-      const specialEventId = 'event-123!@#$%^&*()';
-      const organisationId = 'org-456';
-      
-      mockQuery.single.mockResolvedValue({
-        data: { organisation_id: organisationId },
-        error: null
-      });
-
-      const result = await getOrganisationFromEvent(mockSupabase, specialEventId);
-
-      expect(result).toBe(organisationId);
-      expect(mockQuery.eq).toHaveBeenCalledWith('event_id', specialEventId);
-    });
-
-    it('should handle concurrent calls to getOrganisationFromEvent', async () => {
-      const eventId1 = 'event-123';
-      const eventId2 = 'event-456';
-      const organisationId1 = 'org-123';
-      const organisationId2 = 'org-456';
-      
-      mockQuery.single
-        .mockResolvedValueOnce({
-          data: { organisation_id: organisationId1 },
-          error: null
-        })
-        .mockResolvedValueOnce({
-          data: { organisation_id: organisationId2 },
-          error: null
-        });
-
-      const [result1, result2] = await Promise.all([
-        getOrganisationFromEvent(mockSupabase, eventId1),
-        getOrganisationFromEvent(mockSupabase, eventId2)
-      ]);
-
-      expect(result1).toBe(organisationId1);
-      expect(result2).toBe(organisationId2);
-    });
-
-    it('should handle concurrent calls to createScopeFromEvent', async () => {
-      const eventId1 = 'event-123';
-      const eventId2 = 'event-456';
-      const organisationId1 = 'org-123';
-      const organisationId2 = 'org-456';
-      const appId1 = 'app-123';
-      const appId2 = 'app-456';
-      
-      mockQuery.single
-        .mockResolvedValueOnce({
-          data: { organisation_id: organisationId1 },
-          error: null
-        })
-        .mockResolvedValueOnce({
-          data: { organisation_id: organisationId2 },
-          error: null
-        });
-
-      const [result1, result2] = await Promise.all([
-        createScopeFromEvent(mockSupabase, eventId1, appId1),
-        createScopeFromEvent(mockSupabase, eventId2, appId2)
-      ]);
-
-      expect(result1).toEqual({
-        organisationId: organisationId1,
-        eventId: eventId1,
-        appId: appId1
-      });
-      expect(result2).toEqual({
-        organisationId: organisationId2,
-        eventId: eventId2,
-        appId: appId2
-      });
-    });
-  });
-
-  describe('Type Safety', () => {
-    it('should handle UUID types correctly', () => {
-      const validUUID = '123e4567-e89b-12d3-a456-426614174000';
-      const scope: Scope = {
-        eventId: validUUID,
-        appId: validUUID
-      };
-
-      expect(isValidEventBasedScope(scope)).toBe(true);
-    });
-
-    it('should handle string types correctly', () => {
-      const stringId = 'event-123';
-      const scope: Scope = {
-        eventId: stringId,
-        appId: 'app-456'
-      };
-
-      expect(isValidEventBasedScope(scope)).toBe(true);
-    });
-  });
-});