@nocobase/app-template-default 1.0.0-beta.75 → 1.0.0-beta.77

package/tests/components/default-access-editor.test.tsx

@@ -0,0 +1,130 @@
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { expect, it, vi } from 'vitest';
+import { DefaultAccessEditor } from '../../client/components/default-access-editor.js';
+
+it('reports one explicit scope choice and does not mutate its controlled fields during browsing', async () => {
+  const user = userEvent.setup();
+  const onScopeChange = vi.fn();
+  const props = {
+    ruleKey: 'baseline',
+    resource: 'projects',
+    resources: [{ value: 'projects', label: 'Projects' }],
+    scopes: [
+      {
+        id: 'view-projects',
+        action: 'View',
+        scope: 'Projects',
+        value: 'own',
+        options: [
+          { value: 'own', label: 'Own records' },
+          { value: 'all', label: 'All records' },
+        ],
+      },
+    ],
+    labels: {
+      key: 'Key',
+      resource: 'Business object',
+      chooseResource: 'Choose an object',
+      action: 'Operation',
+      scope: 'Data scope',
+      noScopes: 'Choose an object',
+    },
+    onKeyChange: vi.fn(),
+    onResourceChange: vi.fn(),
+    onScopeChange,
+  };
+  render(<DefaultAccessEditor {...props} existing />);
+  expect(screen.getByRole('textbox', { name: 'Key *' })).toBeDisabled();
+  expect(props.onKeyChange).not.toHaveBeenCalled();
+  await user.click(screen.getByRole('combobox', { name: 'View · Projects' }));
+  expect(onScopeChange).not.toHaveBeenCalled();
+  await user.click(await screen.findByRole('option', { name: 'All records' }));
+  expect(onScopeChange).toHaveBeenCalledExactlyOnceWith('view-projects', 'all');
+});
+
+it('groups ranges by operation, keeps independent choices and preserves explicit operation identities', async () => {
+  const change = vi.fn();
+  const options = [
+    { value: '', label: 'No default scope' },
+    { value: 'all', label: 'All records' },
+  ];
+  const props = {
+    ruleKey: 'baseline',
+    resource: 'library',
+    resources: [{ value: 'library', label: 'Library' }],
+    scopes: [
+      {
+        id: 'books',
+        actionId: 'browse',
+        action: 'Browse holdings',
+        scope: 'Book information',
+        value: '',
+        options,
+      },
+      {
+        id: 'copies',
+        actionId: 'browse',
+        action: 'Browse holdings',
+        scope: 'Physical copies',
+        value: '',
+        options,
+        configuration: <button type='button'>Configure conditions</button>,
+      },
+      {
+        id: 'manage',
+        actionId: 'manage',
+        action: 'Manage',
+        scope: 'Book information',
+        value: '',
+        options,
+      },
+      {
+        id: 'settings',
+        actionId: 'settings',
+        action: 'Manage',
+        scope: 'Settings',
+        value: '',
+        options,
+      },
+    ],
+    labels: {
+      key: 'Key',
+      resource: 'Business object',
+      chooseResource: 'Choose',
+      action: 'Operation',
+      scope: 'Scope',
+      noScopes: 'Choose an object',
+    },
+    onKeyChange: vi.fn(),
+    onResourceChange: vi.fn(),
+    onScopeChange: change,
+  };
+  const view = render(<DefaultAccessEditor {...props} />);
+  expect(
+    screen.getAllByRole('heading', { name: 'Browse holdings' }),
+  ).toHaveLength(1);
+  expect(screen.getAllByRole('region', { name: 'Manage' })).toHaveLength(2);
+  await userEvent.click(
+    screen.getByRole('button', { name: 'Configure conditions' }),
+  );
+  expect(change).not.toHaveBeenCalled();
+  await userEvent.click(
+    screen.getByRole('combobox', { name: 'Browse holdings · Physical copies' }),
+  );
+  await userEvent.click(
+    await screen.findByRole('option', { name: 'All records' }),
+  );
+  expect(change).toHaveBeenCalledExactlyOnceWith('copies', 'all');
+  expect(
+    screen.getByRole('combobox', {
+      name: 'Browse holdings · Book information',
+    }),
+  ).toHaveTextContent('No default scope');
+  view.rerender(<DefaultAccessEditor {...props} readOnly />);
+  expect(
+    screen
+      .getAllByRole('combobox')
+      .every((item) => item.hasAttribute('disabled')),
+  ).toBe(true);
+});

package/tests/components/default-access.test.tsx

@@ -5,9 +5,9 @@ import {
   authorizationClientToken,
   type AuthorizationOptionsResponse,
 } from '@nocobase/app-plugin-authorization/client';
-import { screen, waitFor, within } from '@testing-library/react';
+import { act, screen, waitFor, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
-import { Routes, Route } from 'react-router';
+import { Routes, Route, useLocation, useNavigate } from 'react-router';
 import { expect, it, vi } from 'vitest';
 import Page from '../../client/pages/settings/default-access.js';
 import Form from '../../client/pages/settings/default-access-form.js';
@@ -552,3 +552,142 @@ it('maps a server scope validation error to the affected selector and focuses it
   expect(scope).toHaveTextContent('All records');
   expect(screen.queryByText('Private detail')).not.toBeInTheDocument();
 });
+
+it('does not reset a title-filtered page while its metadata is still loading', async () => {
+  let resolveCatalog!: (value: { data: AuthorizationOptionsResponse }) => void;
+  const pending = new Promise<{ data: AuthorizationOptionsResponse }>(
+    (resolve) => {
+      resolveCatalog = resolve;
+    },
+  );
+  const resources = Array.from({ length: 25 }, (_, i) => ({
+    ...catalog.sections[0]!.subsections[0]!.resources[0]!,
+    id: `resource-${i}`,
+    title: `Projects ${i}`,
+  }));
+  const namedCatalog = {
+    ...catalog,
+    sections: [
+      {
+        ...catalog.sections[0]!,
+        subsections: [{ ...catalog.sections[0]!.subsections[0]!, resources }],
+      },
+    ],
+  };
+  const rules = resources.map((resource, i) => ({
+    ...existing,
+    key: `rule-${i}`,
+    resource: { type: 'composite', id: resource.id },
+  }));
+  function CurrentLocation() {
+    const location = useLocation();
+    return <output data-testid='metadata-location'>{location.search}</output>;
+  }
+  const calls = vi.fn(async ({ path }: { path: string }) =>
+    path === 'authorization/permissions'
+      ? { data: { unrestricted: true, permissions: [] } }
+      : path.endsWith('/options')
+        ? pending
+        : { data: rules },
+  );
+  await renderWithApp(
+    <>
+      <Page />
+      <CurrentLocation />
+    </>,
+    {
+      route: '/default-access?q=Projects&page=2&pageSize=20',
+      namespace,
+      namespaces,
+      services,
+      fetch: answerApi(calls),
+    },
+  );
+  await waitFor(() =>
+    expect(calls).toHaveBeenCalledWith(
+      expect.objectContaining({ path: 'authorization/defaultAccess' }),
+    ),
+  );
+  await act(async () => {
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  });
+  expect(screen.getByTestId('metadata-location')).toHaveTextContent('page=2');
+  await act(async () => {
+    resolveCatalog({ data: namedCatalog });
+  });
+  expect(await screen.findByText('Page 2 of 2')).toBeVisible();
+  expect(screen.getByTestId('metadata-location')).toHaveTextContent('page=2');
+});
+
+it('replaces the saved editor history entry and keeps the list query when going back', async () => {
+  const query = '?q=Projects&pageSize=20&sort=resource&order=desc';
+  function History() {
+    const location = useLocation();
+    const navigate = useNavigate();
+    return (
+      <>
+        <output data-testid='history-location'>
+          {location.pathname}
+          {location.search}
+        </output>
+        <button onClick={() => void navigate(-1)}>Back in history</button>
+      </>
+    );
+  }
+  let patches = 0;
+  let rules = [existing];
+  await renderWithApp(
+    <>
+      {tree()}
+      <History />
+    </>,
+    {
+      route: `/default-access${query}`,
+      namespace,
+      namespaces,
+      services,
+      fetch: answerApi((request) => {
+        if (request.path === 'authorization/permissions')
+          return { data: { unrestricted: true, permissions: [] } };
+        if (request.path.endsWith('/options')) return { data: catalog };
+        if (request.method === 'PATCH') {
+          patches += 1;
+          expect(request.json).toEqual({ actions: [existing.actions[0]] });
+          rules = [{ ...existing, actions: [existing.actions[0]!] }];
+          return { data: rules[0] };
+        }
+        return { data: rules };
+      }),
+    },
+  );
+  await userEvent.click(await screen.findByRole('link', { name: 'Projects' }));
+  await userEvent.click(
+    await screen.findByRole('combobox', { name: 'Edit · Projects' }),
+  );
+  await userEvent.click(
+    await screen.findByRole('option', {
+      name: enUS.settings.defaultAccess.none,
+    }),
+  );
+  const save = screen.getByRole('button', { name: enUS.settings.save });
+  expect(save).toBeEnabled();
+  await userEvent.click(save);
+  await waitFor(() =>
+    expect(screen.getByTestId('history-location').textContent).toBe(
+      `/default-access${query}`,
+    ),
+  );
+  expect(patches).toBe(1);
+  await userEvent.click(
+    screen.getByRole('button', { name: 'Back in history' }),
+  );
+  await waitFor(() =>
+    expect(screen.getByTestId('history-location').textContent).toBe(
+      `/default-access${query}`,
+    ),
+  );
+  expect(
+    screen.queryByRole('button', { name: enUS.settings.save }),
+  ).not.toBeInTheDocument();
+  expect(patches).toBe(1);
+});