@nocobase/client-v2 2.1.0-alpha.40 → 2.1.0-alpha.45

package/src/flow/__tests__/FlowRoute.test.tsx

@@ -11,7 +11,7 @@ import React from 'react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { MemoryRouter, Route, Routes } from 'react-router-dom';
 import { render, screen, waitFor } from '@testing-library/react';
-import { FlowEngine, FlowEngineProvider, type FlowModel } from '@nocobase/flow-engine';
+import { FlowContextProvider, FlowEngine, FlowEngineProvider, type FlowModel } from '@nocobase/flow-engine';
 import FlowRoute from '../components/FlowRoute';
 
 type MockAdminLayoutModel = FlowModel & {
@@ -86,7 +86,7 @@ describe('FlowRoute', () => {
       expect(adminLayoutModel.registerRoutePage).toHaveBeenCalledWith(
         'test-page',
         expect.objectContaining({
-          active: false,
+          active: true,
           refreshDesktopRoutes: expect.any(Function),
           layoutContentElement: expect.any(HTMLDivElement),
         }),
@@ -120,6 +120,200 @@ describe('FlowRoute', () => {
     expect(adminLayoutModel.unregisterRoutePage).toHaveBeenCalledWith('test-page');
   });
 
+  it('should sync explicit active state to layout route page', async () => {
+    const engine = new FlowEngine();
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn(() => ({ type: 'flowPage', schemaUid: 'test-page' })),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({
+        uid: 'admin-layout-model',
+        use: 'FlowModel',
+      }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    const result = render(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/flow/test-page']}>
+          <Routes>
+            <Route path="/flow/:name" element={<FlowRoute active={false} />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(adminLayoutModel.registerRoutePage).toHaveBeenCalledWith(
+        'test-page',
+        expect.objectContaining({
+          active: false,
+        }),
+      );
+    });
+
+    result.rerender(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/flow/test-page']}>
+          <Routes>
+            <Route path="/flow/:name" element={<FlowRoute active={true} />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(adminLayoutModel.updateRoutePage).toHaveBeenCalledWith(
+        'test-page',
+        expect.objectContaining({
+          active: true,
+        }),
+      );
+    });
+  });
+
+  it('should bridge page lifecycle with explicit pageUid', async () => {
+    const engine = new FlowEngine();
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn(() => ({ type: 'flowPage', schemaUid: 'test-page' })),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({
+        uid: 'admin-layout-model',
+        use: 'FlowModel',
+      }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/flow']}>
+          <Routes>
+            <Route path="/flow" element={<FlowRoute pageUid="test-page" />} />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(adminLayoutModel.registerRoutePage).toHaveBeenCalledWith('test-page', expect.any(Object));
+    });
+  });
+
+  it('should derive layout model from current layout context when rendered from schema', async () => {
+    const engine = new FlowEngine();
+    const routeRepository = {
+      refreshAccessible: hookState.refresh,
+      isAccessibleLoaded: () => true,
+      ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+      getRouteBySchemaUid: vi.fn(() => ({ type: 'flowPage', schemaUid: 'test-page' })),
+    };
+    engine.context.defineProperty('route', {
+      value: {
+        params: { name: 'test-page' },
+        pathname: '/embed/test-page',
+      },
+    });
+    engine.context.defineProperty('routeRepository', {
+      value: routeRepository,
+    });
+    const routeModel = engine.createModel({
+      uid: 'route-model',
+      use: 'FlowModel',
+    });
+    routeModel.context.defineProperty('layout', {
+      value: {
+        routeName: 'embed',
+        routePath: '/embed',
+        rootRouteName: 'embed',
+        uid: 'embed-layout-model',
+        layoutModelClass: 'EmbedLayoutModelV2',
+        rootPageModelClass: 'RootPageModel',
+        childPageModelClass: 'ChildPageModel',
+        authCheck: true,
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const embedLayoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({
+        uid: 'embed-layout-model',
+        use: 'FlowModel',
+      }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <FlowContextProvider context={routeModel.context}>
+          <MemoryRouter initialEntries={['/embed/test-page']}>
+            <Routes>
+              <Route path="/embed/:name" element={<FlowRoute />} />
+            </Routes>
+          </MemoryRouter>
+        </FlowContextProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(embedLayoutModel.registerRoutePage).toHaveBeenCalledWith(
+        'test-page',
+        expect.objectContaining({
+          active: true,
+          refreshDesktopRoutes: expect.any(Function),
+          layoutContentElement: expect.any(HTMLDivElement),
+        }),
+      );
+    });
+  });
+
   it('should fail fast when admin-layout-model is missing', () => {
     const engine = new FlowEngine();
     engine.context.defineProperty('route', {
@@ -283,6 +477,339 @@ describe('FlowRoute', () => {
     }
   });
 
+  it('should render not found for legacy page when behavior is notFound', async () => {
+    const originalLocation = window.location;
+    const replace = vi.fn();
+    Object.defineProperty(window, 'location', {
+      configurable: true,
+      value: {
+        ...originalLocation,
+        pathname: '/v2/embed/test-page',
+        replace,
+      },
+    });
+
+    try {
+      const engine = new FlowEngine();
+      engine.context.defineProperty('routeRepository', {
+        value: {
+          refreshAccessible: hookState.refresh,
+          isAccessibleLoaded: () => true,
+          ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+          getRouteBySchemaUid: vi.fn(() => ({ type: 'page', schemaUid: 'test-page' })),
+        },
+      });
+      engine.context.defineProperty('app', {
+        value: {
+          getPublicPath: () => '/v2/',
+          router: {
+            getBasename: () => '/v2',
+          },
+        },
+      });
+
+      const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+        engine.createModel({ uid: 'admin-layout-model', use: 'FlowModel' }),
+        {
+          registerRoutePage: vi.fn(),
+          updateRoutePage: vi.fn(),
+          unregisterRoutePage: vi.fn(),
+        },
+      );
+
+      const result = render(
+        <FlowEngineProvider engine={engine}>
+          <MemoryRouter initialEntries={['/embed/test-page']}>
+            <Routes>
+              <Route path="/embed/:name" element={<FlowRoute legacyPageBehavior="notFound" />} />
+            </Routes>
+          </MemoryRouter>
+        </FlowEngineProvider>,
+      );
+
+      await result.findByText('404');
+      expect(replace).not.toHaveBeenCalled();
+      expect(adminLayoutModel.registerRoutePage).not.toHaveBeenCalled();
+    } finally {
+      Object.defineProperty(window, 'location', {
+        configurable: true,
+        value: originalLocation,
+      });
+    }
+  });
+
+  it('should bridge existing FlowModel when behavior is notFound and routeRepository has no route', async () => {
+    const engine = new FlowEngine();
+    engine.setModelRepository({
+      findOne: vi.fn().mockResolvedValue({
+        uid: 'public-form-1',
+        use: 'FlowModel',
+      }),
+      save: vi.fn(),
+      destroy: vi.fn(),
+    } as any);
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn(() => undefined),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+
+    const layoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'public-form-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <MemoryRouter initialEntries={['/public-forms/public-form-1']}>
+          <Routes>
+            <Route
+              path="/public-forms/:name"
+              element={<FlowRoute legacyPageBehavior="notFound" getLayoutModel={() => layoutModel} />}
+            />
+          </Routes>
+        </MemoryRouter>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(layoutModel.registerRoutePage).toHaveBeenCalledWith('public-form-1', expect.any(Object));
+    });
+    expect(screen.queryByText('404')).not.toBeInTheDocument();
+  });
+
+  it('should check model existence without occupying the route model uid', async () => {
+    const engine = new FlowEngine();
+    const findOne = vi.fn().mockResolvedValue({
+      uid: 'public-form-1',
+    });
+    const request = vi.fn().mockResolvedValue({
+      data: {
+        data: {
+          uid: 'public-form-1',
+        },
+      },
+    });
+    engine.setModelRepository({
+      findOne,
+      save: vi.fn(),
+      destroy: vi.fn(),
+    } as any);
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => true,
+        ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+        getRouteBySchemaUid: vi.fn(() => undefined),
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        apiClient: {
+          request,
+        },
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+    const routeModel = engine.createModel({
+      uid: 'public-form-route-model',
+      use: 'FlowModel',
+    });
+    routeModel.context.defineProperty('layout', {
+      value: {
+        routeName: 'public-forms',
+        routePath: '/public-forms',
+        rootRouteName: 'public-forms',
+        uid: 'public-form-layout-model',
+        layoutModelClass: 'PublicFormLayoutModel',
+        rootPageModelClass: 'PublicFormPageModel',
+        childPageModelClass: 'ChildPageModel',
+        authCheck: false,
+      },
+    });
+
+    const layoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'public-form-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <FlowContextProvider context={routeModel.context}>
+          <MemoryRouter initialEntries={['/public-forms/public-form-1']}>
+            <Routes>
+              <Route path="/public-forms/:name" element={<FlowRoute legacyPageBehavior="notFound" />} />
+            </Routes>
+          </MemoryRouter>
+        </FlowContextProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(layoutModel.registerRoutePage).toHaveBeenCalledWith('public-form-1', expect.any(Object));
+    });
+    expect(findOne).toHaveBeenCalledWith({ uid: 'public-form-1' });
+    expect(request).not.toHaveBeenCalled();
+    expect(engine.getModel('public-form-1')).toBeUndefined();
+  });
+
+  it('should not skip accessible route loading just because layout authCheck is false', async () => {
+    const engine = new FlowEngine();
+    const ensureAccessibleLoaded = vi.fn().mockRejectedValue(new Error('cannot load accessible routes'));
+    const getRouteBySchemaUid = vi.fn();
+    engine.setModelRepository({
+      findOne: vi.fn().mockResolvedValue({
+        uid: 'public-form-1',
+        use: 'FlowModel',
+      }),
+      save: vi.fn(),
+      destroy: vi.fn(),
+    } as any);
+    engine.context.defineProperty('routeRepository', {
+      value: {
+        refreshAccessible: hookState.refresh,
+        isAccessibleLoaded: () => false,
+        ensureAccessibleLoaded,
+        getRouteBySchemaUid,
+      },
+    });
+    engine.context.defineProperty('app', {
+      value: {
+        getPublicPath: () => '/v2/',
+        router: {
+          getBasename: () => '/v2',
+        },
+      },
+    });
+    const routeModel = engine.createModel({
+      uid: 'public-form-route-model',
+      use: 'FlowModel',
+    });
+    routeModel.context.defineProperty('layout', {
+      value: {
+        routeName: 'public-forms',
+        routePath: '/public-forms',
+        rootRouteName: 'public-forms',
+        uid: 'public-form-layout-model',
+        layoutModelClass: 'PublicFormLayoutModel',
+        rootPageModelClass: 'PublicFormPageModel',
+        childPageModelClass: 'ChildPageModel',
+        authCheck: false,
+      },
+    });
+
+    const layoutModel: MockAdminLayoutModel = Object.assign(
+      engine.createModel({ uid: 'public-form-layout-model', use: 'FlowModel' }),
+      {
+        registerRoutePage: vi.fn(),
+        updateRoutePage: vi.fn(),
+        unregisterRoutePage: vi.fn(),
+      },
+    );
+
+    render(
+      <FlowEngineProvider engine={engine}>
+        <FlowContextProvider context={routeModel.context}>
+          <MemoryRouter initialEntries={['/public-forms/public-form-1']}>
+            <Routes>
+              <Route path="/public-forms/:name" element={<FlowRoute legacyPageBehavior="notFound" />} />
+            </Routes>
+          </MemoryRouter>
+        </FlowContextProvider>
+      </FlowEngineProvider>,
+    );
+
+    await waitFor(() => {
+      expect(layoutModel.registerRoutePage).toHaveBeenCalledWith('public-form-1', expect.any(Object));
+    });
+    expect(ensureAccessibleLoaded).toHaveBeenCalledTimes(1);
+    expect(getRouteBySchemaUid).not.toHaveBeenCalled();
+  });
+
+  it('should bridge legacy page when behavior is bridge', async () => {
+    const originalLocation = window.location;
+    const replace = vi.fn();
+    Object.defineProperty(window, 'location', {
+      configurable: true,
+      value: {
+        ...originalLocation,
+        pathname: '/v2/admin/test-page',
+        replace,
+      },
+    });
+
+    try {
+      const engine = new FlowEngine();
+      engine.context.defineProperty('routeRepository', {
+        value: {
+          refreshAccessible: hookState.refresh,
+          isAccessibleLoaded: () => true,
+          ensureAccessibleLoaded: vi.fn().mockResolvedValue([]),
+          getRouteBySchemaUid: vi.fn(() => ({ type: 'page', schemaUid: 'test-page' })),
+        },
+      });
+      engine.context.defineProperty('app', {
+        value: {
+          getPublicPath: () => '/v2/',
+          router: {
+            getBasename: () => '/v2',
+          },
+        },
+      });
+
+      const adminLayoutModel: MockAdminLayoutModel = Object.assign(
+        engine.createModel({ uid: 'admin-layout-model', use: 'FlowModel' }),
+        {
+          registerRoutePage: vi.fn(),
+          updateRoutePage: vi.fn(),
+          unregisterRoutePage: vi.fn(),
+        },
+      );
+
+      render(
+        <FlowEngineProvider engine={engine}>
+          <MemoryRouter initialEntries={['/flow/test-page']}>
+            <Routes>
+              <Route path="/flow/:name" element={<FlowRoute legacyPageBehavior="bridge" />} />
+            </Routes>
+          </MemoryRouter>
+        </FlowEngineProvider>,
+      );
+
+      await waitFor(() => {
+        expect(adminLayoutModel.registerRoutePage).toHaveBeenCalled();
+      });
+      expect(replace).not.toHaveBeenCalled();
+    } finally {
+      Object.defineProperty(window, 'location', {
+        configurable: true,
+        value: originalLocation,
+      });
+    }
+  });
+
   it('should not redirect when route does not exist', async () => {
     const originalLocation = window.location;
     const replace = vi.fn();