@sun-asterisk/sungen 1.0.19 → 1.0.21

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

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

@@ -0,0 +1,131 @@
+/**
+ * Test Generator Interface
+ * Defines contract for test framework code generators
+ */
+
+import { RuntimeConfig } from '../../config/config-schema';
+import { ParsedFeature } from '../../core/selector-base/gherkin-parser';
+import * as path from 'path';
+
+/**
+ * Main Test Generator Interface
+ */
+export interface TestGenerator {
+  readonly framework: string;
+
+  generate(
+    feature: ParsedFeature,
+    selectors: Record<string, any>,
+    testData: Record<string, any>,
+    config: RuntimeConfig
+  ): Promise<GeneratedTest>;
+
+  getFileExtension(): string;
+
+  validate(): boolean;
+}
+
+/**
+ * Generated Test Result (executor-level)
+ */
+export interface GeneratedTest {
+  feature: string;
+  outputPath: string;
+  code: string;
+  stats: GenerationStats;
+}
+
+/**
+ * Generation Statistics
+ */
+export interface GenerationStats {
+  totalScenarios: number;
+  totalSteps: number;
+  dictionaryMatched: number;
+  aiGenerated: number;
+  todoCount: number;
+  generationTime: number;
+}
+
+/**
+ * Test Generator Factory
+ */
+export class TestGeneratorFactory {
+  static create(framework: string, config: RuntimeConfig): TestGenerator {
+    switch (framework) {
+      case 'playwright': {
+        const { CodeGenerator } = require('./code-generator');
+
+        return {
+          framework: 'playwright',
+
+          async generate(
+            feature: ParsedFeature,
+            selectors: Record<string, any>,
+            testData: Record<string, any>,
+            cfg: RuntimeConfig
+          ): Promise<GeneratedTest> {
+            const startTime = Date.now();
+
+            let screenName: string | undefined;
+            if (feature.sourceFile) {
+              const sourceDir = path.dirname(feature.sourceFile);
+              const parts = sourceDir.split(path.sep);
+              const screensIndex = parts.indexOf('screens');
+              if (screensIndex >= 0 && screensIndex < parts.length - 2) {
+                screenName = parts[screensIndex + 1];
+              }
+            }
+
+            const generator = new CodeGenerator({
+              useAI: cfg.testGenerator.enableAIFallback,
+              verbose: cfg.verbose,
+              screenName,
+            });
+
+            const outputDir = cfg.paths.specsDir;
+            const result = await generator.generateTest(feature, outputDir);
+            generator.writeTest(result);
+
+            const countSteps = (f: ParsedFeature) =>
+              f.scenarios.reduce((sum: number, s: any) => sum + (s.steps ? s.steps.length : 0), 0);
+            const countTodos = (code: string) => (code.match(/\/\/ TODO/g) || []).length;
+
+            const stats: GenerationStats = {
+              totalScenarios: feature.scenarios.length,
+              totalSteps: countSteps(feature),
+              dictionaryMatched: 0,
+              aiGenerated: 0,
+              todoCount: countTodos(result.code),
+              generationTime: Date.now() - startTime,
+            };
+
+            return {
+              feature: feature.name,
+              outputPath: result.filePath,
+              code: result.code,
+              stats,
+            };
+          },
+
+          getFileExtension() {
+            return '.spec.ts';
+          },
+
+          validate() {
+            return true;
+          },
+        };
+      }
+
+      case 'appium':
+        throw new Error('Appium generator not yet implemented');
+
+      case 'integration':
+        throw new Error('Integration test generator not yet implemented');
+
+      default:
+        throw new Error(`Unsupported test framework: ${framework}`);
+    }
+  }
+}

package/src/generators/test-generator/utils/data-resolver.ts

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import yaml from 'yaml';
+import { readYamlIfExists } from '../../../utils/yaml-io';
 
 /**
  * DataResolver - Resolves data references to actual values
@@ -102,13 +103,10 @@ export class DataResolver {
 
     // Load in reverse priority order (base first, then overrides on top)
     for (const p of [...possiblePaths].reverse()) {
-      if (fs.existsSync(p)) {
-        const content = fs.readFileSync(p, 'utf-8');
-        const data = yaml.parse(content);
-        if (data && typeof data === 'object' && Object.keys(data).length > 0) {
-          merged = { ...merged, ...data };
-          found = true;
-        }
+      const data = readYamlIfExists(p);
+      if (data && typeof data === 'object' && Object.keys(data).length > 0) {
+        merged = { ...merged, ...data };
+        found = true;
       }
     }
 
@@ -131,13 +129,10 @@ export class DataResolver {
     const possiblePaths = this.getPossibleDataPaths(fileName);
     
     for (const p of possiblePaths) {
-      if (fs.existsSync(p)) {
-        // Check if file has actual data (not just comments/empty)
-        const content = fs.readFileSync(p, 'utf-8');
-        const data = yaml.parse(content);
-        
+      const data = readYamlIfExists(p);
+      if (data !== null) {
         // Skip if file is empty or only contains null/undefined
-        if (data === null || data === undefined || (typeof data === 'object' && Object.keys(data).length === 0)) {
+        if (data === undefined || (typeof data === 'object' && Object.keys(data).length === 0)) {
           continue;
         }
         

package/src/generators/test-generator/utils/selector-resolver.ts

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import yaml from 'yaml';
+import { readYaml, readYamlIfExists } from '../../../utils/yaml-io';
 
 /**
  * Remove Vietnamese diacritics (accents) from text
@@ -187,10 +188,12 @@ function convertJapaneseToRomaji(text: string): string {
   return result;
 }
 
+import { SelectorType } from '../../../utils/selector-types';
+
 // New structured selector format
 interface SelectorEntry {
   locator?: string;  // CSS locator (optional, empty string means use type/value)
-  type?: 'placeholder' | 'role' | 'testid' | 'label' | 'text' | 'locator';  // Locator strategy
+  type?: SelectorType;  // Locator strategy
   value?: string;     // Natural language value for the locator (e.g., 'button', 'link' for role)
   name?: string;      // Accessible name for role-based selectors (e.g., 'Login', 'Submit')
   nth?: number;       // Element index (0 = no index, 1+ = append .nth())
@@ -285,7 +288,7 @@ export class SelectorResolver {
    * NOTE: textbox/textarea must precede "text" to prevent partial matching.
    */
   static extractNthFromStep(afterElement: string): number {
-    const nthRegex = /^\s*(?:field|button|textbox|textarea|text|link|input|element|item|logo|image|img|icon|raw|table|columnheader|list|listitem|row|checkbox|radio|dropdown|select|uploader|heading|header)?\s*(\d+)\b/i;
+    const nthRegex = /^\s*(?:field|button|textbox|textarea|text|link|input|element|item|logo|image|img|icon|raw|table|column|columnheader|list|listitem|row|checkbox|radio|dropdown|select|uploader|heading|header)?\s*(\d+)\b/i;
     const match = nthRegex.exec(afterElement);
     return match ? parseInt(match[1], 10) : 0;
   }
@@ -683,19 +686,17 @@ export class SelectorResolver {
     // 1. Try load base file (screen-level shared selectors) - OPTIONAL
     if (this.screenName) {
       const basePath = this.findBaseSelectorPath(this.screenName);
-      if (basePath && fs.existsSync(basePath)) {
-        const baseContent = fs.readFileSync(basePath, 'utf-8');
-        const baseSelectors = yaml.parse(baseContent) as SelectorFile;
+      if (basePath) {
+        const baseSelectors = readYamlIfExists<SelectorFile>(basePath);
         if (baseSelectors) {
           Object.assign(selectors, baseSelectors);
         }
       }
-      
+
       // Load base override file
       const baseOverridePath = this.findOverrideSelectorPath(this.screenName);
-      if (baseOverridePath && fs.existsSync(baseOverridePath)) {
-        const overrideContent = fs.readFileSync(baseOverridePath, 'utf-8');
-        const overrideSelectors = yaml.parse(overrideContent) as SelectorFile;
+      if (baseOverridePath) {
+        const overrideSelectors = readYamlIfExists<SelectorFile>(baseOverridePath);
         if (overrideSelectors) {
           Object.assign(selectors, overrideSelectors);
         }
@@ -713,18 +714,16 @@ export class SelectorResolver {
         );
       }
     } else {
-      const featureContent = fs.readFileSync(featurePath, 'utf-8');
-      const featureSelectors = yaml.parse(featureContent) as SelectorFile;
+      const featureSelectors = readYamlIfExists<SelectorFile>(featurePath);
       if (featureSelectors) {
         Object.assign(selectors, featureSelectors);
       }
     }
-    
+
     // 3. Load feature override file
     const featureOverridePath = this.findOverrideSelectorPath(featureName);
-    if (featureOverridePath && fs.existsSync(featureOverridePath)) {
-      const overrideContent = fs.readFileSync(featureOverridePath, 'utf-8');
-      const overrideSelectors = yaml.parse(overrideContent) as SelectorFile;
+    if (featureOverridePath) {
+      const overrideSelectors = readYamlIfExists<SelectorFile>(featureOverridePath);
       if (overrideSelectors) {
         Object.assign(selectors, overrideSelectors);
       }
@@ -944,8 +943,7 @@ export class SelectorResolver {
       );
     }
 
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const selectorFile = yaml.parse(content) as LegacySelectorFile;
+    const selectorFile = readYaml<LegacySelectorFile>(filePath);
 
     this.selectorCache.set(cacheKey, selectorFile);
     return selectorFile;