feat(authz): add role assignation wizard scope selection step

Add scope selection step (step 2) to the role assignation wizard, including
ScopeList, ScopeFilterBar, useScopeListData, and useScopePermissions. Migrate
useScopes to infinite query, fix useOrgs data extraction, add missing
userRoles cache invalidation on role assignment, and align all tests with
the updated hook shapes.

Author: bra-i-am

src/authz-module/authz-home/index.test.tsx

@@ -22,6 +22,15 @@ const emptyResponse = {
   refetch: jest.fn(),
 };
 
+const emptyScopesResponse = {
+  data: { pages: [] },
+  error: null,
+  isLoading: false,
+  hasNextPage: false,
+  fetchNextPage: jest.fn(),
+  isFetchingNextPage: false,
+};
+
 const renderAuthzHome = () => renderWithAllProviders(
   <ToastManagerProvider>
     <AuthzHome />
@@ -32,7 +41,7 @@ describe('AuthzHome', () => {
   beforeEach(() => {
     (useAllRoleAssignments as jest.Mock).mockReturnValue(emptyResponse);
     (useOrgs as jest.Mock).mockReturnValue(emptyResponse);
-    (useScopes as jest.Mock).mockReturnValue(emptyResponse);
+    (useScopes as jest.Mock).mockReturnValue(emptyScopesResponse);
   });
 
   it('renders without crashing', () => {

src/authz-module/components/TableControlBar/ScopesFilter.test.tsx

@@ -6,16 +6,20 @@ import ScopesFilter from './ScopesFilter';
 jest.mock('@src/authz-module/data/hooks', () => ({
   useScopes: () => ({
     data: {
-      results: [
+      pages: [
         {
-          externalKey: 'course:123',
-          name: 'Test Course',
-          organization: { name: 'Test Org' },
-        },
-        {
-          externalKey: 'library:456',
-          name: 'Test Library',
-          organization: { name: 'Another Org' },
+          results: [
+            {
+              externalKey: 'course:123',
+              name: 'Test Course',
+              organization: { name: 'Test Org' },
+            },
+            {
+              externalKey: 'library:456',
+              name: 'Test Library',
+              organization: { name: 'Another Org' },
+            },
+          ],
         },
       ],
     },

src/authz-module/components/TableControlBar/ScopesFilter.tsx

@@ -15,9 +15,9 @@ const ScopesFilter = ({
 }: ScopesFilterProps) => {
   const { formatMessage } = useIntl();
   const [searchValue, setSearchValue] = useState<string | undefined>(undefined);
-  const { data: scopesData = { results: [] } } = useScopes(searchValue, 1, DEFAULT_FILTER_PAGE_SIZE);
+  const { data: scopesData } = useScopes({ search: searchValue, pageSize: DEFAULT_FILTER_PAGE_SIZE });
 
-  const filterChoices = useMemo(() => scopesData.results.map((scope) => {
+  const filterChoices = useMemo(() => (scopesData?.pages?.flatMap((p) => p.results) ?? []).map((scope) => {
     const scopeIcon = scope.externalKey?.startsWith('lib') ? RESOURCE_ICONS.LIBRARY : RESOURCE_ICONS.COURSE;
     let groupName = formatMessage(messages['authz.team.members.table.group.courses']);
     if (scope.externalKey?.startsWith('lib')) {
@@ -30,7 +30,7 @@ const ScopesFilter = ({
       groupName,
       groupIcon: scopeIcon,
     };
-  }), [scopesData, formatMessage]);
+  }), [scopesData?.pages, formatMessage]);
 
   const handleSearchChange = (value: string) => {
     setSearchValue(value);

src/authz-module/data/api.ts

@@ -54,13 +54,13 @@ export type PermissionsByRole = {
 };
 export interface PutAssignTeamMembersRoleResponse {
   completed: { userIdentifier: string; status: string }[];
-  errors: { userIdentifier: string; error: string }[];
+  errors: { userIdentifier: string; scope: string; error: string }[];
 }
 
 export interface AssignTeamMembersRoleRequest {
   users: string[];
   role: string;
-  scope: string;
+  scopes: string[];
 }
 
 export interface GetAllRoleAssignmentsResponse {
@@ -97,6 +97,15 @@ export type ValidateUsersResponse = {
   };
 };
 
+export interface GetScopesParams {
+  scopeType?: string;
+  search?: string;
+  org?: string;
+  page?: number;
+  pageSize?: number;
+  managementPermissionOnly?: boolean;
+}
+
 export const getTeamMembers = async (object: string, querySettings: QuerySettings): Promise<GetTeamMembersResponse> => {
   const url = new URL(getApiUrl(`/api/authz/v1/roles/users/?scope=${object}`));
 
@@ -208,17 +217,13 @@ export const getOrgs = async (search?: string, page?: number, pageSize?: number)
   return camelCaseObject(data);
 };
 
-export const getScopes = async (search?: string, page?: number, pageSize?: number): Promise<GetScopesResponse> => {
+export const getScopes = async (params: GetScopesParams): Promise<GetScopesResponse> => {
   const url = new URL(getApiUrl('/api/authz/v1/scopes/'));
-  if (search !== undefined) {
-    url.searchParams.set('search', search);
-  }
-  if (page !== undefined) {
-    url.searchParams.set('page', page.toString());
-  }
-  if (pageSize !== undefined) {
-    url.searchParams.set('page_size', pageSize.toString());
-  }
+  if (params.search) { url.searchParams.set('search', params.search); }
+  if (params.org) { url.searchParams.set('org', params.org); }
+  if (params.managementPermissionOnly) { url.searchParams.set('management_permission_only', 'true'); }
+  url.searchParams.set('page', (params.page ?? 1).toString());
+  url.searchParams.set('page_size', (params.pageSize ?? 10).toString());
   const { data } = await getAuthenticatedHttpClient().get(url);
   return camelCaseObject(data);
 };

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

@@ -388,7 +388,7 @@ describe('useAssignTeamMembersRole', () => {
     });
 
     await act(async () => {
-      result.current.mutate({ data: { scope: 'lib:123', users: ['jdoe'], role: 'author' } });
+      result.current.mutate({ data: { scopes: ['lib:123'], users: ['jdoe'], role: 'author' } });
     });
 
     await waitFor(() => expect(result.current.isSuccess).toBe(true));
@@ -407,7 +407,7 @@ describe('useAssignTeamMembersRole', () => {
     });
 
     await act(async () => {
-      result.current.mutate({ data: { scope: 'lib:123', users: ['jdoe'], role: 'author' } });
+      result.current.mutate({ data: { scopes: ['lib:123'], users: ['jdoe'], role: 'author' } });
     });
 
     await waitFor(() => expect(result.current.isError).toBe(true));
@@ -465,6 +465,128 @@ describe('useValidateUsers', () => {
   });
 });
 
+describe('useScopes', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const makeScopesResponse = (next: string | null = null) => ({
+    results: [{
+      externalKey: 'lib:testorg:testlib',
+      displayName: 'Test Library',
+      org: { id: 1, name: 'Test Org', slug: 'testorg' },
+    }],
+    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('useOrgs', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  const mockOrgs = [{
+    id: 1, name: 'Org One', shortName: 'org1', description: '', logo: null, active: true,
+  }];
+
+  it('returns organizations on success', async () => {
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockResolvedValue({ data: { results: mockOrgs } }),
+    });
+
+    const { result } = renderHook(() => useOrgs(), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data?.results).toEqual(mockOrgs);
+  });
+
+  it('handles error when API fails', async () => {
+    getAuthenticatedHttpClient.mockReturnValue({
+      get: jest.fn().mockRejectedValue(new Error('Failed')),
+    });
+
+    const { result } = renderHook(() => useOrgs(), { wrapper: createWrapper() });
+
+    await waitFor(() => expect(result.current.isError).toBe(true));
+  });
+});
+
 describe('useRevokeUserRoles', () => {
   beforeEach(() => {
     jest.clearAllMocks();
@@ -663,9 +785,9 @@ describe('useScopes', () => {
   it('fetches and returns scopes', async () => {
     const { result } = renderHook(() => useScopes(), { wrapper: createWrapper() });
     await waitFor(() => {
-      expect(result.current.data?.results).toHaveLength(2);
-      expect(result.current.data?.results[0].displayName).toBe('Open edX Demo Course');
-      expect(result.current.data?.count).toBe(2);
+      expect(result.current.data?.pages[0].results).toHaveLength(2);
+      expect(result.current.data?.pages[0].results[0].displayName).toBe('Open edX Demo Course');
+      expect(result.current.data?.pages[0].count).toBe(2);
     });
   });
 
@@ -679,8 +801,8 @@ describe('useScopes', () => {
     });
     const { result } = renderHook(() => useScopes(), { wrapper: createWrapper() });
     await waitFor(() => {
-      expect(result.current.data?.results).toEqual([]);
-      expect(result.current.data?.count).toBe(0);
+      expect(result.current.data?.pages[0].results).toEqual([]);
+      expect(result.current.data?.pages[0].count).toBe(0);
     });
   });
 });