@nocobase/app-template-default 0.0.0-stage → 1.0.0-beta.57

package/tests/logic/account-permissions.test.tsx

@@ -0,0 +1,204 @@
+import {
+  ClientApplicationContext,
+  type ClientApplication,
+} from '@nocobase/app-client';
+import type { AppClientRegisteredRoute } from '@nocobase/app-client/plugins';
+import {
+  AuthorizationClient,
+  authorizationClientToken,
+} from '@nocobase/app-plugin-authorization/client';
+import { reactProviders } from '@nocobase/app-plugin-authorization/client/react-providers';
+import { ServiceContainer } from '@nocobase/service-provider';
+import {
+  TestI18nProvider,
+  createTestI18nRuntime,
+} from '@nocobase/i18n/testing';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { MemoryRouter } from 'react-router';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ClientRoute } from '../../client/routing/client-route.js';
+import { useRouteNavigation } from '../../client/routing/route-navigation.js';
+import enUS from '../../client/locales/en-US.js';
+
+const AuthorizationProvider = reactProviders[0].component;
+
+const runtime = await createTestI18nRuntime({
+  application: { namespace: '@nocobase/app-template-default', resources: enUS },
+});
+
+function I18n({ children }: { readonly children: ReactNode }) {
+  return <TestI18nProvider runtime={runtime}>{children}</TestI18nProvider>;
+}
+
+const authentication = vi.hoisted(() => ({
+  session: null as null | { user: { id: string }; session: { id: string } },
+  isPending: false,
+}));
+vi.mock('@nocobase/app-plugin-authentication/client', () => ({
+  useAuthentication: () => authentication,
+}));
+const routes: AppClientRegisteredRoute[] = ['apps', 'users'].map((name) => ({
+  id: name,
+  name,
+  path: `/${name}`,
+  auth: 'required',
+  authz: { resource: { type: 'page', id: name }, action: 'access' },
+  packageName: 'test',
+  source: 'application',
+  navigation: { title: name },
+  componentLoader: async () => ({ default: () => <div>{name} content</div> }),
+}));
+const permissions = (admin: boolean) => ({
+  data: {
+    permissions: (admin ? ['apps', 'users'] : ['apps']).map((id) => ({
+      resource: { type: 'page', id },
+      actions: ['access'],
+    })),
+  },
+});
+function Menu() {
+  const { items, loading } = useRouteNavigation(routes);
+  return (
+    <nav aria-label='Pages'>
+      {loading
+        ? 'Checking'
+        : items.map(({ route }) => <span key={route.id}>{route.name}</span>)}
+    </nav>
+  );
+}
+function session(user: string, id = user) {
+  authentication.session = { user: { id: user }, session: { id } };
+}
+function setup(
+  request = vi
+    .fn()
+    .mockImplementation(() =>
+      Promise.resolve(permissions(authentication.session?.user.id === 'admin')),
+    ),
+) {
+  const client = new AuthorizationClient({ request } as never);
+  const container = new ServiceContainer();
+  container.instance(authorizationClientToken, client);
+  const app = { services: container } as unknown as ClientApplication;
+  const tree = () => (
+    <ClientApplicationContext.Provider value={app}>
+      <MemoryRouter>
+        <AuthorizationProvider>
+          <Menu />
+          <ClientRoute route={routes[1]} />
+        </AuthorizationProvider>
+      </MemoryRouter>
+    </ClientApplicationContext.Provider>
+  );
+  const view = render(tree(), { wrapper: I18n });
+  return { client, request, rerender: () => view.rerender(tree()) };
+}
+async function expectMenu(admin: boolean) {
+  await waitFor(() =>
+    expect(screen.getByRole('navigation', { name: 'Pages' }).textContent).toBe(
+      admin ? 'appsusers' : 'apps',
+    ),
+  );
+  if (admin)
+    await waitFor(() =>
+      expect(screen.getByText('users content')).toBeInTheDocument(),
+    );
+  else {
+    await waitFor(() =>
+      expect(screen.getByText('Access denied')).toBeInTheDocument(),
+    );
+    expect(screen.queryByText('users content')).not.toBeInTheDocument();
+  }
+}
+
+describe('account permission changes without a browser reload', () => {
+  beforeEach(() => {
+    authentication.session = null;
+    authentication.isPending = false;
+  });
+
+  it('updates menus and cached route guards from admin to operator and back', async () => {
+    session('admin');
+    const view = setup();
+    await expectMenu(true);
+    session('operator');
+    view.rerender();
+    expect(screen.queryByText('users content')).not.toBeInTheDocument();
+    await expectMenu(false);
+    session('admin');
+    view.rerender();
+    await expectMenu(true);
+  });
+
+  it('clears permissions on logout and same-user re-login with a new session', async () => {
+    session('admin', 'first');
+    const view = setup();
+    await expectMenu(true);
+    authentication.isPending = true;
+    view.rerender();
+    expect(screen.queryByRole('navigation')).not.toBeInTheDocument();
+    authentication.session = null;
+    authentication.isPending = false;
+    view.rerender();
+    await expectMenu(false);
+    view.request.mockResolvedValue(permissions(false));
+    session('admin', 'second');
+    view.rerender();
+    await expectMenu(false);
+    expect(view.request).toHaveBeenCalledTimes(3);
+  });
+
+  it('updates a mounted menu and page when permissions change', async () => {
+    session('admin');
+    const view = setup();
+    await expectMenu(true);
+    view.request.mockResolvedValue(permissions(false));
+    act(() => view.client.invalidate());
+    expect(screen.queryByText('users content')).not.toBeInTheDocument();
+    await expectMenu(false);
+    view.request.mockResolvedValue(permissions(true));
+    act(() => view.client.invalidate());
+    await expectMenu(true);
+  });
+
+  it('hides previously allowed pages when revalidation fails and recovers on retry', async () => {
+    session('admin');
+    const view = setup();
+    await expectMenu(true);
+    view.request.mockRejectedValue(new Error('Offline'));
+    act(() => view.client.invalidate());
+    await waitFor(() =>
+      expect(
+        screen.getByRole('navigation', { name: 'Pages' }).textContent,
+      ).toBe(''),
+    );
+    await waitFor(() =>
+      expect(screen.getByText('Access denied')).toBeInTheDocument(),
+    );
+    expect(screen.queryByText('users content')).not.toBeInTheDocument();
+    view.request.mockResolvedValue(permissions(true));
+    act(() => view.client.invalidate());
+    await expectMenu(true);
+  });
+
+  it('does not restore admin menus when an old request returns after switching accounts', async () => {
+    const old = Promise.withResolvers<ReturnType<typeof permissions>>();
+    const request = vi
+      .fn()
+      .mockReturnValueOnce(old.promise)
+      .mockResolvedValue(permissions(false));
+    session('admin');
+    const view = setup(request);
+    await waitFor(() => expect(request).toHaveBeenCalledTimes(1));
+    session('operator');
+    view.rerender();
+    await expectMenu(false);
+    await act(async () => {
+      old.resolve(permissions(true));
+      await old.promise;
+    });
+    await expectMenu(false);
+    expect(request).toHaveBeenCalledTimes(2);
+  });
+});

package/tests/logic/app-locale-coverage.test.ts

@@ -0,0 +1,136 @@
+// @vitest-environment node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { describe, expect, it } from 'vitest';
+
+import enUS from '../../client/locales/en-US.ts';
+import zhCN from '../../client/locales/zh-CN.ts';
+
+const clientDirectory = fileURLToPath(new URL('../../client', import.meta.url));
+
+/** Every addressable key of a locale, as the dot-separated path `t()` is called with. */
+function translationKeys(
+  resource: Record<string, unknown>,
+  prefix = '',
+): string[] {
+  return Object.entries(resource).flatMap(([key, value]) => {
+    if (!prefix && key === 'overrides') return [];
+    const keyPath = prefix ? prefix + '.' + key : key;
+    return value && typeof value === 'object'
+      ? translationKeys(value as Record<string, unknown>, keyPath)
+      : [keyPath.replace(/_(?:zero|one|two|few|many|other)$/u, '')];
+  });
+}
+
+function sourceFiles(directory: string): string[] {
+  return fs.readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const entryPath = path.join(directory, entry.name);
+    if (entry.isDirectory()) return sourceFiles(entryPath);
+    return /\.tsx?$/u.test(entry.name) &&
+      !entryPath.includes(`${path.sep}locales${path.sep}`)
+      ? [entryPath]
+      : [];
+  });
+}
+
+const english = new Set(translationKeys(enUS as Record<string, unknown>));
+const chinese = new Set(translationKeys(zhCN as Record<string, unknown>));
+/** The literal first argument of `t()`: `t('projects.title')`, but not the prefix of `t('appearance.' + mode)`. */
+const calledKey = /\bt\(\s*'([^'$]+)'(?!\s*\+)/gu;
+/** A key completed by concatenation, `t('appearance.' + mode)`: only its prefix is static. */
+const concatenatedKey = /\bt\(\s*'([^']+)'\s*\+/gu;
+/** A key a route or registry names for later translation: `navigation: { title: 'navigation.projects' }`. */
+const namedKey =
+  /\b(?:title|labelKey):\s*'([a-zA-Z][a-zA-Z0-9]*(?:\.[a-zA-Z0-9]+)+)'/gu;
+/** A key the code completes at runtime, such as ``t(`projects.status.${status}`)``: only its prefix is static. */
+const interpolatedKey = /\bt\(\s*\x60([^\x60]*?)\x24\{/gu;
+/** `useTranslation('@nocobase/app-plugin-file')`: the file translates in a plugin's namespace, not the application's. */
+const pluginNamespace = /\buseTranslation\(\s*'/u;
+
+interface References {
+  readonly file: string;
+  readonly keys: readonly string[];
+  readonly prefixes: readonly string[];
+}
+
+/**
+ * The keys and key prefixes one source file references. Comment lines are skipped, and the rest is scanned as one
+ * text, so a `t(` call that Prettier wrapped onto several lines is still read.
+ */
+function scan(source: string): {
+  readonly keys: Set<string>;
+  readonly prefixes: Set<string>;
+} {
+  const code = source
+    .split('\n')
+    .filter((line) => !/^\s*(?:\/\/|\*)/u.test(line))
+    .join('\n');
+  const keys = new Set<string>();
+  const prefixes = new Set<string>();
+  for (const match of code.matchAll(calledKey)) keys.add(match[1]);
+  for (const match of code.matchAll(namedKey)) keys.add(match[1]);
+  for (const match of code.matchAll(interpolatedKey)) prefixes.add(match[1]);
+  for (const match of code.matchAll(concatenatedKey)) prefixes.add(match[1]);
+  return { keys, prefixes };
+}
+
+function referencedKeys(): References[] {
+  return sourceFiles(clientDirectory).flatMap((file) => {
+    const source = fs.readFileSync(file, 'utf8');
+    if (pluginNamespace.test(source)) return [];
+    const { keys, prefixes } = scan(source);
+    return [
+      {
+        file: path.relative(clientDirectory, file),
+        keys: [...keys].sort(),
+        prefixes: [...prefixes].sort(),
+      },
+    ];
+  });
+}
+
+describe('application translations', () => {
+  const references = referencedKeys();
+
+  const missing = (written: ReadonlySet<string>): string[] =>
+    references.flatMap(({ file, keys }) =>
+      keys
+        .filter((key) => !written.has(key))
+        .map((key) => key + ' (' + file + ')'),
+    );
+  const missingFamilies = (written: ReadonlySet<string>): string[] =>
+    references.flatMap(({ file, prefixes }) =>
+      prefixes
+        .filter((prefix) => ![...written].some((key) => key.startsWith(prefix)))
+        .map((prefix) => prefix + '… (' + file + ')'),
+    );
+
+  it('reads the keys the application uses', () => {
+    // Guards the scan itself: a regex that quietly stops matching would turn this suite into a no-op.
+    expect(
+      references.reduce((total, { keys }) => total + keys.length, 0),
+    ).toBeGreaterThan(10);
+  });
+
+  it('reads a t() call that Prettier wrapped onto several lines', () => {
+    expect([
+      ...scan("t(\n  'projects.delete.title',\n  { name },\n)").keys,
+    ]).toEqual(['projects.delete.title']);
+  });
+
+  it('translates every key the application uses into English', () => {
+    expect(missing(english)).toEqual([]);
+  });
+
+  it('translates every key the application uses into Chinese', () => {
+    expect(missing(chinese)).toEqual([]);
+  });
+
+  it('translates the key families the application completes at runtime', () => {
+    expect(missingFamilies(english)).toEqual([]);
+    expect(missingFamilies(chinese)).toEqual([]);
+  });
+});