@jmruthers/pace-core 0.2.4

package/src/components/OrganisationSelector/__tests__/OrganisationSelector.unit.test.tsx

@@ -0,0 +1,664 @@
+import React from 'react';
+import { screen, fireEvent, waitFor, cleanup } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderWithProviders, testDataGenerators, mockHooks } from '../../../__tests__/shared';
+import { OrganisationSelector } from '../OrganisationSelector';
+import type { OrganisationSelectorProps } from '../OrganisationSelector';
+import type { Organisation, OrganisationContextType } from '../../../types/organisation';
+
+// Mock the OrganisationProvider hook
+const mockUseOrganisations = vi.fn();
+vi.mock('../../../providers/OrganisationProvider', () => ({
+  useOrganisations: () => mockUseOrganisations()
+}));
+
+// Mock Radix UI Select components for testing
+const SelectValueChangeContext = React.createContext<((value: string) => void) | undefined>(undefined);
+
+vi.mock('../../Select', () => ({
+  Select: ({ children, value, onValueChange, disabled }: any) => (
+    <SelectValueChangeContext.Provider value={onValueChange}>
+      <div data-testid="select-root" data-value={value} data-disabled={disabled}>
+        {children}
+      </div>
+    </SelectValueChangeContext.Provider>
+  ),
+  SelectTrigger: ({ children, className }: any) => (
+    <button data-testid="select-trigger" className={className}>
+      {children}
+    </button>
+  ),
+  SelectValue: ({ placeholder }: any) => (
+    <span data-testid="select-value">{placeholder}</span>
+  ),
+  SelectContent: ({ children }: any) => (
+    <div data-testid="select-content">{children}</div>
+  ),
+  SelectItem: ({ children, value, disabled }: any) => {
+    const onValueChange = React.useContext(SelectValueChangeContext);
+    return (
+      <div
+        data-testid="select-item"
+        data-value={value}
+        data-disabled={disabled}
+        onClick={() => !disabled && onValueChange?.(value)}
+      >
+        {children}
+      </div>
+    );
+  }
+}));
+
+// Mock other components
+vi.mock('../../Alert/Alert', () => ({
+  Alert: ({ children, variant }: any) => (
+    <div data-testid="alert" data-variant={variant}>{children}</div>
+  ),
+  AlertDescription: ({ children }: any) => (
+    <div data-testid="alert-description">{children}</div>
+  )
+}));
+
+vi.mock('../../Button/Button', () => ({
+  Button: ({ children, onClick, disabled, variant, size, className }: any) => (
+    <button 
+      data-testid="button"
+      onClick={onClick}
+      disabled={disabled}
+      data-variant={variant}
+      data-size={size}
+      className={className}
+    >
+      {children}
+    </button>
+  )
+}));
+
+vi.mock('../../LoadingSpinner/LoadingSpinner', () => ({
+  LoadingSpinner: ({ size }: any) => (
+    <div data-testid="loading-spinner" data-size={size}>Loading...</div>
+  )
+}));
+
+// Mock lucide-react icons
+vi.mock('lucide-react', () => ({
+  RefreshCw: ({ className }: any) => <div data-testid="refresh-icon" className={className} />,
+  AlertCircle: ({ className }: any) => <div data-testid="alert-icon" className={className} />,
+  Building2: ({ className }: any) => <div data-testid="building-icon" className={className} />,
+  Shield: ({ className }: any) => <div data-testid="shield-icon" className={className} />
+}));
+
+// Test data using shared generators
+const mockOrganisations: Organisation[] = [
+  testDataGenerators.createOrganisation(1, {
+    display_name: 'Test Organization 1',
+    description: 'First test organization',
+    subscription_tier: 'standard',
+    is_active: true,
+    settings: {},
+  }),
+  testDataGenerators.createOrganisation(2, {
+    display_name: 'Test Organization 2',
+    description: 'Second test organization',
+    subscription_tier: 'premium',
+    is_active: true,
+    settings: {},
+  }),
+  testDataGenerators.createOrganisation(3, {
+    display_name: 'Test Organization 3',
+    description: 'Third test organization',
+    subscription_tier: 'enterprise',
+    is_active: true,
+    settings: {},
+  }),
+];
+
+const mockSelectedOrganisation = mockOrganisations[0];
+
+// Default mock implementation
+const createMockOrganisationContext = (overrides: Partial<OrganisationContextType> = {}): OrganisationContextType => ({
+  organisations: mockOrganisations,
+  selectedOrganisation: mockSelectedOrganisation,
+  userMemberships: [],
+  isLoading: false,
+  error: null,
+  hasValidOrganisationContext: true,
+  setSelectedOrganisation: vi.fn(),
+  switchOrganisation: vi.fn().mockResolvedValue(undefined),
+  getUserRole: vi.fn().mockReturnValue('member'),
+  validateOrganisationAccess: vi.fn().mockReturnValue(true),
+  refreshOrganisations: vi.fn().mockResolvedValue(undefined),
+  ensureOrganisationContext: vi.fn().mockReturnValue(mockSelectedOrganisation),
+  isOrganisationSecure: vi.fn().mockReturnValue(true),
+  getPrimaryOrganisation: vi.fn().mockReturnValue(mockSelectedOrganisation),
+  ...overrides
+});
+
+describe('OrganisationSelector', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Console mock to suppress debug logs in tests
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    cleanup();
+  });
+
+  describe('Loading State', () => {
+    it('should display loading state when organisations are loading', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        isLoading: true
+      }));
+
+      renderWithProviders(<OrganisationSelector />);
+
+      expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
+      expect(screen.getByText('Loading organisations...')).toBeInTheDocument();
+    });
+
+    it('should display compact loading state when compact prop is true', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        isLoading: true
+      }));
+
+      renderWithProviders(<OrganisationSelector compact />);
+
+      expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
+      // Check for the compact-specific text span
+      const loadingText = screen.getByText((content, element) => {
+        return element?.tagName === 'SPAN' && content.includes('Loading...');
+      });
+      expect(loadingText).toBeInTheDocument();
+    });
+
+    it('should apply custom className during loading', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        isLoading: true
+      }));
+
+      const { container } = renderWithProviders(<OrganisationSelector className="custom-class" />);
+
+      // Find the actual component element and check for the class
+      // The className is applied to the outer div container
+      // Since renderWithProviders wraps in providers, we need to find the component div
+      const componentElement = container.querySelector('div.flex.items-center.gap-2') as HTMLElement;
+      expect(componentElement).toHaveClass('custom-class');
+    });
+  });
+
+  describe('Error State', () => {
+    it('should display error message when organisations fail to load', () => {
+      const error = new Error('Failed to load organisations');
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        error
+      }));
+
+      renderWithProviders(<OrganisationSelector />);
+
+      expect(screen.getByTestId('alert')).toHaveAttribute('data-variant', 'destructive');
+      expect(screen.getByTestId('alert-description')).toHaveTextContent('Failed to load organisations: Failed to load organisations');
+      expect(screen.getByTestId('alert-icon')).toBeInTheDocument();
+    });
+
+    it('should display retry button when showRetryButton is true', () => {
+      const error = new Error('Network error');
+      const mockRefresh = vi.fn().mockResolvedValue(undefined);
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        error,
+        refreshOrganisations: mockRefresh
+      }));
+
+      renderWithProviders(<OrganisationSelector showRetryButton />);
+
+      const retryButton = screen.getByTestId('button');
+      expect(retryButton).toHaveTextContent('Retry');
+      expect(screen.getByTestId('refresh-icon')).toBeInTheDocument();
+    });
+
+    it('should hide retry button when showRetryButton is false', () => {
+      const error = new Error('Network error');
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        error
+      }));
+
+      renderWithProviders(<OrganisationSelector showRetryButton={false} />);
+
+      expect(screen.queryByTestId('button')).not.toBeInTheDocument();
+    });
+
+    it('should call refreshOrganisations when retry button is clicked', async () => {
+      const error = new Error('Network error');
+      const mockRefresh = vi.fn().mockResolvedValue(undefined);
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        error,
+        refreshOrganisations: mockRefresh
+      }));
+
+      const user = userEvent.setup();
+      renderWithProviders(<OrganisationSelector showRetryButton />);
+
+      const retryButton = screen.getByTestId('button');
+      await user.click(retryButton);
+
+      expect(mockRefresh).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('No Organisations State', () => {
+    it('should display no organisations message when organisations array is empty', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        organisations: []
+      }));
+
+      renderWithProviders(<OrganisationSelector />);
+
+      expect(screen.getByTestId('alert-description')).toHaveTextContent(
+        'No organisations available. Please contact your administrator to be added to an organisation.'
+      );
+      expect(screen.getByTestId('building-icon')).toBeInTheDocument();
+    });
+
+    it('should show check again button when no organisations and showRetryButton is true', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        organisations: []
+      }));
+
+      renderWithProviders(<OrganisationSelector showRetryButton />);
+
+      const checkButton = screen.getByTestId('button');
+      expect(checkButton).toHaveTextContent('Check Again');
+    });
+
+    it('should hide no organisations message when showNoOrganisationsMessage is false', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        organisations: []
+      }));
+
+      renderWithProviders(<OrganisationSelector showNoOrganisationsMessage={false} />);
+
+      // Check that no organisations message is not displayed
+      expect(screen.queryByText('No organisations available')).not.toBeInTheDocument();
+    });
+
+    it('should call refreshOrganisations when check again button is clicked', async () => {
+      const mockRefresh = vi.fn().mockResolvedValue(undefined);
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        organisations: [],
+        refreshOrganisations: mockRefresh
+      }));
+
+      const user = userEvent.setup();
+      renderWithProviders(<OrganisationSelector showRetryButton />);
+
+      const checkButton = screen.getByTestId('button');
+      await user.click(checkButton);
+
+      expect(mockRefresh).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('Normal Selector State', () => {
+    it('should render select component with organisations', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext());
+
+      renderWithProviders(<OrganisationSelector />);
+
+      expect(screen.getByTestId('select-root')).toBeInTheDocument();
+      expect(screen.getByTestId('select-trigger')).toBeInTheDocument();
+      expect(screen.getByTestId('select-content')).toBeInTheDocument();
+    });
+
+    it('should display all organisations as select items', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext());
+
+      renderWithProviders(<OrganisationSelector />);
+
+      const selectItems = screen.getAllByTestId('select-item');
+      expect(selectItems).toHaveLength(mockOrganisations.length);
+
+      // Check that organisation names are displayed
+      expect(screen.getByText('Test Organization 1')).toBeInTheDocument();
+      expect(screen.getByText('Test Organization 2')).toBeInTheDocument();
+      expect(screen.getByText('Test Organization 3')).toBeInTheDocument();
+    });
+
+    it('should show building icons for organisations', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext());
+
+      renderWithProviders(<OrganisationSelector />);
+
+      const buildingIcons = screen.getAllByTestId('building-icon');
+      // One in trigger + one per organisation item
+      expect(buildingIcons.length).toBeGreaterThan(1);
+    });
+
+    it('should display organisation descriptions in non-compact mode', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext());
+
+      renderWithProviders(<OrganisationSelector />);
+
+      expect(screen.getByText('First test organization')).toBeInTheDocument();
+      expect(screen.getByText('Second test organization')).toBeInTheDocument();
+    });
+
+    it('should hide organisation descriptions in compact mode', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext());
+
+      renderWithProviders(<OrganisationSelector compact />);
+
+      expect(screen.queryByText('First test organization')).not.toBeInTheDocument();
+      expect(screen.queryByText('Second test organization')).not.toBeInTheDocument();
+    });
+
+    it('should show user roles when showRole is true', () => {
+      const mockGetUserRole = vi.fn()
+        .mockReturnValueOnce('admin')
+        .mockReturnValueOnce('member')
+        .mockReturnValueOnce('org_admin');
+
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        getUserRole: mockGetUserRole
+      }));
+
+      renderWithProviders(<OrganisationSelector showRole />);
+
+      expect(screen.getByText('admin')).toBeInTheDocument();
+      expect(screen.getByText('member')).toBeInTheDocument();
+      expect(screen.getByText('org admin')).toBeInTheDocument();
+      expect(screen.getAllByTestId('shield-icon')).toHaveLength(3);
+    });
+
+    it('should use custom placeholder text', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext());
+
+      renderWithProviders(<OrganisationSelector placeholder="Choose your organization" />);
+
+      expect(screen.getByText('Choose your organization')).toBeInTheDocument();
+    });
+
+    it('should apply custom className', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext());
+
+      const { container } = renderWithProviders(<OrganisationSelector className="custom-selector" />);
+
+      // Find the actual component element and check for the class
+      // The className is applied to the outer div container
+      // Since renderWithProviders wraps in providers, we need to find the component div
+      const componentElement = container.querySelector('div.space-y-2') as HTMLElement;
+      expect(componentElement).toHaveClass('custom-selector');
+    });
+  });
+
+  describe('Organisation Switching', () => {
+    it('should call switchOrganisation when organisation is selected', async () => {
+      const mockSwitch = vi.fn().mockResolvedValue(undefined);
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        switchOrganisation: mockSwitch
+      }));
+
+      const user = userEvent.setup();
+      renderWithProviders(<OrganisationSelector />);
+
+      const orgItem = screen.getByText('Test Organization 2').closest('[data-testid="select-item"]');
+      await user.click(orgItem!);
+
+      expect(mockSwitch).toHaveBeenCalledWith('org-2');
+    });
+
+    it('should call onOrganisationChange callback when organisation is switched', async () => {
+      const mockSwitch = vi.fn().mockResolvedValue(undefined);
+      const mockOnChange = vi.fn();
+      
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        switchOrganisation: mockSwitch
+      }));
+
+      const user = userEvent.setup();
+      renderWithProviders(<OrganisationSelector onOrganisationChange={mockOnChange} />);
+
+      const orgItem = screen.getByText('Test Organization 2').closest('[data-testid="select-item"]');
+      await user.click(orgItem!);
+
+      await waitFor(() => {
+        expect(mockOnChange).toHaveBeenCalledWith(mockOrganisations[1]);
+      });
+    });
+
+    it('should display error message when organisation switch fails', async () => {
+      const mockSwitch = vi.fn().mockRejectedValue(new Error('Switch failed'));
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        switchOrganisation: mockSwitch
+      }));
+
+      const user = userEvent.setup();
+      renderWithProviders(<OrganisationSelector />);
+
+      const orgItem = screen.getByText('Test Organization 2').closest('[data-testid="select-item"]');
+      await user.click(orgItem!);
+
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toHaveAttribute('data-variant', 'destructive');
+        expect(screen.getByTestId('alert-description')).toHaveTextContent('Switch failed');
+      });
+    });
+
+    it('should validate organisation access before switching', async () => {
+      // Mock that initially allows access but then denies it when switching
+      const mockValidate = vi.fn()
+        .mockReturnValue(true)       // Allow access for rendering
+        .mockReturnValueOnce(false); // Deny access when switching
+      const mockSwitch = vi.fn();
+      
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        validateOrganisationAccess: mockValidate,
+        switchOrganisation: mockSwitch
+      }));
+
+      const user = userEvent.setup();
+      renderWithProviders(<OrganisationSelector />);
+
+      // Reset the mock to return false for the actual switch attempt
+      mockValidate.mockReturnValue(false);
+
+      const orgItem = screen.getByText('Test Organization 2').closest('[data-testid="select-item"]');
+      await user.click(orgItem!);
+
+      await waitFor(() => {
+        expect(mockSwitch).not.toHaveBeenCalled();
+        expect(screen.getByTestId('alert-description')).toHaveTextContent('You do not have access to this organisation');
+      });
+    });
+
+    it('should disable select items for organisations without access', () => {
+      const mockValidate = vi.fn()
+        .mockReturnValueOnce(true)   // org-1: has access
+        .mockReturnValueOnce(false)  // org-2: no access
+        .mockReturnValueOnce(true);  // org-3: has access
+
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        validateOrganisationAccess: mockValidate
+      }));
+
+      renderWithProviders(<OrganisationSelector />);
+
+      const selectItems = screen.getAllByTestId('select-item');
+      expect(selectItems[0]).not.toHaveAttribute('data-disabled', 'true');
+      expect(selectItems[1]).toHaveAttribute('data-disabled', 'true');
+      expect(selectItems[2]).not.toHaveAttribute('data-disabled', 'true');
+    });
+  });
+
+  describe('Disabled State', () => {
+    it('should disable select when disabled prop is true', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext());
+
+      renderWithProviders(<OrganisationSelector disabled />);
+
+      expect(screen.getByTestId('select-root')).toHaveAttribute('data-disabled', 'true');
+    });
+
+    it('should not switch organisation when disabled', async () => {
+      const mockSwitch = vi.fn();
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        switchOrganisation: mockSwitch
+      }));
+
+      const user = userEvent.setup();
+      renderWithProviders(<OrganisationSelector disabled />);
+
+      const orgItem = screen.getByText('Test Organization 2').closest('[data-testid="select-item"]');
+      await user.click(orgItem!);
+
+      expect(mockSwitch).not.toHaveBeenCalled();
+    });
+
+    it('should disable select during loading', async () => {
+      const mockSwitch = vi.fn().mockImplementation(() => new Promise(resolve => setTimeout(resolve, 100)));
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        switchOrganisation: mockSwitch
+      }));
+
+      const user = userEvent.setup();
+      renderWithProviders(<OrganisationSelector />);
+
+      const orgItem = screen.getByText('Test Organization 2').closest('[data-testid="select-item"]');
+      await user.click(orgItem!);
+
+      // Should be disabled while switching
+      expect(screen.getByTestId('select-root')).toHaveAttribute('data-disabled', 'true');
+    });
+  });
+
+  describe('Accessibility', () => {
+    it('should have proper ARIA attributes', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext());
+
+      renderWithProviders(<OrganisationSelector />);
+
+      expect(screen.getByTestId('select-trigger')).toBeInTheDocument();
+      expect(screen.getByTestId('select-value')).toBeInTheDocument();
+    });
+
+    it('should display loading spinner with accessible context', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        isLoading: true
+      }));
+
+      renderWithProviders(<OrganisationSelector />);
+
+      expect(screen.getByTestId('loading-spinner')).toHaveAttribute('data-size', 'sm');
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle missing organisation in organisations list', async () => {
+      const mockSwitch = vi.fn().mockResolvedValue(undefined);
+      const mockOnChange = vi.fn();
+      
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        switchOrganisation: mockSwitch
+      }));
+
+      const user = userEvent.setup();
+      renderWithProviders(<OrganisationSelector onOrganisationChange={mockOnChange} />);
+
+      // Simulate clicking on non-existent organisation
+      const SelectChangeContext = React.createContext<((value: string) => void) | undefined>(undefined);
+      const mockOnValueChange = vi.fn();
+      
+      // Trigger value change for non-existent org
+      fireEvent.click(screen.getByText('Test Organization 1').closest('[data-testid="select-item"]')!);
+
+      await waitFor(() => {
+        expect(mockSwitch).toHaveBeenCalled();
+      });
+
+      // onOrganisationChange should not be called if organisation not found
+      if (mockOnChange.mock.calls.length > 0) {
+        expect(mockOnChange).toHaveBeenCalledWith(mockOrganisations[0]);
+      }
+    });
+
+    it('should handle organisations without descriptions', () => {
+      const orgsWithoutDescription = mockOrganisations.map(org => ({
+        ...org,
+        description: undefined
+      }));
+
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        organisations: orgsWithoutDescription
+      }));
+
+      renderWithProviders(<OrganisationSelector />);
+
+      expect(screen.getByText('Test Organization 1')).toBeInTheDocument();
+      expect(screen.queryByText('First test organization')).not.toBeInTheDocument();
+    });
+
+    it('should handle role names with underscores', () => {
+      const mockGetUserRole = vi.fn().mockReturnValue('super_admin');
+
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        getUserRole: mockGetUserRole
+      }));
+
+      renderWithProviders(<OrganisationSelector showRole />);
+
+      const roleElements = screen.getAllByText('super admin');
+      expect(roleElements.length).toBeGreaterThan(0);
+      expect(roleElements[0]).toBeInTheDocument();
+    });
+
+    it('should handle retry failures gracefully', async () => {
+      const mockRefresh = vi.fn().mockRejectedValue(new Error('Retry failed'));
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext({
+        organisations: [],
+        refreshOrganisations: mockRefresh
+      }));
+
+      const user = userEvent.setup();
+      renderWithProviders(<OrganisationSelector showRetryButton />);
+
+      const retryButton = screen.getByTestId('button');
+      await user.click(retryButton);
+
+      await waitFor(() => {
+        expect(console.error).toHaveBeenCalledWith(
+          '[OrganisationSelector] Failed to refresh organisations:',
+          expect.any(Error)
+        );
+      });
+    });
+  });
+
+  describe('Props Validation', () => {
+    it('should use default props when none provided', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext());
+
+      renderWithProviders(<OrganisationSelector />);
+
+      expect(screen.getByText('Select organisation')).toBeInTheDocument();
+      expect(screen.getByTestId('select-root')).not.toHaveAttribute('data-disabled', 'true');
+    });
+
+    it('should handle all boolean props correctly', () => {
+      mockUseOrganisations.mockReturnValue(createMockOrganisationContext());
+
+      renderWithProviders(
+        <OrganisationSelector
+          showNoOrganisationsMessage={false}
+          showRetryButton={false}
+          showRole={true}
+          compact={true}
+          disabled={true}
+        />
+      );
+
+      expect(screen.getByTestId('select-root')).toHaveAttribute('data-disabled', 'true');
+    });
+  });
+}); 

package/src/components/OrganisationSelector/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @file Organisation Selector Component Exports
+ * @package @jmruthers/pace-core
+ * @module Components/OrganisationSelector
+ * @since 0.4.0
+ */
+
+export { OrganisationSelector } from './OrganisationSelector';
+export type { OrganisationSelectorProps } from './OrganisationSelector';