@sun-asterisk/sungen 1.0.24 → 2.0.1

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

@@ -1,202 +0,0 @@
-/**
- * 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

@@ -1,176 +0,0 @@
-/**
- * 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

@@ -1,57 +0,0 @@
-/**
- * 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';

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

@@ -1,209 +0,0 @@
-/**
- * Screen Validator
- * Orchestrates validation for a screen (all features in qa/screens/<name>/)
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import {
-  ValidationResult,
-  FileValidationResult,
-  ValidationSummary,
-  ValidationIssue,
-} from './index';
-import { FeatureValidator } from './feature-validator';
-import { SelectorValidator } from './selector-validator';
-import { DataValidator } from './data-validator';
-
-export interface ScreenValidatorOptions {
-  verbose?: boolean;
-  baseDir?: string;
-}
-
-export class ScreenValidator {
-  private baseDir: string;
-  private verbose: boolean;
-
-  constructor(options: ScreenValidatorOptions = {}) {
-    this.baseDir = options.baseDir || process.cwd();
-    this.verbose = options.verbose || false;
-  }
-
-  /**
-   * Validate a specific screen
-   */
-  validateScreen(screenName: string): ValidationResult {
-    const results: FileValidationResult[] = [];
-
-    const screenDir = path.join(this.baseDir, 'qa', 'screens', screenName);
-    const featuresDir = path.join(screenDir, 'features');
-
-    // Check if screen exists
-    if (!fs.existsSync(screenDir)) {
-      return this.createErrorResult(`Screen "${screenName}" not found at ${screenDir}`);
-    }
-
-    if (!fs.existsSync(featuresDir)) {
-      return this.createErrorResult(`Features directory not found at ${featuresDir}`);
-    }
-
-    // Find all feature files
-    const featureFiles = this.discoverFeatureFiles(featuresDir);
-
-    if (featureFiles.length === 0) {
-      return this.createErrorResult(`No .feature files found in ${featuresDir}`);
-    }
-
-    // Initialize validators
-    const featureValidator = new FeatureValidator();
-    const selectorValidator = new SelectorValidator(screenName, this.baseDir);
-    const dataValidator = new DataValidator(screenName, this.baseDir);
-
-    // Validate each feature file
-    for (const featureFile of featureFiles) {
-      const featureName = path.basename(featureFile, '.feature');
-      const relativeFile = path.relative(this.baseDir, featureFile);
-
-      const fileResult: FileValidationResult = {
-        file: relativeFile,
-        valid: true,
-        errors: [],
-        warnings: [],
-      };
-
-      // 1. Validate Gherkin syntax and extract refs
-      const featureResult = featureValidator.validate(featureFile);
-      fileResult.errors.push(...featureResult.errors);
-      fileResult.warnings.push(...featureResult.warnings);
-
-      // 2. Validate selector file
-      const selectorFileResult = selectorValidator.validateFile(featureName);
-      fileResult.errors.push(...selectorFileResult.errors);
-      fileResult.warnings.push(...selectorFileResult.warnings);
-
-      // 3. Validate selector refs exist
-      if (featureResult.refs.selectors.length > 0) {
-        const selectorRefErrors = selectorValidator.validateRefs(
-          featureName,
-          featureResult.refs.selectors,
-          relativeFile
-        );
-        fileResult.errors.push(...selectorRefErrors);
-      }
-
-      // 4. Validate data file
-      const dataFileResult = dataValidator.validateFile(featureName);
-      fileResult.errors.push(...dataFileResult.errors);
-      fileResult.warnings.push(...dataFileResult.warnings);
-
-      // 5. Validate data refs exist
-      if (featureResult.refs.dataRefs.length > 0) {
-        const dataRefErrors = dataValidator.validateRefs(
-          featureName,
-          featureResult.refs.dataRefs,
-          relativeFile
-        );
-        fileResult.errors.push(...dataRefErrors);
-      }
-
-      // Update validity
-      fileResult.valid = fileResult.errors.length === 0;
-      results.push(fileResult);
-    }
-
-    return this.buildResult(results);
-  }
-
-  /**
-   * Validate all screens
-   */
-  validateAll(): ValidationResult {
-    const screensDir = path.join(this.baseDir, 'qa', 'screens');
-
-    if (!fs.existsSync(screensDir)) {
-      return this.createErrorResult(`Screens directory not found at ${screensDir}`);
-    }
-
-    const screens = fs.readdirSync(screensDir, { withFileTypes: true })
-      .filter(entry => entry.isDirectory())
-      .map(entry => entry.name);
-
-    if (screens.length === 0) {
-      return this.createErrorResult(`No screens found in ${screensDir}`);
-    }
-
-    const allResults: FileValidationResult[] = [];
-
-    for (const screenName of screens) {
-      const screenResult = this.validateScreen(screenName);
-      allResults.push(...screenResult.results);
-    }
-
-    return this.buildResult(allResults);
-  }
-
-  /**
-   * Discover .feature files in a directory
-   */
-  private discoverFeatureFiles(dir: string): string[] {
-    const files: string[] = [];
-
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        files.push(...this.discoverFeatureFiles(fullPath));
-      } else if (entry.isFile() && entry.name.endsWith('.feature')) {
-        files.push(fullPath);
-      }
-    }
-
-    return files;
-  }
-
-  /**
-   * Build final validation result
-   */
-  private buildResult(results: FileValidationResult[]): ValidationResult {
-    const summary: ValidationSummary = {
-      totalFiles: results.length,
-      passedFiles: results.filter(r => r.valid).length,
-      failedFiles: results.filter(r => !r.valid).length,
-      totalErrors: results.reduce((sum, r) => sum + r.errors.length, 0),
-      totalWarnings: results.reduce((sum, r) => sum + r.warnings.length, 0),
-    };
-
-    return {
-      valid: summary.failedFiles === 0,
-      summary,
-      results,
-    };
-  }
-
-  /**
-   * Create error result for invalid setup
-   */
-  private createErrorResult(message: string): ValidationResult {
-    return {
-      valid: false,
-      summary: {
-        totalFiles: 0,
-        passedFiles: 0,
-        failedFiles: 0,
-        totalErrors: 1,
-        totalWarnings: 0,
-      },
-      results: [{
-        file: '',
-        valid: false,
-        errors: [{
-          type: 'error',
-          code: 'GHERKIN_SYNTAX_ERROR',
-          message,
-          file: '',
-        }],
-        warnings: [],
-      }],
-    };
-  }
-}