@sun-asterisk/sungen 3.1.2 → 3.2.0-beta.142

package/src/generators/test-generator/patterns/scroll-patterns.ts

@@ -1,27 +0,0 @@
-/**
- * Scroll Patterns
- * Handles: scroll to [Target] type
- */
-
-import { StepPattern } from './types';
-
-export const scrollPatterns: StepPattern[] = [
-  {
-    name: 'scroll-to-element',
-    matcher: (step) => {
-      return /\bscroll(?:s)?\s+to\b/i.test(step.text) && !!step.selectorRef;
-    },
-    resolver: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(
-        step.selectorRef!, context.featureName, step.elementType, step.nth
-      );
-
-      return {
-        templateName: 'scroll-action',
-        data: { ...resolved },
-        comment: `Scroll to ${step.selectorRef}`,
-      };
-    },
-    priority: 8,
-  },
-];

package/src/generators/test-generator/patterns/setup-patterns.ts

@@ -1,76 +0,0 @@
-import { ParsedStep } from '../../gherkin-parser';
-import { StepPattern } from './types';
-
-/**
- * Setup and precondition patterns: application setup, authentication state, etc.
- */
-export const setupPatterns: StepPattern[] = [
-  {
-    name: 'application-running',
-    matcher: (step: ParsedStep) =>
-      step.text.includes('application is running') ||
-      step.text.includes('application running') ||
-      step.text.includes('app is running'),
-    resolver: (step, context) => ({
-      templateName: 'application-running',
-      data: {},
-      comment: `Setup: Application is running`,
-    }),
-    priority: 5,
-  },
-  {
-    name: 'user-not-logged-in',
-    matcher: (step: ParsedStep) =>
-      step.text.includes('user is not logged in') ||
-      step.text.includes('not logged in') ||
-      step.text.includes('logged out'),
-    resolver: (step, context) => ({
-      templateName: 'clear-auth',
-      data: {},
-      comment: `Clear authentication state (ensure user is logged out)`,
-    }),
-    priority: 9,
-  },
-  {
-    name: 'user-logged-in',
-    matcher: (step: ParsedStep) =>
-      (step.text.includes('user is logged in') ||
-       step.text.includes('logged in as')) &&
-      !step.text.includes('not logged in'),
-    resolver: (step, context) => {
-      const userRef = step.dataRef || 'valid_user';
-      return {
-        templateName: 'user-login-todo',
-        data: { userRef },
-        comment: `Setup: User logged in as ${userRef}`,
-      };
-    },
-    priority: 9,
-  },
-  {
-    name: 'clear-database',
-    matcher: (step: ParsedStep) =>
-      step.text.includes('database is empty') ||
-      step.text.includes('database is cleared') ||
-      step.text.includes('clear database'),
-    resolver: (step, context) => ({
-      templateName: 'clear-database',
-      data: {},
-      comment: `Setup: Clear/reset database`,
-    }),
-    priority: 7,
-  },
-  {
-    name: 'browser-state-clean',
-    matcher: (step: ParsedStep) =>
-      step.text.includes('clean browser state') ||
-      step.text.includes('fresh browser') ||
-      step.text.includes('new browser session'),
-    resolver: (step, context) => ({
-      templateName: 'clear-browser-state',
-      data: {},
-      comment: `Clear browser state (cookies, storage)`,
-    }),
-    priority: 8,
-  },
-];

package/src/generators/test-generator/patterns/table-patterns.ts

@@ -1,279 +0,0 @@
-/**
- * Table Patterns
- * Handles: table row assertions, table cell lookups, actions in table rows
- *
- * Syntax (v2.4 final):
- * - User see [Col] column in [Table] table                             # column exists
- * - User see [Ref] row in [Table] table with {{value}}                 # row exists (enters row scope)
- * - User see [Ref] row in [Table] table with {{value}} is hidden       # row hidden
- * - User see [Table] table with {{count}}                              # row count
- * - User see [Table] table is empty                                    # empty table
- * - User see [Col] column with {{value}}                               # cell value (row scoped — handled in step-mapper)
- * - User click [Act] button in [Table] table with {{filter}}           # action in row
- * - User see [Table] table match data:                                 # exact table match with inline DataTable
- *       | Header1    | Header2    |
- *       | {{value1}} | {{value2}} |
- */
-
-import { StepPattern, PatternContext } from './types';
-
-/** Helper: check if current step is in a Given context */
-function isGivenContext(context: PatternContext): boolean {
-  return context.effectiveKeyword === 'Given';
-}
-
-/** Map Gherkin element type to Playwright ARIA role */
-const typeToRole: Record<string, string> = {
-  button: 'button',
-  link: 'link',
-  checkbox: 'checkbox',
-  icon: 'img',
-  image: 'img',
-  radio: 'radio',
-  switch: 'switch',
-};
-
-export const tablePatterns: StepPattern[] = [
-  // "User see [Table] table with {{count}}" — row count (no "rows" keyword needed)
-  {
-    name: 'table-row-count',
-    matcher: (step) => {
-      return step.elementType === 'table' &&
-             /\btable\s+with\b/i.test(step.text) &&
-             !!step.dataRef &&
-             !/\brow\b/i.test(step.text) &&
-             !/\bcolumn\b/i.test(step.text) &&
-             !/\bempty\b/i.test(step.text);
-    },
-    resolver: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(
-        step.selectorRef!, context.featureName, 'table', step.nth
-      );
-      const count = context.dataResolver.resolveData(step.dataRef!, context.featureName);
-
-      const isGiven = isGivenContext(context);
-      return {
-        templateName: 'table-row-count',
-        data: { ...resolved, expectedCount: count, isGiven },
-        comment: `${isGiven ? 'Wait' : 'Assert'} ${step.selectorRef} table has ${count} rows`,
-      };
-    },
-    priority: 16,
-  },
-
-  // "User see [Col] column in [Table] table"
-  {
-    name: 'table-column-exists',
-    matcher: (step) => {
-      return /\bcolumn\s+in\b/i.test(step.text) &&
-             /\btable\b/i.test(step.text) &&
-             !step.dataRef;
-    },
-    resolver: (step, context) => {
-      // brackets[0] = Col, brackets[1] = Table
-      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
-      const columnName = brackets[0]?.replace(/[\[\]]/g, '') || 'Unknown';
-      const tableName = brackets.length >= 2
-        ? brackets[1].replace(/[\[\]]/g, '')
-        : brackets[0]?.replace(/[\[\]]/g, '') || '';
-
-      const resolved = context.selectorResolver.resolveSelector(
-        tableName, context.featureName, 'table', step.nth
-      );
-
-      const isGiven = isGivenContext(context);
-      return {
-        templateName: 'table-column-exists',
-        data: { ...resolved, columnName, isGiven },
-        comment: `${isGiven ? 'Wait' : 'Assert'} ${columnName} column in ${tableName} table`,
-      };
-    },
-    priority: 16,
-  },
-
-  // "User see [Table] table is empty"
-  {
-    name: 'table-is-empty',
-    matcher: (step) => {
-      return /\btable\s+is\s+empty\b/i.test(step.text);
-    },
-    resolver: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(
-        step.selectorRef!, context.featureName, 'table', step.nth
-      );
-
-      const isGiven = isGivenContext(context);
-      return {
-        templateName: 'table-empty',
-        data: { ...resolved, isGiven },
-        comment: `${isGiven ? 'Wait' : 'Assert'} ${step.selectorRef} table is empty`,
-      };
-    },
-    priority: 16,
-  },
-
-  // "User see [Ref] row in [Table] table with {{value}}" — row exists (enters row scope)
-  {
-    name: 'table-row-exists',
-    matcher: (step) => {
-      return step.elementType === 'row' &&
-             /\bin\b.*\btable\b/i.test(step.text) &&
-             /\bwith\b/i.test(step.text) &&
-             !!step.dataRef &&
-             !/\bis\s+hidden\b/i.test(step.text);
-    },
-    resolver: (step, context) => {
-      // brackets[0] = Ref (row label), brackets[1] = Table
-      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
-      const rowLabel = brackets[0]?.replace(/[\[\]]/g, '') || '';
-      const tableName = brackets.length >= 2
-        ? brackets[1].replace(/[\[\]]/g, '')
-        : '';
-
-      const resolved = context.selectorResolver.resolveSelector(
-        tableName, context.featureName, 'table', step.nth
-      );
-      const filterValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
-
-      const isGiven = isGivenContext(context);
-      return {
-        templateName: 'table-row-exists',
-        data: { ...resolved, filterValue, isGiven },
-        comment: `${isGiven ? 'Wait' : 'Assert'} ${rowLabel} row in ${tableName} table with ${step.dataRef}`,
-      };
-    },
-    priority: 17,
-  },
-
-  // "User see [Ref] row in [Table] table with {{value}} is hidden"
-  {
-    name: 'table-row-hidden',
-    matcher: (step) => {
-      return step.elementType === 'row' &&
-             /\bin\b.*\btable\b/i.test(step.text) &&
-             /\bwith\b/i.test(step.text) &&
-             !!step.dataRef &&
-             /\bis\s+hidden\b/i.test(step.text);
-    },
-    resolver: (step, context) => {
-      // brackets[0] = Ref (row label), brackets[1] = Table
-      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
-      const rowLabel = brackets[0]?.replace(/[\[\]]/g, '') || '';
-      const tableName = brackets.length >= 2
-        ? brackets[1].replace(/[\[\]]/g, '')
-        : '';
-
-      const resolved = context.selectorResolver.resolveSelector(
-        tableName, context.featureName, 'table', step.nth
-      );
-      const filterValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
-
-      const isGiven = isGivenContext(context);
-      return {
-        templateName: 'table-row-not-exists',
-        data: { ...resolved, filterValue, isGiven },
-        comment: `${isGiven ? 'Wait' : 'Assert'} ${rowLabel} row in ${tableName} table is hidden`,
-      };
-    },
-    priority: 19,
-  },
-
-  // "User click [Act] button in [Table] table with {{filter}}" — action in row
-  {
-    name: 'table-action-in-row',
-    matcher: (step) => {
-      return /\bin\b.*\btable\b/i.test(step.text) &&
-             /\bwith\b/i.test(step.text) &&
-             !!step.dataRef &&
-             step.elementType !== 'column' &&
-             step.elementType !== 'row' &&
-             step.elementType !== 'table';
-    },
-    resolver: (step, context) => {
-      // brackets[0] = Act (element name), brackets[1] = Table
-      const brackets = step.text.match(/\[([^\]]+)\]/g) || [];
-      const elementName = brackets[0]?.replace(/[\[\]]/g, '') || '';
-      const tableName = brackets.length >= 2
-        ? brackets[1].replace(/[\[\]]/g, '')
-        : '';
-
-      const filterValue = step.dataRef
-        ? context.dataResolver.resolveData(step.dataRef, context.featureName)
-        : '';
-
-      const tableResolved = context.selectorResolver.resolveSelector(
-        tableName, context.featureName, 'table', 0
-      );
-
-      // Determine action from step text
-      const actionMatch = step.text.match(/\b(click|check|uncheck)\b/i);
-      const action = actionMatch ? actionMatch[1].toLowerCase() : 'click';
-
-      // Extract element type (word after [Act]) and map to ARIA role
-      const elementTypeMatch = step.text.match(/\]\s+([\w-]+)\s+in\b/i);
-      const elementType = elementTypeMatch ? elementTypeMatch[1].toLowerCase() : 'button';
-      const elementRole = typeToRole[elementType] || elementType;
-
-      return {
-        templateName: 'table-action-in-row',
-        data: { ...tableResolved, elementName, filterValue, action, elementRole },
-        comment: `${action} ${elementName} in ${tableName} table row with ${step.dataRef}`,
-      };
-    },
-    priority: 17,
-  },
-
-  // "User see [Table] table match data:" — filter-based table match with inline DataTable
-  // First row = headers, remaining rows = expected data
-  // Uses filter({ hasText }) per row — resilient to data changes, row ordering, extra rows
-  {
-    name: 'table-match-data',
-    matcher: (step) => {
-      return step.elementType === 'table' &&
-             /\btable\s+match\s+data\b/i.test(step.text) &&
-             !!step.dataTable;
-    },
-    resolver: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(
-        step.selectorRef!, context.featureName, 'table', step.nth
-      );
-
-      const dataTable = step.dataTable!;
-
-      // Resolve {{variable}} references in cell values
-      const resolvedRows = dataTable.rows.map(row => ({
-        cells: row.cells.map(cell => {
-          const varMatch = cell.match(/^\{\{([a-z0-9\-\.\_]+)\}\}$/i);
-          if (varMatch) {
-            return context.dataResolver.resolveData(varMatch[1], context.featureName);
-          }
-          return cell;
-        }),
-      }));
-
-      // Pre-compute filter-based assertion lines
-      // For each expected row: chain .filter({ hasText }) for all cell values, then assert visible
-      const assertions: string[] = [];
-      for (const row of resolvedRows) {
-        const filters = row.cells
-          .map(cell => `.filter({ hasText: '${cell.replace(/'/g, "\\'")}' })`)
-          .join('');
-        assertions.push(
-          `await expect(rows${filters}).toBeVisible();`
-        );
-      }
-
-      const isGiven = isGivenContext(context);
-      return {
-        templateName: 'table-match-data',
-        data: {
-          ...resolved,
-          assertions,
-          isGiven,
-        },
-        comment: `${isGiven ? 'Wait' : 'Assert'} ${step.selectorRef} table contains ${resolvedRows.length} expected row(s)`,
-      };
-    },
-    priority: 20, // Higher than other table patterns to match first
-  },
-];