@nocobase/client-v2 2.1.0-beta.36 → 2.1.0-beta.37

package/src/components/form/filter/__tests__/CollectionFilterItem.test.tsx

@@ -0,0 +1,205 @@
+/**
+ * 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 { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { observable } from '@nocobase/flow-engine';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+
+type StubField = {
+  name: string;
+  title: string;
+  children?: StubField[];
+};
+
+// `fieldsToOptions` walks the live data-source registry to build option trees with operator lists per field interface. For a focused unit test we stub it so the test isn't coupled to interface registration. The stub returns the same nested shape `fieldsToOptions` would produce so `CollectionFilterItem`'s Cascader sees children for association-like fields.
+vi.mock('../../../../flow/components/filter/fieldsToOptions', () => {
+  const toOption = (field: StubField): any => ({
+    name: field.name,
+    title: field.title,
+    operators: field.children
+      ? undefined
+      : [
+          { value: '$eq', label: 'equals' },
+          { value: '$ne', label: 'not equals' },
+        ],
+    children: field.children?.map(toOption),
+  });
+  return {
+    fieldsToOptions: (fields: StubField[], _depth: number, ignore: string[]) =>
+      fields.filter((f) => !ignore.includes(f.name)).map(toOption),
+  };
+});
+
+import { CollectionFilterItem, createCollectionFilterItem } from '../CollectionFilterItem';
+
+function buildStubCollection(fieldDefs: StubField[]) {
+  return {
+    getFields: () =>
+      fieldDefs.map((f) => ({
+        name: f.name,
+        title: f.title,
+        type: 'string',
+        interface: 'input',
+        target: undefined as string | undefined,
+        // Mirror the stub's children so any downstream call that descends through the field tree behaves the same as `fieldsToOptions` does.
+        children: f.children,
+      })),
+  } as any;
+}
+
+function openFieldCascader(container: HTMLElement) {
+  const selector = container.querySelector('.ant-select-selector');
+  if (!selector) throw new Error('expected Cascader trigger to be rendered');
+  // antd Cascader renders an internal Select-style selector; mouseDown opens its popup just like a plain Select.
+  fireEvent.mouseDown(selector);
+}
+
+function openOperatorSelect(container: HTMLElement) {
+  // Operator dropdown is the second `.ant-select-selector` on the row; the first one is the Cascader's internal selector.
+  const selectors = container.querySelectorAll('.ant-select-selector');
+  if (selectors.length < 2) throw new Error('expected operator Select to be rendered');
+  fireEvent.mouseDown(selectors[1]);
+}
+
+describe('CollectionFilterItem', () => {
+  it('renders field options from the bound collection', async () => {
+    const value = observable({ path: '', operator: '', value: '' });
+    const collection = buildStubCollection([
+      { name: 'username', title: 'Username' },
+      { name: 'lockReason', title: 'Lock reason' },
+    ]);
+
+    const { container } = render(<CollectionFilterItem value={value} collection={collection} />);
+
+    openFieldCascader(container);
+    expect(await screen.findByText('Username')).toBeInTheDocument();
+    expect(await screen.findByText('Lock reason')).toBeInTheDocument();
+  });
+
+  it('updates value.path and seeds operator on leaf selection', async () => {
+    const value = observable({ path: '', operator: '', value: '' });
+    const collection = buildStubCollection([
+      { name: 'username', title: 'Username' },
+      { name: 'lockReason', title: 'Lock reason' },
+    ]);
+
+    const { container } = render(<CollectionFilterItem value={value} collection={collection} />);
+
+    openFieldCascader(container);
+    fireEvent.click(await screen.findByText('Username'));
+
+    await waitFor(() => {
+      expect(value.path).toBe('username');
+      // First operator from the stubbed options must be seeded automatically so the row is immediately usable without an extra click.
+      expect(value.operator).toBe('$eq');
+      // Field change clears the value — its shape is operator/field dependent (string for `$eq`, descriptor for `$dateOn`, etc.), so we don't carry the old value across field switches.
+      expect(value.value).toBeUndefined();
+    });
+  });
+
+  it('clears value when the operator changes', async () => {
+    const value = observable({ path: 'username', operator: '$eq', value: 'alice' });
+    const collection = buildStubCollection([{ name: 'username', title: 'Username' }]);
+
+    const { container } = render(<CollectionFilterItem value={value} collection={collection} />);
+
+    openOperatorSelect(container);
+    fireEvent.click(await screen.findByText('not equals'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$ne');
+      // Same rationale as the field-change branch — a stale string from `$eq` would be structurally incompatible with e.g. a `$dateOn` descriptor if the user picks a date operator next.
+      expect(value.value).toBeUndefined();
+    });
+  });
+
+  it('honours filterableFieldNames whitelist', async () => {
+    const value = observable({ path: '', operator: '', value: '' });
+    const collection = buildStubCollection([
+      { name: 'username', title: 'Username' },
+      { name: 'lockReason', title: 'Lock reason' },
+    ]);
+
+    const { container } = render(
+      <CollectionFilterItem value={value} collection={collection} filterableFieldNames={['username']} />,
+    );
+
+    openFieldCascader(container);
+    expect(await screen.findByText('Username')).toBeInTheDocument();
+    expect(screen.queryByText('Lock reason')).not.toBeInTheDocument();
+  });
+
+  it('writes through value.value on input change', () => {
+    const value = observable({ path: 'username', operator: '$eq', value: '' });
+    const collection = buildStubCollection([{ name: 'username', title: 'Username' }]);
+
+    render(<CollectionFilterItem value={value} collection={collection} />);
+
+    fireEvent.change(screen.getByPlaceholderText('Enter value'), { target: { value: 'alice' } });
+    expect(value.value).toBe('alice');
+  });
+
+  it('lets the user change the operator independently', async () => {
+    const value = observable({ path: 'username', operator: '$eq', value: '' });
+    const collection = buildStubCollection([{ name: 'username', title: 'Username' }]);
+
+    const { container } = render(<CollectionFilterItem value={value} collection={collection} />);
+
+    openOperatorSelect(container);
+    fireEvent.click(await screen.findByText('not equals'));
+
+    await waitFor(() => {
+      expect(value.operator).toBe('$ne');
+    });
+  });
+
+  it('drills into nested association fields and joins the path with dots', async () => {
+    const value = observable({ path: '', operator: '', value: '' });
+    const collection = buildStubCollection([
+      {
+        name: 'user',
+        title: 'User',
+        // Association parent — no operators of its own; should appear disabled in the Cascader so users have to drill into a leaf.
+        children: [
+          { name: 'username', title: 'Username' },
+          { name: 'nickname', title: 'Nickname' },
+        ],
+      },
+      { name: 'lockedTs', title: 'Locked time' },
+    ]);
+
+    const { container } = render(<CollectionFilterItem value={value} collection={collection} />);
+
+    openFieldCascader(container);
+    // Click the association parent to reveal its children. Cascader is configured with `expandTrigger="click"`.
+    fireEvent.click(await screen.findByText('User'));
+    fireEvent.click(await screen.findByText('Username'));
+
+    await waitFor(() => {
+      // The selected leaf path is dot-joined so callers can use it directly as a filter path (e.g. `user.username`).
+      expect(value.path).toBe('user.username');
+      expect(value.operator).toBe('$eq');
+    });
+  });
+
+  it('createCollectionFilterItem binds the collection so FilterContainer can drive it', async () => {
+    const value = observable({ path: '', operator: '', value: '' });
+    const collection = buildStubCollection([{ name: 'username', title: 'Username' }]);
+
+    const Item = createCollectionFilterItem(collection, { filterableFieldNames: ['username'] });
+    const { container } = render(<Item value={value} />);
+
+    openFieldCascader(container);
+    fireEvent.click(await screen.findByText('Username'));
+    await waitFor(() => {
+      expect(value.path).toBe('username');
+    });
+  });
+});

package/src/components/form/filter/__tests__/DateFilterDynamicComponent.test.tsx

@@ -0,0 +1,148 @@
+/**
+ * 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 { fireEvent, render, screen } from '@testing-library/react';
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import {
+  DateFilterDynamicComponent,
+  FORMAT_BY_PICKER,
+  formatDateFilterValue,
+  parseDateFilterValue,
+} from '../DateFilterDynamicComponent';
+
+// `formatDateFilterValue` needs the quarter plugin to format `[Q]Q`, and `parseDateFilterValue` needs customParseFormat to parse non-ISO strings like `2026-02`. The component itself imports `dayjs` directly and relies on plugins being registered at app boot; in tests we register them locally so the unit-style helpers can run standalone.
+dayjs.extend(customParseFormat);
+dayjs.extend(quarterOfYear);
+
+function openModeDropdown(container: HTMLElement) {
+  const selector = container.querySelector('.ant-select-selector');
+  if (!selector) throw new Error('expected mode Select to be rendered');
+  fireEvent.mouseDown(selector);
+}
+
+describe('DateFilterDynamicComponent', () => {
+  it('defaults to Exact day mode and shows the picker-granularity + DatePicker controls', () => {
+    const { container } = render(<DateFilterDynamicComponent value={undefined} onChange={() => undefined} />);
+    // Three controls in the compact row: mode select, granularity select, DatePicker. antd renders Select via `.ant-select`, DatePicker via `.ant-picker`.
+    expect(container.querySelectorAll('.ant-select').length).toBeGreaterThanOrEqual(2);
+    expect(container.querySelector('.ant-picker')).not.toBeNull();
+    // Mode display reads "Exact day" with no value yet.
+    expect(screen.getByText('Exact day')).toBeInTheDocument();
+  });
+
+  it('emits { type: "past", number: 1, unit: "day" } when switching mode to Past', () => {
+    const onChange = vi.fn();
+    const { container } = render(<DateFilterDynamicComponent value={undefined} onChange={onChange} />);
+
+    openModeDropdown(container);
+    // "Past" appears in the dropdown's primary list (rendered via dropdownRender, so options have role="option" instead of antd's stock list).
+    const option = screen.getAllByRole('option').find((el) => el.textContent === 'Past');
+    if (!option) throw new Error('expected a Past option in the dropdown');
+    fireEvent.click(option);
+
+    expect(onChange).toHaveBeenCalledWith({ type: 'past', number: 1, unit: 'day' });
+  });
+
+  it('emits { type: "today" } when switching mode to Today (no number / unit / picker)', () => {
+    const onChange = vi.fn();
+    const { container } = render(<DateFilterDynamicComponent value={undefined} onChange={onChange} />);
+
+    openModeDropdown(container);
+    const option = screen.getAllByRole('option').find((el) => el.textContent === 'Today');
+    if (!option) throw new Error('expected a Today option in the dropdown');
+    fireEvent.click(option);
+
+    expect(onChange).toHaveBeenCalledWith({ type: 'today' });
+  });
+
+  it('emits undefined (clears the descriptor) when switching back to Exact day', () => {
+    const onChange = vi.fn();
+    const { container } = render(<DateFilterDynamicComponent value={{ type: 'today' }} onChange={onChange} />);
+
+    openModeDropdown(container);
+    const option = screen.getAllByRole('option').find((el) => el.textContent === 'Exact day');
+    if (!option) throw new Error('expected an Exact day option in the dropdown');
+    fireEvent.click(option);
+
+    // Exact mode owns its value via the DatePicker, so the descriptor is cleared first; the picker emits its own value on user pick.
+    expect(onChange).toHaveBeenCalledWith(undefined);
+  });
+
+  it('shows InputNumber + unit Select when the value is a past/next descriptor', () => {
+    const onChange = vi.fn();
+    const { container } = render(
+      <DateFilterDynamicComponent value={{ type: 'past', number: 3, unit: 'week' }} onChange={onChange} />,
+    );
+
+    // InputNumber present (antd renders `.ant-input-number`); unit Select is the second `.ant-select` in the row (mode is first).
+    expect(container.querySelector('.ant-input-number')).not.toBeNull();
+    expect(container.querySelectorAll('.ant-select').length).toBeGreaterThanOrEqual(2);
+    // DatePicker should NOT be rendered in relative-number mode.
+    expect(container.querySelector('.ant-picker')).toBeNull();
+  });
+
+  it('renders the RangePicker when isRange is true', () => {
+    const { container } = render(<DateFilterDynamicComponent value={undefined} onChange={() => undefined} isRange />);
+    // RangePicker carries the `.ant-picker-range` class; the granularity Select is suppressed in range mode (only mode select + range picker).
+    expect(container.querySelector('.ant-picker-range')).not.toBeNull();
+  });
+
+  it('hydrates a stored granularity-formatted string back into the DatePicker', () => {
+    // `2026-02-15` is the canonical Date-picker shape NocoBase's `$dateOn` operator emits when the user picks an exact day. The DatePicker must hydrate from it (so reopening the popover or re-rendering keeps the value) instead of treating it as an opaque blob.
+    //
+    // Note: the picker-mode state is local to the component and defaults to `date` on every mount, so values stored at other granularities (`2026-02` for month, `2026` for year) won't pre-fill on remount — only when the user is still in the same session. This matches v1's behaviour, where reopening a filter popover also re-derives the picker mode from the input shape.
+    const { container } = render(<DateFilterDynamicComponent value="2026-02-15" onChange={() => undefined} />);
+    const dateInput = container.querySelector('.ant-picker input') as HTMLInputElement;
+    if (!dateInput) throw new Error('expected antd DatePicker input to be rendered');
+    expect(dateInput.value).toBe('2026-02-15');
+  });
+
+  describe('format helpers (parseDateFilterValue / formatDateFilterValue)', () => {
+    // These two helpers are the heart of the v1-compatible URL output: `formatDateFilterValue` converts a Dayjs into the picker-shaped string the server expects, and `parseDateFilterValue` round-trips back so the controlled DatePicker can hydrate. Driving them directly is more reliable than poking antd's picker panel under jsdom.
+
+    it('formats Dayjs values per picker granularity (date / month / quarter / year)', () => {
+      const sample = dayjs('2026-02-15');
+      expect(formatDateFilterValue(sample, 'date')).toBe('2026-02-15');
+      expect(formatDateFilterValue(sample, 'month')).toBe('2026-02');
+      expect(formatDateFilterValue(sample, 'year')).toBe('2026');
+      expect(formatDateFilterValue(sample, 'quarter')).toBe('2026-Q1');
+    });
+
+    it('returns undefined for empty / non-Dayjs input so callers can drop the value', () => {
+      expect(formatDateFilterValue(null, 'date')).toBeUndefined();
+      expect(formatDateFilterValue(undefined, 'date')).toBeUndefined();
+    });
+
+    it('round-trips a granularity string back into a Dayjs at the matching format', () => {
+      const parsed = parseDateFilterValue('2026-02', 'month');
+      expect(parsed?.isValid()).toBe(true);
+      expect(parsed?.format(FORMAT_BY_PICKER.month)).toBe('2026-02');
+    });
+
+    it('returns null for missing / unparseable strings', () => {
+      expect(parseDateFilterValue(undefined, 'month')).toBeNull();
+      expect(parseDateFilterValue('', 'month')).toBeNull();
+      expect(parseDateFilterValue('not-a-date', 'month')).toBeNull();
+    });
+  });
+
+  it('translates mode labels via the provided t function', () => {
+    const t = (key: string) => (key === 'Past' ? 'PAST_ZH' : key);
+    const { container } = render(<DateFilterDynamicComponent value={undefined} onChange={() => undefined} t={t} />);
+
+    openModeDropdown(container);
+    // The translated label should appear in the dropdown options.
+    expect(screen.getAllByRole('option').some((el) => el.textContent === 'PAST_ZH')).toBe(true);
+    expect(container).toBeTruthy();
+  });
+});

package/src/components/form/filter/__tests__/FilterValueInput.test.tsx

@@ -0,0 +1,243 @@
+/**
+ * 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 { fireEvent, render, screen } from '@testing-library/react';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { FilterValueInput } from '../FilterValueInput';
+import type { FilterOperator, FilterOption } from '../../../../flow/components/filter/useFilterOptions';
+
+type Case = {
+  /** Human-readable description of the v1 interface this case mirrors. */
+  name: string;
+  /** Field uiSchema. Operator schema is optional and overrides this. */
+  fieldComponent?: string;
+  fieldEnum?: any[];
+  operator?: FilterOperator;
+  /** Selector used to confirm the right antd control rendered. */
+  selector: string;
+  /** Optional: drive an interaction and assert onChange payload. */
+  interact?: (container: HTMLElement, onChange: ReturnType<typeof vi.fn>) => void;
+  expectedOnChange?: any;
+};
+
+const fieldOf = (component: string, extra: Partial<FilterOption['schema']> = {}): FilterOption => ({
+  name: 'f',
+  title: 'F',
+  schema: { 'x-component': component, ...extra },
+});
+
+const opOf = (overrides: Partial<FilterOperator> = {}): FilterOperator => ({
+  value: '$eq',
+  label: 'is',
+  ...overrides,
+});
+
+// One row per v1 field interface → expected v2 antd control. Detection is kept to a single CSS selector per case so the table reads as "interface ↔ selector"; interactive assertions are added only where the value-onChange contract is non-trivial (e.g. Checkbox.target.checked, ColorPicker hex extraction).
+const CASES: Case[] = [
+  // string / email / phone / uuid / nanoid / url all default to Input
+  { name: 'input → antd Input', fieldComponent: 'Input', selector: 'input[type="text"]' },
+  { name: 'Input.URL → antd Input', fieldComponent: 'Input.URL', selector: 'input[type="text"]' },
+  { name: 'NanoIDInput → antd Input', fieldComponent: 'NanoIDInput', selector: 'input[type="text"]' },
+
+  // textarea / markdown / richText / json all collapse to TextArea
+  { name: 'textarea → antd Input.TextArea', fieldComponent: 'Input.TextArea', selector: 'textarea' },
+  { name: 'markdown → antd Input.TextArea', fieldComponent: 'Markdown', selector: 'textarea' },
+  { name: 'richText → antd Input.TextArea', fieldComponent: 'RichText', selector: 'textarea' },
+  { name: 'json → antd Input.TextArea', fieldComponent: 'Input.JSON', selector: 'textarea' },
+
+  // numeric inputs
+  { name: 'integer → antd InputNumber', fieldComponent: 'InputNumber', selector: '.ant-input-number' },
+  { name: 'percent → antd InputNumber', fieldComponent: 'Percent', selector: '.ant-input-number' },
+
+  // password — the case that prompted this audit
+  {
+    name: 'password → PasswordInput (Input.Password)',
+    fieldComponent: 'Password',
+    selector: 'input[type="password"]',
+  },
+
+  // pickers
+  {
+    name: 'datetime field → antd DatePicker (no operator override)',
+    fieldComponent: 'DatePicker',
+    selector: '.ant-picker',
+  },
+  { name: 'unixTimestamp → antd DatePicker', fieldComponent: 'UnixTimestamp', selector: '.ant-picker' },
+  { name: 'time → antd TimePicker', fieldComponent: 'TimePicker', selector: '.ant-picker' },
+  { name: 'color → antd ColorPicker', fieldComponent: 'ColorPicker', selector: '.ant-color-picker-trigger' },
+
+  // boolean / single-choice / multi-choice
+  { name: 'checkbox → antd Checkbox', fieldComponent: 'Checkbox', selector: 'input[type="checkbox"]' },
+  {
+    name: 'checkboxGroup with field enum → antd Checkbox.Group',
+    fieldComponent: 'Checkbox.Group',
+    fieldEnum: [
+      { label: 'A', value: 'a' },
+      { label: 'B', value: 'b' },
+    ],
+    selector: '.ant-checkbox-group',
+  },
+  {
+    name: 'radioGroup with field enum → antd Radio.Group',
+    fieldComponent: 'Radio.Group',
+    fieldEnum: [
+      { label: 'A', value: 'a' },
+      { label: 'B', value: 'b' },
+    ],
+    selector: '.ant-radio-group',
+  },
+  { name: 'select → antd Select', fieldComponent: 'Select', selector: '.ant-select' },
+
+  // operator-level overrides — datetime operator schema wins over field uiSchema
+  {
+    name: '$dateOn operator → smart date picker',
+    fieldComponent: 'DatePicker',
+    operator: opOf({
+      schema: { 'x-component': 'DateFilterDynamicComponent', 'x-component-props': { isRange: false } },
+    }),
+    selector: '.ant-picker',
+  },
+  {
+    name: '$anyOf array operator → Select with tags mode',
+    fieldComponent: 'Input',
+    operator: opOf({
+      value: '$anyOf',
+      schema: { 'x-component': 'Select', 'x-component-props': { mode: 'tags' } },
+    }),
+    selector: '.ant-select-selection-overflow',
+  },
+
+  // noValue operators render nothing
+  {
+    name: '$empty operator → renders nothing',
+    fieldComponent: 'Input',
+    operator: opOf({ value: '$empty', noValue: true }),
+    selector: '*',
+    // selector intentionally generic; we assert empty container via interact
+  },
+];
+
+function setup(c: Case) {
+  const onChange = vi.fn();
+  const field = c.fieldComponent
+    ? fieldOf(c.fieldComponent, c.fieldEnum ? ({ enum: c.fieldEnum } as any) : {})
+    : undefined;
+  const utils = render(<FilterValueInput field={field} operator={c.operator} value={undefined} onChange={onChange} />);
+  return { onChange, ...utils };
+}
+
+describe('FilterValueInput dispatch table', () => {
+  for (const c of CASES) {
+    it(c.name, () => {
+      const { container } = setup(c);
+      if (c.operator?.noValue) {
+        // For noValue operators the component returns null.
+        expect(
+          container.querySelector('input, textarea, .ant-select, .ant-picker, .ant-color-picker-trigger'),
+        ).toBeNull();
+        return;
+      }
+      expect(container.querySelector(c.selector)).not.toBeNull();
+    });
+  }
+});
+
+describe('FilterValueInput interaction wiring', () => {
+  // Spot-check a handful of write-through paths that have non-trivial event shapes (target.checked, event vs raw value, hex extraction from ColorPicker).
+  it('Checkbox emits the boolean from target.checked', () => {
+    const onChange = vi.fn();
+    const { container } = render(
+      <FilterValueInput field={fieldOf('Checkbox')} operator={opOf()} value={false} onChange={onChange} />,
+    );
+    fireEvent.click(container.querySelector('input[type="checkbox"]') as HTMLInputElement);
+    expect(onChange).toHaveBeenCalledWith(true);
+  });
+
+  it('Password emits the unwrapped string from the input event', () => {
+    const onChange = vi.fn();
+    const { container } = render(
+      <FilterValueInput field={fieldOf('Password')} operator={opOf()} value="" onChange={onChange} />,
+    );
+    const input = container.querySelector('input[type="password"]') as HTMLInputElement;
+    fireEvent.change(input, { target: { value: 'hunter2' } });
+    expect(onChange).toHaveBeenCalledWith('hunter2');
+  });
+
+  it('TextArea emits the unwrapped string', () => {
+    const onChange = vi.fn();
+    const { container } = render(
+      <FilterValueInput field={fieldOf('Input.TextArea')} operator={opOf()} value="" onChange={onChange} />,
+    );
+    fireEvent.change(container.querySelector('textarea') as HTMLTextAreaElement, {
+      target: { value: 'abuse' },
+    });
+    expect(onChange).toHaveBeenCalledWith('abuse');
+  });
+
+  it('Radio.Group emits the picked value (not the event)', () => {
+    const onChange = vi.fn();
+    const { container } = render(
+      <FilterValueInput
+        field={fieldOf('Radio.Group', {
+          enum: [
+            { label: 'A', value: 'a' },
+            { label: 'B', value: 'b' },
+          ],
+        } as any)}
+        operator={opOf()}
+        value={undefined}
+        onChange={onChange}
+      />,
+    );
+    fireEvent.click(container.querySelectorAll('input[type="radio"]')[1] as HTMLInputElement);
+    expect(onChange).toHaveBeenCalledWith('b');
+  });
+
+  it('Fallback Input honours the placeholder prop', () => {
+    render(<FilterValueInput operator={opOf()} value="" onChange={() => undefined} placeholder="Enter value" />);
+    expect(screen.getByPlaceholderText('Enter value')).toBeInTheDocument();
+  });
+});
+
+describe('FilterValueInput schema precedence', () => {
+  it('operator schema wins over field uiSchema', () => {
+    // Field would render Input, but operator forces Select.
+    render(
+      <FilterValueInput
+        field={fieldOf('Input')}
+        operator={opOf({
+          schema: { 'x-component': 'Select', 'x-component-props': { mode: 'tags' } },
+        })}
+        value={[]}
+        onChange={() => undefined}
+      />,
+    );
+    expect(document.querySelector('.ant-select')).not.toBeNull();
+  });
+
+  it('field uiSchema is used when operator has none', () => {
+    const { container } = render(
+      <FilterValueInput
+        field={fieldOf('InputNumber')}
+        operator={opOf()}
+        value={undefined}
+        onChange={() => undefined}
+      />,
+    );
+    expect(container.querySelector('.ant-input-number')).not.toBeNull();
+  });
+
+  it('plain Input is used when neither side has a schema', () => {
+    const { container } = render(
+      <FilterValueInput operator={opOf()} value="" onChange={() => undefined} placeholder="x" />,
+    );
+    expect(container.querySelector('input[type="text"]')).not.toBeNull();
+  });
+});