@sun-asterisk/sungen 1.0.0

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

@@ -0,0 +1,183 @@
+import { ParsedStep } from '../../gherkin-parser';
+import { StepPattern } from './types';
+
+/**
+ * Assertion patterns: visibility, text content, state, attributes
+ * Uses template engine for framework-agnostic code generation
+ */
+export const assertionPatterns: StepPattern[] = [
+  {
+    name: 'should-be-visible',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should be visible') || 
+       step.text.includes('should be displayed') ||
+       step.text.includes('should see') ||
+       step.text.match(/\b(see|sees)\s+\[/)) &&
+      !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      const code = context.templateEngine.renderStep('visible-assertion', resolved);
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} is visible`,
+      };
+    },
+    priority: 10,
+  },
+  {
+    name: 'should-not-be-visible',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should not be visible') || 
+       step.text.includes('should be hidden') ||
+       step.text.includes('should not see')) && 
+      !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      const code = context.templateEngine.renderStep('not-visible-assertion', resolved);
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} is not visible`,
+      };
+    },
+    priority: 11,
+  },
+  {
+    name: 'should-be-enabled',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should be enabled') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      const code = context.templateEngine.renderStep('enabled-assertion', resolved);
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} is enabled`,
+      };
+    },
+    priority: 9,
+  },
+  {
+    name: 'should-be-disabled',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should be disabled') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      const code = context.templateEngine.renderStep('disabled-assertion', resolved);
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} is disabled`,
+      };
+    },
+    priority: 9,
+  },
+  {
+    name: 'should-contain-text',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should contain') && !!step.selectorRef && !!(step.value || step.dataRef),
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      const expectedText = step.value || `\${${step.dataRef}}`;
+      const code = context.templateEngine.renderStep('contain-text-assertion', {
+        ...resolved,
+        expectedText,
+      });
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} contains "${step.value || step.dataRef}"`,
+      };
+    },
+    priority: 9,
+  },
+  {
+    name: 'should-have-text',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should have text') && !!step.selectorRef && !!(step.value || step.dataRef),
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      const expectedText = step.value || `\${${step.dataRef}}`;
+      const code = context.templateEngine.renderStep('have-text-assertion', {
+        ...resolved,
+        expectedText,
+      });
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} has text "${step.value || step.dataRef}"`,
+      };
+    },
+    priority: 10,
+  },
+  {
+    name: 'should-be-empty',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should be empty') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      const code = context.templateEngine.renderStep('empty-assertion', resolved);
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} is empty`,
+      };
+    },
+    priority: 8,
+  },
+  {
+    name: 'should-be-checked',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should be checked') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      const code = context.templateEngine.renderStep('checked-assertion', resolved);
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} is checked`,
+      };
+    },
+    priority: 8,
+  },
+  {
+    name: 'should-be-unchecked',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should be unchecked') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      const code = context.templateEngine.renderStep('not-checked-assertion', resolved);
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} is unchecked`,
+      };
+    },
+    priority: 8,
+  },
+  {
+    name: 'should-be-focused',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should be focused') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      const code = context.templateEngine.renderStep('focused-assertion', resolved);
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} is focused`,
+      };
+    },
+    priority: 7,
+  },
+  {
+    name: 'should-have-count',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('should have') && step.text.includes('count') && !!step.selectorRef,
+    generator: (step, context) => {
+      const match = step.text.match(/count\s+(\d+)/);
+      const expectedCount = match ? parseInt(match[1]) : 1;
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      const code = context.templateEngine.renderStep('count-assertion', {
+        ...resolved,
+        expectedCount,
+      });
+      return {
+        code,
+        comment: `Assert ${step.selectorRef} has count ${expectedCount}`,
+      };
+    },
+    priority: 8,
+  },
+];

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

@@ -0,0 +1,124 @@
+import { ParsedStep } from '../../gherkin-parser';
+import { StepPattern } 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[] = [
+  {
+    name: 'fill-input',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('fills') || step.text.includes('fill')) && !!step.selectorRef && !!(step.dataRef || step.value),
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      
+      // 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
+        fillValue: value,
+      });
+      
+      return {
+        code,
+        comment: `Fill ${step.selectorRef} with ${step.dataRef || step.value}`,
+      };
+    },
+    priority: 10,
+  },
+  {
+    name: 'check-checkbox',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('checks') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      
+      const code = context.templateEngine.renderStep('check-action', resolved);
+      
+      return {
+        code,
+        comment: `Check ${step.selectorRef}`,
+      };
+    },
+    priority: 8,
+  },
+  {
+    name: 'uncheck-checkbox',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('unchecks') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      
+      const code = context.templateEngine.renderStep('uncheck-action', resolved);
+      
+      return {
+        code,
+        comment: `Uncheck ${step.selectorRef}`,
+      };
+    },
+    priority: 8,
+  },
+  {
+    name: 'select-dropdown',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('selects') && !!step.selectorRef && !!(step.dataRef || step.value),
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      
+      // Resolve data reference to actual value
+      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 code = context.templateEngine.renderStep('select-action', {
+        ...resolved,
+        selectValue: value,
+      });
+      
+      return {
+        code,
+        comment: `Select ${step.dataRef || step.value} in ${step.selectorRef}`,
+      };
+    },
+    priority: 8,
+  },
+  {
+    name: 'clear-input',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('clears') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      
+      const code = context.templateEngine.renderStep('clear-action', resolved);
+      
+      return {
+        code,
+        comment: `Clear ${step.selectorRef}`,
+      };
+    },
+    priority: 7,
+  },
+];
+
+

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

@@ -0,0 +1,97 @@
+import { ParsedStep } from '../../gherkin-parser';
+import { MappedStep } from '../step-mapper';
+import { StepPattern, PatternContext } from './types';
+import { navigationPatterns } from './navigation-patterns';
+import { formPatterns } from './form-patterns';
+import { interactionPatterns } from './interaction-patterns';
+import { assertionPatterns } from './assertion-patterns';
+import { setupPatterns } from './setup-patterns';
+
+/**
+ * Pattern Registry - manages all step patterns
+ */
+export class PatternRegistry {
+  private patterns: StepPattern[] = [];
+
+  constructor() {
+    this.registerDefaultPatterns();
+  }
+
+  /**
+   * Register default patterns from all pattern modules
+   */
+  private registerDefaultPatterns(): void {
+    this.patterns.push(...setupPatterns);
+    this.patterns.push(...navigationPatterns);
+    this.patterns.push(...formPatterns);
+    this.patterns.push(...interactionPatterns);
+    this.patterns.push(...assertionPatterns);
+    
+    // Sort by priority (higher first)
+    this.patterns.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+  }
+
+  /**
+   * Register a custom pattern
+   */
+  registerPattern(pattern: StepPattern): void {
+    this.patterns.push(pattern);
+    this.patterns.sort((a, b) => (b.priority || 0) - (a.priority || 0));
+  }
+
+  /**
+   * Find matching pattern for a step
+   */
+  findPattern(step: ParsedStep): StepPattern | null {
+    for (const pattern of this.patterns) {
+      if (this.matchesPattern(step, pattern.matcher)) {
+        return pattern;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Generate code for a step using matched pattern
+   */
+  generateStep(step: ParsedStep, context: PatternContext): MappedStep | null {
+    const pattern = this.findPattern(step);
+    if (!pattern) {
+      return null;
+    }
+    
+    return pattern.generator(step, context);
+  }
+
+  /**
+   * Check if step matches a pattern matcher
+   */
+  private matchesPattern(step: ParsedStep, matcher: StepPattern['matcher']): boolean {
+    if (matcher instanceof RegExp) {
+      return matcher.test(step.text);
+    }
+    return matcher(step);
+  }
+
+  /**
+   * Get all registered patterns
+   */
+  getPatterns(): StepPattern[] {
+    return [...this.patterns];
+  }
+
+  /**
+   * Get pattern count
+   */
+  getPatternCount(): number {
+    return this.patterns.length;
+  }
+}
+
+// Export pattern modules for advanced usage
+export { setupPatterns } from './setup-patterns';
+export { navigationPatterns } from './navigation-patterns';
+export { formPatterns } from './form-patterns';
+export { interactionPatterns } from './interaction-patterns';
+export { assertionPatterns } from './assertion-patterns';
+export * from './types';

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

@@ -0,0 +1,119 @@
+import { ParsedStep } from '../../gherkin-parser';
+import { StepPattern } from './types';
+
+/**
+ * Interaction patterns: click, hover, press, wait
+ * Uses template engine for framework-agnostic code generation
+ */
+export const interactionPatterns: StepPattern[] = [
+  {
+    name: 'click-element',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('clicks') || step.text.includes('click')) && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      
+      const code = context.templateEngine.renderStep('click-action', resolved);
+      
+      return {
+        code,
+        comment: `Click ${step.selectorRef}`,
+      };
+    },
+    priority: 10,
+  },
+  {
+    name: 'double-click',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('double') && step.text.includes('clicks') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      
+      const code = context.templateEngine.renderStep('double-click-action', resolved);
+      
+      return {
+        code,
+        comment: `Double click ${step.selectorRef}`,
+      };
+    },
+    priority: 11,
+  },
+  {
+    name: 'hover-element',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('hovers') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      
+      const code = context.templateEngine.renderStep('hover-action', resolved);
+      
+      return {
+        code,
+        comment: `Hover ${step.selectorRef}`,
+      };
+    },
+    priority: 8,
+  },
+  {
+    name: 'press-enter',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('presses') && step.text.includes('Enter') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      
+      const code = context.templateEngine.renderStep('press-action', {
+        ...resolved,
+        key: 'Enter',
+      });
+      
+      return {
+        code,
+        comment: `Press Enter in ${step.selectorRef}`,
+      };
+    },
+    priority: 9,
+  },
+  {
+    name: 'wait-for-time',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('waits for') && /\d+/.test(step.text),
+    generator: (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,
+        comment: `Wait for ${duration}ms`,
+      };
+    },
+    priority: 7,
+  },
+  {
+    name: 'wait-for-element',
+    matcher: (step: ParsedStep) =>
+      step.text.includes('waits for') && !!step.selectorRef,
+    generator: (step, context) => {
+      const resolved = context.selectorResolver.resolveSelector(step.selectorRef!);
+      
+      const code = context.templateEngine.renderStep('wait-for-element', {
+        ...resolved,
+        state: 'visible',
+      });
+      
+      return {
+        code,
+        comment: `Wait for ${step.selectorRef}`,
+      };
+    },
+    priority: 8,
+  },
+];
+

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

@@ -0,0 +1,110 @@
+import { ParsedStep } from '../../gherkin-parser';
+import { StepPattern } from './types';
+import { inferPath, resolvePathVariables, getPathCode } from '../utils/path-inference';
+
+/**
+ * Navigation patterns: goto, navigate, open page
+ * Uses baseURL from config (optional) + path from feature metadata
+ * Templates handle URL construction
+ */
+export const navigationPatterns: StepPattern[] = [
+  {
+    name: 'open-page',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('open') || step.text.includes('opens')) &&
+      (step.text.includes('page') || !!step.selectorRef),
+    generator: (step, context) => {
+      // Extract page/screen reference
+      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,
+        comment: `Open ${pageName}`,
+      };
+    },
+    priority: 15,
+  },
+  {
+    name: 'navigate-to-route',
+    matcher: (step: ParsedStep) => 
+      (step.text.includes('navigates to') || step.text.includes('is on')) && 
+      !!(step.selectorRef || step.dataRef),
+    generator: (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,
+        comment: `Navigate to ${route}`,
+      };
+    },
+    priority: 10,
+  },
+  {
+    name: 'route-assertion',
+    matcher: (step: ParsedStep) =>
+      (step.text.includes('should see route') || step.text.includes('should remain on')) &&
+      !!(step.selectorRef || step.dataRef),
+    generator: (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,
+        comment: `Assert current route is ${route}`,
+      };
+    },
+    priority: 10,
+  },
+];
+