@jmruthers/pace-core 0.5.53 → 0.5.55

package/src/providers/UnifiedAuthProvider.test.tsx

@@ -0,0 +1,128 @@
+/**
+ * @file Simplified Unified Authentication Provider Tests
+ * @package @jmruthers/pace-core
+ * @module Providers/UnifiedAuthProvider
+ * @since 0.1.0
+ * 
+ * Basic tests for the UnifiedAuthProvider component.
+ */
+
+import { render, screen } from '@testing-library/react';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import { ReactNode } from 'react';
+import { UnifiedAuthProvider, useUnifiedAuth } from './UnifiedAuthProvider';
+
+// Mock all the child providers with minimal implementations
+vi.mock('./AuthProvider', () => ({
+  AuthProvider: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  useAuth: () => ({
+    user: { id: 'test-user', email: 'test@example.com' },
+    session: { access_token: 'test-token' },
+    authLoading: false,
+    authError: null,
+    signIn: vi.fn(),
+    signUp: vi.fn(),
+    signOut: vi.fn(),
+    resetPassword: vi.fn(),
+    isAuthenticated: true,
+    supabase: {}
+  })
+}));
+
+vi.mock('../rbac/providers/RBACProvider', () => ({
+  RBACProvider: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  useRBAC: () => ({
+    rbacLoading: false,
+    rbacError: null,
+    hasPermission: vi.fn().mockReturnValue(true),
+    hasRole: vi.fn().mockReturnValue(true),
+    hasAccessLevel: vi.fn().mockReturnValue(true),
+    validatePermission: vi.fn().mockResolvedValue(true),
+    canAccess: vi.fn().mockReturnValue(true),
+    getAccessLevel: vi.fn().mockReturnValue('admin'),
+    setSelectedEventId: vi.fn(),
+    permissions: { 'read:users': true },
+    roles: ['admin'],
+    accessLevel: 'admin',
+    selectedEventId: null,
+    appConfig: null,
+    userEventAccess: [],
+    eventAccessLoading: false,
+    selectedOrganisationId: 'org-123',
+    requireOrganisationContext: vi.fn().mockReturnValue('org-123'),
+    hasAnyPermission: vi.fn().mockReturnValue(true),
+    hasAllPermissions: vi.fn().mockReturnValue(true),
+    validateAccess: vi.fn().mockResolvedValue(true),
+    refreshPermissions: vi.fn().mockResolvedValue(undefined),
+    loadUserEventAccess: vi.fn().mockResolvedValue(undefined),
+    getUserEventAccess: vi.fn().mockReturnValue(undefined)
+  })
+}));
+
+vi.mock('./InactivityProvider', () => ({
+  InactivityProvider: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  useInactivity: () => ({
+    isIdle: false,
+    timeRemaining: 30 * 60 * 1000,
+    showWarning: false,
+    staySignedIn: vi.fn(),
+    signOutNow: vi.fn()
+  })
+}));
+
+// Mock Supabase client
+const mockSupabase = {
+  auth: {
+    getUser: vi.fn().mockResolvedValue({ data: { user: null }, error: null }),
+    getSession: vi.fn().mockResolvedValue({ data: { session: null }, error: null }),
+    onAuthStateChange: vi.fn().mockReturnValue({ data: { subscription: { unsubscribe: vi.fn() } } })
+  }
+};
+
+describe('UnifiedAuthProvider', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Basic Functionality', () => {
+    it('renders without crashing', () => {
+      render(
+        <UnifiedAuthProvider supabaseClient={mockSupabase as any} appName="test-app">
+          <div data-testid="test-content">Test Content</div>
+        </UnifiedAuthProvider>
+      );
+
+      expect(screen.getByTestId('test-content')).toBeInTheDocument();
+    });
+
+    it('provides context without errors', () => {
+      const TestConsumer = () => {
+        const context = useUnifiedAuth();
+        // Just verify context exists without checking specific values
+        expect(context).toBeDefined();
+        return <div data-testid="context-consumer">Context Available</div>;
+      };
+
+      render(
+        <UnifiedAuthProvider supabaseClient={mockSupabase as any} appName="test-app">
+          <TestConsumer />
+        </UnifiedAuthProvider>
+      );
+
+      expect(screen.getByTestId('context-consumer')).toBeInTheDocument();
+    });
+
+    it('renders children correctly', () => {
+      render(
+        <UnifiedAuthProvider supabaseClient={mockSupabase as any} appName="test-app">
+          <div data-testid="child-1">Child 1</div>
+          <div data-testid="child-2">Child 2</div>
+        </UnifiedAuthProvider>
+      );
+
+      expect(screen.getByTestId('child-1')).toBeInTheDocument();
+      expect(screen.getByTestId('child-2')).toBeInTheDocument();
+    });
+  });
+
+});

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

@@ -509,9 +509,8 @@ describe('InactivityProvider', () => {
     it('warns about disabling inactivity in production', () => {
       const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
       
-      // Mock production environment
-      const originalEnv = process.env.NODE_ENV;
-      process.env.NODE_ENV = 'production';
+      // Mock production environment using vi.stubEnv
+      vi.stubEnv('MODE', 'production');
 
       render(
         <TestWrapper dangerouslyDisableInactivity={true}>
@@ -524,7 +523,7 @@ describe('InactivityProvider', () => {
       );
 
       // Restore environment
-      process.env.NODE_ENV = originalEnv;
+      vi.unstubAllEnvs();
       consoleErrorSpy.mockRestore();
     });
 

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

@@ -178,27 +178,32 @@ describe('OrganisationProvider', () => {
     // Create mock Supabase client
     mockSupabaseClient = createMockSupabaseClient();
     mockSupabaseClient.from = vi.fn((table: string) => {
-      // Return different responses based on the table
-      if (table === 'organisation_memberships') {
-        return {
+      // Create a mock query builder that handles the chained calls
+      const createMockQueryBuilder = (data: any) => {
+        const queryBuilder = {
           select: vi.fn().mockReturnThis(),
           eq: vi.fn().mockReturnThis(),
           is: vi.fn().mockReturnThis(),
-          in: vi.fn().mockResolvedValue({
-            data: mockMemberships,
-            error: null
+          in: vi.fn().mockReturnThis(),
+          order: vi.fn().mockReturnThis(),
+          limit: vi.fn().mockReturnThis(),
+          single: vi.fn().mockResolvedValue({ data: data[0] || null, error: null }),
+          maybeSingle: vi.fn().mockResolvedValue({ data: data[0] || null, error: null }),
+          // Make it thenable
+          then: vi.fn().mockImplementation((resolve) => {
+            resolve({ data, error: null });
           }),
         };
+        return queryBuilder;
+      };
+
+      // Return different responses based on the table
+      if (table === 'rbac_organisation_roles') {
+        return createMockQueryBuilder(mockMemberships);
       } else if (table === 'organisations') {
-        return {
-          select: vi.fn().mockReturnThis(),
-          in: vi.fn().mockResolvedValue({
-            data: mockOrganisations,
-            error: null
-          }),
-        };
+        return createMockQueryBuilder(mockOrganisations);
       }
-      return mockQueryBuilder;
+      return createMockQueryBuilder([]);
     });
     
     // Mock auth state

package/src/rbac/__tests__/integration.authflow.test.tsx

@@ -0,0 +1,123 @@
+import React from 'react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { createMemoryRouter, RouterProvider } from 'react-router-dom';
+import { UnifiedAuthProvider } from '../../providers/UnifiedAuthProvider';
+import { OrganisationProvider } from '../../providers/OrganisationProvider';
+import { RBACProvider } from '../providers/RBACProvider';
+import { useRBAC } from '../hooks/useRBAC';
+import type { SupabaseClient, User } from '@supabase/supabase-js';
+
+const mockSupabaseClient = {
+  auth: {
+    getUser: vi.fn(),
+  },
+} as unknown as SupabaseClient;
+
+// Local lightweight mocks to avoid importing heavy RBAC modules during bisect
+vi.mock('../hooks/useRBAC', () => ({
+  useRBAC: () => ({
+    user: { email: 'test@example.com' },
+    isAuthenticated: true,
+    isLoading: false,
+  }),
+}));
+
+vi.mock('../providers/RBACProvider', () => ({
+  RBACProvider: ({ children }: any) => children,
+}));
+
+const mockUser: User = {
+  id: 'user-123',
+  email: 'test@example.com',
+  created_at: '2023-01-01T00:00:00Z',
+  updated_at: '2023-01-01T00:00:00Z',
+  aud: 'authenticated',
+  role: 'authenticated',
+  app_metadata: {},
+  user_metadata: {},
+  identities: [],
+  factors: [],
+} as User;
+
+const MinimalAuthComponent = () => {
+  const { user, isAuthenticated, isLoading } = useRBAC();
+  if (isLoading) return <div>Loading...</div>;
+  if (!isAuthenticated) return <div>Not authenticated</div>;
+  return (
+    <div>
+      <h1>AuthFlow Minimal</h1>
+      <p>User: {user?.email}</p>
+    </div>
+  );
+};
+
+const Wrapper = ({ children }: { children: React.ReactNode }) => {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+  });
+  return (
+    <QueryClientProvider client={queryClient}>
+      <UnifiedAuthProvider supabase={mockSupabaseClient}>
+        <OrganisationProvider>
+          <RBACProvider>{children}</RBACProvider>
+        </OrganisationProvider>
+      </UnifiedAuthProvider>
+    </QueryClientProvider>
+  );
+};
+
+describe('RBAC AuthFlow Minimal', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSupabaseClient.auth.getUser = vi
+      .fn()
+      .mockResolvedValue({ data: { user: mockUser }, error: null });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('renders authenticated view', async () => {
+    const router = createMemoryRouter([{ path: '/', element: <MinimalAuthComponent /> }]);
+
+    render(
+      <Wrapper>
+        <RouterProvider router={router} />
+      </Wrapper>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText('AuthFlow Minimal')).toBeInTheDocument();
+    });
+    expect(screen.getByText('User: test@example.com')).toBeInTheDocument();
+  });
+
+  it('renders not authenticated view', async () => {
+    const useRBACModule = await import('../hooks/useRBAC');
+    vi.spyOn(useRBACModule, 'useRBAC').mockReturnValue({
+      user: null,
+      isAuthenticated: false,
+      isLoading: false,
+    } as any);
+    mockSupabaseClient.auth.getUser = vi
+      .fn()
+      .mockResolvedValue({ data: { user: null }, error: null });
+
+    const router = createMemoryRouter([{ path: '/', element: <MinimalAuthComponent /> }]);
+
+    render(
+      <Wrapper>
+        <RouterProvider router={router} />
+      </Wrapper>
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText('Not authenticated')).toBeInTheDocument();
+    });
+  });
+});
+
+

package/src/rbac/__tests__/integration.navigation.test.tsx

@@ -0,0 +1,72 @@
+import React from 'react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { createMemoryRouter, RouterProvider } from 'react-router-dom';
+import { UnifiedAuthProvider } from '../../providers/UnifiedAuthProvider';
+import { OrganisationProvider } from '../../providers/OrganisationProvider';
+import { RBACProvider } from '../providers/RBACProvider';
+import { NavigationProvider } from '../components/NavigationProvider';
+import { EnhancedNavigationMenu } from '../components/EnhancedNavigationMenu';
+
+// Local lightweight mocks
+vi.mock('../components/EnhancedNavigationMenu', () => ({
+  EnhancedNavigationMenu: () => (
+    <div>
+      <div>Users</div>
+      <div>Settings</div>
+      <div>Admin</div>
+    </div>
+  ),
+}));
+
+const Wrapper = ({ children }: { children: React.ReactNode }) => {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+  });
+  return (
+    <QueryClientProvider client={queryClient}>
+      <UnifiedAuthProvider supabase={{} as any}>
+        <OrganisationProvider>
+          <RBACProvider>{children}</RBACProvider>
+        </OrganisationProvider>
+      </UnifiedAuthProvider>
+    </QueryClientProvider>
+  );
+};
+
+const NavUnderTest = () => {
+  const navigationItems = [
+    { label: 'Users', path: '/users', permissions: ['read:users'] },
+    { label: 'Settings', path: '/settings', permissions: ['write:users'] },
+    { label: 'Admin', path: '/admin', permissions: ['delete:users'] },
+  ];
+  return (
+    <NavigationProvider navigationItems={navigationItems}>
+      <EnhancedNavigationMenu />
+    </NavigationProvider>
+  );
+};
+
+describe('RBAC Navigation Integration', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+  afterEach(() => vi.restoreAllMocks());
+
+  it('shows all mocked navigation items', async () => {
+    const router = createMemoryRouter([{ path: '/', element: <NavUnderTest /> }]);
+    render(
+      <Wrapper>
+        <RouterProvider router={router} />
+      </Wrapper>
+    );
+    await waitFor(() => {
+      expect(screen.getByText('Users')).toBeInTheDocument();
+      expect(screen.getByText('Settings')).toBeInTheDocument();
+      expect(screen.getByText('Admin')).toBeInTheDocument();
+    });
+  });
+});
+
+

package/src/rbac/__tests__/integration.securedata.test.tsx

@@ -0,0 +1,92 @@
+import React from 'react';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { createMemoryRouter, RouterProvider } from 'react-router-dom';
+import { UnifiedAuthProvider } from '../../providers/UnifiedAuthProvider';
+import { OrganisationProvider } from '../../providers/OrganisationProvider';
+import { RBACProvider } from '../providers/RBACProvider';
+import { useSecureDataAccess } from '../../hooks/useSecureDataAccess';
+
+// Local lightweight mock for secure data access
+vi.mock('../../hooks/useSecureDataAccess', () => ({
+  useSecureDataAccess: () => ({
+    secureDataAccess: {
+      secureQuery: vi.fn().mockResolvedValue([
+        { id: '1', name: 'User 1', email: 'user1@example.com' },
+        { id: '2', name: 'User 2', email: 'user2@example.com' },
+      ]),
+    },
+  }),
+}));
+
+const Wrapper = ({ children }: { children: React.ReactNode }) => {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+  });
+  return (
+    <QueryClientProvider client={queryClient}>
+      <UnifiedAuthProvider supabase={{} as any}>
+        <OrganisationProvider>
+          <RBACProvider>{children}</RBACProvider>
+        </OrganisationProvider>
+      </UnifiedAuthProvider>
+    </QueryClientProvider>
+  );
+};
+
+const SecureDataProbe = () => {
+  const { secureDataAccess: secureData } = useSecureDataAccess();
+  const [data, setData] = React.useState<any[] | null>(null);
+  const [loading, setLoading] = React.useState(false);
+
+  const fetchData = async () => {
+    setLoading(true);
+    const result = await secureData.secureQuery({
+      table: 'users',
+      select: 'id, name, email',
+      organisationId: 'org-123',
+    });
+    setData(result);
+    setLoading(false);
+  };
+
+  return (
+    <div>
+      <button onClick={fetchData} disabled={loading}>
+        {loading ? 'Loading...' : 'Fetch Data'}
+      </button>
+      {data && (
+        <>
+          <div>{data[0]?.name}</div>
+          <div>{data[1]?.name}</div>
+        </>
+      )}
+    </div>
+  );
+};
+
+describe('RBAC Secure Data Integration', () => {
+  beforeEach(() => vi.clearAllMocks());
+  afterEach(() => vi.restoreAllMocks());
+
+  it('fetches data with organisation context via secureQuery', async () => {
+    const router = createMemoryRouter([{ path: '/', element: <SecureDataProbe /> }]);
+    render(
+      <Wrapper>
+        <RouterProvider router={router} />
+      </Wrapper>
+    );
+
+    const user = userEvent.setup();
+    await user.click(screen.getByText('Fetch Data'));
+
+    await waitFor(() => {
+      expect(screen.getByText('User 1')).toBeInTheDocument();
+      expect(screen.getByText('User 2')).toBeInTheDocument();
+    });
+  });
+});
+
+

package/src/rbac/__tests__/integration.smoke.test.tsx

@@ -0,0 +1,73 @@
+import React from 'react';
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { UnifiedAuthProvider } from '../../providers/UnifiedAuthProvider';
+import { OrganisationProvider } from '../../providers/OrganisationProvider';
+import { RBACProvider } from '../providers/RBACProvider';
+import { useCan } from '../hooks';
+
+describe('RBAC Integration Smoke', () => {
+  it('renders trivial component without providers', () => {
+    render(<div>RBAC Smoke OK</div>);
+    expect(screen.getByText('RBAC Smoke OK')).toBeInTheDocument();
+  });
+
+  it('renders with UnifiedAuthProvider only', () => {
+    render(
+      <UnifiedAuthProvider supabase={{} as any}>
+        <div>Auth Only</div>
+      </UnifiedAuthProvider>
+    );
+    expect(screen.getByText('Auth Only')).toBeInTheDocument();
+  });
+
+  it('renders with OrganisationProvider only', () => {
+    render(
+      <OrganisationProvider>
+        <div>Org Only</div>
+      </OrganisationProvider>
+    );
+    expect(screen.getByText('Org Only')).toBeInTheDocument();
+  });
+
+  it('renders with RBACProvider only', () => {
+    render(
+      <RBACProvider>
+        <div>RBAC Only</div>
+      </RBACProvider>
+    );
+    expect(screen.getByText('RBAC Only')).toBeInTheDocument();
+  });
+
+  it('renders full minimal stack without RBAC hooks usage', () => {
+    render(
+      <UnifiedAuthProvider supabase={{} as any}>
+        <OrganisationProvider>
+          <RBACProvider>
+            <div>Full Stack Minimal</div>
+          </RBACProvider>
+        </OrganisationProvider>
+      </UnifiedAuthProvider>
+    );
+    expect(screen.getByText('Full Stack Minimal')).toBeInTheDocument();
+  });
+
+  it('mounts a component that calls useCan() (global mock) without leaking', () => {
+    const Probe = () => {
+      const { hasPermission } = useCan() as any;
+      return <div>{hasPermission('read:users') ? 'HasPerm' : 'NoPerm'}</div>;
+    };
+    render(
+      <UnifiedAuthProvider supabase={{} as any}>
+        <OrganisationProvider>
+          <RBACProvider>
+            <Probe />
+          </RBACProvider>
+        </OrganisationProvider>
+      </UnifiedAuthProvider>
+    );
+    expect(screen.getByText('HasPerm')).toBeInTheDocument();
+  });
+});
+
+