@nocobase/client-v2 2.2.0-beta.13 → 2.2.0-beta.15

package/src/flow/models/base/PageModel/__tests__/PageTabModel.test.ts

@@ -18,24 +18,53 @@ vi.mock('@nocobase/flow-engine', async (importOriginal) => {
   return {
     ...actual,
     FlowModel: class {
+      uid: string;
+      parentId?: string;
       props: any;
       context: any;
       stepParams: any;
+      flowEngine?: {
+        modelRepository?: {
+          findOne?: (query: Record<string, unknown>) => Promise<unknown>;
+        };
+        flowSettings?: {
+          open?: (options: Record<string, unknown>) => Promise<unknown> | unknown;
+        };
+      };
+      flowRegistryData: Record<string, unknown>;
+      invalidateFlowCache = vi.fn();
+      rerender = vi.fn(async () => undefined);
 
       constructor(options: any = {}) {
+        this.uid = options.uid || 'mock-model';
+        this.parentId = options.parentId;
         this.props = options.props || {};
         this.context = options.context || {};
         this.stepParams = options.stepParams || {};
+        this.flowEngine = options.flowEngine;
+        this.flowRegistryData = options.flowRegistry || {};
       }
 
       serialize() {
-        return { flowRegistry: {} };
+        return { flowRegistry: this.flowRegistryData };
       }
 
       setProps(key: string, value: any) {
         this.props[key] = value;
       }
 
+      setStepParams(flowKey: string, stepKey: string, params: Record<string, unknown>) {
+        this.stepParams[flowKey] = this.stepParams[flowKey] || {};
+        this.stepParams[flowKey][stepKey] = {
+          ...(this.stepParams[flowKey][stepKey] || {}),
+          ...params,
+        };
+      }
+
+      openFlowSettings(options: Record<string, unknown> = {}) {
+        return this.flowEngine?.flowSettings?.open?.({ model: this, ...options });
+      }
+
       onInit() {}
       static registerFlow(flow: any) {
         registerFlowMock(flow);
@@ -86,6 +115,13 @@ describe('PageTabModel', () => {
     expect(keys.indexOf('documentTitle')).toBe(keys.indexOf('title') + 1);
   });
 
+  it('should expose tab linkage rules in page tab settings', async () => {
+    await import('../PageTabModel');
+    const flow = registerFlowMock.mock.calls.find((call) => call[0]?.key === 'pageTabSettings')?.[0];
+
+    expect(flow?.steps?.linkageRules?.use).toBe('tabLinkageRules');
+  });
+
   it('should trigger parent page title update in tab settings handler', async () => {
     await import('../PageTabModel');
     const flow = registerFlowMock.mock.calls.find((call) => call[0]?.key === 'pageTabSettings')?.[0];
@@ -222,4 +258,539 @@ describe('PageTabModel', () => {
       documentTitle: 'Server doc title',
     });
   });
+
+  describe('root tab linkage hydrate', () => {
+    it('should hydrate linkage rules before opening settings in configuration mode', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      const linkageRules = { value: [{ key: 'rule-1' }] };
+      const request = vi.fn().mockResolvedValue({
+        data: {
+          data: {
+            uid: 'tab-1',
+            use: 'RouteModel',
+            props: { title: 'Stale anchor title' },
+            stepParams: {
+              pageTabSettings: {
+                tab: { title: 'Stale tab title' },
+                linkageRules,
+              },
+            },
+          },
+        },
+      });
+      const open = vi.fn(({ model }: { model: { stepParams: Record<string, unknown> } }) => {
+        expect(model.stepParams).toMatchObject({ pageTabSettings: { linkageRules } });
+        return 'opened';
+      });
+      const model = new RootPageTabModel({
+        uid: 'tab-1',
+        flowEngine: {
+          flowSettings: { open },
+        },
+        props: {
+          route: {
+            schemaUid: 'tab-1',
+            title: 'Current route title',
+            options: {},
+          },
+        },
+        stepParams: {
+          pageTabSettings: {
+            tab: { title: 'Current tab title' },
+          },
+        },
+        context: {
+          api: { request },
+          flowSettingsEnabled: true,
+          defineProperty: vi.fn(),
+          t: (value: string) => value,
+        },
+      } as any);
+
+      model.onInit({});
+      await model.openFlowSettings({ flowKey: 'pageTabSettings', stepKey: 'linkageRules' });
+
+      expect(request).toHaveBeenCalledWith({
+        url: 'flowModels:findOne',
+        params: { uid: 'tab-1' },
+      });
+      expect(model.props.route.title).toBe('Current route title');
+      expect(model.stepParams.pageTabSettings.tab.title).toBe('Current tab title');
+      expect(model.stepParams.pageTabSettings.linkageRules).toEqual(linkageRules);
+      expect(model.invalidateFlowCache).toHaveBeenCalledWith('beforeRender', true);
+      expect(model.rerender).toHaveBeenCalledTimes(1);
+      expect(open).toHaveBeenCalledTimes(1);
+    });
+
+    it('should only hydrate marked root tabs at runtime', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      const unmarkedRequest = vi.fn().mockResolvedValue({ data: { data: null } });
+      const markedRequest = vi.fn().mockResolvedValue({
+        data: {
+          data: {
+            stepParams: {
+              pageTabSettings: {
+                linkageRules: { value: [] },
+              },
+            },
+          },
+        },
+      });
+      const createModel = (request: typeof markedRequest, marked: boolean) =>
+        new RootPageTabModel({
+          uid: marked ? 'tab-marked' : 'tab-unmarked',
+          props: {
+            route: {
+              schemaUid: marked ? 'tab-marked' : 'tab-unmarked',
+              options: marked ? { hasPersistedPageTabFlowModel: true } : {},
+            },
+          },
+          context: {
+            api: { request },
+            flowSettingsEnabled: false,
+            defineProperty: vi.fn(),
+            t: (value: string) => value,
+          },
+        } as any);
+
+      const unmarkedModel = createModel(unmarkedRequest, false);
+      const markedModel = createModel(markedRequest, true);
+      unmarkedModel.onInit({});
+      markedModel.onInit({});
+
+      await vi.waitFor(() => {
+        expect(markedRequest).toHaveBeenCalledTimes(1);
+        expect(markedModel.stepParams.pageTabSettings.linkageRules).toEqual({ value: [] });
+      });
+      expect(unmarkedRequest).not.toHaveBeenCalled();
+    });
+
+    it('should ignore the linkage-specific legacy marker at runtime', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      const request = vi.fn().mockResolvedValue({ data: { data: null } });
+      const legacyMarker = ['hasPersistedPageTab', 'LinkageRules'].join('');
+      const model = new RootPageTabModel({
+        uid: 'tab-legacy-marker',
+        props: {
+          route: {
+            schemaUid: 'tab-legacy-marker',
+            options: { [legacyMarker]: true },
+          },
+        },
+        context: {
+          api: { request },
+          flowSettingsEnabled: false,
+          defineProperty: vi.fn(),
+          t: (value: string) => value,
+        },
+      } as any);
+
+      model.onInit({});
+
+      expect(request).not.toHaveBeenCalled();
+    });
+
+    it('should share one in-flight hydrate request across concurrent settings opens', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      let resolveAnchor: (value: unknown) => void = () => undefined;
+      const request = vi.fn(
+        () =>
+          new Promise<unknown>((resolve) => {
+            resolveAnchor = (value) => resolve({ data: { data: value } });
+          }),
+      );
+      const open = vi.fn().mockResolvedValue(undefined);
+      const model = new RootPageTabModel({
+        uid: 'tab-1',
+        flowEngine: {
+          flowSettings: { open },
+        },
+        props: { route: { schemaUid: 'tab-1', options: {} } },
+        context: {
+          api: { request },
+          flowSettingsEnabled: false,
+          t: (value: string) => value,
+        },
+      } as any);
+
+      const firstOpen = model.openFlowSettings({ flowKey: 'pageTabSettings', stepKey: 'linkageRules' });
+      const secondOpen = model.openFlowSettings({ flowKey: 'pageTabSettings', stepKey: 'linkageRules' });
+
+      await vi.waitFor(() => expect(request).toHaveBeenCalledTimes(1));
+      resolveAnchor({
+        stepParams: {
+          pageTabSettings: {
+            linkageRules: { value: [] },
+          },
+        },
+      });
+      await Promise.all([firstOpen, secondOpen]);
+
+      expect(request).toHaveBeenCalledTimes(1);
+      expect(open).toHaveBeenCalledTimes(2);
+    });
+
+    it('should safely handle missing anchors and missing linkage steps', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      const request = vi.fn().mockResolvedValue({ data: { data: null } });
+      const model = new RootPageTabModel({
+        uid: 'tab-1',
+        flowEngine: {
+          flowSettings: { open: vi.fn().mockResolvedValue(undefined) },
+        },
+        props: { route: { schemaUid: 'tab-1', options: {} } },
+        stepParams: {
+          pageTabSettings: {
+            tab: { title: 'Current tab title' },
+          },
+        },
+        context: {
+          api: { request },
+          flowSettingsEnabled: true,
+          defineProperty: vi.fn(),
+          t: (value: string) => value,
+        },
+      } as any);
+
+      model.onInit({});
+      await expect(
+        model.openFlowSettings({ flowKey: 'pageTabSettings', stepKey: 'linkageRules' }),
+      ).resolves.toBeUndefined();
+
+      expect(request).toHaveBeenCalledWith({
+        url: 'flowModels:findOne',
+        params: { uid: 'tab-1' },
+      });
+      expect(model.stepParams.pageTabSettings.linkageRules).toBeUndefined();
+      expect(model.stepParams.pageTabSettings.tab.title).toBe('Current tab title');
+    });
+  });
+
+  describe('root tab linkage persistence', () => {
+    it('should not touch the anchor or marker when linkage rules were never loaded', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      const request = vi.fn().mockResolvedValue({});
+      const updateRoute = vi.fn();
+      const model = new RootPageTabModel({
+        uid: 'tab-1',
+        props: {
+          route: {
+            id: 10,
+            schemaUid: 'tab-1',
+            options: { badge: 'new' },
+          },
+        },
+        stepParams: {
+          pageTabSettings: {
+            tab: { title: 'Tab title' },
+          },
+        },
+        context: {
+          api: { request },
+          routeRepository: { updateRoute },
+          t: (value: string) => value,
+        },
+      } as any);
+
+      await model.saveStepParams();
+
+      expect(request).toHaveBeenCalledTimes(1);
+      expect(request.mock.calls[0][0].url).toBe('desktopRoutes:updateOrCreate');
+      expect(updateRoute).not.toHaveBeenCalled();
+    });
+
+    it('should merge the latest anchor without sending subModels and then set the marker', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      const latestAnchor = {
+        uid: 'tab-1',
+        use: 'CustomRouteModel',
+        props: { anchorProp: true },
+        decoratorProps: { compact: true },
+        stepParams: {
+          pageTabSettings: {
+            tab: { title: 'Anchor tab title' },
+            linkageRules: { value: [{ key: 'old-rule' }] },
+          },
+          otherFlow: {
+            otherStep: { value: 1 },
+          },
+        },
+        flowRegistry: { customFlow: { steps: {} } },
+        unknownRoot: { keep: true },
+        subModels: {
+          grid: { uid: 'grid-1' },
+        },
+      };
+      const request = vi.fn(async ({ url }: { url: string }) => {
+        if (url === 'desktopRoutes:updateOrCreate') {
+          return { data: { data: { id: 10, schemaUid: 'tab-1' } } };
+        }
+        if (url === 'flowModels:findOne') {
+          return { data: { data: latestAnchor } };
+        }
+        return { data: { data: {} } };
+      });
+      const updateRoute = vi.fn().mockResolvedValue(undefined);
+      const linkageRules = { value: [{ key: 'new-rule' }] };
+      const model = new RootPageTabModel({
+        uid: 'tab-1',
+        flowRegistry: { routeFlow: { steps: {} } },
+        props: {
+          route: {
+            id: 10,
+            schemaUid: 'tab-1',
+            options: {
+              badge: 'new',
+              pluginOption: { keep: true },
+              flowRegistry: { routeFlow: { steps: {} } },
+            },
+          },
+        },
+        stepParams: {
+          pageTabSettings: {
+            tab: {
+              title: 'Tab title',
+              documentTitle: 'Tab document title',
+            },
+            linkageRules,
+          },
+        },
+        context: {
+          api: { request },
+          routeRepository: { updateRoute },
+          t: (value: string) => value,
+        },
+      } as any);
+
+      await model.saveStepParams();
+
+      const urls = request.mock.calls.map(([config]) => config.url);
+      expect(urls).toEqual(['desktopRoutes:updateOrCreate', 'flowModels:findOne', 'flowModels:save']);
+      expect(request.mock.calls[0][0].data.options).toMatchObject({
+        badge: 'new',
+        pluginOption: { keep: true },
+        flowRegistry: { routeFlow: { steps: {} } },
+        documentTitle: 'Tab document title',
+      });
+
+      const anchorPayload = request.mock.calls[2][0].data;
+      expect(anchorPayload).toMatchObject({
+        uid: 'tab-1',
+        use: 'CustomRouteModel',
+        props: { anchorProp: true },
+        decoratorProps: { compact: true },
+        stepParams: {
+          pageTabSettings: {
+            tab: { title: 'Anchor tab title' },
+            linkageRules,
+          },
+          otherFlow: {
+            otherStep: { value: 1 },
+          },
+        },
+        flowRegistry: { customFlow: { steps: {} } },
+        unknownRoot: { keep: true },
+      });
+      expect(anchorPayload).not.toHaveProperty('subModels');
+      expect(updateRoute).toHaveBeenCalledWith(
+        10,
+        {
+          options: expect.objectContaining({
+            badge: 'new',
+            pluginOption: { keep: true },
+            hasPersistedPageTabFlowModel: true,
+          }),
+        },
+        { refreshAfterMutation: false },
+      );
+      expect(request.mock.invocationCallOrder[2]).toBeLessThan(updateRoute.mock.invocationCallOrder[0]);
+      expect(model.props.route.options.hasPersistedPageTabFlowModel).toBe(true);
+    });
+
+    it('should read the latest anchor again before every linkage save', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      const request = vi.fn(async ({ url }: { url: string }) => {
+        if (url === 'flowModels:findOne') {
+          return { data: { data: { uid: 'tab-1', use: 'RouteModel' } } };
+        }
+        return {};
+      });
+      const model = new RootPageTabModel({
+        uid: 'tab-1',
+        props: { route: { id: 10, schemaUid: 'tab-1', options: {} } },
+        stepParams: {
+          pageTabSettings: {
+            tab: { title: 'Tab title' },
+            linkageRules: { value: [] },
+          },
+        },
+        context: {
+          api: { request },
+          routeRepository: { updateRoute: vi.fn().mockResolvedValue(undefined) },
+          t: (value: string) => value,
+        },
+      } as any);
+
+      await model.saveStepParams();
+      await model.saveStepParams();
+
+      expect(request.mock.calls.filter(([config]) => config.url === 'flowModels:findOne')).toHaveLength(2);
+    });
+
+    it('should persist empty rules without destroying the anchor and clear the marker', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      const request = vi.fn(async ({ url }: { url: string }) => {
+        if (url === 'flowModels:findOne') {
+          return {
+            data: {
+              data: {
+                uid: 'tab-1',
+                use: 'RouteModel',
+                subModels: { grid: { uid: 'grid-1' } },
+              },
+            },
+          };
+        }
+        return {};
+      });
+      const updateRoute = vi.fn().mockResolvedValue(undefined);
+      const model = new RootPageTabModel({
+        uid: 'tab-1',
+        props: {
+          route: {
+            id: 10,
+            schemaUid: 'tab-1',
+            options: {
+              badge: 'new',
+              hasPersistedPageTabFlowModel: true,
+            },
+          },
+        },
+        stepParams: {
+          pageTabSettings: {
+            tab: { title: 'Tab title' },
+            linkageRules: { value: [] },
+          },
+        },
+        context: {
+          api: { request },
+          routeRepository: { updateRoute },
+          t: (value: string) => value,
+        },
+      } as any);
+
+      await model.saveStepParams();
+
+      const urls = request.mock.calls.map(([config]) => config.url);
+      expect(urls).toContain('flowModels:save');
+      expect(urls).not.toContain('flowModels:destroy');
+      const anchorPayload = request.mock.calls.find(([config]) => config.url === 'flowModels:save')?.[0].data;
+      expect(anchorPayload.stepParams.pageTabSettings.linkageRules).toEqual({ value: [] });
+      expect(anchorPayload).not.toHaveProperty('subModels');
+      expect(updateRoute.mock.calls[0][1].options).toMatchObject({ badge: 'new' });
+      expect(updateRoute.mock.calls[0][1].options).not.toHaveProperty('hasPersistedPageTabFlowModel');
+      expect(model.props.route.options).not.toHaveProperty('hasPersistedPageTabFlowModel');
+    });
+
+    it('should create a minimal RouteModel anchor when the anchor is missing', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      const request = vi.fn(async ({ url }: { url: string }) => {
+        if (url === 'flowModels:findOne') {
+          return { data: { data: null } };
+        }
+        return {};
+      });
+      const model = new RootPageTabModel({
+        uid: 'tab-1',
+        props: { route: { id: 10, schemaUid: 'tab-1', options: {} } },
+        stepParams: {
+          pageTabSettings: {
+            tab: { title: 'Tab title' },
+            linkageRules: { value: [{ key: 'rule-1' }] },
+          },
+        },
+        context: {
+          api: { request },
+          routeRepository: { updateRoute: vi.fn().mockResolvedValue(undefined) },
+          t: (value: string) => value,
+        },
+      } as any);
+
+      await model.saveStepParams();
+
+      const anchorPayload = request.mock.calls.find(([config]) => config.url === 'flowModels:save')?.[0].data;
+      expect(anchorPayload).toMatchObject({
+        uid: 'tab-1',
+        use: 'RouteModel',
+        stepParams: {
+          pageTabSettings: {
+            linkageRules: { value: [{ key: 'rule-1' }] },
+          },
+        },
+      });
+      expect(anchorPayload).not.toHaveProperty('props.route');
+      expect(anchorPayload).not.toHaveProperty('subModels');
+    });
+
+    it('should not update the marker when saving the anchor fails', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      const error = new Error('anchor save failed');
+      const request = vi.fn(async ({ url }: { url: string }) => {
+        if (url === 'flowModels:findOne') {
+          return { data: { data: { uid: 'tab-1', use: 'RouteModel' } } };
+        }
+        if (url === 'flowModels:save') {
+          throw error;
+        }
+        return {};
+      });
+      const updateRoute = vi.fn();
+      const model = new RootPageTabModel({
+        uid: 'tab-1',
+        props: { route: { id: 10, schemaUid: 'tab-1', options: {} } },
+        stepParams: {
+          pageTabSettings: {
+            linkageRules: { value: [{ key: 'rule-1' }] },
+          },
+        },
+        context: {
+          api: { request },
+          routeRepository: { updateRoute },
+          t: (value: string) => value,
+        },
+      } as any);
+
+      await expect(model.saveStepParams()).rejects.toBe(error);
+      expect(updateRoute).not.toHaveBeenCalled();
+    });
+
+    it('should reject when updating the route marker fails', async () => {
+      const { RootPageTabModel } = await import('../PageTabModel');
+      const error = new Error('marker update failed');
+      const request = vi.fn(async ({ url }: { url: string }) => {
+        if (url === 'flowModels:findOne') {
+          return { data: { data: { uid: 'tab-1', use: 'RouteModel' } } };
+        }
+        return {};
+      });
+      const updateRoute = vi.fn().mockRejectedValue(error);
+      const model = new RootPageTabModel({
+        uid: 'tab-1',
+        props: { route: { id: 10, schemaUid: 'tab-1', options: {} } },
+        stepParams: {
+          pageTabSettings: {
+            linkageRules: { value: [{ key: 'rule-1' }] },
+          },
+        },
+        context: {
+          api: { request },
+          routeRepository: { updateRoute },
+          t: (value: string) => value,
+        },
+      } as any);
+
+      await expect(model.saveStepParams()).rejects.toBe(error);
+      expect(request.mock.calls.some(([config]) => config.url === 'flowModels:save')).toBe(true);
+    });
+  });
 });

package/src/flow/models/blocks/table/TableBlockModel.tsx

@@ -310,7 +310,7 @@ export class TableBlockModel extends CollectionBlockModel<TableBlockModelStructu
                 transform: translateY(-50%);
               }
               &:hover {
-                background: rgba(24, 144, 255, 0.1) !important;
+                box-shadow: inset 0 0 0 9999px rgba(24, 144, 255, 0.1);
               }
               &:hover .edit-icon {
                 display: inline-flex;

package/src/flow/models/fields/AssociationFieldModel/PopupSubTableFieldModel/PopupSubTableFieldModel.tsx

@@ -102,7 +102,7 @@ const RenderCell = observer<any>((props) => {
               transform: translateY(-50%);
             }
             &:hover {
-              background: rgba(24, 144, 255, 0.1) !important;
+              box-shadow: inset 0 0 0 9999px rgba(24, 144, 255, 0.1);
             }
             &:hover .edit-icon {
               display: inline-flex;

package/src/flow/models/fields/VariableFieldFormModel.tsx

@@ -48,12 +48,12 @@ export class VariableFieldFormModel extends FlowModel {
       <FormProvider form={this.form}>
         <FormLayout layout={'vertical'}>
           {this.mapSubModels('fields', (field) => {
-            // 确保字段模型具备稳定的 id/name，便于依赖路径的组件（如公式字段）正确解析
+            // Avoid conflicting with the DOM nodeName property when rendering the temporary input.
             const init = field?.getStepParams?.('fieldSettings', 'init') || {};
             const fp = init?.fieldPath as string | undefined;
             if (fp) {
-              const namePath = fp.includes('.') ? fp.split('.') : [fp];
-              const toSet: any = {};
+              const namePath = (fp === 'nodeName' ? '__nb_variable_field_nodeName' : fp).split('.');
+              const toSet: Record<string, unknown> = {};
               if (!field?.props?.id) toSet.id = namePath;
               if (!field?.props?.name) toSet.name = namePath;
               if (Object.keys(toSet).length) field?.setProps?.(toSet);

package/src/flow/models/fields/__tests__/VariableFieldFormModel.test.tsx

@@ -0,0 +1,51 @@
+/**
+ * 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 { FlowEngine, FlowEngineProvider } from '@nocobase/flow-engine';
+import { render, screen, waitFor } from '@testing-library/react';
+import React from 'react';
+import { describe, expect, it } from 'vitest';
+import { InputFieldModel } from '../InputFieldModel';
+import { VariableFieldFormModel } from '../VariableFieldFormModel';
+
+describe('VariableFieldFormModel', () => {
+  it('uses DOM-safe name and id for temporary controls created from reserved form property names', async () => {
+    const engine = new FlowEngine();
+    engine.registerModels({ InputFieldModel, VariableFieldFormModel });
+    const model = engine.createModel<VariableFieldFormModel>({
+      use: 'VariableFieldFormModel',
+      subModels: {
+        fields: [
+          {
+            use: 'InputFieldModel',
+            stepParams: {
+              fieldSettings: {
+                init: {
+                  fieldPath: 'nodeName',
+                },
+              },
+            },
+          },
+        ],
+      },
+    });
+    const field = model.subModels.fields[0];
+
+    render(<FlowEngineProvider engine={engine}>{model.render()}</FlowEngineProvider>);
+
+    const input = await screen.findByRole('textbox');
+    await waitFor(() => {
+      expect(field.props.name).toEqual(['__nb_variable_field_nodeName']);
+    });
+    expect(input).toHaveAttribute('name', '__nb_variable_field_nodeName');
+    expect(input).toHaveAttribute('id', '__nb_variable_field_nodeName');
+    expect(field.props.id).toEqual(['__nb_variable_field_nodeName']);
+    expect(field.getStepParams('fieldSettings', 'init')).toEqual({ fieldPath: 'nodeName' });
+  });
+});