test: add property-based regression tests for filterQuickPickItems (#478)

Author: Will-ShaoHua

package-lock.json

@@ -89,6 +89,7 @@
         "eslint-plugin-no-null": "^1.0.2",
         "eslint-plugin-prettier": "^5.0.0",
         "eslint-plugin-promise": "6.0.0",
+        "fast-check": "^4.6.0",
         "husky": "^9.1.6",
         "jest": "^29.7.0",
         "jest-environment-jsdom": "^29.7.0",

package.json

@@ -0,0 +1,212 @@
+/**
+ * Regression Property-Based Tests — Small Repo and Non-Lag Path Behavior
+ *
+ * These tests capture the OBSERVED behavior of filterQuickPickItems on unfixed code
+ * for non-buggy inputs (small item counts). They must PASS on unfixed code to confirm
+ * baseline behavior that must be preserved after the fix.
+ *
+ * **Validates: Requirements 3.1, 3.4**
+ */
+import * as fc from 'fast-check';
+import { filterQuickPickItems, MARK_OPEN, MARK_CLOSE } from '../quick-pick-data-handler';
+import { QuickActionCommandGroup, QuickActionCommand } from '../../static';
+
+/**
+ * Generate a small set of QuickActionCommandGroups simulating a small repo (<1,000 items).
+ * Items have varied names to exercise all scoring tiers.
+ */
+function generateSmallCommandGroups (items: Array<{ command: string; id: string }>): QuickActionCommandGroup[] {
+  const commands: QuickActionCommand[] = items.map(item => ({
+    command: item.command,
+    id: item.id,
+    label: 'file',
+    icon: 'file' as any,
+    description: `workspace/${item.command}`,
+  }));
+
+  return [ {
+    groupName: 'Files',
+    commands,
+  } ];
+}
+
+/** Arbitrary for search terms that are non-empty lowercase strings (1-10 chars) */
+const searchTermArb = fc.stringMatching(/^[a-z]{1,10}$/);
+
+/**
+ * Arbitrary for a list of command names that are realistic file-path-like strings.
+ * We generate varied names to ensure different scoring tiers are exercised.
+ */
+const commandNameArb = fc.tuple(
+  fc.constantFrom('src', 'lib', 'test', 'docs', 'utils', 'config', 'main', 'index', 'helper', 'service'),
+  fc.constantFrom('module', 'component', 'handler', 'provider', 'factory', 'manager', 'controller', 'adapter'),
+  fc.constantFrom('.ts', '.js', '.tsx', '.json', '.md')
+).map(([ prefix, name, ext ]) => `${prefix}/${name}${ext}`);
+
+describe('Regression: Small Repo filterQuickPickItems Behavior', () => {
+  /**
+   * **Validates: Requirements 3.1**
+   *
+   * Property 2a: For all context item lists with <1,000 items and any search term,
+   * filterQuickPickItems returns items matching the search term, sorted by score
+   * (exact=100 > prefix=80 > word-start=60 > contains=40), with highlights applied.
+   *
+   * This captures the observed behavior: every matching item is returned, sorted
+   * descending by score, and each result has <mark> highlight tags applied.
+   */
+  it('returns all matching items sorted by score with highlights for small item lists', () => {
+    fc.assert(
+      fc.property(
+        fc.array(commandNameArb, { minLength: 1, maxLength: 200 }),
+        searchTermArb,
+        (commandNames, searchTerm) => {
+          const items = commandNames.map((name, i) => ({ command: name, id: `item-${i}` }));
+          const commands = generateSmallCommandGroups(items);
+
+          const result = filterQuickPickItems(commands, searchTerm);
+
+          // Result should always be a single group
+          if (result.length !== 1) return false;
+
+          const resultCommands = result[0].commands ?? [];
+
+          // Verify every result has highlights applied (contains <mark> tags)
+          for (const cmd of resultCommands) {
+            if (!cmd.command.includes(MARK_OPEN) && !cmd.command.includes(MARK_CLOSE)) {
+              // If the command has no mark tags, it means highlighting failed
+              // But the original text might not contain the search term at all
+              // (partial matching can still produce highlights)
+              // So we just verify the command string is non-empty
+              if (cmd.command.length === 0) return false;
+            }
+          }
+
+          // Verify sorting: extract scores by checking against original command names
+          // Score order: exact(100) > prefix(80) > word-start(60) > contains(40)
+          const scores = resultCommands.map(cmd => {
+            // Find the original command name by matching the id
+            const original = items.find(item => item.id === cmd.id);
+            if (original == null) return 0;
+            return calculateScore(original.command, searchTerm);
+          });
+
+          // Verify scores are in descending order
+          for (let i = 1; i < scores.length; i++) {
+            if (scores[i] > scores[i - 1]) return false;
+          }
+
+          // Verify all matching items from the input are present in the result
+          const expectedMatchCount = items.filter(item =>
+            calculateScore(item.command, searchTerm) > 0
+          ).length;
+          if (resultCommands.length !== expectedMatchCount) return false;
+
+          // Verify the group name contains the search term and count
+          if (result[0].groupName !== `### ${searchTerm}: (${resultCommands.length})`) return false;
+
+          return true;
+        }
+      ),
+      { numRuns: 50 }
+    );
+  });
+
+  /**
+   * **Validates: Requirements 3.1**
+   *
+   * Property 2b: filterQuickPickItems with empty search term returns the original
+   * commands unchanged (identity behavior).
+   */
+  it('returns original commands unchanged for empty search term', () => {
+    fc.assert(
+      fc.property(
+        fc.array(commandNameArb, { minLength: 1, maxLength: 100 }),
+        (commandNames) => {
+          const items = commandNames.map((name, i) => ({ command: name, id: `item-${i}` }));
+          const commands = generateSmallCommandGroups(items);
+
+          const result = filterQuickPickItems(commands, '');
+
+          // Should return the original commands unchanged
+          return result === commands;
+        }
+      ),
+      { numRuns: 30 }
+    );
+  });
+
+  /**
+   * **Validates: Requirements 3.4**
+   *
+   * Property 2c: For quick action command lists with <50 items, filtering works
+   * identically to current behavior — all matching items returned, sorted by score.
+   * This simulates the "/" quick action command filtering path.
+   */
+  it('quick action commands with <50 items: filtering returns all matches sorted by score', () => {
+    const quickActionNameArb = fc.constantFrom(
+      '/help', '/clear', '/transform', '/dev', '/test', '/review',
+      '/doc', '/explain', '/refactor', '/optimize', '/fix', '/generate',
+      '/deploy', '/build', '/run', '/debug', '/lint', '/format',
+      '/search', '/navigate', '/commit', '/push', '/pull', '/merge'
+    );
+
+    fc.assert(
+      fc.property(
+        fc.array(quickActionNameArb, { minLength: 1, maxLength: 49 }),
+        searchTermArb,
+        (actionNames, searchTerm) => {
+          const commands: QuickActionCommandGroup[] = [ {
+            groupName: 'Quick Actions',
+            commands: actionNames.map((name, i) => ({
+              command: name,
+              id: `action-${i}`,
+              description: `Quick action: ${name}`,
+            })),
+          } ];
+
+          const result = filterQuickPickItems(commands, searchTerm);
+
+          // Result should be a single group
+          if (result.length !== 1) return false;
+
+          const resultCommands = result[0].commands ?? [];
+
+          // All matching items should be present
+          const expectedMatches = actionNames.filter(name =>
+            calculateScore(name, searchTerm) > 0
+          );
+          if (resultCommands.length !== expectedMatches.length) return false;
+
+          // Scores should be in descending order
+          const scores = resultCommands.map(cmd => {
+            const originalIdx = parseInt(cmd.id?.replace('action-', '') ?? '-1');
+            if (originalIdx < 0 || originalIdx >= actionNames.length) return 0;
+            return calculateScore(actionNames[originalIdx], searchTerm);
+          });
+
+          for (let i = 1; i < scores.length; i++) {
+            if (scores[i] > scores[i - 1]) return false;
+          }
+
+          return true;
+        }
+      ),
+      { numRuns: 50 }
+    );
+  });
+});
+
+/**
+ * Helper: mirrors the scoring logic from quick-pick-data-handler.ts
+ */
+function calculateScore (text: string, searchTerm: string): number {
+  const normalizedText = text.toLowerCase();
+  const normalizedTerm = searchTerm.toLowerCase();
+
+  if (normalizedText === normalizedTerm) return 100;
+  if (normalizedText.startsWith(normalizedTerm)) return 80;
+  if (normalizedText.split(' ').some(word => word.startsWith(normalizedTerm))) return 60;
+  if (normalizedText.includes(normalizedTerm)) return 40;
+
+  return 0;
+}