@astryxdesign/core 0.7.5 → 0.7.6-canary.0bd3b37

package/src/PowerSearch/usePowerSearchSource.test.ts

@@ -1,621 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file usePowerSearchSource.test.ts
- * @input usePowerSearchSource, useInternalConfig
- * @output Tests for field typeahead search source, including contentSearchFieldKey
- * @position Testing; validates usePowerSearchSource.ts
- */
-
-import {describe, it, expect} from 'vitest';
-import {renderHook} from '@testing-library/react';
-import {usePowerSearchSource} from './usePowerSearchSource';
-import {useInternalConfig} from './useInternalConfig';
-import type {
-  PowerSearchConfig,
-  PowerSearchAuxData,
-  PowerSearchItem,
-} from './types';
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-function createSource(
-  config: PowerSearchConfig,
-  // Uncapped by default so these tests exercise matching and ranking rather
-  // than the typed-result cap, which has its own test below.
-  maxTypedResults: number = Number.POSITIVE_INFINITY,
-) {
-  const {result} = renderHook(() => {
-    const internal = useInternalConfig(config);
-    return usePowerSearchSource(internal, maxTypedResults);
-  });
-  return result.current;
-}
-
-function syncBootstrap(
-  source: ReturnType<typeof createSource>,
-): PowerSearchItem[] {
-  const result = source.bootstrap();
-  if (result instanceof Promise) {
-    throw new Error('Expected synchronous bootstrap');
-  }
-  return result;
-}
-
-function syncSearch(
-  source: ReturnType<typeof createSource>,
-  query: string,
-): PowerSearchItem[] {
-  const result = source.search(query);
-  if (result instanceof Promise) {
-    throw new Error('Expected synchronous search');
-  }
-  return result;
-}
-
-// =============================================================================
-// Fixtures
-// =============================================================================
-
-const baseConfig: PowerSearchConfig = {
-  name: 'TestSearch',
-  fields: [
-    {
-      key: 'title',
-      label: 'Title',
-      defaultOperator: 'contains',
-      operators: [
-        {key: 'contains', label: 'contains', value: {type: 'string'}},
-        {key: 'is', label: 'is', value: {type: 'string'}},
-      ],
-    },
-    {
-      key: 'status',
-      label: 'Status',
-      defaultOperator: 'is',
-      operators: [
-        {
-          key: 'is',
-          label: 'is',
-          value: {
-            type: 'enum',
-            values: [
-              {value: 'open', label: 'Open'},
-              {value: 'closed', label: 'Closed'},
-            ],
-          },
-        },
-      ],
-    },
-  ],
-};
-
-const configWithContentSearch: PowerSearchConfig = {
-  ...baseConfig,
-  contentSearchFieldKey: 'title',
-};
-
-const groupedConfig: PowerSearchConfig = {
-  name: 'GroupedSearch',
-  fields: [
-    field('team_a', 'Field Team A', 'Team'),
-    field('plain_a', 'Field Plain A'),
-    field('time_a', 'Field Time A', 'Time'),
-    field('team_b', 'Field Team B', 'Team'),
-    field('plain_b', 'Field Plain B'),
-    field('time_b', 'Field Time B', 'Time'),
-  ],
-};
-
-function field(key: string, label: string, group?: string) {
-  return {
-    key,
-    label,
-    group,
-    operators: [{key: 'is', label: 'is', value: {type: 'string'} as const}],
-  };
-}
-
-// =============================================================================
-// Tests
-// =============================================================================
-
-describe('usePowerSearchSource', () => {
-  describe('bootstrap (no query)', () => {
-    it('returns only field names without operator labels', () => {
-      const source = createSource(baseConfig);
-      const items = syncBootstrap(source);
-
-      expect(items.map((i: PowerSearchItem) => i.label)).toEqual([
-        'Title',
-        'Status',
-      ]);
-    });
-
-    it('sets defaultOperator on bootstrap items', () => {
-      const source = createSource(baseConfig);
-      const items = syncBootstrap(source);
-
-      const titleAux = items[0].auxiliaryData as PowerSearchAuxData;
-      expect(titleAux.fieldKey).toBe('title');
-      expect(titleAux.operatorKey).toBe('contains');
-
-      const statusAux = items[1].auxiliaryData as PowerSearchAuxData;
-      expect(statusAux.fieldKey).toBe('status');
-      expect(statusAux.operatorKey).toBe('is');
-    });
-
-    it('empty search returns same as bootstrap', () => {
-      const source = createSource(baseConfig);
-      expect(syncSearch(source, '')).toEqual(syncBootstrap(source));
-    });
-
-    it('orders ungrouped fields before named groups', () => {
-      const items = syncBootstrap(createSource(groupedConfig));
-      expect(items.map(item => item.label)).toEqual([
-        'Field Plain A',
-        'Field Plain B',
-        'Field Team A',
-        'Field Team B',
-        'Field Time A',
-        'Field Time B',
-      ]);
-      expect(
-        items.map(item => (item.auxiliaryData as PowerSearchAuxData).group),
-      ).toEqual([undefined, undefined, 'Team', 'Team', 'Time', 'Time']);
-    });
-  });
-
-  describe('search (with query)', () => {
-    it('shows field name for partial match', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'tit');
-
-      expect(results.some(r => r.label === 'Title')).toBe(true);
-    });
-
-    it('shows all field+operator combos for partial match', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'tit');
-      const labels = results.map(r => r.label);
-
-      expect(labels).toContain('Title');
-      expect(labels).toContain('Title contains');
-      expect(labels).toContain('Title is');
-    });
-
-    it('matches query against combined field and operator label', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'title contains');
-
-      expect(results.some(r => r.label === 'Title contains')).toBe(true);
-    });
-
-    it('matches partial field + operator query', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'title con');
-
-      expect(results.some(r => r.label === 'Title contains')).toBe(true);
-    });
-
-    it('field name item uses defaultOperator', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'tit');
-
-      const titleItem = results.find(r => r.label === 'Title');
-      const aux = titleItem?.auxiliaryData as PowerSearchAuxData;
-      expect(aux.operatorKey).toBe('contains');
-    });
-
-    it('field+operator items use specific operator', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'tit');
-
-      const isItem = results.find(r => r.label === 'Title is');
-      const aux = isItem?.auxiliaryData as PowerSearchAuxData;
-      expect(aux.operatorKey).toBe('is');
-    });
-
-    it('leaves ranked results flat and in relevance order', () => {
-      const results = syncSearch(createSource(groupedConfig), 'field');
-      expect(results.slice(0, 6).map(item => item.label)).toEqual([
-        'Field Team A',
-        'Field Team A is',
-        'Field Plain A',
-        'Field Plain A is',
-        'Field Time A',
-        'Field Time A is',
-      ]);
-      expect(
-        results.every(
-          item => (item.auxiliaryData as PowerSearchAuxData).group == null,
-        ),
-      ).toBe(true);
-    });
-  });
-
-  describe('contentSearchFieldKey', () => {
-    it('shows content search item for non-matching query', () => {
-      const source = createSource(configWithContentSearch);
-      const results = syncSearch(source, 'foobar');
-
-      expect(results[0].label).toBe('"foobar"');
-      const aux = results[0].auxiliaryData as PowerSearchAuxData;
-      expect(aux.fieldKey).toBe('title');
-      expect(aux.operatorKey).toBe('contains');
-      expect(aux.filterValue).toEqual({type: 'string', value: 'foobar'});
-    });
-
-    it('does not show content search item when query exactly matches a field name', () => {
-      const source = createSource(configWithContentSearch);
-      const results = syncSearch(source, 'title');
-
-      const contentItem = results.find(r => r.label.startsWith('"'));
-      expect(contentItem).toBeUndefined();
-    });
-
-    it('does not show content search item when query exactly matches field + operator', () => {
-      const source = createSource(configWithContentSearch);
-      const results = syncSearch(source, 'Title contains');
-
-      const contentItem = results.find(r => r.label.startsWith('"'));
-      expect(contentItem).toBeUndefined();
-    });
-
-    it('exact match check is case-insensitive', () => {
-      const source = createSource(configWithContentSearch);
-      const results = syncSearch(source, 'TITLE');
-
-      const contentItem = results.find(r => r.label.startsWith('"'));
-      expect(contentItem).toBeUndefined();
-    });
-
-    it('shows content search item for partial field match', () => {
-      const source = createSource(configWithContentSearch);
-      const results = syncSearch(source, 'tit');
-
-      expect(results[0].label).toBe('"tit"');
-      // Field and field+operator results should still appear after
-      expect(results.some(r => r.label === 'Title')).toBe(true);
-      expect(results.some(r => r.label === 'Title contains')).toBe(true);
-    });
-
-    it('does not show content search item when contentSearchFieldKey is not set', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'foobar');
-
-      const contentItem = results.find(r => r.label.startsWith('"'));
-      expect(contentItem).toBeUndefined();
-    });
-
-    it('content search item is first in results', () => {
-      const source = createSource(configWithContentSearch);
-      const results = syncSearch(source, 'sta');
-
-      expect(results[0].label).toBe('"sta"');
-      expect(results.length).toBeGreaterThan(1);
-    });
-  });
-
-  describe('field+operator+value suggestions', () => {
-    it('suggests all string-valued operators for "title foobar"', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'title foobar');
-
-      const valueItems = results.filter(r => r.label.includes('"foobar"'));
-      expect(valueItems.map(r => r.label)).toEqual([
-        'Title contains "foobar"',
-        'Title is "foobar"',
-      ]);
-
-      const containsAux = valueItems[0].auxiliaryData as PowerSearchAuxData;
-      expect(containsAux.fieldKey).toBe('title');
-      expect(containsAux.operatorKey).toBe('contains');
-      expect(containsAux.filterValue).toEqual({
-        type: 'string',
-        value: 'foobar',
-      });
-
-      const isAux = valueItems[1].auxiliaryData as PowerSearchAuxData;
-      expect(isAux.operatorKey).toBe('is');
-    });
-
-    it('suggests only the matching operator for "title contains foobar"', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'title contains foobar');
-
-      const valueItems = results.filter(r => r.label.includes('"foobar"'));
-      expect(valueItems).toHaveLength(1);
-      expect(valueItems[0].label).toBe('Title contains "foobar"');
-      const aux = valueItems[0].auxiliaryData as PowerSearchAuxData;
-      expect(aux.operatorKey).toBe('contains');
-      expect(aux.filterValue).toEqual({type: 'string', value: 'foobar'});
-    });
-
-    it('does not suggest "<field> <value>" matches when explicit operator matched', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'title contains foobar');
-
-      // Should NOT have 'Title is "contains foobar"' or similar
-      const spurious = results.filter(r =>
-        r.label.includes('"contains foobar"'),
-      );
-      expect(spurious).toHaveLength(0);
-    });
-
-    it('suggests only the matching operator for "title is foobar"', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'title is foobar');
-
-      const valueItems = results.filter(r => r.label.includes('"foobar"'));
-      expect(valueItems).toHaveLength(1);
-      expect(valueItems[0].label).toBe('Title is "foobar"');
-      const aux = valueItems[0].auxiliaryData as PowerSearchAuxData;
-      expect(aux.operatorKey).toBe('is');
-    });
-
-    it('is case-insensitive for field and operator matching', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'TITLE CONTAINS hello');
-
-      const valueItem = results.find(r => r.label === 'Title contains "hello"');
-      expect(valueItem).toBeDefined();
-    });
-
-    it('preserves original case of the value', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'title FooBar');
-
-      const valueItem = results.find(
-        r => r.label === 'Title contains "FooBar"',
-      );
-      expect(valueItem).toBeDefined();
-      const aux = valueItem!.auxiliaryData as PowerSearchAuxData;
-      expect(aux.filterValue).toEqual({type: 'string', value: 'FooBar'});
-    });
-
-    it('does not suggest value match for non-string operators', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'status foobar');
-
-      const valueItem = results.find(r => r.label.includes('"foobar"'));
-      expect(valueItem).toBeUndefined();
-    });
-
-    it('does not suggest value match when remainder matches an operator prefix', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'title con');
-
-      // "con" is a prefix of "contains", so should not suggest a value match
-      const valueItem = results.find(r => r.label.includes('"con"'));
-      expect(valueItem).toBeUndefined();
-    });
-
-    it('does not suggest value match when field has isValueMatchAllowed=false', () => {
-      const config: PowerSearchConfig = {
-        name: 'Test',
-        fields: [
-          {
-            key: 'title',
-            label: 'Title',
-            isValueMatchAllowed: false,
-            operators: [
-              {key: 'contains', label: 'contains', value: {type: 'string'}},
-            ],
-          },
-        ],
-      };
-      const source = createSource(config);
-      const results = syncSearch(source, 'title foobar');
-
-      const valueItem = results.find(r => r.label.includes('"foobar"'));
-      expect(valueItem).toBeUndefined();
-    });
-
-    it('uses string_list filter value for string_list operators', () => {
-      const config: PowerSearchConfig = {
-        name: 'Test',
-        fields: [
-          {
-            key: 'tags',
-            label: 'Tags',
-            operators: [
-              {
-                key: 'contains',
-                label: 'contains',
-                value: {type: 'string_list'},
-              },
-            ],
-          },
-        ],
-      };
-      const source = createSource(config);
-      const results = syncSearch(source, 'tags hello');
-
-      const valueItem = results.find(r => r.label === 'Tags contains "hello"');
-      expect(valueItem).toBeDefined();
-      const aux = valueItem!.auxiliaryData as PowerSearchAuxData;
-      expect(aux.filterValue).toEqual({type: 'string_list', value: ['hello']});
-    });
-
-    it('suggests matching enum values for "<field> <value>"', () => {
-      const config: PowerSearchConfig = {
-        name: 'Test',
-        fields: [
-          {
-            key: 'genre',
-            label: 'Genre',
-            operators: [
-              {
-                key: 'is',
-                label: 'is',
-                value: {
-                  type: 'enum',
-                  values: [
-                    {value: 'fiction', label: 'Fiction'},
-                    {value: 'nonfiction', label: 'Non-Fiction'},
-                    {value: 'science', label: 'Science'},
-                  ],
-                },
-              },
-              {
-                key: 'is_not',
-                label: 'is not',
-                value: {
-                  type: 'enum',
-                  values: [
-                    {value: 'fiction', label: 'Fiction'},
-                    {value: 'nonfiction', label: 'Non-Fiction'},
-                    {value: 'science', label: 'Science'},
-                  ],
-                },
-              },
-            ],
-          },
-        ],
-      };
-      const source = createSource(config);
-      const results = syncSearch(source, 'genre fiction');
-
-      const valueItems = results.filter(
-        r => r.label.startsWith('Genre ') && r.label.includes('Fiction'),
-      );
-      // "fiction" matches both "Fiction" and "Non-Fiction"
-      expect(valueItems.map(r => r.label)).toEqual([
-        'Genre is Fiction',
-        'Genre is Non-Fiction',
-        'Genre is not Fiction',
-        'Genre is not Non-Fiction',
-      ]);
-
-      const isAux = valueItems[0].auxiliaryData as PowerSearchAuxData;
-      expect(isAux.filterValue).toEqual({type: 'enum', value: 'fiction'});
-    });
-
-    it('suggests only matching operator for "<field> <operator> <value>" with enum', () => {
-      const config: PowerSearchConfig = {
-        name: 'Test',
-        fields: [
-          {
-            key: 'genre',
-            label: 'Genre',
-            operators: [
-              {
-                key: 'is',
-                label: 'is',
-                value: {
-                  type: 'enum',
-                  values: [
-                    {value: 'fiction', label: 'Fiction'},
-                    {value: 'nonfiction', label: 'Non-Fiction'},
-                  ],
-                },
-              },
-              {
-                key: 'is_not',
-                label: 'is not',
-                value: {
-                  type: 'enum',
-                  values: [
-                    {value: 'fiction', label: 'Fiction'},
-                    {value: 'nonfiction', label: 'Non-Fiction'},
-                  ],
-                },
-              },
-            ],
-          },
-        ],
-      };
-      const source = createSource(config);
-      const results = syncSearch(source, 'genre is fiction');
-
-      const valueItems = results.filter(r => r.label === 'Genre is Fiction');
-      expect(valueItems).toHaveLength(1);
-      // Should NOT include "is not" operator results
-      const isNotItems = results.filter(r =>
-        r.label.startsWith('Genre is not'),
-      );
-      expect(isNotItems).toHaveLength(0);
-    });
-
-    it('suggests multiple matching enum values for partial match', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'status o');
-
-      // "o" matches "Open" and "Closed"
-      const valueItems = results.filter(
-        r => r.label.startsWith('Status is ') && r.label !== 'Status is',
-      );
-      expect(valueItems.map(r => r.label)).toEqual([
-        'Status is Open',
-        'Status is Closed',
-      ]);
-    });
-
-    it('does not suggest enum values when no labels match', () => {
-      const source = createSource(baseConfig);
-      const results = syncSearch(source, 'status xyz');
-
-      const valueItems = results.filter(
-        r => r.label.startsWith('Status is ') && r.label !== 'Status is',
-      );
-      expect(valueItems).toHaveLength(0);
-    });
-
-    it('uses enum_list filter value for enum_list operators', () => {
-      const config: PowerSearchConfig = {
-        name: 'Test',
-        fields: [
-          {
-            key: 'tags',
-            label: 'Tags',
-            operators: [
-              {
-                key: 'includes',
-                label: 'includes',
-                value: {
-                  type: 'enum_list',
-                  values: [
-                    {value: 'bug', label: 'Bug'},
-                    {value: 'feature', label: 'Feature'},
-                  ],
-                },
-              },
-            ],
-          },
-        ],
-      };
-      const source = createSource(config);
-      const results = syncSearch(source, 'tags bug');
-
-      const valueItem = results.find(r => r.label === 'Tags includes Bug');
-      expect(valueItem).toBeDefined();
-      const aux = valueItem!.auxiliaryData as PowerSearchAuxData;
-      expect(aux.filterValue).toEqual({type: 'enum_list', value: ['bug']});
-    });
-  });
-});
-
-describe('typed-result cap', () => {
-  const manyFields: PowerSearchConfig = {
-    name: 'many',
-    fields: Array.from({length: 25}, (_, i) => ({
-      key: `field_${i}`,
-      label: `Zebra ${String(i).padStart(2, '0')}`,
-      operators: [{key: 'is', label: 'is', value: {type: 'string'} as const}],
-    })),
-  };
-
-  it('caps results for a typed query', () => {
-    const source = createSource(manyFields, 10);
-    expect(source.search('zebra')).toHaveLength(10);
-  });
-
-  it('never caps the field list for an empty query', () => {
-    const source = createSource(manyFields, 10);
-    expect(syncBootstrap(source)).toHaveLength(25);
-    expect(source.search('')).toHaveLength(25);
-  });
-});