@jmruthers/pace-core 0.6.10 → 0.6.12

package/src/providers/services/EventServiceProvider.test.tsx

@@ -0,0 +1,844 @@
+/**
+ * @file Event Service Provider Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Providers/Services
+ * @since 0.1.0
+ *
+ * Comprehensive unit tests for EventServiceProvider component covering:
+ * - Context provision and access
+ * - Service instance creation and reuse
+ * - Dependency updates (user, session, organisation changes)
+ * - Initialization and cleanup lifecycle
+ * - Error handling during initialization
+ * - Conditional initialization (only when user/session available)
+ */
+
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { EventServiceProvider } from './EventServiceProvider';
+import { EventServiceContext } from './EventServiceContext';
+import { EventService } from '../../services/EventService';
+import type { User, Session } from '@supabase/supabase-js';
+import type { Organisation } from '../../types/organisation';
+
+// Following testing standards: use timeout parameter to prevent hanging
+const TEST_TIMEOUT = 10000; // 10 seconds per test
+
+const mockEventServiceInstanceRef = vi.hoisted(() => ({ current: null as any }));
+
+vi.mock('../../services/EventService', () => ({
+  EventService: vi.fn(function EventService(this: any) {
+    return mockEventServiceInstanceRef.current;
+  }),
+}));
+vi.mock('../../utils/core/logger', () => ({
+  logger: {
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+    info: vi.fn(),
+  },
+}));
+
+// Mock Supabase client
+const createMockSupabaseClient = () => ({
+  auth: {
+    getSession: vi.fn().mockResolvedValue({ data: { session: null }, error: null }),
+  },
+});
+
+// Test component that uses the context
+const TestComponent = () => {
+  const context = React.useContext(EventServiceContext);
+  
+  if (!context) {
+    return <section data-testid="no-context">No context</section>;
+  }
+  
+  return (
+    <section data-testid="test-component">
+      <p data-testid="has-service">{context.eventService ? 'true' : 'false'}</p>
+    </section>
+  );
+};
+
+describe('EventServiceProvider', () => {
+  let mockSupabaseClient: ReturnType<typeof createMockSupabaseClient>;
+  let mockEventService: any;
+  let mockUser: User;
+  let mockSession: Session;
+  let mockOrganisation: Organisation;
+  let mockSetSelectedEventId: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSupabaseClient = createMockSupabaseClient();
+    mockSetSelectedEventId = vi.fn();
+    
+    mockUser = {
+      id: 'user-123',
+      email: 'test@example.com',
+    } as User;
+    
+    mockSession = {
+      access_token: 'token',
+      refresh_token: 'refresh',
+      expires_in: 3600,
+      expires_at: Date.now() + 3600000,
+      token_type: 'bearer',
+      user: mockUser,
+    } as Session;
+    
+    mockOrganisation = {
+      id: 'org-123',
+      name: 'Test Org',
+      organisation_id: 'org-123',
+    } as Organisation;
+    
+    // Create mock EventService instance
+    mockEventService = {
+      initialize: vi.fn().mockResolvedValue(undefined),
+      cleanup: vi.fn(),
+      updateDependencies: vi.fn().mockResolvedValue(undefined),
+    };
+    
+    // Mock EventService constructor
+    mockEventServiceInstanceRef.current = mockEventService;
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Context Provision', () => {
+    it('should provide event service context to children', () => {
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      expect(screen.getByTestId('has-service')).toHaveTextContent('true');
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Service Instance Management', () => {
+    it('should create service instance once', () => {
+      const { rerender } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      expect(EventService).toHaveBeenCalledTimes(1);
+
+      // Rerender with same props - should not create new instance
+      rerender(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      expect(EventService).toHaveBeenCalledTimes(1);
+    }, TEST_TIMEOUT);
+
+    it('should pass all dependencies to service constructor', () => {
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      expect(EventService).toHaveBeenCalledWith(
+        mockSupabaseClient,
+        mockUser,
+        mockSession,
+        'TestApp',
+        mockOrganisation,
+        mockSetSelectedEventId
+      );
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Dependency Updates', () => {
+    it('should update dependencies when user changes', async () => {
+      const { rerender } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      const newUser = { ...mockUser, id: 'user-456' };
+      rerender(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={newUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+
+    it('should update dependencies when session changes', async () => {
+      const { rerender } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      const newSession = { ...mockSession, access_token: 'new-token' };
+      rerender(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={newSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+
+    it('should update dependencies when organisation changes', async () => {
+      const { rerender } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      const newOrganisation = { ...mockOrganisation, id: 'org-456' };
+      rerender(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={newOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Initialization and Cleanup', () => {
+    it('should initialize service when user and session are available', async () => {
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+        expect(mockEventService.initialize).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+
+    it('should not initialize service when user is missing', async () => {
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={null}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+
+      // Should not initialize without user
+      expect(mockEventService.initialize).not.toHaveBeenCalled();
+    }, TEST_TIMEOUT);
+
+    it('should not initialize service when session is missing', async () => {
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={null}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+
+      // Should not initialize without session
+      expect(mockEventService.initialize).not.toHaveBeenCalled();
+    }, TEST_TIMEOUT);
+
+    it('should cleanup service on unmount', () => {
+      const { unmount } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      unmount();
+
+      expect(mockEventService.cleanup).toHaveBeenCalledTimes(1);
+    }, TEST_TIMEOUT);
+
+    it('should handle initialization errors gracefully', async () => {
+      const initError = new Error('Initialization failed');
+      mockEventService.initialize.mockRejectedValue(initError);
+
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.initialize).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+
+      // Should not crash - error is logged but component continues
+      expect(screen.getByTestId('test-component')).toBeInTheDocument();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Concurrent Initialization Prevention', () => {
+    it('should prevent concurrent initialization', async () => {
+      // Make updateDependencies slow to simulate concurrent calls
+      let resolveUpdate: () => void;
+      const updatePromise = new Promise<void>((resolve) => {
+        resolveUpdate = resolve;
+      });
+      mockEventService.updateDependencies.mockReturnValue(updatePromise);
+
+      const { rerender } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      // Trigger another update before first completes
+      rerender(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={{ ...mockUser, id: 'user-456' }}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      // Resolve the first update
+      resolveUpdate!();
+
+      await waitFor(() => {
+        // Should only initialize once (second call should be prevented)
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+  });
+
+  describe('AppName Changes', () => {
+    it('should update dependencies when appName changes', async () => {
+      const { rerender } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="App1"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+
+      // Clear previous calls
+      vi.clearAllMocks();
+
+      rerender(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="App2"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalledWith(
+          mockSupabaseClient,
+          mockUser,
+          mockSession,
+          'App2',
+          mockOrganisation,
+          mockSetSelectedEventId
+        );
+      }, { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+  });
+
+  describe('setSelectedEventId Callback', () => {
+    it('should handle setSelectedEventId callback changes', async () => {
+      const firstCallback = vi.fn();
+      const { rerender } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={firstCallback}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+
+      // Clear previous calls
+      vi.clearAllMocks();
+
+      const secondCallback = vi.fn();
+      rerender(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={secondCallback}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalledWith(
+          mockSupabaseClient,
+          mockUser,
+          mockSession,
+          'TestApp',
+          mockOrganisation,
+          secondCallback
+        );
+      }, { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+
+    it('should handle setSelectedEventId being undefined', async () => {
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={undefined as any}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+
+      // Should not crash
+      expect(screen.getByTestId('test-component')).toBeInTheDocument();
+    }, TEST_TIMEOUT);
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle missing children gracefully', () => {
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          {null}
+        </EventServiceProvider>
+      );
+
+      // Should not crash
+      expect(mockEventService.updateDependencies).toHaveBeenCalled();
+    }, TEST_TIMEOUT);
+
+    it('should handle updateDependencies errors gracefully', async () => {
+      const updateError = new Error('Update failed');
+      mockEventService.updateDependencies.mockRejectedValue(updateError);
+
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+
+      // Should not crash - error is handled
+      expect(screen.getByTestId('test-component')).toBeInTheDocument();
+    }, TEST_TIMEOUT);
+
+    it('should handle null selectedOrganisation', async () => {
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={null}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalledWith(
+          mockSupabaseClient,
+          mockUser,
+          mockSession,
+          'TestApp',
+          null,
+          mockSetSelectedEventId
+        );
+      }, { timeout: TEST_TIMEOUT });
+
+      // Should still initialize if user, session, supabaseClient, and appName are present
+      // (selectedOrganisation is not required for initialization)
+      await waitFor(() => {
+        expect(mockEventService.initialize).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+
+    it('should handle missing appName', async () => {
+      render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName=""
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+
+      // Should not initialize without appName
+      expect(mockEventService.initialize).not.toHaveBeenCalled();
+    }, TEST_TIMEOUT);
+
+    it('should prevent concurrent initialization using initializingRef', async () => {
+      // Make updateDependencies slow to simulate concurrent calls
+      let resolveUpdate: () => void;
+      const updatePromise = new Promise<void>((resolve) => {
+        resolveUpdate = resolve;
+      });
+      mockEventService.updateDependencies.mockReturnValue(updatePromise);
+
+      const { rerender } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      // Trigger another update before first completes
+      rerender(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={{ ...mockUser, id: 'user-456' }}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      // Resolve the first update
+      resolveUpdate!();
+
+      await waitFor(() => {
+        // Should have called updateDependencies
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+
+      // Should only initialize once (second call should be prevented by initializingRef)
+      await waitFor(() => {
+        expect(mockEventService.initialize).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+
+    it('should cleanup service on unmount', () => {
+      const { unmount } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      unmount();
+
+      expect(mockEventService.cleanup).toHaveBeenCalledTimes(1);
+    }, TEST_TIMEOUT);
+
+    it('should cleanup service when unmounting during initialization', async () => {
+      // Make initialization slow
+      let resolveInit: () => void;
+      const initPromise = new Promise<void>((resolve) => {
+        resolveInit = resolve;
+      });
+      mockEventService.initialize.mockReturnValue(initPromise);
+
+      const { unmount } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      // Unmount before initialization completes
+      unmount();
+
+      // Cleanup should be called
+      expect(mockEventService.cleanup).toHaveBeenCalledTimes(1);
+
+      // Resolve initialization (should not cause issues)
+      resolveInit!();
+    }, TEST_TIMEOUT);
+
+    it('should handle rapid dependency changes', async () => {
+      const { rerender } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      // Rapidly change dependencies multiple times
+      for (let i = 0; i < 5; i++) {
+        rerender(
+          <EventServiceProvider
+            supabaseClient={mockSupabaseClient}
+            user={{ ...mockUser, id: `user-${i}` }}
+            session={mockSession}
+            appName={`App${i}`}
+            selectedOrganisation={mockOrganisation}
+            setSelectedEventId={mockSetSelectedEventId}
+          >
+            <TestComponent />
+          </EventServiceProvider>
+        );
+      }
+
+      await waitFor(() => {
+        // Should have called updateDependencies multiple times
+        expect(mockEventService.updateDependencies).toHaveBeenCalled();
+      }, { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+
+    it('should handle concurrent user and organisation changes', async () => {
+      const { rerender } = render(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={mockUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={mockOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      const newUser = { ...mockUser, id: 'user-456' };
+      const newOrganisation = { ...mockOrganisation, id: 'org-456' };
+
+      rerender(
+        <EventServiceProvider
+          supabaseClient={mockSupabaseClient}
+          user={newUser}
+          session={mockSession}
+          appName="TestApp"
+          selectedOrganisation={newOrganisation}
+          setSelectedEventId={mockSetSelectedEventId}
+        >
+          <TestComponent />
+        </EventServiceProvider>
+      );
+
+      await waitFor(() => {
+        expect(mockEventService.updateDependencies).toHaveBeenCalledWith(
+          mockSupabaseClient,
+          newUser,
+          mockSession,
+          'TestApp',
+          newOrganisation,
+          mockSetSelectedEventId
+        );
+      }, { timeout: TEST_TIMEOUT });
+    }, TEST_TIMEOUT);
+  });
+});