@sun-asterisk/sungen 1.0.0

package/src/generators/test-generator/utils/path-inference.ts

@@ -0,0 +1,344 @@
+/**
+ * Path Inference Utility
+ * Intelligently infers navigation paths when not explicitly provided
+ * Supports dynamic path variables from scenario context
+ */
+
+import { ParsedStep, ParsedScenario } from '../../gherkin-parser';
+
+export interface PathInferenceContext {
+  featureName?: string;      // e.g., 'sign-in', 'user-profile'
+  screenName?: string;        // e.g., 'sign-in', 'product-detail'
+  scenario?: ParsedScenario;  // Current scenario for context
+  allSteps?: ParsedStep[];    // All steps in scenario for data extraction
+}
+
+/**
+ * Infer navigation path with smart defaults and variable interpolation
+ * 
+ * Priority:
+ * 1. Explicit featurePath (from feature metadata)
+ * 2. Inferred from screen/feature name
+ * 3. Extract from step context (e.g., path variables)
+ * 
+ * @param explicitPath - Path from feature metadata (e.g., '/login', '/user/:id')
+ * @param context - Context for inference
+ * @returns Inferred path or '/' as last resort
+ */
+export function inferPath(
+  explicitPath: string | undefined,
+  context: PathInferenceContext = {}
+): string {
+  // 1. Use explicit path if provided
+  if (explicitPath && explicitPath.trim() !== '') {
+    return explicitPath;
+  }
+
+  // 2. Infer from screen name (preferred)
+  if (context.screenName) {
+    return screenNameToPath(context.screenName);
+  }
+
+  // 3. Infer from feature name
+  if (context.featureName) {
+    return featureNameToPath(context.featureName);
+  }
+
+  // 4. Last resort: root path
+  return '/';
+}
+
+/**
+ * Convert screen name to path
+ * Examples:
+ *   'sign-in' -> '/sign-in'
+ *   'user-profile' -> '/user-profile'
+ *   'product-detail' -> '/product-detail'
+ *   'home' -> '/'
+ */
+function screenNameToPath(screenName: string): string {
+  const normalized = screenName.trim().toLowerCase();
+  
+  // Special cases
+  if (normalized === 'home' || normalized === 'index' || normalized === 'root') {
+    return '/';
+  }
+
+  // Convert screen name to path
+  return `/${normalized}`;
+}
+
+/**
+ * Convert feature name to path
+ * Examples:
+ *   'login' -> '/login'
+ *   'sign-in-valid' -> '/sign-in'
+ *   'user-authentication-login' -> '/login'
+ */
+function featureNameToPath(featureName: string): string {
+  const normalized = featureName.trim().toLowerCase();
+  
+  // Special cases
+  if (normalized === 'home' || normalized === 'index' || normalized === 'root') {
+    return '/';
+  }
+
+  // Remove common suffixes (-valid, -invalid, -test, etc.)
+  const cleaned = normalized
+    .replace(/-(valid|invalid|test|spec|feature)$/, '')
+    .replace(/\.feature$/, '');
+
+  // Take the last meaningful part if hyphenated
+  // e.g., 'user-authentication-login' -> 'login'
+  const parts = cleaned.split('-');
+  const relevantPart = parts.length > 2 ? parts[parts.length - 1] : cleaned;
+
+  return `/${relevantPart}`;
+}
+
+/**
+ * Resolve path with variable interpolation
+ * Supports dynamic path parameters from scenario context
+ * 
+ * Examples:
+ *   '/user/:id' + steps with {{user.id}} -> '/user/${user.id}'
+ *   '/user/$id' + steps with {{user.id}} -> '/user/${user.id}'
+ *   '/product/:productId' + steps with {{product.id}} -> '/product/${product.id}'
+ * 
+ * @param pathTemplate - Path with variables (e.g., '/user/:id', '/user/$id')
+ * @param steps - Scenario steps to extract data references from
+ * @returns Path with template literal syntax for runtime interpolation
+ */
+export function resolvePathVariables(
+  pathTemplate: string,
+  steps: ParsedStep[]
+): string {
+  // No variables to resolve
+  if (!pathTemplate.includes(':') && !pathTemplate.includes('$')) {
+    return pathTemplate;
+  }
+
+  // Extract data references from Given steps
+  const dataContext = extractDataFromSteps(steps);
+
+  // Split path by segments to handle each variable contextually
+  const segments = pathTemplate.split('/');
+  const resolvedSegments = segments.map(segment => {
+    // Check if segment is a variable
+    const varMatch = segment.match(/^[:$](\w+)$/);
+    if (!varMatch) {
+      return segment; // Not a variable, keep as-is
+    }
+
+    const variableName = varMatch[1]; // 'id', 'userId', 'postId', etc.
+    
+    // Try to find matching data reference with context from path
+    let dataRef = findDataRefWithContext(variableName, dataContext, pathTemplate);
+
+    if (dataRef) {
+      // Convert to template literal: {{user.id}} -> ${user.id}
+      const cleanRef = dataRef.replace(/\{\{|\}\}/g, '');
+      return `\${${cleanRef}}`;
+    } else {
+      // No matching data found - use variable name as-is
+      return `\${${variableName}}`;
+    }
+  });
+
+  return resolvedSegments.join('/');
+}
+
+/**
+ * Find data reference with path context
+ * Uses path structure to guide matching (e.g., /user/:id should prefer user.id)
+ */
+function findDataRefWithContext(
+  variableName: string,
+  dataContext: Record<string, string>,
+  pathTemplate: string
+): string | null {
+  const normalized = variableName.toLowerCase();
+
+  // 1. Exact match
+  if (dataContext[normalized]) {
+    return dataContext[normalized];
+  }
+
+  // 2. Try to infer context from path
+  // e.g., if path is /user/:id, prefer user.id over post.id
+  const pathSegments = pathTemplate.split('/');
+  const varIndex = pathSegments.findIndex(s => s === `:${variableName}` || s === `$${variableName}`);
+  
+  if (varIndex > 0) {
+    const contextSegment = pathSegments[varIndex - 1]; // segment before variable
+    // Try to match with context prefix
+    const contextKey = `${contextSegment}.${normalized}`;
+    if (dataContext[contextKey]) {
+      return dataContext[contextKey];
+    }
+  }
+
+  // 3. Match by suffix (e.g., 'userId' matches 'user.id', 'postId' matches 'post.id')
+  for (const [key, value] of Object.entries(dataContext)) {
+    if (key.includes('.')) {
+      const parts = key.split('.');
+      const lastPart = parts[parts.length - 1].toLowerCase();
+      // Also check camelCase variations: 'postId' contains 'post'
+      const keyNormalized = key.toLowerCase().replace(/[._-]/g, '');
+      if (lastPart === normalized || normalized.endsWith(lastPart)) {
+        return value;
+      }
+    }
+  }
+
+  // 4. Match by containing prefix (e.g., 'postId' should match 'post.id')
+  // Be careful to match the correct prefix
+  if (normalized.length > 2) {
+    for (const [key, value] of Object.entries(dataContext)) {
+      if (key.includes('.')) {
+        const keyPrefix = key.split('.')[0].toLowerCase();
+        // Check if variable name starts with the prefix (e.g., 'postId' starts with 'post')
+        // AND the variable name is similar enough (not just any 'id')
+        if (normalized.startsWith(keyPrefix) && normalized.length <= keyPrefix.length + 3) {
+          return value;
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Extract data references from scenario steps
+ * Looks for patterns like:
+ *   - "User have id {{user.id}}"
+ *   - "Given user id is {{userId}}"
+ *   - "And product id is {{product.id}}"
+ */
+function extractDataFromSteps(steps: ParsedStep[]): Record<string, string> {
+  const dataContext: Record<string, string> = {};
+
+  for (const step of steps) {
+    // Only process Given steps (setup steps)
+    if (step.keyword.trim() !== 'Given' && step.keyword.trim() !== 'And') {
+      continue;
+    }
+
+    // Extract data references: {{dataRef}}
+    const dataRefPattern = /\{\{([^}]+)\}\}/g;
+    const matches = [...step.text.matchAll(dataRefPattern)];
+
+    for (const match of matches) {
+      const dataRef = match[1].trim();
+
+      // Store full reference (most important)
+      dataContext[dataRef] = `{{${dataRef}}}`;
+
+      // Also store by the last part of dotted reference (but only if not too generic)
+      const parts = dataRef.split('.');
+      if (parts.length > 1) {
+        const lastPart = parts[parts.length - 1]; // 'user.id' -> 'id'
+        // Only store if last part is not super generic OR if it doesn't already exist
+        if (lastPart.length > 2 && !dataContext[lastPart]) {
+          dataContext[lastPart] = `{{${dataRef}}}`;
+        }
+      }
+
+      // Try to extract the variable name from context
+      // "User have id {{user.id}}" -> extract "id" -> "{{user.id}}"
+      const contextMatch = step.text.match(/(\w+)\s+(?:is|have|has)\s+\{\{/i);
+      if (contextMatch) {
+        const varName = contextMatch[1].toLowerCase();
+        // Only if unique enough
+        if (varName.length > 2 && !dataContext[varName]) {
+          dataContext[varName] = `{{${dataRef}}}`;
+        }
+      }
+    }
+
+    // Also check for direct dataRef property
+    if (step.dataRef) {
+      const parts = step.dataRef.split('.');
+      dataContext[step.dataRef] = `{{${step.dataRef}}}`;
+      
+      // Store last part only if unique
+      if (parts.length > 1) {
+        const lastPart = parts[parts.length - 1];
+        if (lastPart.length > 2 && !dataContext[lastPart]) {
+          dataContext[lastPart] = `{{${step.dataRef}}}`;
+        }
+      }
+    }
+  }
+
+  return dataContext;
+}
+
+/**
+ * Find data reference for a variable name
+ * Tries multiple strategies: exact match, suffix match, prefix match
+ */
+function findDataRef(
+  variableName: string,
+  dataContext: Record<string, string>
+): string | null {
+  const normalized = variableName.toLowerCase();
+
+  // 1. Exact match
+  if (dataContext[normalized]) {
+    return dataContext[normalized];
+  }
+
+  // 2. Match by exact key (case-insensitive)
+  for (const [key, value] of Object.entries(dataContext)) {
+    if (key.toLowerCase() === normalized) {
+      return value;
+    }
+  }
+
+  // 3. Match by suffix (e.g., 'userId' matches 'user.id', 'postId' matches 'post.id')
+  // Must match the last part after dot
+  for (const [key, value] of Object.entries(dataContext)) {
+    if (key.includes('.')) {
+      const parts = key.split('.');
+      const lastPart = parts[parts.length - 1].toLowerCase();
+      if (lastPart === normalized) {
+        return value;
+      }
+    }
+  }
+
+  // 4. Match by partial (e.g., 'id' could match first occurrence)
+  // Only if normalized is not too generic
+  if (normalized.length > 2) {
+    for (const [key, value] of Object.entries(dataContext)) {
+      const keyLower = key.toLowerCase();
+      if (keyLower.includes(normalized) || normalized.includes(keyLower)) {
+        return value;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if path contains variables that need interpolation
+ */
+export function hasPathVariables(path: string): boolean {
+  return path.includes(':') || path.includes('$') || path.includes('{{');
+}
+
+/**
+ * Get path code for template rendering
+ * Returns appropriate format based on whether variables exist
+ */
+export function getPathCode(path: string): string {
+  if (hasPathVariables(path) && path.includes('${')) {
+    // Template literal with variables
+    return `\`${path}\``;
+  }
+  // Static string
+  return `'${path}'`;
+}