@sungen/driver-ui 3.1.2-beta.100

package/src/patterns/capture-patterns.ts

@@ -0,0 +1,97 @@
+import { ParsedStep } from '@sun-asterisk/sungen';
+import { StepPattern, StepTemplateData } from '@sun-asterisk/sungen';
+
+/**
+ * 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/patterns/form-patterns.ts

@@ -0,0 +1,167 @@
+import { ParsedStep } from '@sun-asterisk/sungen';
+import { StepPattern, StepTemplateData } from '@sun-asterisk/sungen';
+
+/**
+ * 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,
+  },
+];