@sun-asterisk/sungen 1.0.5 → 1.0.6

package/src/cli/index.ts

@@ -8,6 +8,56 @@ import { CLIAdapter } from '../input/cli-adapter';
 import { ConfigLoader } from '../config/config-loader';
 import { Pipeline } from '../orchestrator/pipeline';
 import { CacheManager } from '../orchestrator/cache-manager';
+import { ValidationResult } from '../core/validator';
+
+/**
+ * Print validation result to console
+ */
+function printValidationResult(result: ValidationResult, verbose: boolean = false): void {
+  for (const fileResult of result.results) {
+    if (fileResult.valid) {
+      if (verbose) {
+        console.log(`✓ ${fileResult.file}`);
+        console.log(`  ✓ Gherkin syntax valid`);
+        if (fileResult.warnings.length === 0) {
+          console.log(`  ✓ All checks passed`);
+        }
+      } else {
+        console.log(`✓ ${fileResult.file}`);
+      }
+    } else {
+      console.log(`✗ ${fileResult.file}`);
+    }
+
+    // Print warnings
+    for (const warning of fileResult.warnings) {
+      const lineInfo = warning.line ? `:${warning.line}` : '';
+      console.log(`  ⊘ ${warning.message}${lineInfo}`);
+    }
+
+    // Print errors
+    for (const error of fileResult.errors) {
+      const lineInfo = error.line ? `:${error.line}` : '';
+      console.log(`  ✗ ${error.message}${lineInfo}`);
+    }
+
+    if (!fileResult.valid || (verbose && fileResult.warnings.length > 0)) {
+      console.log('');
+    }
+  }
+
+  // Print summary
+  console.log('\nSummary:');
+  console.log(`  Files: ${result.summary.totalFiles} total, ${result.summary.passedFiles} passed, ${result.summary.failedFiles} failed`);
+  console.log(`  Errors: ${result.summary.totalErrors}`);
+  console.log(`  Warnings: ${result.summary.totalWarnings}`);
+
+  if (result.valid) {
+    console.log('\n✅ Validation passed');
+  } else {
+    console.log('\n❌ Validation failed');
+  }
+}
 
 async function main() {
   const adapter = new CLIAdapter();
@@ -195,6 +245,41 @@ async function main() {
     }
   });
 
+  const validateCmd = adapter.addValidateCommand(program);
+  validateCmd.action(async (options) => {
+    try {
+      const { ScreenValidator } = require('../core/validator');
+
+      const validator = new ScreenValidator({
+        verbose: options.verbose,
+      });
+
+      let result: ValidationResult;
+      if (options.screen) {
+        console.log(`Validating screen: ${options.screen}\n`);
+        result = validator.validateScreen(options.screen);
+      } else {
+        console.log('Validating all screens...\n');
+        result = validator.validateAll();
+      }
+
+      // Output results
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        printValidationResult(result, options.verbose);
+      }
+
+      // Exit with error code if validation failed
+      if (!result.valid) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('❌ Validation failed:', error);
+      process.exit(1);
+    }
+  });
+
   // Parse arguments
   await program.parseAsync(process.argv);
 }

package/src/core/validator/data-validator.ts

@@ -0,0 +1,202 @@
+/**
+ * Data Validator
+ * Validates test-data YAML files and checks referenced data paths exist
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import yaml from 'yaml';
+import { ValidationIssue } from './index';
+
+type DataFile = Record<string, unknown>;
+
+export class DataValidator {
+  private screenName: string;
+  private baseDir: string;
+  private dataCache = new Map<string, DataFile>();
+
+  constructor(screenName: string, baseDir?: string) {
+    this.screenName = screenName;
+    this.baseDir = baseDir || process.cwd();
+  }
+
+  /**
+   * Validate test-data file for a feature
+   */
+  validateFile(featureName: string): { errors: ValidationIssue[]; warnings: ValidationIssue[] } {
+    const errors: ValidationIssue[] = [];
+    const warnings: ValidationIssue[] = [];
+
+    const filePath = this.findDataPath(featureName);
+
+    if (!filePath) {
+      // Data file is optional - only warn if there are data refs
+      return { errors, warnings };
+    }
+
+    // Load and parse YAML
+    let content: string;
+    let data: DataFile;
+
+    try {
+      content = fs.readFileSync(filePath, 'utf-8');
+    } catch (error) {
+      errors.push({
+        type: 'error',
+        code: 'INVALID_YAML_SYNTAX',
+        message: `Cannot read file: ${(error as Error).message}`,
+        file: filePath,
+      });
+      return { errors, warnings };
+    }
+
+    try {
+      data = yaml.parse(content) as DataFile;
+    } catch (error) {
+      errors.push({
+        type: 'error',
+        code: 'INVALID_YAML_SYNTAX',
+        message: `YAML parse error: ${(error as Error).message}`,
+        file: filePath,
+      });
+      return { errors, warnings };
+    }
+
+    if (data && typeof data !== 'object') {
+      errors.push({
+        type: 'error',
+        code: 'INVALID_YAML_SYNTAX',
+        message: 'Test data file must be a valid YAML object',
+        file: filePath,
+      });
+      return { errors, warnings };
+    }
+
+    // Cache for later ref validation
+    this.dataCache.set(featureName, data || {});
+
+    return { errors, warnings };
+  }
+
+  /**
+   * Check if data references exist and resolve to primitives
+   */
+  validateRefs(
+    featureName: string,
+    refs: Array<{ ref: string; line: number }>,
+    featureFile: string
+  ): ValidationIssue[] {
+    const errors: ValidationIssue[] = [];
+
+    if (refs.length === 0) {
+      return errors;
+    }
+
+    // Load data if not cached
+    if (!this.dataCache.has(featureName)) {
+      const filePath = this.findDataPath(featureName);
+      if (!filePath) {
+        // Data file doesn't exist but we have refs - error
+        for (const { ref, line } of refs) {
+          errors.push({
+            type: 'error',
+            code: 'MISSING_DATA_FILE',
+            message: `Test data file not found for feature "${featureName}" (needed for {{${ref}}})`,
+            file: featureFile,
+            line,
+            element: ref,
+          });
+        }
+        return errors;
+      }
+
+      try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const data = yaml.parse(content) as DataFile;
+        this.dataCache.set(featureName, data || {});
+      } catch {
+        // Error already reported in validateFile
+        return errors;
+      }
+    }
+
+    const data = this.dataCache.get(featureName);
+    if (!data) {
+      return errors;
+    }
+
+    // Check each ref
+    for (const { ref, line } of refs) {
+      const result = this.resolvePath(data, ref);
+
+      if (!result.found) {
+        errors.push({
+          type: 'error',
+          code: 'MISSING_DATA_REF',
+          message: `Data {{${ref}}} not found in test-data/${featureName}.yaml (failed at: ${result.failedAt})`,
+          file: featureFile,
+          line,
+          element: ref,
+        });
+      } else if (!this.isPrimitive(result.value)) {
+        errors.push({
+          type: 'error',
+          code: 'INVALID_DATA_VALUE',
+          message: `Data {{${ref}}} must resolve to a primitive value, got: ${typeof result.value}`,
+          file: featureFile,
+          line,
+          element: ref,
+        });
+      }
+    }
+
+    return errors;
+  }
+
+  /**
+   * Resolve dotted path in data object
+   */
+  private resolvePath(data: DataFile, ref: string): { found: boolean; value?: unknown; failedAt?: string } {
+    const parts = ref.split('.');
+    let current: unknown = data;
+
+    for (const key of parts) {
+      if (current && typeof current === 'object' && key in (current as Record<string, unknown>)) {
+        current = (current as Record<string, unknown>)[key];
+      } else {
+        return { found: false, failedAt: key };
+      }
+    }
+
+    return { found: true, value: current };
+  }
+
+  /**
+   * Check if value is a primitive (string, number, boolean)
+   */
+  private isPrimitive(value: unknown): boolean {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+  }
+
+  /**
+   * Find test-data file path
+   */
+  private findDataPath(featureName: string): string | null {
+    const possiblePaths = [
+      // New structure
+      path.join(this.baseDir, 'qa', 'screens', this.screenName, 'test-data', `${featureName}.yaml`),
+      path.join(this.baseDir, 'qa', 'screens', this.screenName, 'test-data', `${featureName}.yml`),
+      // Legacy structure
+      path.join(this.baseDir, 'qa', 'test-data', `${featureName}.yaml`),
+      path.join(this.baseDir, 'qa', 'test-data', `${featureName}.yml`),
+    ];
+
+    for (const p of possiblePaths) {
+      if (fs.existsSync(p)) {
+        return p;
+      }
+    }
+
+    return null;
+  }
+}

package/src/core/validator/feature-validator.ts

@@ -0,0 +1,176 @@
+/**
+ * Feature Validator
+ * Validates Gherkin feature files and extracts selector/data references
+ */
+
+import * as fs from 'fs';
+import * as Gherkin from '@cucumber/gherkin';
+import * as Messages from '@cucumber/messages';
+import { ValidationIssue, ExtractedRefs } from './index';
+
+export interface FeatureValidationResult {
+  valid: boolean;
+  errors: ValidationIssue[];
+  warnings: ValidationIssue[];
+  path?: string;  // Extracted Path metadata
+  refs: ExtractedRefs;
+}
+
+export class FeatureValidator {
+  private builder: Gherkin.AstBuilder;
+  private matcher: Gherkin.GherkinClassicTokenMatcher;
+  // @ts-ignore - Parser typing issue with @cucumber/gherkin
+  private parser: Gherkin.Parser;
+
+  constructor() {
+    const uuidFn = Messages.IdGenerator.uuid();
+    this.builder = new Gherkin.AstBuilder(uuidFn);
+    this.matcher = new Gherkin.GherkinClassicTokenMatcher();
+    // @ts-ignore - Parser typing issue with @cucumber/gherkin
+    this.parser = new Gherkin.Parser(this.builder, this.matcher);
+  }
+
+  /**
+   * Validate a feature file
+   */
+  validate(filePath: string): FeatureValidationResult {
+    const errors: ValidationIssue[] = [];
+    const warnings: ValidationIssue[] = [];
+    const refs: ExtractedRefs = { selectors: [], dataRefs: [] };
+    let path: string | undefined;
+
+    // Check file exists
+    if (!fs.existsSync(filePath)) {
+      errors.push({
+        type: 'error',
+        code: 'GHERKIN_SYNTAX_ERROR',
+        message: `Feature file not found: ${filePath}`,
+        file: filePath,
+      });
+      return { valid: false, errors, warnings, refs };
+    }
+
+    // Read and parse content
+    let content: string;
+    try {
+      content = fs.readFileSync(filePath, 'utf-8');
+    } catch (error) {
+      errors.push({
+        type: 'error',
+        code: 'GHERKIN_SYNTAX_ERROR',
+        message: `Cannot read file: ${(error as Error).message}`,
+        file: filePath,
+      });
+      return { valid: false, errors, warnings, refs };
+    }
+
+    // Parse Gherkin
+    let gherkinDocument: Messages.GherkinDocument;
+    try {
+      gherkinDocument = this.parser.parse(content);
+    } catch (error) {
+      const errMsg = (error as Error).message;
+      // Try to extract line number from error message
+      const lineMatch = errMsg.match(/\((\d+):\d+\)/);
+      const line = lineMatch ? parseInt(lineMatch[1], 10) : undefined;
+
+      errors.push({
+        type: 'error',
+        code: 'GHERKIN_SYNTAX_ERROR',
+        message: `Gherkin parse error: ${errMsg}`,
+        file: filePath,
+        line,
+      });
+      return { valid: false, errors, warnings, refs };
+    }
+
+    // Check feature exists
+    if (!gherkinDocument.feature) {
+      errors.push({
+        type: 'error',
+        code: 'EMPTY_FEATURE',
+        message: 'No feature found in file',
+        file: filePath,
+      });
+      return { valid: false, errors, warnings, refs };
+    }
+
+    const feature = gherkinDocument.feature;
+
+    // Extract Path metadata
+    const description = feature.description || '';
+    const pathMatch = description.match(/^\s*Path:\s*(.+)$/m);
+    if (pathMatch) {
+      path = pathMatch[1].trim();
+    } else {
+      warnings.push({
+        type: 'warning',
+        code: 'MISSING_PATH_METADATA',
+        message: 'Missing Path: metadata in feature description',
+        file: filePath,
+      });
+    }
+
+    // Extract refs from background
+    const background = feature.children.find(child => child.background)?.background;
+    if (background) {
+      this.extractRefsFromSteps(background.steps, filePath, refs);
+    }
+
+    // Extract refs from scenarios
+    for (const child of feature.children) {
+      if (child.scenario) {
+        this.extractRefsFromSteps(child.scenario.steps, filePath, refs);
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      path,
+      refs,
+    };
+  }
+
+  /**
+   * Extract selector and data references from steps
+   */
+  private extractRefsFromSteps(
+    steps: readonly Messages.Step[],
+    filePath: string,
+    refs: ExtractedRefs
+  ): void {
+    for (const step of steps) {
+      const text = step.text;
+      const line = step.location?.line;
+
+      // Extract selector references: [Element Name]
+      const selectorMatches = text.matchAll(/\[([^\]]+)\]/g);
+      for (const match of selectorMatches) {
+        refs.selectors.push({
+          ref: match[1],
+          line: line || 0,
+        });
+      }
+
+      // Extract data references: {{variable}} or {{path.to.value}}
+      const dataMatches = text.matchAll(/\{\{([a-zA-Z0-9\-\.\_]+)\}\}/g);
+      for (const match of dataMatches) {
+        refs.dataRefs.push({
+          ref: match[1],
+          line: line || 0,
+        });
+      }
+
+      // Legacy format: <variable>
+      const legacyDataMatches = text.matchAll(/<([^>]+)>/g);
+      for (const match of legacyDataMatches) {
+        refs.dataRefs.push({
+          ref: match[1],
+          line: line || 0,
+        });
+      }
+    }
+  }
+}

package/src/core/validator/index.ts

@@ -0,0 +1,57 @@
+/**
+ * Validator Core - Types and Exports
+ * Validates Gherkin features and selector/test-data mappings
+ */
+
+export interface ValidationIssue {
+  type: 'error' | 'warning';
+  code: ValidationCode;
+  message: string;
+  file: string;
+  line?: number;
+  element?: string;  // The [element] or {{variable}} that caused the issue
+}
+
+export interface ValidationSummary {
+  totalFiles: number;
+  passedFiles: number;
+  failedFiles: number;
+  totalErrors: number;
+  totalWarnings: number;
+}
+
+export interface FileValidationResult {
+  file: string;
+  valid: boolean;
+  errors: ValidationIssue[];
+  warnings: ValidationIssue[];
+}
+
+export interface ValidationResult {
+  valid: boolean;
+  summary: ValidationSummary;
+  results: FileValidationResult[];
+}
+
+export type ValidationCode =
+  | 'GHERKIN_SYNTAX_ERROR'
+  | 'MISSING_PATH_METADATA'
+  | 'MISSING_SELECTOR_FILE'
+  | 'MISSING_SELECTOR'
+  | 'MISSING_DATA_FILE'
+  | 'MISSING_DATA_REF'
+  | 'INVALID_YAML_SYNTAX'
+  | 'INVALID_SELECTOR_TYPE'
+  | 'INVALID_DATA_VALUE'
+  | 'EMPTY_FEATURE';
+
+export interface ExtractedRefs {
+  selectors: Array<{ ref: string; line: number }>;
+  dataRefs: Array<{ ref: string; line: number }>;
+}
+
+// Re-exports
+export { FeatureValidator } from './feature-validator';
+export { SelectorValidator } from './selector-validator';
+export { DataValidator } from './data-validator';
+export { ScreenValidator } from './screen-validator';