@nocobase/client-v2 2.2.0-beta.1 → 2.2.0-beta.10

package/src/__tests__/RouteRepository.test.ts

@@ -0,0 +1,239 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import type { NocoBaseDesktopRoute } from '../flow-compat';
+import { RouteRepository } from '../RouteRepository';
+
+function createRouteRepository() {
+  const request = vi.fn().mockResolvedValue({
+    data: {
+      data: [],
+    },
+  });
+  const create = vi.fn().mockResolvedValue({
+    data: {
+      data: {},
+    },
+  });
+  const resource = vi.fn(() => ({
+    create,
+  }));
+  const repository = new RouteRepository({
+    api: {
+      request,
+      resource,
+    },
+  } as never);
+
+  return {
+    create,
+    repository,
+    request,
+    resource,
+  };
+}
+
+function route(schemaUid: string): NocoBaseDesktopRoute {
+  return { schemaUid } as NocoBaseDesktopRoute;
+}
+
+describe('RouteRepository', () => {
+  it('should pass the default admin layout when loading accessible routes', async () => {
+    const { repository, request } = createRouteRepository();
+
+    await repository.refreshAccessible();
+
+    expect(request).toHaveBeenCalledWith({
+      url: '/desktopRoutes:listAccessible',
+      params: {
+        tree: true,
+        sort: 'sort',
+        layout: 'admin-layout-model',
+      },
+    });
+  });
+
+  it('should pass the active client-v2 layout when loading accessible routes', async () => {
+    const { repository, request } = createRouteRepository();
+    const deactivateLayout = repository.activateLayout({
+      uid: 'custom-desktop-layout-model',
+    });
+
+    await repository.refreshAccessible();
+    deactivateLayout();
+
+    expect(request).toHaveBeenCalledWith({
+      url: '/desktopRoutes:listAccessible',
+      params: {
+        tree: true,
+        sort: 'sort',
+        layout: 'custom-desktop-layout-model',
+      },
+    });
+  });
+
+  it('should reload accessible routes when the active client-v2 layout changes', async () => {
+    const { repository, request } = createRouteRepository();
+    const deactivateFirstLayout = repository.activateLayout({
+      uid: 'first-layout-model',
+    });
+    await repository.ensureAccessibleLoaded();
+    deactivateFirstLayout();
+
+    const deactivateSecondLayout = repository.activateLayout({
+      uid: 'second-layout-model',
+    });
+    await repository.ensureAccessibleLoaded();
+    deactivateSecondLayout();
+
+    expect(request).toHaveBeenNthCalledWith(1, {
+      url: '/desktopRoutes:listAccessible',
+      params: {
+        tree: true,
+        sort: 'sort',
+        layout: 'first-layout-model',
+      },
+    });
+    expect(request).toHaveBeenNthCalledWith(2, {
+      url: '/desktopRoutes:listAccessible',
+      params: {
+        tree: true,
+        sort: 'sort',
+        layout: 'second-layout-model',
+      },
+    });
+  });
+
+  it('should report accessible routes as unloaded when the active layout changes', () => {
+    const { repository } = createRouteRepository();
+
+    repository.setRoutes([], 'first-layout-model');
+    const deactivateLayout = repository.activateLayout({
+      uid: 'second-layout-model',
+    });
+
+    expect(repository.isAccessibleLoaded()).toBe(false);
+    deactivateLayout();
+  });
+
+  it('should keep accessible route caches isolated by active layout', () => {
+    const { repository } = createRouteRepository();
+
+    repository.setRoutes([route('admin-page')], 'admin-layout-model');
+    const deactivateLayout = repository.activateLayout({
+      uid: 'custom-desktop-layout-model',
+    });
+    repository.setRoutes([route('custom-page')], 'custom-desktop-layout-model');
+
+    expect(repository.listAccessible().map((route) => route.schemaUid)).toEqual(['custom-page']);
+    expect(repository.getRouteBySchemaUid('admin-page')).toBeUndefined();
+    deactivateLayout();
+
+    expect(repository.listAccessible().map((route) => route.schemaUid)).toEqual(['admin-page']);
+    expect(repository.getRouteBySchemaUid('custom-page')).toBeUndefined();
+  });
+
+  it('should find nested routes by id', () => {
+    const { repository } = createRouteRepository();
+
+    repository.setRoutes([
+      {
+        id: 1,
+        schemaUid: 'group-1',
+        children: [
+          {
+            id: 11,
+            schemaUid: 'page-1',
+          },
+        ],
+      },
+    ] as NocoBaseDesktopRoute[]);
+
+    expect(repository.getRouteById('11')).toMatchObject({
+      id: 11,
+      schemaUid: 'page-1',
+    });
+    expect(repository.getRouteById('missing')).toBeUndefined();
+  });
+
+  it('should notify only subscribers for the changed layout cache', () => {
+    const { repository } = createRouteRepository();
+    const adminEvents: string[][] = [];
+    const customEvents: string[][] = [];
+
+    const unsubscribeAdmin = repository.subscribe(() => {
+      adminEvents.push(repository.listAccessible().map((route) => route.schemaUid || ''));
+    });
+    const deactivateLayout = repository.activateLayout({
+      uid: 'custom-desktop-layout-model',
+    });
+    const unsubscribeCustom = repository.subscribe(() => {
+      customEvents.push(repository.listAccessible().map((route) => route.schemaUid || ''));
+    });
+
+    repository.setRoutes([route('custom-page')], 'custom-desktop-layout-model');
+
+    expect(adminEvents).toEqual([]);
+    expect(customEvents).toEqual([['custom-page']]);
+
+    deactivateLayout();
+    repository.setRoutes([route('admin-page')], 'admin-layout-model');
+
+    expect(adminEvents).toEqual([['admin-page']]);
+    expect(customEvents).toEqual([['custom-page']]);
+
+    unsubscribeAdmin();
+    unsubscribeCustom();
+  });
+
+  it('should pass the default admin layout when creating a route', async () => {
+    const { repository, create } = createRouteRepository();
+
+    await repository.createRoute(
+      {
+        title: 'Admin page',
+      },
+      {
+        refreshAfterMutation: false,
+      },
+    );
+
+    expect(create).toHaveBeenCalledWith({
+      values: {
+        title: 'Admin page',
+      },
+      layout: 'admin-layout-model',
+    });
+  });
+
+  it('should pass the active client-v2 layout when creating a route', async () => {
+    const { repository, create } = createRouteRepository();
+    const deactivateLayout = repository.activateLayout({
+      uid: 'custom-desktop-layout-model',
+    });
+
+    await repository.createRoute(
+      {
+        title: 'Custom page',
+      },
+      {
+        refreshAfterMutation: false,
+      },
+    );
+    deactivateLayout();
+
+    expect(create).toHaveBeenCalledWith({
+      values: {
+        title: 'Custom page',
+      },
+      layout: 'custom-desktop-layout-model',
+    });
+  });
+});

package/src/__tests__/RouterManager.test.ts

@@ -0,0 +1,125 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import type { BaseApplication } from '../BaseApplication';
+import { RouterManager, shouldOpenAdminRouteInNewWindow } from '../RouterManager';
+
+describe('RouterManager', () => {
+  describe('shouldOpenAdminRouteInNewWindow', () => {
+    it('opens admin route in a new window from a non-admin portal', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: '/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(true);
+    });
+
+    it('supports target pathname with the v2 base path', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/nocobase/v/test',
+          targetPathname: '/nocobase/v/admin/settings',
+          basePath: '/nocobase/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(true);
+    });
+
+    it('supports custom portal routes in sub-apps', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/apps/a_9xlild35jir/crm-amd/ekeisumx1zu',
+          targetPathname: '/v/apps/a_9xlild35jir/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(true);
+    });
+
+    it('keeps admin route navigation in the current window when already in sub-app admin', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/apps/a_9xlild35jir/admin',
+          targetPathname: '/v/apps/a_9xlild35jir/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+
+    it('keeps admin route navigation in the current window when already in admin', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/admin',
+          targetPathname: '/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+
+    it('keeps non-admin portal navigation in the current window', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: '/test/page',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+
+    it('does not intercept replace navigation or relative paths', () => {
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: '/admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+          replace: true,
+        }),
+      ).toBe(false);
+      expect(
+        shouldOpenAdminRouteInNewWindow({
+          currentPathname: '/v/test',
+          targetPathname: 'admin/settings',
+          basePath: '/v',
+          adminRoutePath: '/admin',
+        }),
+      ).toBe(false);
+    });
+  });
+
+  it('opens admin route in a new window through the underlying router navigate from a sub-app portal', async () => {
+    const app = {
+      name: 'a_9xlild35jir',
+      getPublicPath: () => '/v/',
+      getHref: (pathname: string) => `/v/apps/a_9xlild35jir/${pathname.replace(/^\/+/, '')}`,
+      layoutManager: {
+        getLayout: () => ({ routePath: '/admin' }),
+      },
+      renderComponent: () => null,
+    } as unknown as BaseApplication<unknown>;
+    const manager = new RouterManager({ type: 'browser' }, app);
+    const open = vi.spyOn(window, 'open').mockImplementation(() => null);
+
+    window.history.pushState({}, '', '/v/apps/a_9xlild35jir/crm-amd/ekeisumx1zu');
+    manager.getRouterComponent();
+    await manager.router.navigate('/admin/settings/version-control/list');
+
+    expect(open).toHaveBeenCalledWith(
+      '/v/apps/a_9xlild35jir/admin/settings/version-control/list',
+      '_blank',
+      'noopener,noreferrer',
+    );
+  });
+});

package/src/__tests__/authRedirect.test.ts

@@ -10,6 +10,7 @@
 import {
   buildV2SigninHref,
   getCurrentV2RedirectPath,
+  normalizeV2RedirectPath,
   redirectToV2Signin,
   resolveV2SigninRedirect,
 } from '../authRedirect';
@@ -133,6 +134,22 @@ describe('auth redirect helpers', () => {
   });
 
   describe('v2 sub-app context (router basename contains /apps/<id>/)', () => {
+    it('should normalize signin redirect fallback under the current sub-app basename', () => {
+      const app = {
+        getPublicPath: () => '/v/',
+        router: {
+          getBasename: () => '/v/apps/test-app/',
+        },
+      } as any;
+
+      expect(normalizeV2RedirectPath(app, '')).toBe('/v/apps/test-app/admin/');
+      expect(normalizeV2RedirectPath(app, '/admin/?tab=overview#panel')).toBe(
+        '/v/apps/test-app/admin/?tab=overview#panel',
+      );
+      expect(normalizeV2RedirectPath(app, '/v/apps/test-app/admin/')).toBe('/v/apps/test-app/admin/');
+      expect(normalizeV2RedirectPath(app, '/v/admin/')).toBe('/v/apps/test-app/admin/');
+    });
+
     it('should preserve sub-app segment when building current redirect path under simple public path', () => {
       const app = {
         getPublicPath: () => '/v2/',

package/src/__tests__/exports.test.ts

@@ -0,0 +1,16 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { IconPicker } from '..';
+
+describe('@nocobase/client-v2 exports', () => {
+  it('should export IconPicker from the root entry', () => {
+    expect(IconPicker).toBeDefined();
+  });
+});

package/src/__tests__/nocobase-buildin-plugin-auth.test.tsx

@@ -12,6 +12,10 @@ import { act, render, screen, waitFor } from '@testing-library/react';
 import React from 'react';
 import { NocoBaseBuildInPlugin } from '../nocobase-buildin-plugin';
 
+const TestingAppSpin = () => <div data-testid="app-spin">app spin</div>;
+
+const TestingAppError = ({ error }: { error: Error }) => <div role="alert">{error.message}</div>;
+
 class SkippedPublicRoutePlugin extends Plugin {
   async load() {
     this.router.add('public', {
@@ -22,6 +26,31 @@ class SkippedPublicRoutePlugin extends Plugin {
   }
 }
 
+class DummySigninRoutePlugin extends Plugin {
+  async load() {
+    this.router.add('signin-test', {
+      path: '/signin',
+      skipAuthCheck: true,
+      Component: () => <div>signin page</div>,
+    });
+  }
+}
+
+class AuthBootstrapRoutePlugin extends Plugin {
+  async load() {
+    this.router.add('secure', {
+      path: '/secure',
+      authCheck: true,
+      Component: () => <div>secure page</div>,
+    });
+    this.router.add('guest', {
+      path: '/guest',
+      authCheck: false,
+      Component: () => <div>guest page</div>,
+    });
+  }
+}
+
 describe('nocobase buildin plugin auth redirect', () => {
   const originalLocation = globalThis.window.location;
 
@@ -155,6 +184,176 @@ describe('nocobase buildin plugin auth redirect', () => {
     });
   });
 
+  it('should defer data source bootstrap until auth-required route is authenticated after signin redirect', async () => {
+    const app = createMockClient({
+      publicPath: '/v2/',
+      plugins: [NocoBaseBuildInPlugin as any, DummySigninRoutePlugin as any, AuthBootstrapRoutePlugin as any],
+      components: { AppSpin: TestingAppSpin },
+      router: { type: 'memory', initialEntries: ['/v2/secure'] },
+    });
+    app.apiMock.onGet('app:getLang').reply(200, {
+      data: { lang: 'en-US', resources: { client: {} }, cron: {} },
+    });
+    const events: string[] = [];
+    app.apiMock.onGet('/auth:check').replyOnce(() => {
+      events.push('auth:first');
+      return [200, { data: {} }];
+    });
+    app.apiMock.onGet('/auth:check').reply(() => {
+      events.push('auth:second');
+      return [200, { data: { id: 1 } }];
+    });
+
+    const ensureLoaded = vi.spyOn(app.dataSourceManager, 'ensureLoaded').mockImplementation(() => {
+      if (!app.apiClient.auth.token) {
+        const pending = new Promise<void>(() => undefined);
+        app.dataSourceManager.loadingPromise = pending;
+        return pending;
+      }
+      events.push('bootstrap');
+      expect(events).toContain('auth:second');
+      return Promise.resolve();
+    });
+
+    const Root = app.getRootComponent();
+    render(<Root />);
+
+    await waitFor(() => {
+      expect(app.router.router.state.location.pathname).toBe('/v2/signin');
+      expect(app.router.router.state.location.search).toBe('?redirect=%2Fv2%2Fsecure');
+    });
+    expect(await screen.findByText('signin page')).toBeInTheDocument();
+    expect(screen.queryByTestId('app-spin')).not.toBeInTheDocument();
+    expect(ensureLoaded).not.toHaveBeenCalled();
+    expect(app.dataSourceManager.loadingPromise).toBeNull();
+    expect(events).toEqual(['auth:first']);
+
+    act(() => {
+      app.apiClient.auth.setToken('test-token');
+    });
+
+    await act(async () => {
+      await app.router.router.navigate('/secure');
+    });
+
+    expect(await screen.findByText('secure page')).toBeInTheDocument();
+    await waitFor(() => {
+      expect(document.querySelector('.ant-spin-spinning')).not.toBeInTheDocument();
+    });
+    expect(ensureLoaded).toHaveBeenCalledTimes(1);
+  });
+
+  it('should redirect on auth-required /auth:check 401 without bootstrapping data sources', async () => {
+    const app = createMockClient({
+      publicPath: '/v2/',
+      plugins: [NocoBaseBuildInPlugin as any, DummySigninRoutePlugin as any, AuthBootstrapRoutePlugin as any],
+      components: { AppSpin: TestingAppSpin },
+      router: { type: 'memory', initialEntries: ['/v2/secure'] },
+    });
+    app.apiMock.onGet('app:getLang').reply(200, {
+      data: { lang: 'en-US', resources: { client: {} }, cron: {} },
+    });
+    app.apiMock.onGet('/auth:check').reply(401, { errors: [{ code: 'EMPTY_TOKEN' }] });
+    const ensureLoaded = vi.spyOn(app.dataSourceManager, 'ensureLoaded').mockImplementation(() => {
+      const pending = new Promise<void>(() => undefined);
+      app.dataSourceManager.loadingPromise = pending;
+      return pending;
+    });
+
+    const Root = app.getRootComponent();
+    render(<Root />);
+
+    await waitFor(() => {
+      expect(app.router.router.state.location.pathname).toBe('/v2/signin');
+      expect(app.router.router.state.location.search).toBe('?redirect=%2Fv2%2Fsecure');
+    });
+    expect(await screen.findByText('signin page')).toBeInTheDocument();
+    expect(screen.queryByTestId('app-spin')).not.toBeInTheDocument();
+    expect(ensureLoaded).not.toHaveBeenCalled();
+    expect(app.dataSourceManager.loadingPromise).toBeNull();
+  });
+
+  it('should surface non-auth /auth:check errors instead of leaving auth-required route spinning', async () => {
+    const app = createMockClient({
+      publicPath: '/v2/',
+      plugins: [NocoBaseBuildInPlugin as any, AuthBootstrapRoutePlugin as any],
+      components: { AppSpin: TestingAppSpin, AppError: TestingAppError },
+      router: { type: 'memory', initialEntries: ['/v2/secure'] },
+    });
+    app.apiMock.onGet('app:getLang').reply(200, {
+      data: { lang: 'en-US', resources: { client: {} }, cron: {} },
+    });
+    app.apiMock.onGet('/auth:check').reply(500, { errors: [{ message: 'auth check failed' }] });
+    const ensureLoaded = vi.spyOn(app.dataSourceManager, 'ensureLoaded').mockResolvedValue(undefined);
+
+    const Root = app.getRootComponent();
+    render(<Root />);
+
+    expect(await screen.findByRole('alert')).toHaveTextContent('Request failed with status code 500');
+    expect(screen.queryByTestId('app-spin')).not.toBeInTheDocument();
+    expect(ensureLoaded).not.toHaveBeenCalled();
+  });
+
+  it.each(['/v2/signin', '/v2/public'])('should not bootstrap data sources on skipped auth route: %s', async (path) => {
+    const app = createMockClient({
+      publicPath: '/v2/',
+      plugins: [NocoBaseBuildInPlugin as any, DummySigninRoutePlugin as any, SkippedPublicRoutePlugin as any],
+      components: { AppSpin: TestingAppSpin },
+      router: { type: 'memory', initialEntries: [path] },
+    });
+    app.apiMock.onGet('app:getLang').reply(200, {
+      data: { lang: 'en-US', resources: { client: {} }, cron: {} },
+    });
+    const ensureLoaded = vi.spyOn(app.dataSourceManager, 'ensureLoaded').mockResolvedValue(undefined);
+
+    const Root = app.getRootComponent();
+    render(<Root />);
+
+    expect(await screen.findByText(path === '/v2/signin' ? 'signin page' : 'public page')).toBeInTheDocument();
+    expect(screen.queryByTestId('app-spin')).not.toBeInTheDocument();
+    expect(ensureLoaded).not.toHaveBeenCalled();
+    expect(app.apiMock.history.get.filter((request) => request.url === '/auth:check')).toHaveLength(0);
+  });
+
+  it('should bootstrap data sources for authenticated auth-required route access', async () => {
+    const app = createMockClient({
+      publicPath: '/v2/',
+      plugins: [NocoBaseBuildInPlugin as any, AuthBootstrapRoutePlugin as any],
+      router: { type: 'memory', initialEntries: ['/v2/secure'] },
+    });
+    app.apiClient.auth.setToken('test-token');
+    app.apiMock.onGet('app:getLang').reply(200, {
+      data: { lang: 'en-US', resources: { client: {} }, cron: {} },
+    });
+    app.apiMock.onGet('/auth:check').reply(200, { data: { id: 1 } });
+    const ensureLoaded = vi.spyOn(app.dataSourceManager, 'ensureLoaded').mockResolvedValue(undefined);
+
+    const Root = app.getRootComponent();
+    render(<Root />);
+
+    expect(await screen.findByText('secure page')).toBeInTheDocument();
+    expect(ensureLoaded).toHaveBeenCalledTimes(1);
+  });
+
+  it('should not auth-check or bootstrap authCheck false routes', async () => {
+    const app = createMockClient({
+      publicPath: '/v2/',
+      plugins: [NocoBaseBuildInPlugin as any, AuthBootstrapRoutePlugin as any],
+      router: { type: 'memory', initialEntries: ['/v2/guest'] },
+    });
+    app.apiMock.onGet('app:getLang').reply(200, {
+      data: { lang: 'en-US', resources: { client: {} }, cron: {} },
+    });
+    const ensureLoaded = vi.spyOn(app.dataSourceManager, 'ensureLoaded').mockResolvedValue(undefined);
+
+    const Root = app.getRootComponent();
+    render(<Root />);
+
+    expect(await screen.findByText('guest page')).toBeInTheDocument();
+    expect(ensureLoaded).not.toHaveBeenCalled();
+    expect(app.apiMock.history.get.filter((request) => request.url === '/auth:check')).toHaveLength(0);
+  });
+
   it('should render v2 admin root without redirecting away', async () => {
     const app = createMockClient({
       publicPath: '/v2/',

package/src/__tests__/plugin-manager.test.tsx

@@ -18,6 +18,19 @@ class TestAclPlugin extends Plugin {
   }
 }
 
+class TestSettingsLinkPlugin extends Plugin {
+  async load() {
+    this.app.pluginSettingsManager.addMenuItem({ key: 'shared-settings', title: 'Shared settings' });
+    this.app.pluginSettingsManager.addPageTabItem({
+      menuKey: 'shared-settings',
+      key: 'target',
+      title: 'Target settings',
+      Component: () => <div>Target settings page</div>,
+    });
+    this.app.pluginSettingsManager.setPluginSettingsLink('demo-plugin', 'shared-settings.target');
+  }
+}
+
 type MockClientApplication = ReturnType<typeof createMockClient>;
 
 const renderApp = (app: MockClientApplication) => {
@@ -35,9 +48,9 @@ const waitForGetRequests = async (app: MockClientApplication, urls: string[]) =>
   );
 };
 
-const setupApp = (pmList: any[]) => {
+const setupApp = (pmList: any[], plugins: Array<typeof Plugin> = []) => {
   const app = createMockClient({
-    plugins: [NocoBaseBuildInPlugin, TestAclPlugin],
+    plugins: [NocoBaseBuildInPlugin, TestAclPlugin, ...plugins],
     router: { type: 'memory', initialEntries: ['/admin/settings/plugin-manager'] },
   });
 
@@ -174,4 +187,33 @@ describe('plugin-manager page', () => {
       expect(removeCall?.params).toMatchObject({ filterByTk: 'demo-plugin' });
     });
   });
+
+  it('shows Settings for a plugin linked to a different settings page', async () => {
+    const app = setupApp(
+      [
+        {
+          name: 'demo-plugin',
+          packageName: '@nocobase/demo-plugin',
+          displayName: 'Demo plugin',
+          description: 'A demo',
+          enabled: true,
+          builtIn: false,
+          removable: false,
+          version: '0.1.0',
+          isCompatible: true,
+          keywords: [],
+        },
+      ],
+      [TestSettingsLinkPlugin],
+    );
+
+    renderApp(app);
+    await waitForGetRequests(app, ['/auth:check', 'roles:check', 'pm:list']);
+
+    const card = await screen.findByRole('button', { name: 'Demo plugin' });
+    const settingsLink = within(card.closest('.ant-card') as HTMLElement).getByText('Settings');
+    fireEvent.click(settingsLink);
+
+    expect(await screen.findByText('Target settings page')).toBeInTheDocument();
+  });
 });