@sun-asterisk/sungen 1.0.6 → 1.0.7

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

@@ -75,10 +75,12 @@ export const formPatterns: StepPattern[] = [
   {
     name: 'select-dropdown',
     matcher: (step: ParsedStep) =>
-      step.text.includes('selects') && !!step.selectorRef && !!(step.dataRef || step.value),
+      (step.text.includes('selects') || step.text.match(/\bselect\b/)) &&
+      !!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) {
@@ -90,12 +92,29 @@ export const formPatterns: StepPattern[] = [
       } else {
         value = step.value!;
       }
-      
-      const code = context.templateEngine.renderStep('select-action', {
-        ...resolved,
-        selectValue: value,
-      });
-      
+
+      // Determine action based on role type
+      // Radio buttons use check(), dropdowns use selectOption()
+      const isRadio = resolved.role === 'radio' || step.text.includes('radio');
+      const isCheckbox = resolved.role === 'checkbox' || step.text.includes('checkbox');
+
+      let code: string;
+      if (isRadio) {
+        // For radio buttons, we need to find the specific radio with the value
+        code = context.templateEngine.renderStep('radio-select-action', {
+          ...resolved,
+          selectValue: value,
+        });
+      } else if (isCheckbox) {
+        code = context.templateEngine.renderStep('check-action', resolved);
+      } else {
+        // Default to dropdown/combobox selectOption
+        code = context.templateEngine.renderStep('select-action', {
+          ...resolved,
+          selectValue: value,
+        });
+      }
+
       return {
         code,
         comment: `Select ${step.dataRef || step.value} in ${step.selectorRef}`,

package/src/generators/test-generator/templates/auth-setup.ts.hbs

@@ -0,0 +1,36 @@
+import { test as setup, expect } from '@playwright/test';
+
+/**
+ * Authentication Setup
+ * 
+ * This file creates authenticated browser contexts for your tests.
+ * Update the TODOs with your application's actual login flow.
+ * 
+ * Generated roles: {{#each roles}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}
+ */
+
+const authFile = (role: string) => `specs/.auth/${role}.json`;
+
+{{#each roles}}
+setup('authenticate as {{this}}', async ({ page }) => {
+  // TODO: Navigate to your login page
+  await page.goto('/login');
+
+  // TODO: Fill in credentials for {{this}} role
+  // Update these selectors to match your application
+  await page.getByLabel('Email').fill('{{this}}@example.com');
+  await page.getByLabel('Password').fill('{{this}}123');
+  
+  // TODO: Click login button
+  await page.getByRole('button', { name: 'Sign in' }).click();
+
+  // TODO: Wait for authentication to complete
+  // Update this to match your post-login URL or element
+  await page.waitForURL('/dashboard');
+
+  // Save authentication state
+  await page.context().storageState({ path: authFile('{{this}}') });
+});
+
+{{/each}}
+// TODO: Add more roles as needed by adding @auth:{role} tags to your features

package/src/input/cli-adapter.ts

@@ -36,7 +36,7 @@ export class CLIAdapter implements InputAdapter {
     program
       .name('sungen')
       .description('AI-Native E2E Test Generator - Generate Playwright tests from Gherkin features')
-      .version('1.0.6');
+      .version('1.0.7');
 
     // Global options
     program
@@ -81,6 +81,7 @@ export class CLIAdapter implements InputAdapter {
       .command('map')
       .description('Generate selector and test-data YAML from Gherkin feature files')
       .option('-s, --screen <name>', 'Screen name (reads from qa/screens/<name>/features/)')
+      .option('--file <path>', 'Single feature file path (generates selectors next to features folder)')
       .option('-o, --output <dir>', 'Output directory for generated files')
       .option('-f, --force', 'Force overwrite existing YAML files')
       .option('-v, --verbose', 'Detailed output');
@@ -169,6 +170,25 @@ export class CLIAdapter implements InputAdapter {
       .option('-v, --verbose', 'Show all checks, not just failures');
   }
 
+  /**
+   * Add makeauth command - Generate auth state for E2E tests
+   */
+  addMakeAuthCommand(program: Command): Command {
+    return program
+      .command('makeauth <name>')
+      .description('Generate auth state by opening browser for manual SSO login')
+      .option('-u, --url <url>', 'Base URL of the application')
+      .option('-p, --path <path>', 'Login page path (default: /login)')
+      .option('-o, --output <dir>', 'Output directory (default: specs/.auth)')
+      .option('-t, --timeout <ms>', 'Overall timeout in milliseconds (default: 180000)')
+      .option('--nav-timeout <ms>', 'Navigation timeout in milliseconds (default: 180000)')
+      .option('--stability-wait <ms>', 'URL stability wait in milliseconds (default: 5000)')
+      .option('--headless', 'Run browser in headless mode')
+      .option('--verify', 'Verify existing auth state instead of creating new')
+      .option('--list', 'List all existing auth states')
+      .option('--export', 'Export auth state as base64 for CI');
+  }
+
   /**
    * Extract options from commander Command
    */

package/src/orchestrator/pipeline.ts

@@ -367,11 +367,12 @@ export class Pipeline {
       : this.findAllFeatureFiles();
     
     if (screenName && featureFiles.length === 0) {
-      console.error(`No feature files found for screen: ${screenName}`);
-      console.error(`Looked in:`);
-      console.error(`  - qa/screens/${screenName}/features/`);
-      console.error(`  - qa/features/${screenName}.feature`);
-      process.exit(1);
+      throw new Error(
+        `No feature files found for screen: ${screenName}\n` +
+        `Looked in:\n` +
+        `  - qa/screens/${screenName}/features/\n` +
+        `  - qa/features/${screenName}.feature`
+      );
     }
 
     // Parse features
@@ -385,34 +386,48 @@ export class Pipeline {
       const missing = validation.filter(v => !v.selectorExists);
       
       if (missing.length > 0) {
-        console.log(`\nMissing selector files:\n`);
-        missing.forEach(v => {
-          console.log(`  ✗ ${v.featureName}.feature → selector file not found`);
-        });
-        console.log(`\nRun: sungen map --screen ${screenName}\n`);
-        process.exit(1);
+        const missingList = missing.map(v => `  ✗ ${v.featureName}.feature → selector file not found`).join('\n');
+        throw new Error(
+          `Missing selector files:\n${missingList}\n\n` +
+          `Run: sungen map --screen ${screenName}`
+        );
       }
     }
 
     // Generate tests
     const generator = TestGeneratorFactory.create(this.config.testGenerator.framework, this.config);
     const results: GeneratedTest[] = [];
+    const errors: Array<{ feature: string; error: any }> = [];
 
     for (const feature of features) {
-      // Load selectors and test data
-      const selectors = {}; // TODO: Load from selector files
-      const testData = {};  // TODO: Load from test-data files
-
-      const result = await generator.generate(feature, selectors, testData, this.config);
-      results.push(result);
+      try {
+        // Load selectors and test data
+        const selectors = {}; // TODO: Load from selector files
+        const testData = {};  // TODO: Load from test-data files
+
+        const result = await generator.generate(feature, selectors, testData, this.config);
+        results.push(result);
+
+        // Display per-file result
+        const fileName = path.basename(result.outputPath);
+        const relativePath = path.relative(process.cwd(), result.outputPath);
+        const stepInfo = result.stats?.totalSteps ? ` (${result.stats.totalSteps} steps)` : '';
+        
+        console.log(`✓ Generated ${fileName}`);
+        console.log(`   → ${relativePath}${stepInfo}\n`);
+      } catch (error) {
+        const featureName = typeof feature === 'object' && feature.name ? feature.name : 'unknown';
+        console.error(`✗ Failed to generate test for feature: ${featureName}`);
+        errors.push({ feature: featureName, error });
+      }
+    }
 
-      // Display per-file result
-      const fileName = path.basename(result.outputPath);
-      const relativePath = path.relative(process.cwd(), result.outputPath);
-      const stepInfo = result.stats?.totalSteps ? ` (${result.stats.totalSteps} steps)` : '';
-      
-      console.log(`✓ Generated ${fileName}`);
-      console.log(`   → ${relativePath}${stepInfo}\n`);
+    // Throw if any errors occurred
+    if (errors.length > 0) {
+      const errorList = errors.map(e => `  - ${e.feature}`).join('\n');
+      throw new Error(
+        `Failed to generate ${errors.length} test(s):\n${errorList}`
+      );
     }
 
     // Generate report

package/src/tools/auth-maker.ts

@@ -0,0 +1,467 @@
+/**
+ * Auth Maker - Generate authentication state for E2E tests
+ *
+ * Usage: sungen makeauth <name>
+ * Example: sungen makeauth admin -> generates specs/.auth/admin.json
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { chromium, Browser, BrowserContext } from '@playwright/test';
+
+/**
+ * Extract baseURL from playwright.config.ts
+ * Returns { url, source } or null
+ */
+function getPlaywrightBaseURL(configPath?: string): { url: string; source: string } | null {
+  const possiblePaths = configPath
+    ? [configPath]
+    : [
+        path.join(process.cwd(), 'playwright.config.ts'),
+        path.join(process.cwd(), 'playwright.config.js'),
+      ];
+
+  for (const configFile of possiblePaths) {
+    if (fs.existsSync(configFile)) {
+      try {
+        const content = fs.readFileSync(configFile, 'utf-8');
+
+        // Match baseURL in use: { baseURL: '...' } or baseURL: '...'
+        const patterns = [
+          /baseURL:\s*['"]([^'"]+)['"]/,
+          /baseURL:\s*`([^`]+)`/,
+        ];
+
+        for (const pattern of patterns) {
+          const match = content.match(pattern);
+          if (match) {
+            return {
+              url: match[1],
+              source: path.basename(configFile),
+            };
+          }
+        }
+      } catch {
+        // Ignore read errors
+      }
+    }
+  }
+
+  return null;
+}
+
+export interface AuthMakerOptions {
+  name: string;
+  baseURL?: string;
+  loginPath?: string;
+  outputDir?: string;
+  timeout?: number;
+  navigationTimeout?: number;
+  stabilityWait?: number;
+  headless?: boolean;
+  successSelector?: string;
+}
+
+export interface AuthMakerConfig {
+  baseURL: string;
+  loginPath: string;
+  outputDir: string;
+  timeout: number;
+  navigationTimeout: number;
+  stabilityWait: number;
+  successSelector?: string;
+}
+
+export class AuthMaker {
+  private config: AuthMakerConfig;
+  private activeReadline: readline.Interface | null = null;
+
+  constructor(config: Partial<AuthMakerConfig> = {}) {
+    // Priority: config > playwright.config.ts > env > default
+    const playwrightConfig = getPlaywrightBaseURL();
+
+    this.config = {
+      baseURL: config.baseURL || playwrightConfig?.url || process.env.APP_BASE_URL || 'http://localhost:3000',
+      loginPath: config.loginPath || '/login',
+      outputDir: config.outputDir || 'specs/.auth',
+      timeout: config.timeout || 180000, // 3 minutes for overall timeout
+      navigationTimeout: config.navigationTimeout || 180000, // 3 minutes for page navigation
+      stabilityWait: config.stabilityWait || 5000, // 5 seconds for URL stability check
+      successSelector: config.successSelector,
+    };
+
+    // Store source for display
+    if (!config.baseURL && playwrightConfig) {
+      this.baseURLSource = playwrightConfig.source;
+    } else if (!config.baseURL && process.env.APP_BASE_URL) {
+      this.baseURLSource = 'APP_BASE_URL env';
+    } else if (config.baseURL) {
+      this.baseURLSource = 'config';
+    } else {
+      this.baseURLSource = 'default';
+    }
+  }
+
+  private baseURLSource: string = 'default';
+
+  /**
+   * Generate auth state by opening browser for manual login
+   */
+  async makeAuth(options: AuthMakerOptions): Promise<string> {
+    const { name, headless = false } = options;
+
+    // Merge options with config
+    const baseURL = options.baseURL || this.config.baseURL;
+    const loginPath = options.loginPath || this.config.loginPath;
+    const outputDir = options.outputDir || this.config.outputDir;
+    const timeout = options.timeout || this.config.timeout;
+    const navigationTimeout = options.navigationTimeout || this.config.navigationTimeout;
+    const stabilityWait = options.stabilityWait || this.config.stabilityWait;
+    const successSelector = options.successSelector || this.config.successSelector;
+
+    const loginURL = `${baseURL}${loginPath}`;
+    const authFile = path.join(outputDir, `${name}.json`);
+
+    console.log('');
+    console.log('========================================');
+    console.log(`  Auth Maker: ${name}`);
+    console.log('========================================');
+    console.log('');
+    console.log(`  Base URL: ${baseURL} (from ${this.baseURLSource})`);
+    console.log(`  Login URL: ${loginURL}`);
+    console.log(`  Output: ${authFile}`);
+    console.log('');
+
+    // Create output directory
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    // Check if auth file already exists
+    if (fs.existsSync(authFile)) {
+      const overwrite = await this.askQuestion(
+        `⚠️  File ${authFile} already exists. Overwrite? (y/N): `
+      );
+      if (overwrite.toLowerCase() !== 'y') {
+        console.log('Cancelled.');
+        return authFile;
+      }
+    }
+
+    let browser: Browser | null = null;
+    let context: BrowserContext | null = null;
+
+    try {
+      console.log('🚀 Opening browser...');
+
+      browser = await chromium.launch({
+        headless,
+        slowMo: 50,
+        args: ['--start-maximized'],
+      });
+
+      context = await browser.newContext({
+        viewport: { width: 1280, height: 800 },
+      });
+
+      const page = await context.newPage();
+
+      // Navigate to login page
+      console.log(`📍 Navigating to ${loginURL}...`);
+      await page.goto(loginURL, { timeout: navigationTimeout });
+      await page.waitForLoadState('domcontentloaded');
+
+      // Check if already logged in (URL changed)
+      const currentURL = page.url();
+      if (!currentURL.includes(loginPath)) {
+        console.log('');
+        console.log('✅ Already logged in!');
+        await this.saveAuthState(context, authFile);
+        return authFile;
+      }
+
+      console.log('');
+      console.log('========================================');
+      console.log('  MANUAL LOGIN REQUIRED');
+      console.log('========================================');
+      console.log('');
+      console.log('  1. Login in the browser window');
+      console.log('  2. Complete any 2FA if required');
+      console.log('  3. Browser will auto-close when redirected back');
+      console.log('  (Or press ENTER to save manually)');
+      console.log('');
+      console.log(`  Timeout: ${Math.round(timeout / 60000)} minutes`);
+      console.log('========================================');
+      console.log('');
+
+      // Wait for callback to baseURL OR user press Enter
+      const callbackPromise = this.waitForCallback(page, baseURL, loginPath, timeout, stabilityWait);
+      const enterPromise = this.waitForEnter();
+
+      await Promise.race([callbackPromise, enterPromise]);
+
+      // Cancel readline if callback was detected (so process can exit)
+      this.cancelWaitForEnter();
+
+      // Verify login was successful
+      const finalURL = page.url();
+      if (finalURL.includes(loginPath)) {
+        console.log('');
+        console.log('⚠️  Still on login page. Saving state anyway...');
+      }
+
+      // Save auth state
+      await this.saveAuthState(context, authFile);
+
+      return authFile;
+    } catch (error: any) {
+      console.error('');
+      console.error('❌ Error:', error.message);
+      throw error;
+    } finally {
+      if (context) await context.close();
+      if (browser) await browser.close();
+    }
+  }
+
+  /**
+   * Detect SSO provider from URL
+   */
+  private detectSSOProvider(url: string): string {
+    const providers: { pattern: RegExp; name: string; icon: string }[] = [
+      { pattern: /accounts\.google\.com|googleapis\.com/i, name: 'Google', icon: '🔵' },
+      { pattern: /facebook\.com|fb\.com/i, name: 'Facebook', icon: '🔷' },
+      { pattern: /github\.com/i, name: 'GitHub', icon: '⚫' },
+      { pattern: /login\.microsoftonline\.com|login\.live\.com|microsoft\.com/i, name: 'Microsoft', icon: '🟦' },
+      { pattern: /appleid\.apple\.com/i, name: 'Apple', icon: '🍎' },
+      { pattern: /twitter\.com|x\.com/i, name: 'X (Twitter)', icon: '🐦' },
+      { pattern: /linkedin\.com/i, name: 'LinkedIn', icon: '🔗' },
+      { pattern: /\.okta\.com/i, name: 'Okta', icon: '🔐' },
+      { pattern: /\.auth0\.com/i, name: 'Auth0', icon: '🔑' },
+      { pattern: /gitlab\.com/i, name: 'GitLab', icon: '🦊' },
+      { pattern: /bitbucket\.org|atlassian\.com/i, name: 'Atlassian', icon: '🔹' },
+      { pattern: /slack\.com/i, name: 'Slack', icon: '💬' },
+      { pattern: /discord\.com/i, name: 'Discord', icon: '🎮' },
+      { pattern: /amazon\.com|amazoncognito\.com/i, name: 'Amazon', icon: '📦' },
+      { pattern: /yahoo\.com/i, name: 'Yahoo', icon: '🟣' },
+    ];
+
+    for (const provider of providers) {
+      if (provider.pattern.test(url)) {
+        return `${provider.icon} ${provider.name}`;
+      }
+    }
+
+    // Try to extract domain name for unknown providers
+    try {
+      const domain = new URL(url).hostname;
+      return `🔐 ${domain}`;
+    } catch {
+      return '🔐 Unknown SSO';
+    }
+  }
+
+  /**
+   * Wait for callback to app URL after SSO login
+   * Flow: Wait for user to leave baseURL (click SSO) -> Wait for return to baseURL (not login page)
+   */
+  private async waitForCallback(
+    page: any,
+    baseURL: string,
+    loginPath: string,
+    timeout: number = 180000,
+    stabilityWait: number = 5000
+  ): Promise<void> {
+    const startTime = Date.now();
+    const checkInterval = 1000; // Check every 1 second
+    let hasLeftBaseURL = false;
+    let detectedProvider = '';
+    let callbackDetectedAt = 0;
+    let lastCallbackURL = '';
+
+    console.log('⏳ Waiting for SSO redirect...');
+    console.log('   Supported: Google, Facebook, GitHub, Microsoft, Apple, Twitter, LinkedIn, Okta, Auth0, GitLab, Slack, Discord, and more...');
+
+    while (Date.now() - startTime < timeout) {
+      const currentURL = page.url();
+
+      // Phase 1: Wait for user to click SSO and leave baseURL
+      if (!hasLeftBaseURL) {
+        if (!currentURL.startsWith(baseURL)) {
+          hasLeftBaseURL = true;
+          detectedProvider = this.detectSSOProvider(currentURL);
+          console.log(`🔄 ${detectedProvider} SSO detected, waiting for callback...`);
+        }
+        await page.waitForTimeout(checkInterval);
+        continue;
+      }
+
+      // Phase 2: Wait for callback to baseURL (not login page)
+      const isCallback = currentURL.startsWith(baseURL) && !currentURL.includes(loginPath);
+
+      if (isCallback) {
+        // First time detecting callback - start stability timer
+        if (callbackDetectedAt === 0 || lastCallbackURL !== currentURL) {
+          callbackDetectedAt = Date.now();
+          lastCallbackURL = currentURL;
+          console.log('🔍 Callback detected, verifying login...');
+        }
+
+        // Check if URL has been stable for stabilityWait duration
+        if (Date.now() - callbackDetectedAt >= stabilityWait) {
+          console.log('');
+          console.log(`✅ ${detectedProvider} login successful!`);
+          return;
+        }
+      } else {
+        // Reset if URL changed back (e.g., redirects during auth)
+        if (callbackDetectedAt > 0) {
+          console.log('🔄 Redirect detected, continuing to wait...');
+        }
+        callbackDetectedAt = 0;
+        lastCallbackURL = '';
+      }
+
+      await page.waitForTimeout(checkInterval);
+    }
+
+    throw new Error('Timeout waiting for login callback');
+  }
+
+  /**
+   * Wait for user to press Enter (cancellable)
+   */
+  private waitForEnter(): Promise<void> {
+    return new Promise((resolve) => {
+      this.activeReadline = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      this.activeReadline.question('', () => {
+        this.activeReadline?.close();
+        this.activeReadline = null;
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Cancel waiting for Enter (close readline interface)
+   */
+  private cancelWaitForEnter(): void {
+    if (this.activeReadline) {
+      this.activeReadline.close();
+      this.activeReadline = null;
+    }
+  }
+
+  /**
+   * Save browser auth state to file
+   */
+  private async saveAuthState(context: BrowserContext, authFile: string): Promise<void> {
+    console.log('💾 Saving auth state...');
+
+    await context.storageState({ path: authFile });
+
+    console.log('');
+    console.log('========================================');
+    console.log('  ✅ AUTH STATE SAVED!');
+    console.log('========================================');
+    console.log('');
+    console.log(`  File: ${authFile}`);
+    console.log('');
+    console.log('  Usage in Playwright:');
+    console.log(`    storageState: '${authFile}'`);
+    console.log('');
+  }
+
+  /**
+   * Ask user a question
+   */
+  private askQuestion(question: string): Promise<string> {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+
+  /**
+   * Verify auth state is valid
+   */
+  async verifyAuth(name: string): Promise<boolean> {
+    const authFile = path.join(this.config.outputDir, `${name}.json`);
+
+    if (!fs.existsSync(authFile)) {
+      console.log(`❌ Auth file not found: ${authFile}`);
+      return false;
+    }
+
+    console.log(`🔍 Verifying auth state: ${name}...`);
+
+    const browser = await chromium.launch({ headless: true });
+
+    try {
+      const context = await browser.newContext({
+        storageState: authFile,
+      });
+
+      const page = await context.newPage();
+      await page.goto(this.config.baseURL);
+      await page.waitForLoadState('networkidle');
+
+      const currentURL = page.url();
+      const isLoggedIn = !currentURL.includes(this.config.loginPath);
+
+      if (isLoggedIn) {
+        console.log('✅ Auth state is valid');
+      } else {
+        console.log('❌ Auth state expired or invalid');
+      }
+
+      await context.close();
+      return isLoggedIn;
+    } finally {
+      await browser.close();
+    }
+  }
+
+  /**
+   * List all auth states
+   */
+  listAuth(): string[] {
+    const outputDir = this.config.outputDir;
+
+    if (!fs.existsSync(outputDir)) {
+      return [];
+    }
+
+    return fs
+      .readdirSync(outputDir)
+      .filter((f) => f.endsWith('.json'))
+      .map((f) => f.replace('.json', ''));
+  }
+
+  /**
+   * Export auth state as base64 (for CI)
+   */
+  exportAuth(name: string): string | null {
+    const authFile = path.join(this.config.outputDir, `${name}.json`);
+
+    if (!fs.existsSync(authFile)) {
+      console.log(`❌ Auth file not found: ${authFile}`);
+      return null;
+    }
+
+    const authJson = fs.readFileSync(authFile, 'utf-8');
+    return Buffer.from(authJson).toString('base64');
+  }
+}