@jmruthers/pace-core 0.5.67 → 0.5.69

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

@@ -0,0 +1,477 @@
+/**
+ * @file Service Providers Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Providers/__tests__
+ * @since 0.1.0
+ *
+ * Unit tests for service provider components.
+ * Tests React context providers and service instantiation.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import React from 'react';
+import { AuthServiceProvider, useAuthService } from '../services/AuthServiceProvider';
+import { RBACServiceProvider, useRBACService } from '../services/RBACServiceProvider';
+import { OrganisationServiceProvider, useOrganisationService } from '../services/OrganisationServiceProvider';
+import { EventServiceProvider, useEventService } from '../services/EventServiceProvider';
+import { InactivityServiceProvider, useInactivityService } from '../services/InactivityServiceProvider';
+
+// 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'
+};
+
+// Test components for each service
+const AuthTestComponent = () => {
+  const authService = useAuthService();
+  return <div data-testid="service">{authService ? 'Service Available' : 'No Service'}</div>;
+};
+
+const RBACTestComponent = () => {
+  const rbacService = useRBACService();
+  return <div data-testid="service">{rbacService ? 'Service Available' : 'No Service'}</div>;
+};
+
+const OrganisationTestComponent = () => {
+  const organisationService = useOrganisationService();
+  return <div data-testid="service">{organisationService ? 'Service Available' : 'No Service'}</div>;
+};
+
+const EventTestComponent = () => {
+  const eventService = useEventService();
+  return <div data-testid="service">{eventService ? 'Service Available' : 'No Service'}</div>;
+};
+
+const InactivityTestComponent = () => {
+  const inactivityService = useInactivityService();
+  return <div data-testid="service">{inactivityService ? 'Service Available' : 'No Service'}</div>;
+};
+
+describe('Service Providers', () => {
+  let mockSupabase: ReturnType<typeof createMockSupabaseClient>;
+
+  beforeEach(() => {
+    mockSupabase = createMockSupabaseClient();
+    vi.clearAllMocks();
+  });
+
+  describe('AuthServiceProvider', () => {
+    it('should provide AuthService to children', () => {
+      render(
+        <AuthServiceProvider supabaseClient={mockSupabase as any}>
+          <AuthTestComponent />
+        </AuthServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should create new service instance when supabaseClient changes', () => {
+      const { rerender } = render(
+        <AuthServiceProvider supabaseClient={mockSupabase as any}>
+          <AuthTestComponent />
+        </AuthServiceProvider>
+      );
+
+      const newMockSupabase = createMockSupabaseClient();
+      rerender(
+        <AuthServiceProvider supabaseClient={newMockSupabase as any}>
+          <AuthTestComponent />
+        </AuthServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should cleanup service on unmount', () => {
+      const { unmount } = render(
+        <AuthServiceProvider supabaseClient={mockSupabase as any}>
+          <AuthTestComponent />
+        </AuthServiceProvider>
+      );
+
+      unmount();
+      // Service should be cleaned up (tested indirectly through cleanup calls)
+    });
+  });
+
+  describe('RBACServiceProvider', () => {
+    it('should provide RBACService to children', () => {
+      render(
+        <RBACServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+          appName="test-app"
+          enableRBAC={true}
+        >
+          <RBACTestComponent />
+        </RBACServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should create new service instance when dependencies change', () => {
+      const { rerender } = render(
+        <RBACServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+          appName="test-app"
+          enableRBAC={true}
+        >
+          <RBACTestComponent />
+        </RBACServiceProvider>
+      );
+
+      const newUser = { ...mockUser, id: 'user-2' };
+      rerender(
+        <RBACServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={newUser}
+          session={mockSession}
+          appName="test-app"
+          enableRBAC={true}
+        >
+          <RBACTestComponent />
+        </RBACServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should handle missing user gracefully', () => {
+      render(
+        <RBACServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={null}
+          session={null}
+          appName="test-app"
+          enableRBAC={true}
+        >
+          <RBACTestComponent />
+        </RBACServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+  });
+
+  describe('OrganisationServiceProvider', () => {
+    it('should provide OrganisationService to children', () => {
+      render(
+        <OrganisationServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+        >
+          <OrganisationTestComponent />
+        </OrganisationServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should create new service instance when dependencies change', () => {
+      const { rerender } = render(
+        <OrganisationServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+        >
+          <OrganisationTestComponent />
+        </OrganisationServiceProvider>
+      );
+
+      const newUser = { ...mockUser, id: 'user-2' };
+      rerender(
+        <OrganisationServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={newUser}
+          session={mockSession}
+        >
+          <OrganisationTestComponent />
+        </OrganisationServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should handle missing user gracefully', () => {
+      render(
+        <OrganisationServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={null}
+          session={null}
+        >
+          <OrganisationTestComponent />
+        </OrganisationServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+  });
+
+  describe('EventServiceProvider', () => {
+    it('should provide EventService to children', () => {
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+          appName="test-app"
+          selectedOrganisation={mockOrganisation}
+          organisationService={{} as any}
+          rbacService={{} as any}
+        >
+          <EventTestComponent />
+        </EventServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should create new service instance when dependencies change', () => {
+      const { rerender } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+          appName="test-app"
+          selectedOrganisation={mockOrganisation}
+          organisationService={{} as any}
+          rbacService={{} as any}
+        >
+          <EventTestComponent />
+        </EventServiceProvider>
+      );
+
+      const newOrganisation = { ...mockOrganisation, id: 'org-2' };
+      rerender(
+        <EventServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+          appName="test-app"
+          selectedOrganisation={newOrganisation}
+          organisationService={{} as any}
+          rbacService={{} as any}
+        >
+          <EventTestComponent />
+        </EventServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should handle missing organisation gracefully', () => {
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+          appName="test-app"
+          selectedOrganisation={null}
+          organisationService={{} as any}
+          rbacService={{} as any}
+        >
+          <EventTestComponent />
+        </EventServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+  });
+
+  describe('InactivityServiceProvider', () => {
+    it('should provide InactivityService to children', () => {
+      render(
+        <InactivityServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+          idleTimeoutMs={300000}
+          warnBeforeMs={60000}
+          onIdleLogout={() => {}}
+          dangerouslyDisableInactivity={false}
+        >
+          <InactivityTestComponent />
+        </InactivityServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should create new service instance when dependencies change', () => {
+      const { rerender } = render(
+        <InactivityServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+          idleTimeoutMs={300000}
+          warnBeforeMs={60000}
+          onIdleLogout={() => {}}
+          dangerouslyDisableInactivity={false}
+        >
+          <InactivityTestComponent />
+        </InactivityServiceProvider>
+      );
+
+      rerender(
+        <InactivityServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+          idleTimeoutMs={600000} // Changed timeout
+          warnBeforeMs={120000}   // Changed warning time
+          onIdleLogout={() => {}}
+          dangerouslyDisableInactivity={false}
+        >
+          <InactivityTestComponent />
+        </InactivityServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should handle missing user gracefully', () => {
+      render(
+        <InactivityServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={null}
+          session={null}
+          idleTimeoutMs={300000}
+          warnBeforeMs={60000}
+          onIdleLogout={() => {}}
+          dangerouslyDisableInactivity={false}
+        >
+          <InactivityTestComponent />
+        </InactivityServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should handle missing onIdleLogout callback', () => {
+      render(
+        <InactivityServiceProvider
+          supabaseClient={mockSupabase as any}
+          user={mockUser}
+          session={mockSession}
+          idleTimeoutMs={300000}
+          warnBeforeMs={60000}
+          onIdleLogout={undefined}
+          dangerouslyDisableInactivity={false}
+        >
+          <InactivityTestComponent />
+        </InactivityServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+  });
+
+  describe('Provider Composition', () => {
+    it('should work with multiple providers', () => {
+      render(
+        <AuthServiceProvider supabaseClient={mockSupabase as any}>
+          <RBACServiceProvider
+            supabaseClient={mockSupabase as any}
+            user={mockUser}
+            session={mockSession}
+            appName="test-app"
+            enableRBAC={true}
+          >
+            <OrganisationServiceProvider
+              supabaseClient={mockSupabase as any}
+              user={mockUser}
+              session={mockSession}
+            >
+              <AuthTestComponent />
+            </OrganisationServiceProvider>
+          </RBACServiceProvider>
+        </AuthServiceProvider>
+      );
+
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should handle provider unmounting gracefully', () => {
+      const { unmount } = render(
+        <AuthServiceProvider supabaseClient={mockSupabase as any}>
+          <RBACServiceProvider
+            supabaseClient={mockSupabase as any}
+            user={mockUser}
+            session={mockSession}
+            appName="test-app"
+            enableRBAC={true}
+          >
+            <AuthTestComponent />
+          </RBACServiceProvider>
+        </AuthServiceProvider>
+      );
+
+      unmount();
+      // Should not throw errors during unmount
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle service creation errors gracefully', () => {
+      // Mock service constructor to throw error
+      const errorSupabase = {
+        ...mockSupabase,
+        auth: {
+          ...mockSupabase.auth,
+          getSession: vi.fn().mockRejectedValue(new Error('Service creation error'))
+        }
+      };
+
+      render(
+        <AuthServiceProvider supabaseClient={errorSupabase as any}>
+          <AuthTestComponent />
+        </AuthServiceProvider>
+      );
+
+      // Should still render without crashing
+      expect(screen.getByTestId('service')).toHaveTextContent('Service Available');
+    });
+
+    it('should handle missing context gracefully', () => {
+      // This should throw an error because there's no provider
+      expect(() => {
+        render(<AuthTestComponent />);
+      }).toThrow('useAuthService must be used within AuthServiceProvider');
+    });
+  });
+});