@nocobase/app-template-default 1.0.0-beta.83 → 1.0.0-beta.85

package/tests/client/list-tabs.test.tsx

@@ -0,0 +1,121 @@
+import type { AppClientRegisteredRoute } from '@nocobase/app-client/plugins';
+import { act, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import {
+  createMemoryRouter,
+  Link,
+  Navigate,
+  Outlet,
+  RouterProvider,
+  useLocation,
+} from 'react-router';
+import { expect, it } from 'vitest';
+import { useListTabs } from '../../client/hooks/use-list-tabs.js';
+import { RouteTreeProvider } from '../../client/routing/route-context.js';
+
+const tabs = [
+  { path: 'active', label: 'Active', dataset: 'active' },
+  { path: 'archived', label: 'Archived', dataset: 'archived' },
+  { path: 'cards', label: 'Cards', dataset: 'active' },
+];
+function Layout() {
+  const state = useListTabs({
+    tabs,
+    parameterKeys: ['q', 'page', 'pageSize', 'sort', 'order'],
+  });
+  const location = useLocation();
+  if (state.fallback) return <Navigate to={state.fallback} replace />;
+  return (
+    <>
+      <output data-testid='tab'>{state.active?.label}</output>
+      <output data-testid='url'>
+        {location.pathname}
+        {location.search}
+      </output>
+      <output data-testid='source'>{JSON.stringify(state.source)}</output>
+      {tabs.map((tab) => (
+        <Link key={tab.path} to={state.destination(tab)}>
+          {tab.label}
+        </Link>
+      ))}
+      <Outlet />
+    </>
+  );
+}
+function setup(url: string) {
+  const router = createMemoryRouter(
+    [
+      {
+        element: (
+          <RouteTreeProvider routes={[] as AppClientRegisteredRoute[]}>
+            <Outlet />
+          </RouteTreeProvider>
+        ),
+        children: [
+          {
+            path: '/assets',
+            element: <Layout />,
+            children: [
+              ...tabs.map((tab) => ({
+                path: tab.path,
+                element: <Outlet />,
+                children: [
+                  { index: true, element: <p>Content</p> },
+                  { path: ':id', element: <p>Detail</p> },
+                ],
+              })),
+              {
+                path: ':unavailableTab',
+                element: null,
+                children: [{ path: ':id', element: null }],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+    { initialEntries: [url] },
+  );
+  render(<RouterProvider router={router} />);
+  return router;
+}
+
+it('isolates different datasets and retains compatible display tabs and enclosing context', async () => {
+  const router = setup(
+    '/assets/active?q=drill&page=3&pageSize=20&sort=name&order=desc&parentFilter=kept',
+  );
+  await userEvent.click(screen.getByRole('link', { name: 'Cards' }));
+  expect(router.state.location.search).toContain('page=3');
+  await userEvent.click(screen.getByRole('link', { name: 'Archived' }));
+  expect(router.state.location.search).toBe('?parentFilter=kept');
+  await act(() => router.navigate(-1));
+  expect(screen.getByTestId('tab')).toHaveTextContent('Cards');
+  expect(router.state.location.search).toContain('q=drill');
+});
+
+it('retains the source tab and its query when a real detail route writes its own query', async () => {
+  const router = setup('/assets/archived?q=drill&page=2&sort=name&order=desc');
+  await act(() => router.navigate('/assets/archived/42?detailPage=7'));
+  expect(screen.getByTestId('tab')).toHaveTextContent('Archived');
+  expect(screen.getByTestId('source')).toHaveTextContent(
+    '"pathname":"/assets/archived","search":"?q=drill&page=2&sort=name&order=desc"',
+  );
+});
+
+it('replaces a removed tab with the first accessible tab without stale dataset parameters', async () => {
+  const router = setup(
+    '/assets/deleted?page=99&sort=deleted&parentFilter=kept',
+  );
+  expect(router.state.location.pathname).toBe('/assets/active');
+  expect(router.state.location.search).toBe('?parentFilter=kept');
+  expect(router.state.historyAction).toBe('REPLACE');
+});
+
+// Match the declared detail shape even after its source tab is removed.
+it('returns a removed tab detail to the group default without retaining its page', async () => {
+  const router = setup('/assets/deleted/42?page=3&sort=name&order=desc');
+  await screen.findByText('Content');
+  expect(router.state.location.pathname).toBe('/assets/active');
+  expect(router.state.location.search).toBe('');
+  expect(screen.getByTestId('tab')).toHaveTextContent('Active');
+});

package/tests/client/manual-list-retry.test.tsx

@@ -0,0 +1,190 @@
+import { useState } from 'react';
+import { answerApi, renderWithApp } from '@nocobase/app-testing/client';
+import { resolveListState } from '@nocobase/app-client';
+import { act, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, expect, it } from 'vitest';
+import { useSettingsData } from '../../client/pages/settings/hooks.js';
+
+import {
+  ListFeedback,
+  ListFeedbackActions,
+} from '../../client/components/list-feedback.js';
+import enUS from '../../client/locales/en-US.js';
+
+type Rows = { data: string[] };
+const options = {
+  namespace: '@nocobase/manual-list-test',
+  namespaces: {
+    '@nocobase/manual-list-test': {
+      'en-US': async () => ({ default: enUS }),
+    },
+  },
+};
+function deferred() {
+  let resolve!: (value: Rows | Response) => void;
+  const promise = new Promise<Rows | Response>((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+}
+function failure(status = 500) {
+  return new Response(JSON.stringify({ error: { message: 'Unavailable' } }), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+const adapters = {
+  useSettings: (query: string) =>
+    useSettingsData<Rows>(`manual-list?q=${query}&page=3&orderBy=title`),
+};
+function Harness({ kind }: { readonly kind: keyof typeof adapters }) {
+  const [query, setQuery] = useState('first');
+  const useData = adapters[kind];
+  const request = useData(query);
+  const state = resolveListState(request, request.data?.data.length ?? 0);
+  const useRetryAction = state === 'failed' || state === 'refresh-failed';
+  return (
+    <>
+      <div>
+        {useRetryAction ? (
+          <ListFeedbackActions
+            state={state}
+            onRetry={request.reload}
+            busy={request.loading}
+          />
+        ) : (
+          <button onClick={request.reload}>Refresh</button>
+        )}
+        <button onClick={() => setQuery('second')}>Change query</button>
+        <ListFeedbackActions state={state} />
+      </div>
+      <ListFeedback state={state}>
+        {request.data?.data.map((row) => (
+          <p key={row}>{row}</p>
+        ))}
+      </ListFeedback>
+    </>
+  );
+}
+describe.each(Object.keys(adapters) as (keyof typeof adapters)[])(
+  '%s manual list',
+  (kind) => {
+    it.each(['success', 'failure'] as const)(
+      'retains the stale warning during retry until %s',
+      async (outcome) => {
+        let response: Rows | Response | Promise<Rows | Response> = {
+          data: ['Original row'],
+        };
+        const calls: string[] = [];
+        await renderWithApp(<Harness kind={kind} />, {
+          ...options,
+          fetch: answerApi(({ path, query }) => {
+            calls.push(JSON.stringify({ path, query }));
+            return response;
+          }),
+        });
+        await screen.findByText('Original row');
+        response = failure();
+        await userEvent.click(screen.getByRole('button', { name: 'Refresh' }));
+        await screen.findByText(enUS.listFeedback.refreshFailed);
+        const pending = deferred();
+        response = pending.promise;
+        await userEvent.click(
+          screen.getByRole('button', { name: 'Retry', exact: true }),
+        );
+        expect(screen.getByRole('alert')).toHaveTextContent(
+          enUS.listFeedback.refreshFailed,
+        );
+        expect(screen.getByText('Original row')).toBeVisible();
+        expect(
+          screen.getByRole('button', { name: 'Retrying…' }),
+        ).toBeDisabled();
+        expect(calls).toHaveLength(3);
+        expect(new Set(calls).size).toBe(1);
+        await act(async () =>
+          pending.resolve(
+            outcome === 'success' ? { data: ['Updated row'] } : failure(),
+          ),
+        );
+        if (outcome === 'success') {
+          await screen.findByText('Updated row');
+          expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+        } else {
+          await waitFor(() =>
+            expect(
+              screen.getByRole('button', { name: 'Retry', exact: true }),
+            ).toBeEnabled(),
+          );
+          expect(screen.getByRole('alert')).toHaveTextContent(
+            enUS.listFeedback.refreshFailed,
+          );
+          expect(screen.getByText('Original row')).toBeVisible();
+        }
+      },
+    );
+    it.each([401, 403])(
+      'hides cached rows through a pending retry after %s',
+      async (status) => {
+        let response: Rows | Response | Promise<Rows | Response> = {
+          data: ['Private row'],
+        };
+        await renderWithApp(<Harness kind={kind} />, {
+          ...options,
+          fetch: answerApi(() => response),
+        });
+        await screen.findByText('Private row');
+        response = failure(status);
+        await userEvent.click(screen.getByRole('button', { name: 'Refresh' }));
+        await screen.findByText(
+          status === 401
+            ? enUS.listFeedback.unauthenticated
+            : enUS.listFeedback.forbidden,
+        );
+        expect(screen.queryByText('Private row')).not.toBeInTheDocument();
+        const pending = deferred();
+        response = pending.promise;
+        await userEvent.click(screen.getByRole('button', { name: 'Refresh' }));
+        expect(screen.getByRole('alert')).toHaveTextContent(
+          status === 401
+            ? enUS.listFeedback.unauthenticated
+            : enUS.listFeedback.forbidden,
+        );
+        expect(screen.queryByText('Private row')).not.toBeInTheDocument();
+        await act(async () => pending.resolve({ data: ['Authorized row'] }));
+        await screen.findByText('Authorized row');
+      },
+    );
+    it('withholds the previous query and ignores its late retry completion', async () => {
+      let response: Rows | Response | Promise<Rows | Response> = {
+        data: ['First row'],
+      };
+      await renderWithApp(<Harness kind={kind} />, {
+        ...options,
+        fetch: answerApi(() => response),
+      });
+      await screen.findByText('First row');
+      response = failure();
+      await userEvent.click(screen.getByRole('button', { name: 'Refresh' }));
+      await screen.findByText(enUS.listFeedback.refreshFailed);
+      const old = deferred();
+      response = old.promise;
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Retry', exact: true }),
+      );
+      const current = deferred();
+      response = current.promise;
+      await userEvent.click(
+        screen.getByRole('button', { name: 'Change query' }),
+      );
+      expect(screen.getByRole('status')).toHaveTextContent('Loading');
+      expect(screen.queryByText('First row')).not.toBeInTheDocument();
+      expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+      await act(async () => current.resolve({ data: ['Second row'] }));
+      await screen.findByText('Second row');
+      await act(async () => old.resolve({ data: ['Obsolete row'] }));
+      expect(screen.queryByText('Obsolete row')).not.toBeInTheDocument();
+      expect(screen.getByText('Second row')).toBeVisible();
+    });
+  },
+);

package/tests/client/page-permission-navigation.test.ts

@@ -151,6 +151,13 @@ describe('page permission navigation projection', () => {
     ]);
     expect(result[0]?.children?.[1]?.children?.[0]?.label).toBe('Warehouses');
     expect(result[1]?.rowId).toBe('["page","legacy-loans","access"]');
+    expect(result[1]?.path).toBe('/loans');
+    expect(result[0]?.children?.[0]?.path).toBe('/materials');
+    expect(
+      flatten(result).find(
+        (node) => node.rowId === '["page","legacy-audit","access"]',
+      )?.path,
+    ).toBe('/loans/audit');
     expect(result[1]?.children?.[0]?.rowId).toBe(
       '["page","legacy-reviews","access"]',
     );
@@ -185,6 +192,7 @@ describe('page permission navigation projection', () => {
       {
         id: 'page:legacy-audit',
         label: 'Audit details',
+        path: '/loans/audit',
         rowId: '["page","legacy-audit","access"]',
       },
     ]);

package/tests/client/permission-editor.test.tsx

@@ -60,13 +60,7 @@ describe('application-owned permission workspace', () => {
         onLevelChange={vi.fn()}
       />,
     );
-    const checkboxes = screen
-      .getAllByRole('checkbox')
-      .filter(
-        (item) =>
-          item.getAttribute('aria-label') !== 'Enabled only' &&
-          item.id !== screen.getByRole('checkbox', { name: 'Enabled only' }).id,
-      );
+    const checkboxes = screen.getAllByRole('checkbox');
     expect(checkboxes.map((item) => item.textContent)).toHaveLength(2);
     expect(checkboxes[0]).toHaveAccessibleName('Approve order');
     expect(checkboxes[1]).toHaveAccessibleName('Withdraw order');
@@ -74,7 +68,7 @@ describe('application-owned permission workspace', () => {
       screen.queryByRole('checkbox', { name: 'Configure numbering' }),
     ).not.toBeInTheDocument();
     expect(
-      screen.getByRole('navigation', { name: 'Permission categories' }),
+      screen.getByRole('tablist', { name: 'Permission categories' }),
     ).toBeVisible();
     expect(
       screen.getByText('Confirm the order and reserve stock.'),
@@ -99,7 +93,7 @@ describe('application-owned permission workspace', () => {
     expect(screen.getByRole('status')).toHaveTextContent(
       'Ask the application developer',
     );
-    expect(screen.getAllByRole('checkbox')).toHaveLength(1);
+    expect(screen.queryAllByRole('checkbox')).toHaveLength(0);
     expect(screen.queryByRole('heading', { level: 2 })).not.toBeInTheDocument();
   });
 
@@ -149,11 +143,11 @@ describe('application-owned permission workspace', () => {
         onLevelChange={vi.fn()}
       />,
     );
-    const category = screen.getByRole('button', {
+    const category = screen.getByRole('tab', {
       name: 'Application configuration',
     });
     await user.click(category);
-    expect(category).toHaveAttribute('aria-current', 'page');
+    expect(category).toHaveAttribute('aria-selected', 'true');
     expect(
       screen.getByRole('checkbox', { name: 'Configure numbering' }),
     ).toBeVisible();
@@ -168,9 +162,9 @@ describe('application-owned permission workspace', () => {
     expect(
       screen.getByRole('checkbox', { name: 'Configure numbering' }),
     ).toBeVisible();
-    expect(category).toHaveAttribute('aria-current', 'page');
+    expect(category).toHaveAttribute('aria-selected', 'true');
     await user.type(screen.getByRole('textbox'), 'missing');
-    await user.click(screen.getByRole('button', { name: 'Business actions' }));
+    await user.click(screen.getByRole('tab', { name: 'Business actions' }));
     expect(screen.getByRole('textbox')).toHaveValue('');
     expect(
       screen.getByRole('checkbox', { name: 'Approve order' }),
@@ -233,7 +227,7 @@ describe('application-owned permission workspace', () => {
       );
     }
     render(<Draft />);
-    await user.click(screen.getByRole('checkbox', { name: 'Enabled only' }));
+    await user.click(screen.getByRole('tab', { name: 'Granted' }));
     await user.click(screen.getByRole('checkbox', { name: 'Approve' }));
     expect(screen.getByRole('textbox')).toHaveFocus();
     expect(screen.getByRole('status')).toHaveTextContent(
@@ -321,13 +315,13 @@ describe('application-owned permission workspace', () => {
     await user.keyboard(' ');
     expect(change).toHaveBeenCalledTimes(2);
     expect(change).toHaveBeenLastCalledWith('withdraw', true);
-    screen.getAllByRole('checkbox', { name: 'Enabled only' })[0]!.focus();
+    screen.getAllByRole('tab', { name: 'Granted' })[0]!.focus();
     await user.keyboard(' ');
     expect(change).toHaveBeenCalledTimes(2);
     await user.type(screen.getAllByRole('textbox')[0]!, 'missing');
     await user.click(screen.getByRole('button', { name: 'Clear filters' }));
     await user.click(
-      screen.getAllByRole('button', { name: 'Application configuration' })[0]!,
+      screen.getAllByRole('tab', { name: 'Application configuration' })[0]!,
     );
     screen.getByRole('checkbox', { name: 'Configure numbering' }).focus();
     await user.keyboard(' ');
@@ -543,7 +537,12 @@ const treeSection: PermissionEditorSection = {
           label: 'Catalog',
           rowId: 'catalog',
           children: [
-            { id: 'books-node', label: 'Books', rowId: 'books' },
+            {
+              id: 'books-node',
+              label: 'Books',
+              rowId: 'books',
+              path: '/library/books',
+            },
             {
               id: 'review-group',
               label: 'Approvals',
@@ -684,7 +683,7 @@ describe('application-owned page navigation', () => {
       );
     }
     render(<ControlledTree />);
-    await user.click(screen.getByRole('checkbox', { name: 'Enabled only' }));
+    await user.click(screen.getByRole('tab', { name: 'Granted' }));
     expect(screen.getByText('Library')).toBeVisible();
     expect(screen.getByText('Catalog')).toBeVisible();
     expect(screen.queryByText('Approvals')).not.toBeInTheDocument();
@@ -711,9 +710,7 @@ describe('application-owned page navigation', () => {
       />,
     );
     expect(screen.getAllByRole('list')).toHaveLength(1);
-    expect(
-      screen.queryByRole('button', { name: /Collapse|Expand/ }),
-    ).not.toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Collapse all' })).toBeDisabled();
     rerender(
       <PermissionEditor
         sections={[treeSection]}
@@ -738,3 +735,176 @@ describe('application-owned page navigation', () => {
     expect(change).not.toHaveBeenCalled();
   });
 });
+
+describe('compact permission controls', () => {
+  const leaves: PermissionEditorSection = {
+    id: 'pages',
+    title: 'Pages',
+    groups: [
+      {
+        id: 'borrowing',
+        title: 'Borrowing',
+        accessOnly: true,
+        rows: [{ id: 'borrow', label: 'Access', enabled: true }],
+      },
+      {
+        id: 'catalog',
+        title: 'Catalog',
+        accessOnly: true,
+        rows: [{ id: 'browse', label: 'Access', enabled: false }],
+      },
+    ],
+  };
+
+  it('keeps an all-leaf section visible and excludes its rows from bulk disclosure', async () => {
+    const user = userEvent.setup();
+    const change = vi.fn();
+    render(
+      <PermissionEditor
+        sections={[leaves]}
+        onEnabledChange={change}
+        onLevelChange={vi.fn()}
+      />,
+    );
+    const collapse = screen.getByRole('button', { name: 'Collapse all' });
+    expect(collapse).toBeDisabled();
+    await user.click(collapse);
+    expect(screen.getByRole('checkbox', { name: 'Borrowing' })).toBeVisible();
+    expect(screen.getByRole('checkbox', { name: 'Borrowing' })).toBeChecked();
+    expect(screen.getByRole('checkbox', { name: 'Catalog' })).not.toBeChecked();
+    expect(
+      screen.queryByRole('button', { name: 'Expand all' }),
+    ).not.toBeInTheDocument();
+    expect(change).not.toHaveBeenCalled();
+  });
+
+  it('collapses only titled groups in a mixed section while leaves stay reachable and unchanged', async () => {
+    const user = userEvent.setup();
+    const change = vi.fn();
+    render(
+      <PermissionEditor
+        sections={[
+          { ...leaves, groups: [...leaves.groups, ...sections[0]!.groups] },
+        ]}
+        onEnabledChange={change}
+        onLevelChange={vi.fn()}
+      />,
+    );
+    for (const action of ['Collapse all', 'Expand all']) {
+      await user.click(screen.getByRole('button', { name: action }));
+      for (const name of ['Borrowing', 'Catalog']) {
+        const checkbox = screen.getByRole('checkbox', { name });
+        expect(checkbox).toBeVisible();
+        checkbox.focus();
+        expect(checkbox).toHaveFocus();
+      }
+      expect(screen.getByRole('checkbox', { name: 'Borrowing' })).toBeChecked();
+      expect(
+        screen.getByRole('checkbox', { name: 'Catalog' }),
+      ).not.toBeChecked();
+      if (action === 'Collapse all') {
+        expect(
+          screen.getByRole('button', { name: 'Expand Orders' }),
+        ).toBeVisible();
+        expect(
+          screen.queryByRole('checkbox', { name: 'Approve order' }),
+        ).not.toBeInTheDocument();
+      } else {
+        expect(
+          screen.getByRole('checkbox', { name: 'Approve order' }),
+        ).toBeChecked();
+        expect(
+          screen.getByRole('checkbox', { name: 'Withdraw order' }),
+        ).not.toBeChecked();
+      }
+    }
+    expect(change).not.toHaveBeenCalled();
+  });
+
+  it('ignores an existing collapsed key when a group becomes an access-only leaf', async () => {
+    const user = userEvent.setup();
+    const change = vi.fn();
+    const props = { onEnabledChange: change, onLevelChange: vi.fn() };
+    const { rerender } = render(
+      <PermissionEditor
+        {...props}
+        sections={[
+          {
+            ...leaves,
+            groups: leaves.groups.map((group) => ({
+              ...group,
+              accessOnly: false,
+            })),
+          },
+        ]}
+      />,
+    );
+    await user.click(screen.getByRole('button', { name: 'Collapse all' }));
+    expect(screen.queryByRole('checkbox')).not.toBeInTheDocument();
+    rerender(<PermissionEditor {...props} sections={[leaves]} />);
+    expect(screen.getByRole('checkbox', { name: 'Borrowing' })).toBeVisible();
+    expect(screen.getByRole('checkbox', { name: 'Borrowing' })).toBeChecked();
+    expect(screen.getByRole('checkbox', { name: 'Catalog' })).not.toBeChecked();
+    expect(screen.getByRole('button', { name: 'Collapse all' })).toBeDisabled();
+    expect(change).not.toHaveBeenCalled();
+  });
+
+  it('filters ungranted rows globally, resets without editing, and searches actual routes', async () => {
+    const user = userEvent.setup();
+    const change = vi.fn();
+    render(
+      <PermissionEditor
+        sections={[treeSection, ...sections]}
+        onEnabledChange={change}
+        onLevelChange={vi.fn()}
+      />,
+    );
+    await user.click(screen.getByRole('tab', { name: 'Ungranted' }));
+    expect(
+      screen.getByRole('checkbox', { name: 'Review loans' }),
+    ).not.toBeChecked();
+    expect(
+      screen.getByRole('checkbox', { name: 'Configure numbering' }),
+    ).not.toBeChecked();
+    expect(
+      screen.queryByRole('checkbox', { name: 'Books' }),
+    ).not.toBeInTheDocument();
+    expect(screen.getByText('2 of 4 enabled')).toBeVisible();
+    await user.click(screen.getByRole('button', { name: 'Clear filters' }));
+    await user.type(screen.getByRole('textbox'), '/library/books');
+    expect(screen.getByRole('checkbox', { name: 'Books' })).toBeChecked();
+    expect(screen.getByText('/library/books')).toBeVisible();
+    expect(
+      screen.queryByRole('checkbox', { name: 'Review loans' }),
+    ).not.toBeInTheDocument();
+    expect(change).not.toHaveBeenCalled();
+  });
+  it('collapses resources without mutating grants and restores disclosure after search', async () => {
+    const user = userEvent.setup();
+    const change = vi.fn();
+    render(
+      <PermissionEditor
+        sections={sections}
+        onEnabledChange={change}
+        onLevelChange={vi.fn()}
+      />,
+    );
+    await user.click(screen.getByRole('button', { name: 'Collapse all' }));
+    expect(
+      screen.queryByRole('checkbox', { name: 'Approve order' }),
+    ).not.toBeInTheDocument();
+    await user.type(screen.getByRole('textbox'), 'reserve');
+    expect(
+      screen.getByRole('checkbox', { name: 'Approve order' }),
+    ).toBeChecked();
+    await user.click(screen.getByRole('button', { name: 'Clear filters' }));
+    expect(
+      screen.queryByRole('checkbox', { name: 'Approve order' }),
+    ).not.toBeInTheDocument();
+    await user.click(screen.getByRole('button', { name: 'Expand all' }));
+    expect(
+      screen.getByRole('checkbox', { name: 'Approve order' }),
+    ).toBeChecked();
+    expect(change).not.toHaveBeenCalled();
+  });
+});

package/tests/client/permission-filter-binding.test.tsx

@@ -127,7 +127,7 @@ it('collects native custom filter parameters before changing the draft, then sav
     );
   }
   render(<Role />);
-  await user.click(screen.getByRole('button', { name: 'Configuration' }));
+  await user.click(screen.getByRole('tab', { name: 'Configuration' }));
   const scope = screen.getByRole('combobox', {
     name: 'How far View · Records reaches',
   });

package/tests/client/permission-workspace.test.ts

@@ -117,6 +117,19 @@ const configurationRoutes = [
 ] as unknown as AppClientRegisteredRoute[];
 
 describe('application-owned permission presentation', () => {
+  it('omits the generic Page access description and retains other section descriptions', () => {
+    const sections = permissionSections(source, [], (value) =>
+      typeof value === 'string' ? value : value.key,
+    );
+
+    expect(
+      sections.find((section) => section.id === 'pages')?.description,
+    ).toBe(undefined);
+    expect(
+      sections.find((section) => section.id === 'business')?.description,
+    ).toBe('settings.businessOperationsHint');
+  });
+
   it('can hide a created-record selector while retaining a related-record selector and stored policy', () => {
     const resource = {
       type: 'composite',

package/tests/client/role-return.test.tsx

@@ -1,4 +1,5 @@
-import { answerApi, renderWithApp } from '@nocobase/app-testing/client';
+import { renderSettingsClient as renderWithApp } from '../helpers/settings-client.js';
+import { answerApi } from '@nocobase/app-testing/client';
 import { apiClientToken, type ClientApplication } from '@nocobase/app-client';
 import {
   AuthorizationClient,