@sun-asterisk/sungen 1.0.20 → 1.0.21

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,
   },
 ];
-

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

@@ -3,7 +3,6 @@ import { StepPattern } from './types';
 
 /**
  * Setup and precondition patterns: application setup, authentication state, etc.
- * Uses templates for framework-agnostic code generation
  */
 export const setupPatterns: StepPattern[] = [
   {
@@ -12,14 +11,11 @@ export const setupPatterns: StepPattern[] = [
       step.text.includes('application is running') ||
       step.text.includes('application running') ||
       step.text.includes('app is running'),
-    generator: (step, context) => {
-      const code = context.templateEngine.renderStep('application-running', {});
-      
-      return {
-        code,
-        comment: `Setup: Application is running`,
-      };
-    },
+    resolver: (step, context) => ({
+      templateName: 'application-running',
+      data: {},
+      comment: `Setup: Application is running`,
+    }),
     priority: 5,
   },
   {
@@ -28,14 +24,11 @@ export const setupPatterns: StepPattern[] = [
       step.text.includes('user is not logged in') ||
       step.text.includes('not logged in') ||
       step.text.includes('logged out'),
-    generator: (step, context) => {
-      const code = context.templateEngine.renderStep('clear-auth', {});
-      
-      return {
-        code,
-        comment: `Clear authentication state (ensure user is logged out)`,
-      };
-    },
+    resolver: (step, context) => ({
+      templateName: 'clear-auth',
+      data: {},
+      comment: `Clear authentication state (ensure user is logged out)`,
+    }),
     priority: 9,
   },
   {
@@ -44,16 +37,11 @@ export const setupPatterns: StepPattern[] = [
       (step.text.includes('user is logged in') ||
        step.text.includes('logged in as')) &&
       !step.text.includes('not logged in'),
-    generator: (step, context) => {
-      // Check if there's a data reference for user credentials
+    resolver: (step, context) => {
       const userRef = step.dataRef || 'valid_user';
-      
-      const code = context.templateEngine.renderStep('user-login-todo', {
-        userRef,
-      });
-      
       return {
-        code,
+        templateName: 'user-login-todo',
+        data: { userRef },
         comment: `Setup: User logged in as ${userRef}`,
       };
     },
@@ -65,14 +53,11 @@ export const setupPatterns: StepPattern[] = [
       step.text.includes('database is empty') ||
       step.text.includes('database is cleared') ||
       step.text.includes('clear database'),
-    generator: (step, context) => {
-      const code = context.templateEngine.renderStep('clear-database', {});
-      
-      return {
-        code,
-        comment: `Setup: Clear/reset database`,
-      };
-    },
+    resolver: (step, context) => ({
+      templateName: 'clear-database',
+      data: {},
+      comment: `Setup: Clear/reset database`,
+    }),
     priority: 7,
   },
   {
@@ -81,14 +66,11 @@ export const setupPatterns: StepPattern[] = [
       step.text.includes('clean browser state') ||
       step.text.includes('fresh browser') ||
       step.text.includes('new browser session'),
-    generator: (step, context) => {
-      const code = context.templateEngine.renderStep('clear-browser-state', {});
-      
-      return {
-        code,
-        comment: `Clear browser state (cookies, storage)`,
-      };
-    },
+    resolver: (step, context) => ({
+      templateName: 'clear-browser-state',
+      data: {},
+      comment: `Clear browser state (cookies, storage)`,
+    }),
     priority: 8,
   },
 ];

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

@@ -9,12 +9,26 @@ import { DataResolver } from '../utils/data-resolver';
 export type PatternMatcher = RegExp | ((step: ParsedStep) => boolean);
 
 /**
- * Pattern generator function
+ * Pattern generator function (legacy — calls templateEngine directly)
  */
 export type PatternGenerator = (step: ParsedStep, context: PatternContext) => MappedStep;
 
 /**
- * Context passed to pattern generators
+ * Resolved step template data — framework-agnostic
+ */
+export interface StepTemplateData {
+  templateName: string;
+  data: Record<string, any>;
+  comment?: string;
+}
+
+/**
+ * Pattern resolver function — returns template name + data, does NOT render
+ */
+export type PatternResolver = (step: ParsedStep, context: PatternContext) => StepTemplateData;
+
+/**
+ * Context passed to pattern generators/resolvers
  */
 export interface PatternContext {
   stepCounter: number;
@@ -23,19 +37,22 @@ export interface PatternContext {
   selectorResolver: SelectorResolver;
   dataResolver: DataResolver;
   renderLocator: (resolved: any) => string;
-  baseURL?: string;  // Base URL from config (e.g., 'http://localhost:3000')
-  featureName?: string;  // Feature name for data resolution (e.g., 'login')
-  screenName?: string;  // Screen name for path inference (e.g., 'sign-in')
-  featurePath?: string;  // Path metadata from feature file (e.g., '/login')
-  scenarioSteps?: ParsedStep[];  // All steps in scenario for path variable extraction
+  baseURL?: string;
+  featureName?: string;
+  screenName?: string;
+  featurePath?: string;
+  scenarioSteps?: ParsedStep[];
 }
 
 /**
  * Step pattern definition
+ * Supports both `resolver` (preferred) and `generator` (legacy).
+ * If both are provided, `resolver` takes precedence.
  */
 export interface StepPattern {
   name: string;
   matcher: PatternMatcher;
-  generator: PatternGenerator;
-  priority?: number; // Higher priority = checked first (default: 0)
+  resolver?: PatternResolver;
+  generator?: PatternGenerator;
+  priority?: number;
 }

package/src/generators/test-generator/step-mapper.ts

@@ -140,15 +140,6 @@ export class StepMapper {
       return mappedStep;
     }
 
-    // Fallback: Try legacy patterns for backward compatibility
-    const legacyStep = this.tryLegacyPatterns(step);
-    if (legacyStep) {
-      if (this.verbose) {
-        console.log(`  ✓ Legacy pattern matched: ${step.text.substring(0, 50)}...`);
-      }
-      return legacyStep;
-    }
-
     // Fallback to AI if enabled
     if (this.useAI && this.aiMapper) {
       if (this.verbose) {
@@ -170,7 +161,10 @@ export class StepMapper {
   private createPatternContext(): PatternContext {
     return {
       stepCounter: this.stepCounter,
-      extractScreenId: this.extractScreenId.bind(this),
+      extractScreenId: (selectorRef: string) => {
+        const match = selectorRef.match(/\[([\w-]+)\./);
+        return match ? match[1] : 'unknown';
+      },
       templateEngine: this.templateEngine,
       selectorResolver: this.selectorResolver,
       dataResolver: this.dataResolver,
@@ -183,118 +177,4 @@ export class StepMapper {
     };
   }
 
-  /**
-   * Extract screen ID from selector reference
-   */
-  private extractScreenId(selectorRef: string): string {
-    const match = selectorRef.match(/\[([\w-]+)\./);
-    return match ? match[1] : 'unknown';
-  }
-
-  /**
-   * Try legacy patterns for backward compatibility
-   * These are patterns not yet migrated to the pattern registry
-   */
-  private tryLegacyPatterns(step: ParsedStep): MappedStep | null {
-    const { text, selectorRef, dataRef, value } = step;
-
-    // Login pattern
-    if (text.includes('user is logged in as') && dataRef) {
-      return this.mapLoginStep(dataRef);
-    }
-
-    // Error message assertions
-    if (text.includes('error message') && text.includes('should')) {
-      return this.mapErrorMessageAssertion();
-    }
-
-    // Generic message assertions
-    if (text.includes('message') && text.includes('should be displayed')) {
-      return this.mapGenericMessageAssertion(text);
-    }
-
-    // Message with value assertions
-    if (text.includes('should see message') && value) {
-      return this.mapMessageAssertion(value, selectorRef);
-    }
-
-    // AI response assertions
-    if (text.includes('user should see') && text.includes('AI response') && selectorRef) {
-      return this.mapAIResponseAssertion(selectorRef);
-    }
-
-    // Message count assertions
-    if (text.includes('messages in') && selectorRef) {
-      return this.mapMessageCountAssertion(text, selectorRef);
-    }
-
-    // Message contains assertions
-    if (text.includes('should contain') && text.includes('messages') && selectorRef) {
-      return this.mapMessageCountAssertion(text, selectorRef);
-    }
-
-    return null;
-  }
-
-  // ========================================
-  // LEGACY METHODS (to be migrated to patterns)
-  // ========================================
-
-  private mapLoginStep(dataRef: string): MappedStep {
-    const varName = dataRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
-    return {
-      code: this.templateEngine.renderStep('login', { varName, dataRef }),
-      comment: `Login as ${dataRef}`,
-    };
-  }
-
-  private mapErrorMessageAssertion(): MappedStep {
-    return {
-      code: this.templateEngine.renderStep('error-message-assertion', {}),
-      comment: 'Assert error message is displayed',
-    };
-  }
-
-  private mapGenericMessageAssertion(text: string): MappedStep {
-    const messageType = text.includes('welcome') ? 'welcome' : 
-                       text.includes('success') ? 'success' : 'message';
-    return {
-      code: this.templateEngine.renderStep('generic-message-assertion', { messageType }),
-      comment: `Assert ${messageType} message is displayed`,
-    };
-  }
-
-  private mapMessageAssertion(value: string, selectorRef?: string): MappedStep {
-    const varName = (selectorRef || 'message').replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
-    return {
-      code: this.templateEngine.renderStep('message-assertion-body', { varName, value, selectorRef }),
-      comment: `Assert message: ${value}`,
-    };
-  }
-
-  private mapAIResponseAssertion(selectorRef: string): MappedStep {
-    const screenId = this.extractScreenId(selectorRef);
-    const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
-    return {
-      code: this.templateEngine.renderStep('ai-response-assertion-selector', { varName, selectorRef, screenId }),
-      comment: `Assert AI response in ${selectorRef}`,
-    };
-  }
-
-  private mapMessageCountAssertion(text: string, selectorRef: string): MappedStep {
-    const match = text.match(/(\d+)\s+messages?/);
-    const expectedCount = match ? parseInt(match[1]) : 1;
-    const screenId = this.extractScreenId(selectorRef);
-    const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
-    
-    return {
-      code: this.templateEngine.renderStep('message-count-assertion', {
-        varName,
-        selectorRef,
-        screenId,
-        expectedCount,
-      }),
-      comment: `Assert ${expectedCount} messages in ${selectorRef}`,
-    };
-  }
 }