feat: add tests for scopes and organizations hooks, including loading states and navigation guards

Author: bra-i-am

src/authz-module/data/api.test.ts

@@ -6,6 +6,8 @@ import {
   getLibrary,
   getPermissionsByRole,
   revokeUserRoles,
+  getScopes,
+  getOrganizations,
 } from './api';
 
 jest.mock('@edx/frontend-platform/auth', () => ({
@@ -180,3 +182,105 @@ describe('revokeUserRoles', () => {
     expect(result).toEqual(mockResponse);
   });
 });
+
+describe('getScopes', () => {
+  const mockScopesData = {
+    results: [{ id: 'lib:123', name: 'Test Library', org: 'testorg', contextType: 'library' }],
+    count: 1,
+    next: null,
+    previous: null,
+  };
+
+  it('builds URL with default page and pageSize when no optional params', async () => {
+    mockGet.mockResolvedValue({ data: mockScopesData });
+
+    const result = await getScopes({});
+
+    const calledUrl = new URL(mockGet.mock.calls[0][0]);
+    expect(calledUrl.searchParams.get('page')).toBe('1');
+    expect(calledUrl.searchParams.get('page_size')).toBe('10');
+    expect(calledUrl.searchParams.get('search')).toBeNull();
+    expect(calledUrl.searchParams.get('org')).toBeNull();
+    expect(calledUrl.searchParams.get('management_permission_only')).toBeNull();
+    expect(result).toEqual(mockScopesData);
+  });
+
+  it('appends search param when provided', async () => {
+    mockGet.mockResolvedValue({ data: mockScopesData });
+
+    await getScopes({ search: 'mylib' });
+
+    const calledUrl = new URL(mockGet.mock.calls[0][0]);
+    expect(calledUrl.searchParams.get('search')).toBe('mylib');
+  });
+
+  it('appends org param when provided', async () => {
+    mockGet.mockResolvedValue({ data: mockScopesData });
+
+    await getScopes({ org: 'testorg' });
+
+    const calledUrl = new URL(mockGet.mock.calls[0][0]);
+    expect(calledUrl.searchParams.get('org')).toBe('testorg');
+  });
+
+  it('appends management_permission_only when set to true', async () => {
+    mockGet.mockResolvedValue({ data: mockScopesData });
+
+    await getScopes({ managementPermissionOnly: true });
+
+    const calledUrl = new URL(mockGet.mock.calls[0][0]);
+    expect(calledUrl.searchParams.get('management_permission_only')).toBe('true');
+  });
+
+  it('uses provided page and pageSize', async () => {
+    mockGet.mockResolvedValue({ data: mockScopesData });
+
+    await getScopes({ page: 3, pageSize: 25 });
+
+    const calledUrl = new URL(mockGet.mock.calls[0][0]);
+    expect(calledUrl.searchParams.get('page')).toBe('3');
+    expect(calledUrl.searchParams.get('page_size')).toBe('25');
+  });
+
+  it('does not append managementPermissionOnly when false', async () => {
+    mockGet.mockResolvedValue({ data: mockScopesData });
+
+    await getScopes({ managementPermissionOnly: false });
+
+    const calledUrl = new URL(mockGet.mock.calls[0][0]);
+    expect(calledUrl.searchParams.get('management_permission_only')).toBeNull();
+  });
+});
+
+describe('getOrganizations', () => {
+  it('returns organizations from data.results when present', async () => {
+    const mockData = {
+      results: [{ org: 'org1', name: 'Org One' }, { org: 'org2', name: 'Org Two' }],
+    };
+    mockGet.mockResolvedValue({ data: mockData });
+
+    const result = await getOrganizations();
+
+    const calledUrl = new URL(mockGet.mock.calls[0][0]);
+    expect(calledUrl.pathname).toBe('/api/authz/v1/organizations/');
+    expect(result).toEqual(mockData.results);
+  });
+
+  it('falls back to data directly when results is not present', async () => {
+    const mockData = [{ org: 'org1', name: 'Org One' }];
+    mockGet.mockResolvedValue({ data: mockData });
+
+    const result = await getOrganizations();
+
+    expect(result).toEqual(mockData);
+  });
+
+  it('accepts contextType param (currently unused in URL but accepted)', async () => {
+    mockGet.mockResolvedValue({ data: { results: [] } });
+
+    const result = await getOrganizations('course');
+
+    expect(result).toEqual([]);
+    expect(mockGet).toHaveBeenCalled();
+  });
+});

src/authz-module/data/hooks.test.tsx

@@ -4,7 +4,7 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
 import {
   useLibrary, usePermissionsByRole, useTeamMembers, useAssignTeamMembersRole, useRevokeUserRoles,
-  useValidateUsers,
+  useValidateUsers, useScopes, useOrganizations, useManagedScopeOrgs,
 } from './hooks';
 
 jest.mock('@edx/frontend-platform/auth', () => ({
@@ -290,6 +290,175 @@ describe('useValidateUsers', () => {
   });
 });
 
+describe('useScopes', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const makeScopesResponse = (next: string | null = null) => ({
+    results: [{ id: 'lib:123', name: 'Test Library', org: 'testorg', contextType: 'library' }],
+    count: 1,
+    next,
+    previous: null,
+  });
+
+  it('returns pages data on success', async () => {
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockResolvedValue({ data: makeScopesResponse() }),
+    });
+
+    const { result } = renderHook(() => useScopes({}), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(result.current.data?.pages).toHaveLength(1);
+    expect(result.current.data?.pages[0].results).toHaveLength(1);
+  });
+
+  it('hasNextPage is false when next is null', async () => {
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockResolvedValue({ data: makeScopesResponse(null) }),
+    });
+
+    const { result } = renderHook(() => useScopes({}), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.hasNextPage).toBe(false);
+  });
+
+  it('hasNextPage is true when next URL has page param', async () => {
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockResolvedValue({
+        data: makeScopesResponse('http://localhost:8000/api/authz/v1/scopes/?page=2'),
+      }),
+    });
+
+    const { result } = renderHook(() => useScopes({}), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.hasNextPage).toBe(true);
+  });
+
+  it('hasNextPage is false when next URL has no page param', async () => {
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockResolvedValue({
+        data: makeScopesResponse('http://localhost:8000/api/authz/v1/scopes/'),
+      }),
+    });
+
+    const { result } = renderHook(() => useScopes({}), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.hasNextPage).toBe(false);
+  });
+
+  it('hasNextPage is false when next is an invalid URL', async () => {
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockResolvedValue({
+        data: makeScopesResponse('not-a-valid-url'),
+      }),
+    });
+
+    const { result } = renderHook(() => useScopes({}), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.hasNextPage).toBe(false);
+  });
+
+  it('handles error when API call fails', async () => {
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockRejectedValue(new Error('Network error')),
+    });
+
+    const { result } = renderHook(() => useScopes({}), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+    expect(result.current.error).toBeDefined();
+  });
+});
+
+describe('useOrganizations', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('returns organizations on success', async () => {
+    const mockOrgs = [{ org: 'org1', name: 'Org One' }];
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockResolvedValue({ data: { results: mockOrgs } }),
+    });
+
+    const { result } = renderHook(() => useOrganizations('library'), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockOrgs);
+  });
+
+  it('handles error when API fails', async () => {
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockRejectedValue(new Error('Failed')),
+    });
+
+    const { result } = renderHook(() => useOrganizations(), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
+describe('useManagedScopeOrgs', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('does not fetch when contextType is undefined', async () => {
+    const mockGet = jest.fn();
+    getAuthenticatedHttpClient.mockReturnValue({ get: mockGet });
+
+    const { result } = renderHook(() => useManagedScopeOrgs(undefined), { wrapper: createWrapper() });
+
+    // Query is disabled, so it should not be loading or have fetched
+    expect(result.current.isFetching).toBe(false);
+    expect(mockGet).not.toHaveBeenCalled();
+  });
+
+  it('fetches and returns a Set of orgs when contextType is provided', async () => {
+    const mockScopesResponse = {
+      results: [
+        { id: 'lib:123', name: 'Lib 1', org: 'org1', contextType: 'library' },
+        { id: 'lib:456', name: 'Lib 2', org: 'org2', contextType: 'library' },
+        { id: 'lib:789', name: 'Lib 3', org: '', contextType: 'library' },
+      ],
+      count: 3,
+      next: null,
+      previous: null,
+    };
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockResolvedValue({ data: mockScopesResponse }),
+    });
+
+    const { result } = renderHook(() => useManagedScopeOrgs('library'), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    const orgs = result.current.data as Set<string>;
+    expect(orgs.has('org1')).toBe(true);
+    expect(orgs.has('org2')).toBe(true);
+    // empty string org is filtered out
+    expect(orgs.has('')).toBe(false);
+    expect(orgs.size).toBe(2);
+  });
+
+  it('handles error when API fails', async () => {
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockRejectedValue(new Error('API error')),
+    });
+
+    const { result } = renderHook(() => useManagedScopeOrgs('course'), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
 describe('useRevokeUserRoles', () => {
   beforeEach(() => {
     jest.clearAllMocks();

src/authz-module/libraries-manager/LibrariesUserManager.test.tsx

@@ -11,9 +11,12 @@ jest.mock('@edx/frontend-platform/logging', () => ({
   logError: jest.fn(),
 }));
 
+const mockNavigate = jest.fn();
+
 jest.mock('react-router-dom', () => ({
   ...jest.requireActual('react-router-dom'),
   useParams: jest.fn(),
+  useNavigate: () => mockNavigate,
 }));
 
 jest.mock('./context', () => ({
@@ -162,6 +165,82 @@ describe('LibrariesUserManager', () => {
     expect(navLinkLibraryTeamManagement).toHaveAttribute('href', '/authz/libraries/lib:123');
   });
 
+  describe('Navigation guards', () => {
+    it('redirects to team path when canManageTeam is false', () => {
+      (useLibraryAuthZ as jest.Mock).mockReturnValue({
+        ...defaultMockData,
+        canManageTeam: false,
+      });
+
+      renderComponent();
+
+      expect(mockNavigate).toHaveBeenCalledWith('/authz/libraries/lib:123');
+    });
+
+    it('redirects to team path when user is not found after loading completes', async () => {
+      (useTeamMembers as jest.Mock).mockReturnValue({
+        data: { results: [] },
+        isLoading: false,
+        isFetching: false,
+      });
+
+      renderComponent();
+
+      await waitFor(() => {
+        expect(mockNavigate).toHaveBeenCalledWith('/authz/libraries/lib:123');
+      });
+    });
+
+    it('does not redirect while member data is still fetching', () => {
+      (useTeamMembers as jest.Mock).mockReturnValue({
+        data: undefined,
+        isLoading: true,
+        isFetching: true,
+      });
+
+      renderComponent();
+
+      // navigate should only be called for canManageTeam=true case (not at all here)
+      expect(mockNavigate).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Loading state', () => {
+    it('renders skeleton while loading team member data', () => {
+      (useTeamMembers as jest.Mock).mockReturnValue({
+        data: undefined,
+        isLoading: true,
+        isFetching: true,
+      });
+
+      renderComponent();
+
+      // Skeleton renders as a placeholder element
+      const skeletons = document.querySelectorAll('[aria-label="loading..."], .react-loading-skeleton, span[style]');
+      // Just verify the component renders without crashing in loading state
+      expect(screen.queryByText('Admin')).not.toBeInTheDocument();
+    });
+  });
+
+  describe('Assign role button', () => {
+    it('navigates to assign-role wizard when Assign Role button is clicked', async () => {
+      const user = userEvent.setup();
+      renderComponent();
+
+      // There are two "Assign Role" elements: the mocked AssignNewRoleTrigger and the real Button
+      // The real Button navigates; use getAllByText and click the one that is a <button>
+      const assignRoleButtons = screen.getAllByText('Assign Role');
+      const realButton = assignRoleButtons.find(
+        (el) => el.tagName === 'BUTTON' || el.closest('button[class*="btn-primary"]') !== null,
+      );
+      await user.click(realButton || assignRoleButtons[0]);
+
+      expect(mockNavigate).toHaveBeenCalledWith(
+        '/authz/assign-role?scope=lib:123&users=testuser',
+      );
+    });
+  });
+
   describe('Revoking User Role Flow', () => {
     it('opens confirmation modal when delete role button is clicked', async () => {
       const user = userEvent.setup();