@sun-asterisk/sungen 1.0.19 → 1.0.21

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

@@ -1,11 +1,45 @@
 import { ParsedStep } from '../../gherkin-parser';
-import { StepPattern } from './types';
+import { StepPattern, StepTemplateData } from './types';
 
 /**
  * Assertion patterns: visibility, text content, state, attributes
  * Uses template engine for framework-agnostic code generation
  */
 export const assertionPatterns: StepPattern[] = [
+  // Column cell assertion: "see [Department] column 1 with {{value}}" -> check table cell text
+  {
+    name: 'column-cell-assertion',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should see') || step.text.match(/\b(see|sees)\s+\[/)) &&
+      !!step.selectorRef &&
+      !!step.dataRef &&
+      (step.elementType === 'column' || step.elementType === 'columnheader'),
+    resolver: (step, context): StepTemplateData => {
+      let dataValue: string;
+      try {
+        dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
+      } catch (error) {
+        dataValue = `\${${step.dataRef}}`;
+      }
+
+      // getByRole('row') includes header row as nth(0), so Gherkin nth=1 maps to locator nth(1)
+      const rowNth = step.nth || 1;
+      // Create a safe variable name from column name
+      const columnIndexVar = `colIndex${step.selectorRef!.replace(/[^a-zA-Z0-9]/g, '')}`;
+
+      return {
+        templateName: 'column-cell-assertion',
+        data: {
+          columnName: step.selectorRef,
+          rowNth,
+          columnIndexVar,
+          dataValue,
+        },
+        comment: `Assert ${step.selectorRef} column row ${step.nth || 1} has text ${step.dataRef}`,
+      };
+    },
+    priority: 15,  // Higher than all other assertion patterns
+  },
   // Page assertion pattern: "see [home] page" -> check URL matches selector value
   {
     name: 'page-assertion',
@@ -14,9 +48,9 @@ export const assertionPatterns: StepPattern[] = [
        step.text.includes('see') ||
        step.text.includes('sees')) &&
       step.elementType === 'page',
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       let path = step.featurePath || '/';
-      
+
       // If selector is present, extract path from selector's value attribute
       if (step.selectorRef) {
         try {
@@ -33,12 +67,12 @@ export const assertionPatterns: StepPattern[] = [
           path = step.featurePath || '/';
         }
       }
-      
+
       // Convert path to regex-safe string
       const pathRegex = path.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
-      const code = context.templateEngine.renderStep('page-assertion', { pathRegex });
       return {
-        code,
+        templateName: 'page-assertion',
+        data: { pathRegex },
         comment: step.selectorRef ? `Assert on ${step.selectorRef} page` : `Assert on page`,
       };
     },
@@ -81,6 +115,14 @@ export const assertionPatterns: StepPattern[] = [
       }
 
       if (resolved.strategy === 'role' && resolved.role) {
+        // Dialog role: check heading inside dialog instead of filter on full text content
+        if (resolved.role === 'dialog') {
+          const code = context.templateEngine.renderStep('hidden-dialog-heading-assertion', {
+            dataValue,
+          });
+          return { code, comment: `Assert ${step.selectorRef} dialog hidden with heading ${step.dataRef}` };
+        }
+
         const code = context.templateEngine.renderStep('hidden-with-role-variable-assertion', {
           role: resolved.role,
           name: resolved.name && resolved.name.trim() ? resolved.name : undefined,
@@ -223,6 +265,17 @@ export const assertionPatterns: StepPattern[] = [
 
       // Check if it's a role-based selector with data
       if (resolved.strategy === 'role' && resolved.role) {
+        // Dialog role: check heading inside dialog instead of filter on full text content
+        if (resolved.role === 'dialog') {
+          const code = context.templateEngine.renderStep('visible-dialog-heading-assertion', {
+            dataValue,
+          });
+          return {
+            code,
+            comment: `Assert ${step.selectorRef} dialog with heading ${step.dataRef}`,
+          };
+        }
+
         const hasName = resolved.name && resolved.name.trim();
         // For img role: images have no text content, so put dataValue in name instead of filter
         const isImgRole = resolved.role === 'img';
@@ -278,11 +331,11 @@ export const assertionPatterns: StepPattern[] = [
        step.text.includes('should see') ||
        step.text.match(/\b(see|sees)\s+\[/)) &&
       !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      const code = context.templateEngine.renderStep('visible-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
-        code,
+        templateName: 'visible-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Assert ${step.selectorRef} is visible`,
       };
     },
@@ -294,11 +347,11 @@ export const assertionPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis hidden\b/.test(step.text) &&
       !step.dataRef && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      const code = context.templateEngine.renderStep('is-hidden-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
-        code,
+        templateName: 'is-hidden-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Assert ${step.selectorRef} is not visible`,
       };
     },
@@ -308,11 +361,11 @@ export const assertionPatterns: StepPattern[] = [
     name: 'should-be-enabled',
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis enabled\b/.test(step.text) && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      const code = context.templateEngine.renderStep('enabled-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
-        code,
+        templateName: 'enabled-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Assert ${step.selectorRef} is enabled`,
       };
     },
@@ -322,11 +375,11 @@ export const assertionPatterns: StepPattern[] = [
     name: 'should-be-disabled',
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis disabled\b/.test(step.text) && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      const code = context.templateEngine.renderStep('disabled-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
-        code,
+        templateName: 'disabled-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Assert ${step.selectorRef} is disabled`,
       };
     },
@@ -336,15 +389,12 @@ export const assertionPatterns: StepPattern[] = [
     name: 'should-contain-text',
     matcher: (step: ParsedStep) =>
       step.text.includes('should contain') && !!step.selectorRef && !!(step.value || step.dataRef),
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const expectedText = step.value || `\${${step.dataRef}}`;
-      const code = context.templateEngine.renderStep('contain-text-assertion', {
-        ...resolved,
-        expectedText,
-      });
       return {
-        code,
+        templateName: 'contain-text-assertion',
+        data: { ...resolved, expectedText },
         comment: `Assert ${step.selectorRef} contains "${step.value || step.dataRef}"`,
       };
     },
@@ -354,15 +404,12 @@ export const assertionPatterns: StepPattern[] = [
     name: 'should-have-text',
     matcher: (step: ParsedStep) =>
       step.text.includes('should have text') && !!step.selectorRef && !!(step.value || step.dataRef),
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const expectedText = step.value || `\${${step.dataRef}}`;
-      const code = context.templateEngine.renderStep('have-text-assertion', {
-        ...resolved,
-        expectedText,
-      });
       return {
-        code,
+        templateName: 'have-text-assertion',
+        data: { ...resolved, expectedText },
         comment: `Assert ${step.selectorRef} has text "${step.value || step.dataRef}"`,
       };
     },
@@ -372,11 +419,11 @@ export const assertionPatterns: StepPattern[] = [
     name: 'is-empty',
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis empty\b/.test(step.text) && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      const code = context.templateEngine.renderStep('empty-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
-        code,
+        templateName: 'empty-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Assert ${step.selectorRef} is empty`,
       };
     },
@@ -386,11 +433,11 @@ export const assertionPatterns: StepPattern[] = [
     name: 'is-checked',
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis checked\b/.test(step.text) && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      const code = context.templateEngine.renderStep('checked-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
-        code,
+        templateName: 'checked-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Assert ${step.selectorRef} is checked`,
       };
     },
@@ -400,11 +447,11 @@ export const assertionPatterns: StepPattern[] = [
     name: 'is-unchecked',
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis unchecked\b/.test(step.text) && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      const code = context.templateEngine.renderStep('not-checked-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
-        code,
+        templateName: 'not-checked-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Assert ${step.selectorRef} is unchecked`,
       };
     },
@@ -414,11 +461,11 @@ export const assertionPatterns: StepPattern[] = [
     name: 'is-focused',
     matcher: (step: ParsedStep) =>
       /\b(see|sees)\s+\[/.test(step.text) && /\bis focused\b/.test(step.text) && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      const code = context.templateEngine.renderStep('focused-assertion', { ...resolved, selectorRef: step.selectorRef });
       return {
-        code,
+        templateName: 'focused-assertion',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Assert ${step.selectorRef} is focused`,
       };
     },
@@ -431,7 +478,7 @@ export const assertionPatterns: StepPattern[] = [
        step.text.match(/\b(see|sees)\b/)) &&
       !step.selectorRef &&
       !!step.dataRef,
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       // Resolve data reference to actual value
       let dataValue: string;
       try {
@@ -440,14 +487,13 @@ export const assertionPatterns: StepPattern[] = [
         dataValue = `\${${step.dataRef}}`;
       }
 
-      const code = context.templateEngine.renderStep('visible-assertion', {
-        strategy: 'text',
-        value: dataValue,
-        nth: 0,
-      });
-
       return {
-        code,
+        templateName: 'visible-assertion',
+        data: {
+          strategy: 'text',
+          value: dataValue,
+          nth: 0,
+        },
         comment: `Assert ${step.dataRef} is visible`,
       };
     },
@@ -459,7 +505,7 @@ export const assertionPatterns: StepPattern[] = [
       step.text.includes('should have') && step.text.includes('count') &&
       !!step.selectorRef && step.text.includes('items') &&
       (step.elementType === 'list' || step.elementType === 'list-item' || step.elementType === 'listitem'),
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       let expectedCount: number | string = 1;
 
       const match = step.text.match(/count\s+(\d+)/);
@@ -476,12 +522,9 @@ export const assertionPatterns: StepPattern[] = [
       }
 
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      const code = context.templateEngine.renderStep('list-item-count-assertion', {
-        ...resolved,
-        expectedCount,
-      });
       return {
-        code,
+        templateName: 'list-item-count-assertion',
+        data: { ...resolved, expectedCount },
         comment: `Assert ${step.selectorRef} list has ${expectedCount} items`,
       };
     },
@@ -491,7 +534,7 @@ export const assertionPatterns: StepPattern[] = [
     name: 'should-have-count',
     matcher: (step: ParsedStep) =>
       step.text.includes('should have') && step.text.includes('count') && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       let expectedCount: number | string = 1;
 
       // Try literal digit first: "count 10"
@@ -510,12 +553,9 @@ export const assertionPatterns: StepPattern[] = [
       }
 
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      const code = context.templateEngine.renderStep('count-assertion', {
-        ...resolved,
-        expectedCount,
-      });
       return {
-        code,
+        templateName: 'count-assertion',
+        data: { ...resolved, expectedCount },
         comment: `Assert ${step.selectorRef} has count ${expectedCount}`,
       };
     },

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

@@ -1,10 +1,8 @@
 import { ParsedStep } from '../../gherkin-parser';
-import { StepPattern } from './types';
+import { StepPattern, StepTemplateData } from './types';
 
 /**
  * Form action patterns: fill, type, select, check, uncheck
- * Uses template engine for framework-agnostic code generation
- * Resolvers return metadata, templates handle framework syntax
  */
 export const formPatterns: StepPattern[] = [
   {
@@ -14,7 +12,7 @@ export const formPatterns: StepPattern[] = [
       step.elementType === 'uploader' &&
       !!step.selectorRef &&
       !!(step.dataRef || step.value),
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
 
       let fileName: string;
@@ -28,14 +26,9 @@ export const formPatterns: StepPattern[] = [
         fileName = step.value!;
       }
 
-      const code = context.templateEngine.renderStep('upload-action', {
-        ...resolved,
-        selectorRef: step.selectorRef,
-        fileName,
-      });
-
       return {
-        code,
+        templateName: 'upload-action',
+        data: { ...resolved, selectorRef: step.selectorRef, fileName },
         comment: `Upload file ${fileName} via ${step.selectorRef}`,
       };
     },
@@ -45,31 +38,23 @@ export const formPatterns: StepPattern[] = [
     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),
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      
-      // Resolve data reference to actual value
+
       let value: string;
       if (step.dataRef) {
         try {
           value = context.dataResolver.resolveData(step.dataRef, context.featureName);
         } catch (error) {
-          // Fallback: keep as template literal if data resolution fails
           value = `\${${step.dataRef}}`;
         }
       } else {
         value = step.value!;
       }
-      
-      // Use template engine to render framework-specific code
-      const code = context.templateEngine.renderStep('fill-action', {
-        ...resolved,  // strategy, value, role, name, selector
-        selectorRef: step.selectorRef,
-        fillValue: value,
-      });
-      
+
       return {
-        code,
+        templateName: 'fill-action',
+        data: { ...resolved, selectorRef: step.selectorRef, fillValue: value },
         comment: `Fill ${step.selectorRef} with ${step.dataRef || step.value}`,
       };
     },
@@ -79,13 +64,11 @@ export const formPatterns: StepPattern[] = [
     name: 'check-checkbox',
     matcher: (step: ParsedStep) =>
       step.text.includes('checks') && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      
-      const code = context.templateEngine.renderStep('check-action', { ...resolved, selectorRef: step.selectorRef });
-      
       return {
-        code,
+        templateName: 'check-action',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Check ${step.selectorRef}`,
       };
     },
@@ -95,13 +78,11 @@ export const formPatterns: StepPattern[] = [
     name: 'uncheck-checkbox',
     matcher: (step: ParsedStep) =>
       step.text.includes('unchecks') && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      
-      const code = context.templateEngine.renderStep('uncheck-action', { ...resolved, selectorRef: step.selectorRef });
-      
       return {
-        code,
+        templateName: 'uncheck-action',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Uncheck ${step.selectorRef}`,
       };
     },
@@ -113,10 +94,9 @@ export const formPatterns: StepPattern[] = [
       (step.text.includes('selects') || step.text.match(/\bselect\b/)) &&
       !!step.selectorRef &&
       !!(step.dataRef || step.value),
-    generator: (step, context) => {
+    resolver: (step, context): StepTemplateData => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
 
-      // Resolve data reference to actual value
       let value: string;
       if (step.dataRef) {
         try {
@@ -128,32 +108,34 @@ export const formPatterns: StepPattern[] = [
         value = step.value!;
       }
 
-      // Determine action based on role type
-      // Radio buttons use check(), dropdowns use selectOption()
       const isRadio = resolved.role === 'radio' || step.text.includes('radio');
       const isCheckbox = resolved.role === 'checkbox' || step.text.includes('checkbox');
 
-      let code: string;
+      let templateName: string;
+      let data: Record<string, any>;
+
       if (isRadio) {
-        // For radio buttons, we need to find the specific radio with the value
-        code = context.templateEngine.renderStep('radio-select-action', {
-          ...resolved,
-          selectorRef: step.selectorRef,
-          selectValue: value,
-        });
+        templateName = 'radio-select-action';
+        data = { ...resolved, selectorRef: step.selectorRef, selectValue: value };
       } else if (isCheckbox) {
-        code = context.templateEngine.renderStep('check-action', { ...resolved, selectorRef: step.selectorRef });
+        templateName = 'check-action';
+        data = { ...resolved, selectorRef: step.selectorRef };
       } else {
-        // Default to dropdown/combobox selectOption
-        code = context.templateEngine.renderStep('select-action', {
-          ...resolved,
-          selectorRef: step.selectorRef,
-          selectValue: value,
-        });
+        const nativeSelectRoles = ['combobox', 'listbox', 'select'];
+        const isNativeSelect = nativeSelectRoles.includes(resolved.role);
+
+        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 {
-        code,
+        templateName,
+        data,
         comment: `Select ${step.dataRef || step.value} in ${step.selectorRef}`,
       };
     },
@@ -163,18 +145,14 @@ export const formPatterns: StepPattern[] = [
     name: 'clear-input',
     matcher: (step: ParsedStep) =>
       step.text.includes('clears') && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
-      
-      const code = context.templateEngine.renderStep('clear-action', { ...resolved, selectorRef: step.selectorRef });
-      
       return {
-        code,
+        templateName: 'clear-action',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Clear ${step.selectorRef}`,
       };
     },
     priority: 7,
   },
 ];
-
-

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

@@ -6,6 +6,7 @@ import { formPatterns } from './form-patterns';
 import { interactionPatterns } from './interaction-patterns';
 import { assertionPatterns } from './assertion-patterns';
 import { setupPatterns } from './setup-patterns';
+import { legacyPatterns } from './legacy-patterns';
 
 /**
  * Pattern Registry - manages all step patterns
@@ -26,7 +27,8 @@ export class PatternRegistry {
     this.patterns.push(...formPatterns);
     this.patterns.push(...interactionPatterns);
     this.patterns.push(...assertionPatterns);
-    
+    this.patterns.push(...legacyPatterns);
+
     // Sort by priority (higher first)
     this.patterns.sort((a, b) => (b.priority || 0) - (a.priority || 0));
   }
@@ -52,15 +54,30 @@ export class PatternRegistry {
   }
 
   /**
-   * Generate code for a step using matched pattern
+   * Generate code for a step using matched pattern.
+   * Prefers resolver (returns template data) over generator (renders directly).
    */
   generateStep(step: ParsedStep, context: PatternContext): MappedStep | null {
     const pattern = this.findPattern(step);
     if (!pattern) {
       return null;
     }
-    
-    return pattern.generator(step, context);
+
+    // Prefer resolver (framework-agnostic) over generator (legacy)
+    if (pattern.resolver) {
+      const resolved = pattern.resolver(step, context);
+      const code = context.templateEngine.renderStep(resolved.templateName, resolved.data);
+      return {
+        code,
+        comment: resolved.comment,
+      };
+    }
+
+    if (pattern.generator) {
+      return pattern.generator(step, context);
+    }
+
+    return null;
   }
 
   /**
@@ -94,4 +111,5 @@ export { navigationPatterns } from './navigation-patterns';
 export { formPatterns } from './form-patterns';
 export { interactionPatterns } from './interaction-patterns';
 export { assertionPatterns } from './assertion-patterns';
+export { legacyPatterns } from './legacy-patterns';
 export * from './types';