qa360 2.1.7 → 2.2.0

package/scripts/validate-examples.mjs

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+/**
+ * QA360 Examples Validator
+ *
+ * Validates all example pack files to ensure they are syntactically correct
+ * and follow the Pack v2 schema.
+ *
+ * Usage:
+ *   node scripts/validate-examples.mjs
+ *   node scripts/validate-examples.mjs --check-exists
+ */
+
+import { readFileSync, readdirSync, existsSync, statSync } from 'fs';
+import { resolve, join, dirname, relative } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const rootDir = resolve(__dirname, '..');
+
+// ANSI colors
+const colors = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m'
+};
+
+function colorize(color, text) {
+  return `${colors[color]}${text}${colors.reset}`;
+}
+
+// Directories to skip (non-pack YAML files)
+const SKIP_DIRS = [
+  '.github',
+  '.gitlab-ci',
+  'ci',
+  'load-testing',  // K6/mcp files, not packs
+  'packs-conformance',  // Pack v1 format, validated separately
+];
+
+// Files that are definitely pack files (validate these)
+const KNOWN_PACK_FILES = [
+  'pack.yml',
+  'pack.yaml',
+];
+
+// Find all YAML files in a directory recursively
+function findYamlFiles(dir, results = []) {
+  if (!existsSync(dir)) return results;
+
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+
+    // Skip certain directories
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.includes(entry.name) || entry.name.startsWith('.') || entry.name === 'node_modules') {
+        continue;
+      }
+      findYamlFiles(fullPath, results);
+    } else if (entry.isFile() && (entry.name.endsWith('.yml') || entry.name.endsWith('.yaml'))) {
+      // Include if it's a known pack file name or in a pack directory
+      const relativePath = relative(rootDir, fullPath);
+      const pathParts = relativePath.split('/');
+
+      // Include if it's named pack.yml/pack.yaml
+      if (KNOWN_PACK_FILES.includes(entry.name)) {
+        results.push(fullPath);
+      }
+      // Include if in a directory that contains "pack" in the name
+      else if (pathParts.some(p => p.includes('pack'))) {
+        results.push(fullPath);
+      }
+      // Include files in restful-api-dev, web-lite, httpbin, packs-business
+      else if (pathParts[0] === 'restful-api-dev' ||
+               pathParts[0] === 'web-lite' && entry.name === 'pack.yml' ||
+               pathParts[0] === 'httpbin' ||
+               pathParts[0] === 'packs-business') {
+        // Only include pack.yml in web-lite (services.yml is docker-compose)
+        if (pathParts[0] !== 'web-lite' || entry.name === 'pack.yml') {
+          results.push(fullPath);
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+// Basic YAML validation (check for common syntax errors)
+function validateYamlSyntax(content, filePath) {
+  const errors = [];
+  const warnings = [];
+  const lines = content.split('\n');
+
+  let inMultilineString = false;
+  let indentStack = [0];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    const trimmed = line.trimEnd();
+
+    // Skip empty lines and comments
+    if (!trimmed || trimmed.startsWith('#')) {
+      continue;
+    }
+
+    // Check for tabs (YAML doesn't allow tabs for indentation)
+    if (line.includes('\t')) {
+      errors.push({
+        line: lineNum,
+        message: 'Tab character found. Use spaces for indentation.',
+        code: 'SYNTAX_TAB'
+      });
+    }
+
+    // Check indentation consistency
+    if (trimmed && !line.startsWith(' ')) {
+      // Top level, reset stack
+      indentStack = [0];
+    } else if (trimmed) {
+      const indent = line.search(/\S/);
+
+      // Check for odd indentation
+      if (indent % 2 !== 0) {
+        warnings.push({
+          line: lineNum,
+          message: 'Odd indentation detected. Use 2-space increments.',
+          code: 'STYLE_INDENT'
+        });
+      }
+
+      // Check for too deep indentation
+      if (indent > 40) {
+        warnings.push({
+          line: lineNum,
+          message: 'Very deep indentation. Consider restructuring.',
+          code: 'STYLE_DEEP'
+        });
+      }
+    }
+
+    // Check for common YAML pitfalls
+    if (trimmed.startsWith('- ')) {
+      // List item
+      const valueIndent = line.indexOf('- ') + 2;
+      const afterDash = line.substring(valueIndent).trim();
+
+      // Check if the value after dash is a colon (nested mapping)
+      if (afterDash.endsWith(':')) {
+        // This is fine - it's a mapping in a list
+      }
+    }
+
+    // Check for trailing colon without space after
+    if (trimmed.endsWith(':') && !trimmed.endsWith(': ')) {
+      const nextLine = lines[i + 1];
+      if (nextLine && nextLine.trim() && !nextLine.trim().startsWith('#')) {
+        // Check if next line is indented more (nested block)
+        const nextIndent = nextLine.search(/\S/);
+        if (nextIndent <= line.search(/\S/)) {
+          warnings.push({
+            line: lineNum,
+            message: 'Mapping key without value. Use "key: value" format.',
+            code: 'SYNTAX_COLON'
+          });
+        }
+      }
+    }
+
+    // Check for unquoted special characters
+    if (trimmed.includes(':') && !trimmed.startsWith('-') && !trimmed.includes("'") && !trimmed.includes('"')) {
+      const colonIndex = trimmed.indexOf(':');
+      if (colonIndex > 0 && colonIndex < trimmed.length - 1) {
+        const afterColon = trimmed.substring(colonIndex + 1).trim();
+        if (afterColon && !afterColon.startsWith('#') && !afterColon.startsWith('|') && !afterColon.startsWith('>')) {
+          // This might be a time like "12:30" or URL like "http://", which is OK
+          const urlPattern = /^[a-z]+:\/\//;
+          if (!urlPattern.test(afterColon)) {
+            // Also check for HH:MM time format
+            const timePattern = /^\d{1,2}:\d{2}(:\d{2})?$/;
+            if (!timePattern.test(trimmed)) {
+              // Might be an issue, but could be valid YAML
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return { errors, warnings };
+}
+
+// Validate pack structure
+function validatePackStructure(content, filePath) {
+  const errors = [];
+  const warnings = [];
+  const lines = content.split('\n');
+
+  // Extract top-level keys
+  const topLevelKeys = new Set();
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith('#')) {
+      const indent = line.search(/\S/);
+      if (indent === 0) {
+        const match = trimmed.match(/^([^:#]+):/);
+        if (match) {
+          topLevelKeys.add(match[1]);
+        }
+      }
+    }
+  }
+
+  // Check for required fields in pack files
+  if (filePath.includes('examples/') || filePath.includes('pack')) {
+    const requiredFields = ['version', 'name', 'gates'];
+    for (const field of requiredFields) {
+      if (!topLevelKeys.has(field)) {
+        errors.push({
+          line: 1,
+          message: `Missing required field: "${field}"`,
+          code: 'PACK_MISSING_FIELD',
+          suggestion: `Add ${field}: to your pack file`
+        });
+      }
+    }
+
+    // Check version field
+    if (topLevelKeys.has('version')) {
+      for (const line of lines) {
+        if (line.trim().startsWith('version:')) {
+          const version = line.trim().substring(8).trim().replace(/['"]/g, '');
+          // Accept simple version numbers (1, 2) or semantic versions (1.0.0, 2.1.3, etc.)
+          const validVersion = /^(1|2)(\.\d+)*$/.test(version);
+          if (!validVersion) {
+            warnings.push({
+              line: lines.indexOf(line) + 1,
+              message: `Unusual version value: ${version}. Expected 1.x or 2.x.`,
+              code: 'PACK_VERSION'
+            });
+          }
+          break;
+        }
+      }
+    }
+
+    // Check for known top-level keys (including extended keys)
+    const validKeys = ['version', 'name', 'description', 'gates', 'auth', 'targets', 'budgets', 'security', 'hooks', 'execution', 'metadata',
+                       // Extended keys for advanced packs
+                       'data', 'observability', 'environment', 'variables', 'templates'];
+    const invalidKeys = [...topLevelKeys].filter(k => !validKeys.includes(k));
+    if (invalidKeys.length > 0) {
+      warnings.push({
+        line: 1,
+        message: `Unrecognized top-level keys: ${invalidKeys.join(', ')}`,
+        code: 'PACK_UNKNOWN_KEYS'
+      });
+    }
+  }
+
+  return { errors, warnings };
+}
+
+// Validate a single YAML file
+function validateYamlFile(filePath) {
+  const relativePath = relative(rootDir, filePath);
+  const result = {
+    file: relativePath,
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+
+    // Syntax validation
+    const syntaxResult = validateYamlSyntax(content, filePath);
+    result.errors.push(...syntaxResult.errors);
+    result.warnings.push(...syntaxResult.warnings);
+
+    // Structure validation
+    const structureResult = validatePackStructure(content, filePath);
+    result.errors.push(...structureResult.errors);
+    result.warnings.push(...structureResult.warnings);
+
+    // Check for empty file
+    if (!content.trim()) {
+      result.errors.push({
+        line: 1,
+        message: 'Empty file',
+        code: 'EMPTY_FILE'
+      });
+    }
+
+    result.valid = result.errors.length === 0;
+  } catch (error) {
+    result.valid = false;
+    result.errors.push({
+      line: 0,
+      message: `Failed to read file: ${error.message}`,
+      code: 'READ_ERROR'
+    });
+  }
+
+  return result;
+}
+
+// Main validation function
+async function validateExamples(options = {}) {
+  const examplesDir = resolve(rootDir, 'examples');
+
+  if (!existsSync(examplesDir)) {
+    console.error(colorize('red', `Error: Examples directory not found: ${examplesDir}`));
+    process.exit(1);
+  }
+
+  console.log(colorize('cyan', '🔍 QA360 Examples Validator'));
+  console.log(colorize('gray', '━'.repeat(50)));
+  console.log(`Scanning: ${examplesDir}\n`);
+
+  // Find all YAML files
+  const yamlFiles = findYamlFiles(examplesDir);
+
+  if (yamlFiles.length === 0) {
+    console.log(colorize('yellow', 'No YAML files found in examples directory.'));
+    return;
+  }
+
+  console.log(colorize('blue', `Found ${yamlFiles.length} YAML file(s) to validate\n`));
+
+  // Validate each file
+  const results = [];
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  let validCount = 0;
+
+  for (const filePath of yamlFiles) {
+    const result = validateYamlFile(filePath);
+    results.push(result);
+
+    if (result.valid) {
+      validCount++;
+      console.log(colorize('green', `✓ ${result.file}`));
+    } else {
+      console.log(colorize('red', `✗ ${result.file}`));
+    }
+
+    // Print errors and warnings
+    if (result.errors.length > 0 || result.warnings.length > 0) {
+      for (const error of result.errors) {
+        console.log(colorize('red', `  [${error.code}] Line ${error.line}: ${error.message}`));
+        if (error.suggestion) {
+          console.log(colorize('gray', `    → ${error.suggestion}`));
+        }
+      }
+      for (const warning of result.warnings) {
+        console.log(colorize('yellow', `  [${warning.code}] Line ${warning.line}: ${warning.message}`));
+        if (warning.suggestion) {
+          console.log(colorize('gray', `    → ${warning.suggestion}`));
+        }
+      }
+    }
+
+    totalErrors += result.errors.length;
+    totalWarnings += result.warnings.length;
+  }
+
+  // Print summary
+  console.log('\n' + colorize('gray', '━'.repeat(50)));
+  console.log(colorize('cyan', 'Summary:'));
+  console.log(`  Total files: ${yamlFiles.length}`);
+  console.log(`  ${colorize('green', `Valid: ${validCount}`)}`);
+  console.log(`  ${colorize('red', `Invalid: ${yamlFiles.length - validCount}`)}`);
+  console.log(`  ${colorize('red', `Errors: ${totalErrors}`)}`);
+  console.log(`  ${colorize('yellow', `Warnings: ${totalWarnings}`)}`);
+
+  // Exit with error code if validation failed
+  if (totalErrors > 0) {
+    process.exit(1);
+  }
+}
+
+// Parse CLI arguments
+const args = process.argv.slice(2);
+const options = {};
+for (const arg of args) {
+  if (arg === '--check-exists') {
+    options.checkExists = true;
+  }
+}
+
+validateExamples(options).catch(error => {
+  console.error(colorize('red', `Error: ${error.message}`));
+  process.exit(1);
+});

package/scripts/validation/simple-pack-check.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+# QA360 Simple Pack Validation - Phase 7-Final Certification
+# Validation basique YAML sans dépendances complexes
+
+set -e
+
+PACK_FILE="$1"
+
+if [ -z "$PACK_FILE" ]; then
+  echo "Usage: $0 <pack.yml>"
+  exit 1
+fi
+
+if [ ! -f "$PACK_FILE" ]; then
+  echo "❌ Pack file not found: $PACK_FILE"
+  exit 1
+fi
+
+echo "🔍 Validating pack: $PACK_FILE"
+
+# Check required fields
+if ! grep -q "^name:" "$PACK_FILE"; then
+  echo "❌ Missing required field: name"
+  exit 1
+fi
+
+if ! grep -q "^version:" "$PACK_FILE"; then
+  echo "❌ Missing required field: version"
+  exit 1
+fi
+
+if ! grep -q "^gates:" "$PACK_FILE"; then
+  echo "❌ Missing required field: gates"
+  exit 1
+fi
+
+# Extract values
+NAME=$(grep "^name:" "$PACK_FILE" | head -1 | sed 's/name: *//' | tr -d '"')
+VERSION=$(grep "^version:" "$PACK_FILE" | head -1 | sed 's/version: *//' | tr -d '"')
+DESCRIPTION=$(grep "^description:" "$PACK_FILE" | head -1 | sed 's/description: *//' | tr -d '"')
+
+# Count enabled gates
+GATES_ENABLED=$(grep -A1 "^  [a-z]*:" "$PACK_FILE" | grep "enabled: true" | wc -l | tr -d ' ')
+
+echo "✅ Pack schema: VALID"
+echo "   Name: $NAME"
+echo "   Version: $VERSION"
+echo "   Description: $DESCRIPTION"
+echo "   Gates enabled: $GATES_ENABLED"
+
+exit 0

package/scripts/validation/validate-universal-pack.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * QA360 Universal Pack Validation Script
+ * Validation directe sans dépendance CLI pour certification Phase 7-Final
+ */
+
+import { readFileSync } from 'fs';
+import { parse } from '../../node_modules/js-yaml/dist/js-yaml.mjs';
+import Ajv from '../../node_modules/ajv/dist/ajv.js';
+import addFormats from '../../node_modules/ajv-formats/dist/index.js';
+
+const ajv = new Ajv({ allErrors: true, strict: false });
+addFormats(ajv);
+
+// Schéma Pack v1 simplifié pour validation
+const packSchema = {
+  type: 'object',
+  required: ['name', 'version', 'gates'],
+  properties: {
+    name: { type: 'string', pattern: '^[a-z0-9-]+$' },
+    version: { type: 'string', pattern: '^\\d+\\.\\d+\\.\\d+$' },
+    description: { type: 'string' },
+    gates: {
+      type: 'object',
+      properties: {
+        api: { type: 'object' },
+        ui: { type: 'object' },
+        perf: { type: 'object' },
+        a11y: { type: 'object' },
+        sast: { type: 'object' },
+        deps: { type: 'object' },
+        secrets: { type: 'object' },
+        dast: { type: 'object' }
+      }
+    },
+    metadata: { type: 'object' }
+  }
+};
+
+const validate = ajv.compile(packSchema);
+
+async function validatePack(packPath) {
+  console.log(`\n🔍 Validating pack: ${packPath}`);
+  
+  try {
+    const content = readFileSync(packPath, 'utf8');
+    const pack = parse(content);
+    
+    const valid = validate(pack);
+    
+    if (valid) {
+      console.log('✅ Pack schema: VALID');
+      console.log(`   Name: ${pack.name}`);
+      console.log(`   Version: ${pack.version}`);
+      console.log(`   Gates enabled: ${Object.keys(pack.gates).filter(g => pack.gates[g]?.enabled).join(', ')}`);
+      return { valid: true, pack };
+    } else {
+      console.log('❌ Pack schema: INVALID');
+      console.log('   Errors:', validate.errors);
+      return { valid: false, errors: validate.errors };
+    }
+  } catch (error) {
+    console.log('❌ Pack parsing: FAILED');
+    console.log('   Error:', error.message);
+    return { valid: false, error: error.message };
+  }
+}
+
+// Main
+const packPath = process.argv[2];
+if (!packPath) {
+  console.error('Usage: node validate-universal-pack.js <pack.yml>');
+  process.exit(1);
+}
+
+const result = await validatePack(packPath);
+process.exit(result.valid ? 0 : 1);

package/scripts/verify-persistence.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+// scripts/verify-persistence.js - Script d'audit persistance après redeploy
+
+const BASE_URL = process.env.BASE_URL || 'https://qa360-cloud-preview.vercel.app';
+
+async function verifyPersistence() {
+  console.log('🔍 AUDIT PERSISTANCE QA360 CLOUD');
+  console.log(`Base URL: ${BASE_URL}`);
+  console.log('');
+
+  try {
+    // 1. POST /api/runpack → récupère runId
+    console.log('1️⃣ Exécution d\'un pack pour générer un runId...');
+    const runResponse = await fetch(`${BASE_URL}/api/runpack`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Origin': BASE_URL
+      },
+      body: JSON.stringify({ pack: 'httpbin' })
+    });
+
+    if (!runResponse.ok) {
+      throw new Error(`POST /api/runpack failed: ${runResponse.status}`);
+    }
+
+    const runData = await runResponse.json();
+    const { pack, runId } = runData;
+    console.log(`✅ Run créé: pack=${pack}, runId=${runId}`);
+    console.log(`📋 Summary: ${runData.summary.tests.passed} passed, ${runData.summary.tests.failed} failed`);
+    console.log('');
+
+    // 2. Vérifier que le run est accessible immédiatement
+    console.log('2️⃣ Vérification accès immédiat au rapport...');
+    const reportResponse = await fetch(`${BASE_URL}/api/report/gherkin?pack=${pack}&runId=${runId}`);
+    
+    if (!reportResponse.ok) {
+      throw new Error(`GET /api/report/gherkin failed: ${reportResponse.status}`);
+    }
+
+    const reportData = await reportResponse.json();
+    console.log(`✅ Rapport accessible: ${reportData.routes.length} routes, ${reportData.gherkin.scenarios.length} scenarios`);
+    console.log('');
+
+    // 3. Vérifier deep-link
+    console.log('3️⃣ Vérification deep-link...');
+    const deepLinkResponse = await fetch(`${BASE_URL}/r/${pack}/${runId}`);
+    
+    if (!deepLinkResponse.ok) {
+      throw new Error(`GET /r/${pack}/${runId} failed: ${deepLinkResponse.status}`);
+    }
+
+    console.log(`✅ Deep-link accessible: ${BASE_URL}/r/${pack}/${runId}`);
+    console.log('');
+
+    // 4. Simuler un redeploy (attendre 30s)
+    console.log('4️⃣ Simulation redeploy (attente 30s pour cold start)...');
+    await new Promise(resolve => setTimeout(resolve, 30000));
+    console.log('');
+
+    // 5. Vérifier persistance après "redeploy"
+    console.log('5️⃣ Vérification persistance après redeploy...');
+    const persistentReportResponse = await fetch(`${BASE_URL}/api/report/gherkin?pack=${pack}&runId=${runId}`);
+    
+    if (!persistentReportResponse.ok) {
+      console.log(`❌ ÉCHEC PERSISTANCE: GET /api/report/gherkin failed: ${persistentReportResponse.status}`);
+      console.log('⚠️  Le store persistant (Vercel KV/Redis) n\'est pas branché correctement');
+      console.log('💡 Action requise: Configurer KV_REST_API_URL et KV_REST_API_TOKEN');
+      return false;
+    }
+
+    const persistentReportData = await persistentReportResponse.json();
+    console.log(`✅ PERSISTANCE OK: Rapport toujours accessible après redeploy`);
+    console.log(`📋 Données: ${persistentReportData.routes.length} routes, ${persistentReportData.gherkin.scenarios.length} scenarios`);
+    console.log('');
+
+    // 6. Vérifier deep-link persistant
+    console.log('6️⃣ Vérification deep-link persistant...');
+    const persistentDeepLinkResponse = await fetch(`${BASE_URL}/r/${pack}/${runId}`);
+    
+    if (!persistentDeepLinkResponse.ok) {
+      console.log(`❌ Deep-link non persistant: ${persistentDeepLinkResponse.status}`);
+      return false;
+    }
+
+    console.log(`✅ Deep-link persistant: ${BASE_URL}/r/${pack}/${runId}`);
+    console.log('');
+
+    // 7. Vérifier KPI
+    console.log('7️⃣ Vérification KPI...');
+    const kpiResponse = await fetch(`${BASE_URL}/api/kpi`);
+    
+    if (!kpiResponse.ok) {
+      console.log(`⚠️  KPI endpoint failed: ${kpiResponse.status}`);
+    } else {
+      const kpiData = await kpiResponse.json();
+      console.log(`✅ KPI accessible: ${Object.keys(kpiData.kpis || {}).length} packs avec KPI`);
+    }
+
+    console.log('');
+    console.log('🎉 AUDIT PERSISTANCE RÉUSSI');
+    console.log('✅ Store persistant opérationnel');
+    console.log('✅ Deep-links durables après redeploy');
+    console.log('✅ KPI accessibles');
+    
+    return true;
+
+  } catch (error) {
+    console.error('❌ AUDIT PERSISTANCE ÉCHOUÉ:', error.message);
+    console.log('');
+    console.log('🔧 Actions correctives:');
+    console.log('1. Vérifier variables d\'environnement KV_REST_API_URL et KV_REST_API_TOKEN');
+    console.log('2. Configurer Vercel KV ou Upstash Redis');
+    console.log('3. Tester le fallback memory en développement');
+    
+    return false;
+  }
+}
+
+// Exécuter si appelé directement
+if (require.main === module) {
+  verifyPersistence().then(success => {
+    process.exit(success ? 0 : 1);
+  });
+}
+
+module.exports = { verifyPersistence };

package/test-pack.yaml

@@ -0,0 +1,43 @@
+# QA360 Test Pack - Validation du Phase3Runner
+# Cible : httpbin.org (API de test publique)
+
+version: 1
+name: "qa360-validation-test"
+description: "Test de validation du Phase3Runner avec httpbin.org"
+
+gates:
+  - api_smoke
+  - ui
+
+targets:
+  api:
+    baseUrl: "https://httpbin.org"
+    smoke:
+      - "GET /get -> 200"
+      - "GET /ip -> 200"
+      - "GET /headers -> 200"
+      - "POST /post -> 200"
+  
+  web:
+    baseUrl: "https://example.com"
+    pages:
+      - "https://example.com"
+
+budgets:
+  perf_p95_ms: 5000
+  a11y_min: 70
+
+security:
+  sast:
+    max_critical: 0
+    max_high: 5
+    max_medium: 20
+
+execution:
+  timeout: 30000
+  max_retries: 1
+  on_failure: continue
+
+observability:
+  metrics: true
+  trace: basic