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,107 @@ 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/api.ts

@@ -147,7 +147,7 @@ export interface OrganizationItem {
 
 export const getScopes = async (params: GetScopesParams): Promise<GetScopesResponse> => {
   const url = new URL(getApiUrl('/api/authz/v1/scopes/'));
-  //   if (params.contextType) { url.searchParams.set('context_type', params.contextType); }
+  if (params.contextType) { url.searchParams.set('context_type', params.contextType); }
   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'); }
@@ -159,7 +159,7 @@ export const getScopes = async (params: GetScopesParams): Promise<GetScopesRespo
 
 export const getOrganizations = async (contextType?: string): Promise<OrganizationItem[]> => {
   const url = new URL(getApiUrl('/api/authz/v1/organizations/'));
-  //   if (contextType) { url.searchParams.set('context_type', contextType); }
+  if (contextType) { url.searchParams.set('context_type', contextType); }
   const { data } = await getAuthenticatedHttpClient().get(url);
   return camelCaseObject(data.results ?? data);
 };

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,183 @@ 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();