@sun-asterisk/sungen 1.0.20 → 1.0.22

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

@@ -14,7 +14,6 @@ function extractWaitState(text: string): string {
 
 /**
  * Map a plain element keyword (no brackets) to a Playwright ARIA role.
- * e.g. "dialog" → "dialog", "modal" → "dialog", "alert" → "alertdialog"
  */
 function elementKeywordToRole(text: string): string | null {
   const match = text.match(/\bwait(?:s)?\s+for\s+(dialog|modal|alert|alertdialog|tooltip|menu|listbox|combobox|grid|table|status|banner|navigation|main|region)\b/i);
@@ -29,32 +28,21 @@ function elementKeywordToRole(text: string): string | null {
 
 /**
  * Interaction patterns: click, hover, press, wait
- * Uses template engine for framework-agnostic code generation
  */
 export const interactionPatterns: StepPattern[] = [
-  // Unknown element with variable pattern (selector value is empty, identified by filter)
-  // Matches: "When User click [target order] row with {{order_name}}"
-  // Generates: await page.getByText('').filter({ hasText: /.*value of order_name$/ }).click();
   {
     name: 'unknown-element-action',
     matcher: (step: ParsedStep) => {
-      // Check if selectorRef starts with "target " (target element indicator)
       const isTargetElement = step.selectorRef && /^target\s/i.test(step.selectorRef);
-      // Must have both selector and variable, and "with" clause
-      // But EXCLUDE assertion verbs (see, sees) - those should use assertion patterns
       const isInteractionAction = !step.text.includes('see') && !step.text.includes('sees');
       return isTargetElement && !!step.dataRef && step.text.includes('with') && isInteractionAction;
     },
-    generator: (step, context) => {
-      // Resolve selector value from YAML (e.g., target.order)
+    resolver: (step, context) => {
       let selectorValue = '';
       let nth = 0;
       try {
         const resolved = context.selectorResolver.resolveSelector(
-          step.selectorRef!,
-          context.featureName,
-          step.elementType,
-          step.nth
+          step.selectorRef!, context.featureName, step.elementType, step.nth
         );
         selectorValue = resolved.value || '';
         nth = resolved.nth || 0;
@@ -63,7 +51,6 @@ export const interactionPatterns: StepPattern[] = [
         nth = 0;
       }
 
-      // Resolve data variable value
       let dataValue: string;
       try {
         dataValue = context.dataResolver.resolveData(step.dataRef!, context.featureName);
@@ -71,27 +58,17 @@ export const interactionPatterns: StepPattern[] = [
         dataValue = `\${${step.dataRef}}`;
       }
 
-      // Determine the action method (click, hover, etc.)
       let actionMethod = 'click';
-      if (step.text.includes('hover')) {
-        actionMethod = 'hover';
-      } else if (step.text.includes('double')) {
-        actionMethod = 'dblclick';
-      }
-
-      const code = context.templateEngine.renderStep('unknown-element-action', {
-        selectorValue,
-        dataValue,
-        action: actionMethod,
-        nth,
-      });
+      if (step.text.includes('hover')) actionMethod = 'hover';
+      else if (step.text.includes('double')) actionMethod = 'dblclick';
 
       return {
-        code,
+        templateName: 'unknown-element-action',
+        data: { selectorValue, dataValue, action: actionMethod, nth },
         comment: `${actionMethod.charAt(0).toUpperCase() + actionMethod.slice(1)} ${step.selectorRef} with ${step.dataRef}`,
       };
     },
-    priority: 15, // Highest priority - match before all other interaction patterns
+    priority: 15,
   },
   {
     name: 'click-element-with-text',
@@ -100,7 +77,7 @@ export const interactionPatterns: StepPattern[] = [
       && !!step.selectorRef
       && !!(step.dataRef || step.value)
       && step.text.includes('with'),
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const resolved = context.selectorResolver.resolveSelector(
         step.selectorRef!, undefined, step.elementType, step.nth
       );
@@ -116,16 +93,11 @@ export const interactionPatterns: StepPattern[] = [
         }
       }
 
-      // When using .filter({ hasText }), name is redundant — data value identifies the element
       const { name: _name, ...resolvedWithoutName } = resolved;
 
-      const code = context.templateEngine.renderStep('click-element-with-text', {
-        ...resolvedWithoutName,
-        dataValue,
-      });
-
       return {
-        code,
+        templateName: 'click-element-with-text',
+        data: { ...resolvedWithoutName, dataValue },
         comment: `Click ${step.selectorRef} with text ${step.dataRef || step.value}`,
       };
     },
@@ -135,13 +107,11 @@ export const interactionPatterns: StepPattern[] = [
     name: 'click-element',
     matcher: (step: ParsedStep) =>
       (step.text.includes('clicks') || step.text.includes('click')) && !!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('click-action', { ...resolved, selectorRef: step.selectorRef });
-      
       return {
-        code,
+        templateName: 'click-action',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Click ${step.selectorRef}`,
       };
     },
@@ -152,13 +122,11 @@ export const interactionPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       (step.text.includes('double click') || step.text.includes('double-click') ||
        (step.text.includes('double') && step.text.includes('clicks'))) && !!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('double-click-action', { ...resolved, selectorRef: step.selectorRef });
-      
       return {
-        code,
+        templateName: 'double-click-action',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Double click ${step.selectorRef}`,
       };
     },
@@ -168,13 +136,11 @@ export const interactionPatterns: StepPattern[] = [
     name: 'hover-element',
     matcher: (step: ParsedStep) =>
       step.text.includes('hovers') && !!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('hover-action', { ...resolved, selectorRef: step.selectorRef });
-      
       return {
-        code,
+        templateName: 'hover-action',
+        data: { ...resolved, selectorRef: step.selectorRef },
         comment: `Hover ${step.selectorRef}`,
       };
     },
@@ -184,16 +150,11 @@ export const interactionPatterns: StepPattern[] = [
     name: 'press-enter',
     matcher: (step: ParsedStep) =>
       step.text.includes('presses') && step.text.includes('Enter') && !!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('press-action', {
-        ...resolved,
-        key: 'Enter',
-      });
-      
       return {
-        code,
+        templateName: 'press-action',
+        data: { ...resolved, key: 'Enter' },
         comment: `Press Enter in ${step.selectorRef}`,
       };
     },
@@ -203,8 +164,7 @@ export const interactionPatterns: StepPattern[] = [
     name: 'click-by-data-text',
     matcher: (step: ParsedStep) =>
       (step.text.includes('clicks') || step.text.includes('click')) && !step.selectorRef && !!step.dataRef,
-    generator: (step, context) => {
-      // Resolve data reference to actual value
+    resolver: (step, context) => {
       let value: string;
       try {
         value = context.dataResolver.resolveData(step.dataRef!, context.featureName);
@@ -212,43 +172,36 @@ export const interactionPatterns: StepPattern[] = [
         value = `\${${step.dataRef}}`;
       }
 
-      const code = context.templateEngine.renderStep('click-action', {
-        strategy: 'text',
-        value,
-        nth: 0,
-      });
-
       return {
-        code,
+        templateName: 'click-action',
+        data: { strategy: 'text', value, nth: 0 },
         comment: `Click ${step.dataRef}`,
       };
     },
-    priority: 5, // Lower than click-element which has selectorRef
+    priority: 5,
   },
   {
     name: 'wait-for-time',
     matcher: (step: ParsedStep) =>
       (step.text.includes('wait for') || step.text.includes('waits for')) && /\d+/.test(step.text),
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const match = step.text.match(/(\d+)\s*(seconds?|ms|milliseconds?)/);
       let duration = 1000;
-      
+
       if (match) {
         const num = parseInt(match[1]);
         const unit = match[2].toLowerCase();
         duration = unit.startsWith('s') ? num * 1000 : num;
       }
-      
-      const code = context.templateEngine.renderStep('wait-timeout', { duration });
-      
+
       return {
-        code,
+        templateName: 'wait-timeout',
+        data: { duration },
         comment: `Wait for ${duration}ms`,
       };
     },
     priority: 7,
   },
-  // "wait for dialog with {{kudo.title}} hidden" - role keyword inline, no selector brackets, with data filter
   {
     name: 'wait-for-role-with-text',
     matcher: (step: ParsedStep) =>
@@ -256,7 +209,7 @@ export const interactionPatterns: StepPattern[] = [
       !step.selectorRef &&
       !!step.dataRef &&
       !!elementKeywordToRole(step.text),
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const role = elementKeywordToRole(step.text)!;
 
       let dataValue: string;
@@ -268,15 +221,14 @@ export const interactionPatterns: StepPattern[] = [
 
       const state = extractWaitState(step.text);
 
-      // Render inline — no locator partial needed, role is known directly
       return {
-        code: `await page.getByRole('${role}').filter({ hasText: '${dataValue.replace(/'/g, "\\'")}' }).waitFor({ state: '${state}' });`,
+        templateName: 'wait-for-role-with-data',
+        data: { role, dataValue, state },
         comment: `Wait for ${role} with ${step.dataRef} to be ${state}`,
       };
     },
     priority: 11,
   },
-  // "wait for dialog hidden" - role keyword inline, no selector brackets, no data filter
   {
     name: 'wait-for-role',
     matcher: (step: ParsedStep) =>
@@ -284,32 +236,32 @@ export const interactionPatterns: StepPattern[] = [
       !step.selectorRef &&
       !step.dataRef &&
       !!elementKeywordToRole(step.text),
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const role = elementKeywordToRole(step.text)!;
       const state = extractWaitState(step.text);
 
       return {
-        code: `await page.getByRole('${role}').waitFor({ state: '${state}' });`,
+        templateName: 'wait-for-role',
+        data: { role, state },
         comment: `Wait for ${role} to be ${state}`,
       };
     },
     priority: 11,
   },
-  // NEW: Wait for page pattern
   {
     name: 'wait-for-page',
     matcher: (step: ParsedStep) =>
       (step.text.includes('wait for') || step.text.includes('waits for')) && step.elementType === 'page',
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const path = step.featurePath || '/';
       const pathRegex = path.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
-      const code = context.templateEngine.renderStep('wait-for-page', { pathRegex });
       return {
-        code,
+        templateName: 'wait-for-page',
+        data: { pathRegex },
         comment: `Wait for page`,
       };
     },
-    priority: 9,  // Higher than wait-for-element
+    priority: 9,
   },
   {
     name: 'wait-for-element-with-text',
@@ -317,7 +269,7 @@ export const interactionPatterns: StepPattern[] = [
       (step.text.includes('wait for') || step.text.includes('waits for')) &&
       !!step.selectorRef &&
       !!step.dataRef,
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
 
       let dataValue: string;
@@ -329,15 +281,9 @@ export const interactionPatterns: StepPattern[] = [
 
       const state = extractWaitState(step.text);
 
-      const code = context.templateEngine.renderStep('wait-for-element-with-text', {
-        ...resolved,
-        selectorRef: step.selectorRef,
-        dataValue,
-        state,
-      });
-
       return {
-        code,
+        templateName: 'wait-for-element-with-text',
+        data: { ...resolved, selectorRef: step.selectorRef, dataValue, state },
         comment: `Wait for ${step.selectorRef} with ${step.dataRef} to be ${state}`,
       };
     },
@@ -347,22 +293,16 @@ export const interactionPatterns: StepPattern[] = [
     name: 'wait-for-element',
     matcher: (step: ParsedStep) =>
       (step.text.includes('wait for') || step.text.includes('waits for')) && !!step.selectorRef,
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const resolved = context.selectorResolver.resolveSelector(step.selectorRef!, undefined, step.elementType, step.nth);
       const state = extractWaitState(step.text);
 
-      const code = context.templateEngine.renderStep('wait-for-element', {
-        ...resolved,
-        selectorRef: step.selectorRef,
-        state,
-      });
-
       return {
-        code,
+        templateName: 'wait-for-element',
+        data: { ...resolved, selectorRef: step.selectorRef, state },
         comment: `Wait for ${step.selectorRef} to be ${state}`,
       };
     },
     priority: 8,
   },
 ];
-

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

@@ -0,0 +1,104 @@
+import { ParsedStep } from '../../gherkin-parser';
+import { StepPattern } from './types';
+
+/**
+ * Helper to extract screen ID from selector reference.
+ */
+function extractScreenId(selectorRef: string): string {
+  const match = selectorRef.match(/\[([\w-]+)\./);
+  return match ? match[1] : 'unknown';
+}
+
+/**
+ * Legacy patterns migrated from step-mapper.ts tryLegacyPatterns().
+ * These use templates that already exist (login, error-message-assertion, etc.)
+ */
+export const legacyPatterns: StepPattern[] = [
+  {
+    name: 'legacy-login',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('user is logged in as') && !!step.dataRef,
+    resolver: (step, context) => {
+      const varName = step.dataRef!.replace(/[^a-zA-Z0-9]/g, '_') + '_' + context.stepCounter;
+      return {
+        templateName: 'login',
+        data: { varName, dataRef: step.dataRef },
+        comment: `Login as ${step.dataRef}`,
+      };
+    },
+    priority: 9,
+  },
+  {
+    name: 'legacy-error-message',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('error message') && step.text.includes('should'),
+    resolver: (step, context) => ({
+      templateName: 'error-message-assertion',
+      data: {},
+      comment: 'Assert error message is displayed',
+    }),
+    priority: 6,
+  },
+  {
+    name: 'legacy-generic-message',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('message') && step.text.includes('should be displayed'),
+    resolver: (step, context) => {
+      const messageType = step.text.includes('welcome') ? 'welcome' :
+                         step.text.includes('success') ? 'success' : 'message';
+      return {
+        templateName: 'generic-message-assertion',
+        data: { messageType },
+        comment: `Assert ${messageType} message is displayed`,
+      };
+    },
+    priority: 6,
+  },
+  {
+    name: 'legacy-message-with-value',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should see message') && !!step.value,
+    resolver: (step, context) => {
+      const varName = (step.selectorRef || 'message').replace(/[^a-zA-Z0-9]/g, '_') + '_' + context.stepCounter;
+      return {
+        templateName: 'message-assertion-body',
+        data: { varName, value: step.value, selectorRef: step.selectorRef },
+        comment: `Assert message: ${step.value}`,
+      };
+    },
+    priority: 6,
+  },
+  {
+    name: 'legacy-ai-response',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('user should see') && step.text.includes('AI response') && !!step.selectorRef,
+    resolver: (step, context) => {
+      const screenId = extractScreenId(step.selectorRef!);
+      const varName = step.selectorRef!.replace(/[^a-zA-Z0-9]/g, '_') + '_' + context.stepCounter;
+      return {
+        templateName: 'ai-response-assertion-selector',
+        data: { varName, selectorRef: step.selectorRef, screenId },
+        comment: `Assert AI response in ${step.selectorRef}`,
+      };
+    },
+    priority: 6,
+  },
+  {
+    name: 'legacy-message-count',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('messages in') || (step.text.includes('should contain') && step.text.includes('messages'))) &&
+      !!step.selectorRef,
+    resolver: (step, context) => {
+      const match = step.text.match(/(\d+)\s+messages?/);
+      const expectedCount = match ? parseInt(match[1]) : 1;
+      const screenId = extractScreenId(step.selectorRef!);
+      const varName = step.selectorRef!.replace(/[^a-zA-Z0-9]/g, '_') + '_' + context.stepCounter;
+      return {
+        templateName: 'message-count-assertion',
+        data: { varName, selectorRef: step.selectorRef, screenId, expectedCount },
+        comment: `Assert ${expectedCount} messages in ${step.selectorRef}`,
+      };
+    },
+    priority: 6,
+  },
+];

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

@@ -4,82 +4,58 @@ import { inferPath, resolvePathVariables, getPathCode } from '../utils/path-infe
 
 /**
  * Navigation patterns: goto, navigate, open page
- * Uses baseURL from config (optional) + path from feature metadata
- * Templates handle URL construction
  */
 export const navigationPatterns: StepPattern[] = [
-  // Open page type pattern (open [home] page) - resolve selector value or use feature path
   {
     name: 'open-page-type',
     matcher: (step: ParsedStep) =>
       (step.text.includes('open') || step.text.includes('opens') || step.text.includes('is on')) &&
       step.elementType === 'page',
-    generator: (step, context) => {
+    resolver: (step, context) => {
       let path = context.featurePath || '/';
-      
-      // If selector is present, extract path from selector's value attribute
+
       if (step.selectorRef) {
         try {
           const resolved = context.selectorResolver.resolveSelector(
-            step.selectorRef,
-            context.featureName,
-            step.elementType,
-            step.nth
+            step.selectorRef, context.featureName, step.elementType, step.nth
           );
-          // Use selector's value as the path for navigation
           path = resolved.value || path;
         } catch (error) {
-          // Fallback to feature path if selector not found
           path = context.featurePath || '/';
         }
       }
-      
-      // Resolve path variables if present
+
       const finalPath = resolvePathVariables(path, context.scenarioSteps || []);
-      
-      const code = context.templateEngine.renderStep('navigation', {
-        baseURL: context.baseURL,
-        path: finalPath,
-      });
-      
+
       return {
-        code,
+        templateName: 'navigation',
+        data: { baseURL: context.baseURL, path: finalPath },
         comment: step.selectorRef ? `Open ${step.selectorRef} page` : `Navigate to page`,
       };
     },
-    priority: 16,  // Higher priority than regular open-page
+    priority: 16,
   },
   {
     name: 'open-page',
     matcher: (step: ParsedStep) =>
       (step.text.includes('open') || step.text.includes('opens')) &&
       step.text.includes('page') &&
-      step.elementType !== 'page',  // Only match if NOT page type (avoid conflict with open-page-type)
-    generator: (step, context) => {
-      // Extract page/screen reference
-      const pageMatch = step.text.match(/open[s]?\s+\[([^\]]+)\]/i) || 
+      step.elementType !== 'page',
+    resolver: (step, context) => {
+      const pageMatch = step.text.match(/open[s]?\s+\[([^\]]+)\]/i) ||
                        step.text.match(/open[s]?\s+"([^"]+)"/i);
       const pageName = pageMatch ? pageMatch[1] : 'page';
-      
-      // Infer path with smart defaults
+
       const inferredPath = inferPath(context.featurePath, {
         featureName: context.featureName,
         screenName: context.screenName,
       });
-
-      // Resolve path variables if present (e.g., /user/:id)
       const resolvedPath = resolvePathVariables(inferredPath, context.scenarioSteps || []);
-      
-      // Get path code (template literal or string)
       const pathCode = getPathCode(resolvedPath);
-      
-      const code = context.templateEngine.renderStep('navigation', {
-        baseURL: context.baseURL,  // null or URL from config
-        path: pathCode.replace(/^['`]|['`]$/g, ''), // Remove quotes for template
-      });
-      
+
       return {
-        code,
+        templateName: 'navigation',
+        data: { baseURL: context.baseURL, path: pathCode.replace(/^['`]|['`]$/g, '') },
         comment: `Open ${pageName}`,
       };
     },
@@ -87,31 +63,22 @@ export const navigationPatterns: StepPattern[] = [
   },
   {
     name: 'navigate-to-route',
-    matcher: (step: ParsedStep) => 
-      (step.text.includes('navigates to') || step.text.includes('is on')) && 
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('navigates to') || step.text.includes('is on')) &&
       !!(step.selectorRef || step.dataRef),
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const route = step.selectorRef || step.dataRef;
-      
-      // Infer path with smart defaults
+
       const inferredPath = inferPath(context.featurePath, {
         featureName: context.featureName,
         screenName: context.screenName,
       });
-
-      // Resolve path variables if present
       const resolvedPath = resolvePathVariables(inferredPath, context.scenarioSteps || []);
-      
-      // Get path code
       const pathCode = getPathCode(resolvedPath);
-      
-      const code = context.templateEngine.renderStep('navigation', {
-        baseURL: context.baseURL,  // null or URL from config
-        path: pathCode.replace(/^['`]|['`]$/g, ''),
-      });
-      
+
       return {
-        code,
+        templateName: 'navigation',
+        data: { baseURL: context.baseURL, path: pathCode.replace(/^['`]|['`]$/g, '') },
         comment: `Navigate to ${route}`,
       };
     },
@@ -122,31 +89,22 @@ export const navigationPatterns: StepPattern[] = [
     matcher: (step: ParsedStep) =>
       (step.text.includes('should see route') || step.text.includes('should remain on')) &&
       !!(step.selectorRef || step.dataRef),
-    generator: (step, context) => {
+    resolver: (step, context) => {
       const route = step.selectorRef || step.dataRef;
-      
-      // Infer path with smart defaults
+
       const inferredPath = inferPath(context.featurePath, {
         featureName: context.featureName,
         screenName: context.screenName,
       });
-
-      // Resolve path variables if present
       const resolvedPath = resolvePathVariables(inferredPath, context.scenarioSteps || []);
-      
-      // Get path code
       const pathCode = getPathCode(resolvedPath);
-      
-      const code = context.templateEngine.renderStep('route-assertion', {
-        path: pathCode.replace(/^['`]|['`]$/g, ''),
-      });
-      
+
       return {
-        code,
+        templateName: 'route-assertion',
+        data: { path: pathCode.replace(/^['`]|['`]$/g, '') },
         comment: `Assert current route is ${route}`,
       };
     },
     priority: 10,
   },
 ];
-