review fixes

Author: eviltester

README.md

@@ -235,11 +235,16 @@ Supported options:
 
 - `-i, --inputfile` path to the input text spec (required)
 - `-n, --numberOfLines` number of rows to generate (default `1`)
+- `--pairwise` generate pairwise combinations for enum fields (requires at least 2 enum rules)
 - `-f, --format` output format (default `csv`)
 - `-o, --outputfile` write output to file instead of stdout
 - `-t, --testMode` enable diagnostics mode and generate one row
 - `--unsafe-faker-expressions` allow expression-style faker args (disabled by default)
 
+Pairwise note:
+
+- when `--pairwise` is enabled, `--numberOfLines` is accepted but ignored (the pairwise engine determines row count)
+
 ## REST API Quick Start
 
 Start the API:
@@ -295,7 +300,8 @@ Raw multiline schema/spec endpoint:
 
 - `Content-Type` must be `text/plain`
 - request body is the full multiline spec
-- query params: `rowCount` (required), `outputFormat` (optional), `seed` (optional), `responseFormat` (optional: `rows|rendered|all|raw`)
+- query params: `rowCount` (required), `outputFormat` (optional), `seed` (optional), `pairwise` (optional), `responseFormat` (optional: `rows|rendered|all|raw`)
+- pairwise note: when `pairwise=true`, `rowCount` is accepted for compatibility but ignored (pairwise output size is computed automatically)
 
 Set format default options:
 
@@ -411,6 +417,7 @@ Inputs:
 
 - `textSpec` (required string)
 - `rowCount` (required integer, >= 0)
+- `pairwise` (optional boolean, default `false`; when `true`, `rowCount` is ignored)
 - `outputFormat` (required string e.g. `csv`, `json`, `jsonl`, `xml`, `sql`)
 - `options` (optional object)
 - `seed` (optional number)

apps/api/src/openapi.js

@@ -41,7 +41,11 @@ const openApiDocument = {
                 required: ['textSpec', 'rowCount'],
                 properties: {
                   textSpec: { type: 'string' },
-                  rowCount: { type: 'integer', minimum: 0 },
+                  rowCount: {
+                    type: 'integer',
+                    minimum: 0,
+                    description: 'Requested row count. Ignored when pairwise is true.',
+                  },
                   outputFormat: {
                     type: 'string',
                     enum: [
@@ -106,7 +110,11 @@ const openApiDocument = {
                 required: ['textSpec', 'rowCount'],
                 properties: {
                   textSpec: { type: 'string' },
-                  rowCount: { type: 'integer', minimum: 0 },
+                  rowCount: {
+                    type: 'integer',
+                    minimum: 0,
+                    description: 'Requested row count. Ignored when pairwise is true.',
+                  },
                   outputFormat: {
                     type: 'string',
                     enum: [
@@ -233,7 +241,7 @@ const openApiDocument = {
             name: 'rowCount',
             required: true,
             schema: { type: 'integer', minimum: 0 },
-            description: 'Number of rows to generate',
+            description: 'Number of rows to generate. Ignored when pairwise=true.',
           },
           {
             in: 'query',
@@ -296,7 +304,8 @@ const openApiDocument = {
               type: 'boolean',
               default: false,
             },
-            description: 'Generate pairwise combinations for ENUM fields (requires at least 2 ENUM rules).',
+            description:
+              'Generate pairwise combinations for ENUM fields (requires at least 2 ENUM rules). When true, rowCount is ignored.',
           },
           {
             in: 'query',

apps/cli/src/run-cli.js

@@ -103,6 +103,11 @@ export async function runCliCommand({ options, platform }) {
   }
 
   progress(result.diagnostics.report);
+  if (Array.isArray(result.diagnostics.warnings)) {
+    for (const warning of result.diagnostics.warnings) {
+      progress(`WARNING: ${warning}`);
+    }
+  }
   if (options.testMode && result.rows.length > 0) {
     progress('e.g.');
     progress(JSON.stringify(result.rows[0]));

apps/cli/src/tests/run-cli.test.js

@@ -146,6 +146,7 @@ test('reports warning in test mode when stream mode is ignored for pairwise', as
   });
   expect(code).toBe(0);
   expect(platform.out.join('')).toContain('WARNING: Streaming is ignored when pairwise generation is enabled');
+  expect(platform.out.join('')).toContain('WARNING: rowCount is ignored when pairwise generation is enabled.');
 });
 
 test('generates deterministic pairwise output in buffered mode', async () => {

apps/web/src/tests/browser/abstractions/components/grid-editor.component.js

@@ -85,7 +85,20 @@ class GridEditorComponent {
   }
 
   async clearFilters() {
-    await this.clearFiltersButton.click();
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      await this.clearFiltersButton.click();
+      for (let check = 0; check < 20; check += 1) {
+        const quickFilterValue = await this.quickFilterInput.inputValue();
+        const hasActiveColumnFilter = await this.grid
+          .locator('.tabulator-header-filter input')
+          .evaluateAll((inputs) => inputs.some((input) => String(input.value || '').trim().length > 0));
+        if (quickFilterValue === '' && !hasActiveColumnFilter) {
+          return;
+        }
+        await this.page.waitForTimeout(50);
+      }
+    }
+    throw new Error('Failed to clear all filters.');
   }
 
   async clearSort() {

apps/web/src/tests/browser/app-coverage/filtering-sorting/filtering-sorting.spec.js

@@ -7,7 +7,9 @@ test('global filter, column filter, sort, and clear filters produce expected vis
   const appPage = new AppPage(page);
   await appPage.goto();
   await seedInstructionsRows(appPage, ['Apple', 'Banana', 'Cherry']);
+  await expect.poll(async () => (await appPage.gridEditor.header.getColumnNames()).length).toBeGreaterThan(0);
   const [primaryColumnName] = await appPage.gridEditor.header.getColumnNames();
+  expect(primaryColumnName).toBeTruthy();
 
   await appPage.gridEditor.setQuickFilter('App');
   await expect.poll(async () => appPage.gridEditor.renderer.countVisibleRows()).toBe(1);
@@ -20,6 +22,7 @@ test('global filter, column filter, sort, and clear filters produce expected vis
 
   await appPage.gridEditor.clearFilters();
   await expect.poll(async () => appPage.gridEditor.renderer.countVisibleRows()).toBe(3);
+  await expect.poll(async () => appPage.gridEditor.quickFilterInput.inputValue()).toBe('');
   await expect.poll(async () => appPage.gridEditor.header.getColumnFilterValue(primaryColumnName)).toBe('');
 
   await appPage.gridEditor.header.sortAsc(primaryColumnName);

packages/core/src/index.js

@@ -201,8 +201,12 @@ export function generateFromTextSpec({
 
   const dataTable = new GenericDataTable();
   let effectiveRowCount = safeRowCount;
+  const diagnosticsWarnings = [];
 
   if (pairwise) {
+    if (rowCount !== undefined && rowCount !== null) {
+      diagnosticsWarnings.push('rowCount is ignored when pairwise generation is enabled.');
+    }
     const pairwiseGenerator = new PairwiseTestDataGenerator(scopedFaker, RandExp);
     const initResult = pairwiseGenerator.initializeFromRules(generator.testDataRules());
     if (initResult?.isError) {
@@ -227,10 +231,17 @@ export function generateFromTextSpec({
     }
 
     const generatedRows = rowsResult?.data?.data || [];
-    const headers = Array.isArray(generatedRows[0]) ? generatedRows[0] : [];
-    dataTable.setHeaders(headers);
+    const generatedHeaders = Array.isArray(generatedRows[0]) ? generatedRows[0] : [];
+    const originalHeaders = generator.generateHeadersArray();
+    const generatedHeaderIndexes = new Map(generatedHeaders.map((header, index) => [header, index]));
+    dataTable.setHeaders(originalHeaders);
     for (let rowIndex = 1; rowIndex < generatedRows.length; rowIndex += 1) {
-      dataTable.appendDataRow(generatedRows[rowIndex]);
+      const generatedRow = Array.isArray(generatedRows[rowIndex]) ? generatedRows[rowIndex] : [];
+      const reorderedRow = originalHeaders.map((header) => {
+        const generatedIndex = generatedHeaderIndexes.get(header);
+        return generatedIndex === undefined ? '' : generatedRow[generatedIndex];
+      });
+      dataTable.appendDataRow(reorderedRow);
     }
     effectiveRowCount = Math.max(generatedRows.length - 1, 0);
   } else {
@@ -260,6 +271,7 @@ export function generateFromTextSpec({
       report: generator.compilationReport(),
       rowCount: effectiveRowCount,
       pairwise,
+      warnings: diagnosticsWarnings,
     },
   };
 }

packages/core/src/tests/core-api/generateFromTextSpec.test.js

@@ -177,24 +177,47 @@ test('generateFromTextSpec remains deterministic under overlapping seeded invoca
 
 test('generateFromTextSpec supports pairwise generation for enum rules', () => {
   const result = generateFromTextSpec({
-    textSpec: 'Browser\nChrome,Firefox,Safari\nTheme\nLight,Dark',
+    textSpec: 'Browser\nChrome,Firefox,Safari\nTheme\nLight,Dark\nRegion\nUS,EU',
     rowCount: 100,
     outputFormat: 'json',
     pairwise: true,
   });
 
   expect(result.ok).toBe(true);
-  expect(result.headers).toEqual(['Browser', 'Theme']);
-  expect(result.rows).toEqual([
-    ['Chrome', 'Light'],
-    ['Chrome', 'Dark'],
-    ['Firefox', 'Light'],
-    ['Firefox', 'Dark'],
-    ['Safari', 'Light'],
-    ['Safari', 'Dark'],
-  ]);
+  expect(result.headers).toEqual(['Browser', 'Theme', 'Region']);
+  expect(result.rows.length).toBeLessThan(3 * 2 * 2);
+
+  const valuesByHeader = {
+    Browser: ['Chrome', 'Firefox', 'Safari'],
+    Theme: ['Light', 'Dark'],
+    Region: ['US', 'EU'],
+  };
+  const getValue = (row, header) => row[result.headers.indexOf(header)];
+
+  const coveredPairs = new Set();
+  for (const row of result.rows) {
+    coveredPairs.add(`Browser:${getValue(row, 'Browser')}|Theme:${getValue(row, 'Theme')}`);
+    coveredPairs.add(`Browser:${getValue(row, 'Browser')}|Region:${getValue(row, 'Region')}`);
+    coveredPairs.add(`Theme:${getValue(row, 'Theme')}|Region:${getValue(row, 'Region')}`);
+  }
+
+  for (const browser of valuesByHeader.Browser) {
+    for (const theme of valuesByHeader.Theme) {
+      expect(coveredPairs.has(`Browser:${browser}|Theme:${theme}`)).toBe(true);
+    }
+    for (const region of valuesByHeader.Region) {
+      expect(coveredPairs.has(`Browser:${browser}|Region:${region}`)).toBe(true);
+    }
+  }
+  for (const theme of valuesByHeader.Theme) {
+    for (const region of valuesByHeader.Region) {
+      expect(coveredPairs.has(`Theme:${theme}|Region:${region}`)).toBe(true);
+    }
+  }
+
   expect(result.diagnostics.pairwise).toBe(true);
-  expect(result.diagnostics.rowCount).toBe(6);
+  expect(result.diagnostics.rowCount).toBe(result.rows.length);
+  expect(result.diagnostics.warnings).toContain('rowCount is ignored when pairwise generation is enabled.');
 });
 
 test('generateFromTextSpec rejects pairwise mode with fewer than 2 enum rules', () => {
@@ -208,3 +231,23 @@ test('generateFromTextSpec rejects pairwise mode with fewer than 2 enum rules',
   expect(result.ok).toBe(false);
   expect(result.errors[0]).toMatch(/requires at least 2 ENUM parameters/i);
 });
+
+test('generateFromTextSpec pairwise preserves original interleaved column order', () => {
+  const result = generateFromTextSpec({
+    textSpec: 'Name\nBob\nBrowser\nChrome,Firefox,Safari\nAge\n30\nTheme\nLight,Dark',
+    rowCount: 100,
+    outputFormat: 'json',
+    pairwise: true,
+  });
+
+  expect(result.ok).toBe(true);
+  expect(result.headers).toEqual(['Name', 'Browser', 'Age', 'Theme']);
+  expect(result.rows).toEqual([
+    ['Bob', 'Chrome', '30', 'Light'],
+    ['Bob', 'Chrome', '30', 'Dark'],
+    ['Bob', 'Firefox', '30', 'Light'],
+    ['Bob', 'Firefox', '30', 'Dark'],
+    ['Bob', 'Safari', '30', 'Light'],
+    ['Bob', 'Safari', '30', 'Dark'],
+  ]);
+});