@nocobase/app-template-default 1.0.0-beta.87 → 1.0.0-beta.89

package/tests/client/registration-feedback.test.tsx

@@ -0,0 +1,143 @@
+import {
+  AuthenticationProvider,
+  GuestAuthentication,
+  authenticationClientToken,
+} from '@nocobase/app-plugin-authentication/client';
+import { authorizationClientToken } from '@nocobase/app-plugin-authorization/client';
+import { reactProviders } from '@nocobase/app-plugin-authorization/client/react-providers';
+import { renderWithApp } from '@nocobase/app-testing/client';
+import { act, fireEvent, screen } from '@testing-library/react';
+import { Route, Routes } from 'react-router';
+import { describe, expect, it, vi } from 'vitest';
+import enUS from '../../client/locales/en-US.js';
+import zhCN from '../../client/locales/zh-CN.js';
+import RegisterPage from '../../client/pages/auth/register.js';
+
+const AuthorizationProvider = reactProviders[0]!.component;
+
+async function renderRegistration(signedIn = false, locale = 'en-US') {
+  let registered = false;
+  const refresh = Promise.withResolvers<void>();
+  const email = vi.fn(async () => {
+    registered = true;
+    return { token: null, user: { id: 'untrusted-id' } };
+  });
+  const getSession = vi.fn(async () => {
+    if (registered) await refresh.promise;
+    return {
+      data:
+        registered && signedIn
+          ? { user: { id: 'real-user' }, session: { id: 'real-session' } }
+          : null,
+    };
+  });
+  const view = await renderWithApp(
+    <AuthenticationProvider>
+      <AuthorizationProvider>
+        <Routes>
+          <Route
+            path='/register'
+            element={
+              <GuestAuthentication>
+                <RegisterPage />
+              </GuestAuthentication>
+            }
+          />
+          <Route path='/' element={<p>Signed-in home</p>} />
+        </Routes>
+      </AuthorizationProvider>
+    </AuthenticationProvider>,
+    {
+      route: '/register',
+      locale,
+      namespace: 'registration-test',
+      namespaces: { 'registration-test': locale === 'en-US' ? enUS : zhCN },
+      services: (app) => {
+        app.container.instance(authorizationClientToken, {
+          resetSession: vi.fn(),
+        });
+        app.container.instance(authenticationClientToken, {
+          getSession,
+          signUp: { email },
+        });
+      },
+    },
+  );
+  await screen.findByRole('heading', {
+    name: locale === 'en-US' ? 'Create an account' : '创建账户',
+  });
+  return { ...view, refresh, email };
+}
+
+function submitForm(container: HTMLElement, locale = 'en-US') {
+  const labels =
+    locale === 'en-US'
+      ? ['Name', 'Username', 'Email', 'Password', 'Confirm password']
+      : ['姓名', '用户名', '邮箱', '密码', '确认密码'];
+  const values = [
+    'Person',
+    'person',
+    'person@example.test',
+    'test-password',
+    'test-password',
+  ];
+  labels.forEach((label, index) =>
+    fireEvent.change(screen.getByLabelText(label), {
+      target: { value: values[index] },
+    }),
+  );
+  fireEvent.submit(container.querySelector('form')!);
+}
+
+describe('registration feedback with the real session provider and guest guard', () => {
+  it.each(['en-US', 'zh-CN'])(
+    'keeps accepted unsigned-in feedback after session refresh in %s',
+    async (locale) => {
+      const { container, refresh, email } = await renderRegistration(
+        false,
+        locale,
+      );
+      submitForm(container, locale);
+      try {
+        await vi.waitFor(() => expect(email).toHaveBeenCalledOnce());
+        expect(container.querySelector('form')).toBeInTheDocument();
+      } finally {
+        await act(async () => {
+          refresh.resolve();
+        });
+      }
+      const status = await screen.findByRole('status');
+      expect(status).toHaveTextContent(
+        locale === 'en-US'
+          ? 'the new details will not take effect'
+          : '新填写的信息不会生效',
+      );
+      expect(container.querySelector('form')).not.toBeInTheDocument();
+      expect(
+        screen.getByRole('link', {
+          name: locale === 'en-US' ? 'Sign in' : '登录',
+        }),
+      ).toHaveAttribute('href', '/login');
+      expect(
+        screen.getByRole('link', {
+          name: locale === 'en-US' ? 'Forgot password?' : '忘记密码？',
+        }),
+      ).toHaveAttribute('href', '/forgot-password');
+      expect(status).not.toHaveTextContent(
+        /account (?:created|has been created)|email (?:sent|has been sent)|账户已创建|邮件已发送/i,
+      );
+    },
+  );
+
+  it('uses the refreshed session to leave the guest page', async () => {
+    const { container, refresh } = await renderRegistration(true);
+    submitForm(container);
+    await act(async () => {
+      refresh.resolve();
+    });
+    expect(await screen.findByText('Signed-in home')).toBeVisible();
+    expect(
+      screen.queryByText('Registration request submitted'),
+    ).not.toBeInTheDocument();
+  });
+});

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

@@ -1,3 +1,5 @@
+import type { AppClientRegisteredRoute } from '@nocobase/app-client/plugins';
+import { RouteTreeProvider } from '../../client/routing/route-context.js';
 import { renderSettingsClient as renderWithApp } from '../helpers/settings-client.js';
 import { answerApi } from '@nocobase/app-testing/client';
 import { apiClientToken, type ClientApplication } from '@nocobase/app-client';
@@ -14,8 +16,24 @@ import enUS from '../../client/locales/en-US.js';
 import zhCN from '../../client/locales/zh-CN.js';
 
 const namespace = '@nocobase/role-return-test';
-function Parent() {
-  return <Outlet context={{ reload: () => undefined }} />;
+function Parent({ path }: { path: string }) {
+  const routes: AppClientRegisteredRoute[] = [
+    {
+      id: 'roles',
+      name: 'roles',
+      path,
+      packageName: namespace,
+      source: 'application',
+      auth: 'required',
+      authz: 'skip',
+      componentLoader: async () => ({ default: () => null }),
+    },
+  ];
+  return (
+    <RouteTreeProvider routes={routes}>
+      <Outlet context={{ reload: () => undefined }} />
+    </RouteTreeProvider>
+  );
 }
 function Location() {
   const { pathname, search } = useLocation();
@@ -50,7 +68,7 @@ it.each(
   const result = await renderWithApp(
     <>
       <Routes>
-        <Route path={parent} element={<Parent />}>
+        <Route path={parent} element={<Parent path={parent} />}>
           <Route index element={<h1>Role list</h1>} />
           <Route path=':key/edit' element={<RoleForm />} />
         </Route>

package/tests/client/roles.test.tsx

@@ -4,10 +4,10 @@ import {
   AuthorizationClient,
   authorizationClientToken,
 } 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 { expect, it } from 'vitest';
+import { Routes, Route, useNavigate } from 'react-router';
+import { expect, it, vi } from 'vitest';
 import RolesPage from '../../client/pages/settings/roles.js';
 import enUS from '../../client/locales/en-US.js';
 import zhCN from '../../client/locales/zh-CN.js';
@@ -83,3 +83,84 @@ it('keeps the standard role table sorted, searchable and linked to the current q
     '/settings/roles/cp-customer/edit?q=Customer',
   );
 });
+
+function Navigate({ to, label }: { to: string; label: string }) {
+  const navigate = useNavigate();
+  return (
+    <button type='button' onClick={() => void navigate(to)}>
+      {label}
+    </button>
+  );
+}
+
+it('announces a slow retry after a refresh failure once, from the retry button', async () => {
+  const user = userEvent.setup();
+  const roles = { data: [{ key: 'team', title: 'NocoBase team', grants: [] }] };
+  let reads = 0;
+  let finish!: () => void;
+  const slow = new Promise<void>((resolve) => {
+    finish = resolve;
+  });
+  await renderWithApp(
+    <>
+      <Routes>
+        <Route path='/settings/roles' element={<RolesPage />}>
+          <Route
+            path='covered'
+            element={<Navigate to='/settings/roles' label='Back to roles' />}
+          />
+        </Route>
+      </Routes>
+      <Navigate to='/settings/roles/covered' label='Cover roles' />
+    </>,
+    {
+      route: '/settings/roles',
+      namespace: settingsNamespace,
+      namespaces,
+      services,
+      fetch: answerApi(async ({ path }) => {
+        if (path === 'authorization/permissions')
+          return { data: { unrestricted: true, permissions: [] } };
+        reads += 1;
+        if (reads === 2)
+          return Response.json(
+            { error: { status: 'INTERNAL', message: 'Unavailable' } },
+            { status: 500 },
+          );
+        if (reads === 3) await slow;
+        return roles;
+      }),
+    },
+  );
+  await screen.findByTitle('NocoBase team');
+  // Returning from a covering route reads the list again; that read fails.
+  await user.click(screen.getByRole('button', { name: 'Cover roles' }));
+  await user.click(
+    await screen.findByRole('button', { name: 'Back to roles' }),
+  );
+  await screen.findByText(enUS.listFeedback.refreshFailed);
+  vi.useFakeTimers();
+  try {
+    await act(async () => {
+      screen.getByRole('button', { name: enUS.listFeedback.retry }).click();
+    });
+    await act(() => vi.advanceTimersByTimeAsync(300));
+    expect(screen.getAllByRole('status')).toHaveLength(1);
+    expect(
+      screen.getByRole('button', { name: enUS.listFeedback.retrying }),
+    ).toBeDisabled();
+    expect(screen.getByTitle('NocoBase team')).toBeVisible();
+    await act(async () => {
+      finish();
+      await vi.advanceTimersByTimeAsync(0);
+    });
+  } finally {
+    vi.useRealTimers();
+  }
+  await waitFor(() =>
+    expect(
+      screen.queryByText(enUS.listFeedback.refreshFailed),
+    ).not.toBeInTheDocument(),
+  );
+  expect(screen.queryByRole('status')).not.toBeInTheDocument();
+});

package/tests/client/route-leave-recheck.test.tsx

@@ -0,0 +1,74 @@
+import { Activity, useState, useLayoutEffect } from 'react';
+import { Link, Route, Routes, useLocation } from 'react-router';
+import { renderWithApp } from '@nocobase/app-testing/client';
+import { act, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { expect, it } from 'vitest';
+import {
+  RouteLeaveBoundary,
+  usePageLeave,
+} from '../../client/routing/route-leave-boundary.js';
+import enUS from '../../client/locales/en-US.js';
+import metadata from '../../package.json' with { type: 'json' };
+
+it('cancels a shell leave confirmation on concealment and requires a fresh decision after recovery', async () => {
+  let conceal: (hidden: boolean) => void;
+  function Editor() {
+    const leave = usePageLeave(true, false);
+    return (
+      <>
+        <p>Unsaved editor</p>
+        {leave.dialog}
+      </>
+    );
+  }
+  function Harness() {
+    const [hidden, setHidden] = useState(false);
+    useLayoutEffect(() => {
+      conceal = setHidden;
+    }, []);
+    return (
+      <RouteLeaveBoundary hidden={hidden}>
+        <Link to='/other'>Leave page</Link>
+        <output data-testid='location'>{useLocation().pathname}</output>
+        <Routes>
+          <Route
+            path='/editor'
+            element={
+              <Activity mode={hidden ? 'hidden' : 'visible'}>
+                <Editor />
+              </Activity>
+            }
+          />
+          <Route path='/other' element={<p>Other page</p>} />
+        </Routes>
+      </RouteLeaveBoundary>
+    );
+  }
+  const user = userEvent.setup();
+  await renderWithApp(<Harness />, {
+    route: '/editor',
+    namespace: metadata.name,
+    namespaces: { [metadata.name]: enUS },
+  });
+  await user.click(screen.getByRole('link', { name: 'Leave page' }));
+  await screen.findByRole('alertdialog');
+  await act(async () => conceal(true));
+  expect(screen.queryByRole('alertdialog')).toBeNull();
+  await user.click(screen.getByRole('link', { name: 'Leave page' }));
+  expect(screen.getByTestId('location')).toHaveTextContent('/editor');
+  const unload = new Event('beforeunload', { cancelable: true });
+  window.dispatchEvent(unload);
+  expect(unload.defaultPrevented).toBe(true);
+  await act(async () => conceal(false));
+  expect(screen.getByText('Unsaved editor')).toBeVisible();
+  expect(screen.getByTestId('location')).toHaveTextContent('/editor');
+  expect(screen.queryByRole('alertdialog')).toBeNull();
+  await user.click(screen.getByRole('link', { name: 'Leave page' }));
+  const question = await screen.findByRole('alertdialog');
+  await user.click(within(question).getByRole('button', { name: 'Confirm' }));
+  await waitFor(() => expect(screen.getByText('Other page')).toBeVisible());
+  const after = new Event('beforeunload', { cancelable: true });
+  window.dispatchEvent(after);
+  expect(after.defaultPrevented).toBe(false);
+});