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

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

@@ -1,97 +0,0 @@
-import { ParsedStep } from '../../gherkin-parser';
-import { StepPattern, StepTemplateData } from './types';
-
-/**
- * Capture & collection patterns (P5) — enable cross-screen data consistency and
- * filter-result correctness that plain single-element assertions can't express.
- *
- *  1. Capture:  `User remember [Product Name] text as {{selected_product_name}}`
- *               → stores the element's text/value into a runtime variable so a
- *               later step (on another screen) can assert against it.
- *               REQUIRES runtime data mode (default) — emits `testData.set(...)`.
- *
- *  2. List:     `User see all [Product Name] contain {{selected_category}}`
- *               → asserts EVERY matching element's text contains the value
- *               (e.g. all products belong to the selected category/brand).
- *
- *  3. All-card:  `User see all [Product Card] contain [Add To Cart] button`
- *               → asserts EVERY container element holds the child element
- *               (structural per-card proof: every card has name/price/action).
- *               Roadmap Q2 — the fix for "each card exposes X" claims.
- */
-export const capturePatterns: StepPattern[] = [
-  {
-    name: 'capture-variable',
-    matcher: (step: ParsedStep) =>
-      /\bremember\b/i.test(step.text) && /\bas\b/i.test(step.text) && !!step.selectorRef && !!step.dataRef,
-    resolver: (step, context): StepTemplateData => {
-      const resolved = context.selectorResolver.resolveSelector(
-        step.selectorRef!, undefined, step.elementType, step.nth,
-      );
-      const varName = step.dataRef!;
-      const isValue = /\bvalue\b/i.test(step.text);
-      // Register so later `{{varName}}` references resolve to testData.get(varName)
-      // and skip YAML validation.
-      context.dataResolver.registerCaptured(varName);
-      return {
-        templateName: 'capture-variable',
-        data: { ...resolved, varName, capture: isValue ? 'inputValue' : 'textContent' },
-        comment: `Remember ${step.selectorRef} ${isValue ? 'value' : 'text'} as ${varName}`,
-      };
-    },
-    priority: 35,
-  },
-  {
-    name: 'all-contain-assertion',
-    matcher: (step: ParsedStep) =>
-      /\b(see|sees)\b/i.test(step.text) &&
-      /\ball\b/i.test(step.text) &&
-      /(contain|contains|match|matches|belong)/i.test(step.text) &&
-      !!step.selectorRef && !!(step.value || step.dataRef),
-    resolver: (step, context): StepTemplateData => {
-      const resolved = context.selectorResolver.resolveSelector(
-        step.selectorRef!, undefined, step.elementType, step.nth,
-      );
-      const expectedText = step.value || context.dataResolver.resolveData(step.dataRef!, context.featureName);
-      return {
-        templateName: 'all-contain-assertion',
-        data: { ...resolved, expectedText, selectorRef: step.selectorRef, stepCounter: context.stepCounter },
-        comment: `Assert all ${step.selectorRef} contain "${step.value || step.dataRef}"`,
-      };
-    },
-    priority: 34,
-  },
-  {
-    // Q2 — all-card structural assertion: every container holds the child element.
-    // Distinguished from `all-contain-assertion` by a second [ref] (childRef) and the
-    // ABSENCE of a value/data (which would make it a text-contains assertion instead).
-    name: 'all-contain-element',
-    matcher: (step: ParsedStep) =>
-      /\b(see|sees)\b/i.test(step.text) &&
-      /\ball\b/i.test(step.text) &&
-      /(contain|contains|include|includes)/i.test(step.text) &&
-      !!step.selectorRef && !!step.childRef && !step.value && !step.dataRef,
-    resolver: (step, context): StepTemplateData => {
-      const container = context.selectorResolver.resolveSelector(
-        step.selectorRef!, undefined, step.elementType, step.nth,
-      );
-      const child = context.selectorResolver.resolveSelector(
-        step.childRef!, undefined, step.childElementType, 0,
-      );
-      const sc = context.stepCounter;
-      return {
-        templateName: 'all-contain-element',
-        data: {
-          ...container,
-          selectorRef: step.selectorRef,
-          childRef: step.childRef,
-          stepCounter: sc,
-          // Render the child RELATIVE to each container row via locator.hbs's parentLocator branch.
-          child: { ...child, parentLocator: `__cards_${sc}.nth(__i_${sc})` },
-        },
-        comment: `Assert all ${step.selectorRef} contain [${step.childRef}]`,
-      };
-    },
-    priority: 36,
-  },
-];

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

@@ -1,96 +0,0 @@
-import { ParsedStep } from '../../gherkin-parser';
-import { StepPattern, PatternContext } from './types';
-import { MappedStep } from '../step-mapper';
-
-/**
- * Database verification patterns (Data Driver v1) — declarative, no-SQL DB assertions
- * that compile to calls on the runtime `db` helper (specs/db.ts). Read-only.
- *
- *   User see [users] row where [email] is {{reg_email}}
- *   User see [users] row where [email] is {{reg_email}} has [status] = "active"
- *   User see [users] no row where [email] is {{dup_email}}
- *   User see [orders] where [buyer] is {{buyer}} count is {{expected_count}}
- *
- * Identifiers ([table]/[column]) are validated by the helper; values bind as parameters.
- */
-
-const TABLE = String.raw`\[([A-Za-z_][A-Za-z0-9_]*)\]`;
-const VALUE = String.raw`\{\{[^}]+\}\}|"[^"]*"|'[^']*'|-?\d+(?:\.\d+)?`;
-
-const reRow = new RegExp(`see\\s+${TABLE}\\s+row\\s+where\\b`, 'i');
-const reNoRow = new RegExp(`see\\s+${TABLE}\\s+no\\s+row\\s+where\\b`, 'i');
-const reCount = new RegExp(`see\\s+${TABLE}.*\\bcount\\s+is\\b`, 'i');
-
-/** True when a step is a declarative DB-verification step (used to wire the `db` import).
- *  Named queries are invoked via the `@query:` annotation, not a step — see code-generator. */
-export function isDbStep(text: string): boolean {
-  return reNoRow.test(text) || reRow.test(text) || reCount.test(text);
-}
-
-/** Render a value token (`{{var}}` | "literal" | 'literal' | number) as a JS expression. */
-function valueExpr(token: string): string {
-  const t = token.trim();
-  const v = t.match(/^\{\{\s*([^}]+?)\s*\}\}$/);
-  if (v) return `testData.get(${JSON.stringify(v[1])})`;
-  const q = t.match(/^["'](.*)["']$/);
-  if (q) return JSON.stringify(q[1]);
-  if (/^-?\d+(?:\.\d+)?$/.test(t)) return t;
-  return JSON.stringify(t);
-}
-
-/** Parse a `[col] is VALUE [and [col2] is VALUE2]` segment into a JS object literal. */
-function parseFilter(segment: string): string {
-  const re = new RegExp(`\\[([A-Za-z_][A-Za-z0-9_]*)\\]\\s+is\\s+(${VALUE})`, 'gi');
-  const parts: string[] = [];
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(segment))) parts.push(`${JSON.stringify(m[1])}: ${valueExpr(m[2])}`);
-  return `{ ${parts.join(', ')} }`;
-}
-
-/** Parse a `has [col] = VALUE [and [col2] = VALUE2]` segment into a JS object literal. */
-function parseExpected(segment: string): string {
-  const re = new RegExp(`\\[([A-Za-z_][A-Za-z0-9_]*)\\]\\s*=\\s*(${VALUE})`, 'gi');
-  const parts: string[] = [];
-  let m: RegExpExecArray | null;
-  while ((m = re.exec(segment))) parts.push(`${JSON.stringify(m[1])}: ${valueExpr(m[2])}`);
-  return parts.length ? `{ ${parts.join(', ')} }` : '';
-}
-
-export const databasePatterns: StepPattern[] = [
-  {
-    name: 'db-no-row',
-    priority: 60, // above generic see-assertions
-    matcher: (step: ParsedStep) => reNoRow.test(step.text),
-    generator: (step: ParsedStep, _ctx: PatternContext): MappedStep => {
-      const m = step.text.match(new RegExp(`${TABLE}\\s+no\\s+row\\s+where\\s+(.+)$`, 'i'))!;
-      const table = m[1];
-      const filter = parseFilter(m[2]);
-      return { code: `await db.assertNoRow(${JSON.stringify(table)}, ${filter});`, comment: `DB: no row in ${table}` };
-    },
-  },
-  {
-    name: 'db-count',
-    priority: 60,
-    matcher: (step: ParsedStep) => reCount.test(step.text) && !reRow.test(step.text),
-    generator: (step: ParsedStep, _ctx: PatternContext): MappedStep => {
-      const m = step.text.match(new RegExp(`${TABLE}(?:\\s+where\\s+(.+?))?\\s+count\\s+is\\s+(${VALUE})`, 'i'))!;
-      const table = m[1];
-      const filter = m[2] ? parseFilter(m[2]) : '{}';
-      return { code: `await db.assertCount(${JSON.stringify(table)}, ${filter}, Number(${valueExpr(m[3])}));`, comment: `DB: count rows in ${table}` };
-    },
-  },
-  {
-    name: 'db-row',
-    priority: 60,
-    matcher: (step: ParsedStep) => reRow.test(step.text),
-    generator: (step: ParsedStep, _ctx: PatternContext): MappedStep => {
-      // [table] row where <filter> [has <expected>]
-      const m = step.text.match(new RegExp(`${TABLE}\\s+row\\s+where\\s+(.+?)(?:\\s+has\\s+(.+))?$`, 'i'))!;
-      const table = m[1];
-      const filter = parseFilter(m[2]);
-      const expected = m[3] ? parseExpected(m[3]) : '';
-      const args = expected ? `${JSON.stringify(table)}, ${filter}, ${expected}` : `${JSON.stringify(table)}, ${filter}`;
-      return { code: `await db.assertRow(${args});`, comment: `DB: row in ${table}` };
-    },
-  },
-];

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

@@ -1,167 +0,0 @@
-import { ParsedStep } from '../../gherkin-parser';
-import { StepPattern, StepTemplateData } from './types';
-
-/**
- * Form action patterns: fill, type, select, check, uncheck
- */
-export const formPatterns: StepPattern[] = [
-  {
-    name: 'upload-file',
-    matcher: (step: ParsedStep) =>
-      (step.text.includes('fill') || step.text.includes('fills')) &&
-      step.elementType === 'uploader' &&
-      !!step.selectorRef &&
-      !!(step.dataRef || step.value),
-    resolver: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-
-      let fileName: string;
-      if (step.dataRef) {
-        try {
-          fileName = context.dataResolver.resolveData(step.dataRef, context.featureName);
-        } catch (error) {
-          fileName = `\${${step.dataRef}}`;
-        }
-      } else {
-        fileName = step.value!;
-      }
-
-      return {
-        templateName: 'upload-action',
-        data: { ...resolved, selectorRef: step.selectorRef, fileName },
-        comment: `Upload file ${fileName} via ${step.selectorRef}`,
-      };
-    },
-    priority: 12,
-  },
-  {
-    name: 'fill-input',
-    matcher: (step: ParsedStep) =>
-      (step.text.includes('fills') || step.text.includes('fill') || step.text.includes('inputs') || step.text.includes('input')) && !!step.selectorRef && !!(step.dataRef || step.value),
-    resolver: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-
-      let value: string;
-      if (step.dataRef) {
-        try {
-          value = context.dataResolver.resolveData(step.dataRef, context.featureName);
-        } catch (error) {
-          value = `\${${step.dataRef}}`;
-        }
-      } else {
-        value = step.value!;
-      }
-
-      // Use pressSequentially template for contenteditable/rich-text editors (auto-detected by live-scan)
-      // or when Gherkin explicitly uses 'editor' element type
-      const isEditor = resolved.inputMethod === 'pressSequentially' || step.elementType === 'editor';
-      const templateName = isEditor ? 'fill-editor-action' : 'fill-action';
-
-      return {
-        templateName,
-        data: { ...resolved, selectorRef: step.selectorRef, fillValue: value },
-        comment: isEditor
-          ? `Fill rich text editor ${step.selectorRef} with ${step.dataRef || step.value}`
-          : `Fill ${step.selectorRef} with ${step.dataRef || step.value}`,
-      };
-    },
-    priority: 10,
-  },
-  {
-    name: 'check-checkbox',
-    matcher: (step: ParsedStep) =>
-      (step.text.includes('checks') || step.text.match(/\bcheck\b/)) && !!step.selectorRef,
-    resolver: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      return {
-        templateName: 'check-action',
-        data: { ...resolved, selectorRef: step.selectorRef },
-        comment: `Check ${step.selectorRef}`,
-      };
-    },
-    priority: 8,
-  },
-  {
-    name: 'uncheck-checkbox',
-    matcher: (step: ParsedStep) =>
-      (step.text.includes('unchecks') || step.text.match(/\buncheck\b/)) && !!step.selectorRef,
-    resolver: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      return {
-        templateName: 'uncheck-action',
-        data: { ...resolved, selectorRef: step.selectorRef },
-        comment: `Uncheck ${step.selectorRef}`,
-      };
-    },
-    priority: 8,
-  },
-  {
-    name: 'select-dropdown',
-    matcher: (step: ParsedStep) =>
-      (step.text.includes('selects') || step.text.match(/\bselect\b/)) &&
-      !!step.selectorRef &&
-      !!(step.dataRef || step.value),
-    resolver: (step, context): StepTemplateData => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-
-      let value: string;
-      if (step.dataRef) {
-        try {
-          value = context.dataResolver.resolveData(step.dataRef, context.featureName);
-        } catch (error) {
-          value = `\${${step.dataRef}}`;
-        }
-      } else {
-        value = step.value!;
-      }
-
-      const isRadio = resolved.role === 'radio' || step.text.includes('radio');
-      const isCheckbox = resolved.role === 'checkbox' || step.text.includes('checkbox');
-
-      let templateName: string;
-      let data: Record<string, any>;
-
-      if (isRadio) {
-        templateName = 'radio-select-action';
-        data = { ...resolved, selectorRef: step.selectorRef, selectValue: value };
-      } else if (isCheckbox) {
-        templateName = 'check-action';
-        data = { ...resolved, selectorRef: step.selectorRef };
-      } else {
-        const nativeSelectRoles = ['combobox', 'listbox', 'select'];
-        // A native <select> is detected by its ARIA role, or by an explicit `variant: native`
-        // on the selector entry (lets a CSS/#id-located select opt into .selectOption()).
-        const isNativeSelect = nativeSelectRoles.includes(resolved.role) || resolved.variant === 'native';
-
-        if (isNativeSelect) {
-          templateName = 'select-action';
-          data = { ...resolved, selectorRef: step.selectorRef, selectValue: value };
-        } else {
-          templateName = 'click-select-action';
-          data = { ...resolved, selectorRef: step.selectorRef, selectValue: value };
-        }
-      }
-
-      return {
-        templateName,
-        data,
-        comment: `Select ${step.dataRef || step.value} in ${step.selectorRef}`,
-      };
-    },
-    priority: 8,
-  },
-  {
-    name: 'clear-input',
-    matcher: (step: ParsedStep) =>
-      (step.text.includes('clears') || step.text.match(/\bclear\b/)) && !!step.selectorRef,
-    resolver: (step, context) => {
-      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      return {
-        templateName: 'clear-action',
-        data: { ...resolved, selectorRef: step.selectorRef },
-        comment: `Clear ${step.selectorRef}`,
-      };
-    },
-    priority: 7,
-  },
-];