@playq/core 0.2.77

package/src/exec/runner.ts

@@ -0,0 +1,241 @@
+import { spawnSync, execSync, spawn } from 'child_process';
+import minimist from 'minimist';
+import { loadEnv } from '../helper/bundle/env';
+import os from 'os';
+import path from 'path';
+// Note: remove stray invalid import; runner does not need faker
+
+// loadEnv();
+// console.log('  - Runner (PLAYQ_ENV):', process.env.PLAYQ_ENV );
+// console.log('  - Runner (PLAYQ_RUNNER):', process.env.PLAYQ_RUNNER );
+// console.log('  - Runner (PLAYQ_GREP):', process.env.PLAYQ_GREP );
+// console.log('  - Runner (PLAYQ_TAGS):', process.env.PLAYQ_TAGS );
+// console.log('  - Runner (PLAYQ_PROJECT):', process.env.PLAYQ_PROJECT );
+// console.log('  - Env (RUNNER - cc_card_type):', process.env['cc_card_type']);
+// console.log('  - Env (RUNNER - config.testExecution.timeout):', process.env['config.testExecution.timeout'] );
+
+if (process.env.PLAYQ_RUNNER && process.env.PLAYQ_RUNNER === 'cucumber') {
+  // Allow vars to initialize in the cucumber child process (do NOT set PLAYQ_NO_INIT_VARS here)
+  // Ensure legacy TEST_RUNNER flag used by helper code is set
+  process.env.TEST_RUNNER = 'cucumber';
+  // Provide a default browser type if none supplied via config/env
+  if (!process.env['PLAYQ__browser__browserType'] && !process.env['browser.browserType']) {
+    process.env.PLAYQ__browser__browserType = 'chromium';
+  }
+  loadEnv();
+  const cucumberArgs = [
+    'cucumber-js',
+    '--config',
+    'cucumber.js',
+    '--profile',
+    'default',
+  ];
+  if (process.env.PLAYQ_TAGS) cucumberArgs.push('--tags', process.env.PLAYQ_TAGS);
+
+  const run = spawn('npx', cucumberArgs, {
+    stdio: 'inherit',
+    env: { ...process.env },
+    shell: true,
+  });
+
+  run.on('close', (code) => {
+    try {
+      const pkgPath = path.resolve(process.cwd(), 'package.json');
+      const pkg = require(pkgPath);
+      if (pkg.scripts && pkg.scripts['posttest:cucumber']) {
+        execSync('npm run posttest:cucumber', { stdio: 'inherit' });
+      } else {
+        console.log('ℹ️ Skipping posttest:cucumber (script not defined)');
+      }
+    } catch (err) {
+      console.log('ℹ️ Posttest check failed, continuing:', (err as any)?.message || err);
+    }
+    process.exit(code);
+  });
+} else {
+  if (process.env.PLAYQ_RUN_CONFIG) {
+    // Dynamically import the run_config object from the specified run config file
+    // Look for run config in the user's project root
+    const runConfigPath = path.resolve(process.cwd(), `resources/run-configs/${process.env.PLAYQ_RUN_CONFIG}.run`);
+    const runConfig = require(runConfigPath).default;
+    console.log('🌐 Running with runConfig:', JSON.stringify(runConfig));
+    for (const cfg of runConfig.runs) {
+
+      console.log(`    - Running test with grep: ${cfg.PLAYQ_GREP}, env: ${cfg.PLAYQ_ENV}`);
+      Object.keys(cfg).forEach(key => {
+        if (key.trim() == 'PLAYQ_RUNNER') throw new Error('PLAYQ_RUNNER is not allowed in run configs');
+        process.env[key] = cfg[key];
+        console.log(`Setting ${key} = ${cfg[key]}`);
+      });
+  process.env.PLAYQ_NO_INIT_VARS = '1';
+  loadEnv();
+      const command = `npx playwright test --config=playq/config/playwright/playwright.config.js${process.env.PLAYQ_GREP ? ` --grep="${process.env.PLAYQ_GREP}"` : ''
+        }${process.env.PLAYQ_PROJECT ? ` --project="${process.env.PLAYQ_PROJECT}"` : ''}`;
+
+  const childEnv = { ...process.env } as any;
+      // Ensure child initializes vars by removing the parent-side guard
+      delete childEnv.PLAYQ_NO_INIT_VARS;
+  const preload = '-r ts-node/register';
+      childEnv.NODE_OPTIONS = childEnv.NODE_OPTIONS
+        ? `${childEnv.NODE_OPTIONS} ${preload}`
+        : preload;
+      // Ensure core and project roots propagate to child
+      if (!childEnv.PLAYQ_CORE_ROOT) childEnv.PLAYQ_CORE_ROOT = path.resolve(__dirname, '..');
+      if (!childEnv.PLAYQ_PROJECT_ROOT) childEnv.PLAYQ_PROJECT_ROOT = process.cwd();
+      // Point ts-node to the project's tsconfig for path aliases
+      const projectTsConfig = path.resolve(process.cwd(), 'tsconfig.json');
+      childEnv.TS_NODE_PROJECT = projectTsConfig;
+      childEnv.TS_NODE_TRANSPILE_ONLY = childEnv.TS_NODE_TRANSPILE_ONLY || 'true';
+      const result = spawnSync(command, {
+        stdio: 'inherit',
+        shell: true,
+        env: childEnv,
+      });
+
+    }
+  } else {
+  process.env.PLAYQ_NO_INIT_VARS = '1';
+  loadEnv();
+    const command = `npx playwright test --config=playq/config/playwright/playwright.config.js${process.env.PLAYQ_GREP ? ` --grep="${process.env.PLAYQ_GREP}"` : ''
+      }${process.env.PLAYQ_PROJECT ? ` --project="${process.env.PLAYQ_PROJECT}"` : ''}`;
+
+  const childEnv = { ...process.env } as any;
+    // Ensure child initializes vars by removing the parent-side guard
+    delete childEnv.PLAYQ_NO_INIT_VARS;
+  const preload = '-r ts-node/register';
+    childEnv.NODE_OPTIONS = childEnv.NODE_OPTIONS
+      ? `${childEnv.NODE_OPTIONS} ${preload}`
+      : preload;
+    // Ensure core and project roots propagate to child
+    if (!childEnv.PLAYQ_CORE_ROOT) childEnv.PLAYQ_CORE_ROOT = path.resolve(__dirname, '..');
+    if (!childEnv.PLAYQ_PROJECT_ROOT) childEnv.PLAYQ_PROJECT_ROOT = process.cwd();
+    // Point ts-node to the project's tsconfig for path aliases
+    const projectTsConfig = path.resolve(process.cwd(), 'tsconfig.json');
+    childEnv.TS_NODE_PROJECT = projectTsConfig;
+    childEnv.TS_NODE_TRANSPILE_ONLY = childEnv.TS_NODE_TRANSPILE_ONLY || 'true';
+    const result = spawnSync(command, {
+      stdio: 'inherit',
+      shell: true,
+      env: childEnv,
+    });
+
+  }
+
+}
+
+// console.log('  - Runner (PLAYQ_ENV):', process.env.PLAYQ_ENV );
+// console.log('  - Runner (PLAYQ_RUNNER):', process.env.PLAYQ_RUNNER );
+// console.log('  - Runner (PLAYQ_GREP):', process.env.PLAYQ_GREP );
+// console.log('  - Runner (PLAYQ_TAGS):', process.env.PLAYQ_TAGS );
+// console.log('  - Runner (PLAYQ_PROJECT):', process.env.PLAYQ_PROJECT );
+// console.log('  - Env (RUNNER - cc_card_type):', process.env.cc_card_type );
+
+
+// let runner = 'playwright';
+// let env = '';
+// let grep = '';
+// let tags = '';
+// let prj = '';
+// console.log('🌐 os.platform():', os.platform());
+
+// // Use minimist for all platforms for consistency
+// const args = minimist(process.argv.slice(2));
+
+// // Try npm_config_* first (for npm script context), then fall back to minimist
+// grep = process.env.npm_config_grep || args.grep || '';
+// env = process.env.npm_config_env || args.env || '';
+// tags = process.env.npm_config_tags || args.tags || '';
+// prj = process.env.npm_config_project || args.project || '';
+// runner = ['cucumber', 'bdd', 'cuke'].includes(
+//   (process.env.npm_config_runner || args.runner || '').toLowerCase()
+// )
+//   ? 'cucumber'
+//   : 'playwright';
+
+// console.log('🌐 grep:', grep);
+// console.log('🌐 env:', env);
+// console.log('🌐 tags:', tags);
+// console.log('🌐 prj:', prj);
+// console.log('🌐 runner:', runner);
+
+// // Debug information
+// console.log('🔍 Debug - process.argv:', process.argv);
+// console.log('🔍 Debug - minimist args:', args);
+// console.log('🔍 Debug - npm_config_env:', process.env.npm_config_env);
+// console.log('🔍 Debug - npm_config_grep:', process.env.npm_config_grep);
+
+// process.env.TS_NODE_PROJECT = './tsconfig.json';
+// require('tsconfig-paths').register();
+
+// console.log('🌐 Running tests with args:', process.argv);
+// console.log(process.platform);
+// console.log(process.env.npm_config_env);
+
+// process.env.TEST_RUNNER = runner;
+// if (tags) process.env.TAGS = tags;
+// if (grep) process.env.GREP = grep;
+// if (prj) process.env.PROJECT = prj;
+
+// if (env) {
+//   process.env.RUN_ENV = env;
+//   loadEnv(env);
+// }
+
+// if (runner === 'cucumber') {
+//   execSync('npm run pretest:cucumber', { stdio: 'inherit' });
+
+//   const cucumberArgs = [
+//     'cucumber-js',
+//     '--config',
+//     'cucumber.js',
+//     '--profile',
+//     'default',
+//   ];
+//   if (tags) cucumberArgs.push('--tags', tags);
+
+//   console.log(`🚀 Running Cucumber with args: ${cucumberArgs.join(' ')}`);
+//   console.log('📦 Final Cucumber command:', `npx ${cucumberArgs.join(' ')}`);
+
+//   const run = spawn('npx', cucumberArgs, {
+//     stdio: 'inherit',
+//     env: { ...process.env, RUN_ENV: env, PROJECT: prj },
+
+//     shell: true,
+//   });
+
+//   run.on('close', (code) => {
+//     execSync('npm run posttest:cucumber', { stdio: 'inherit' });
+//     process.exit(code);
+//   });
+// } else if (runner === 'playwright') {
+//   try {
+//     execSync('npm run pretest:playwright', { stdio: 'inherit' });
+//   } catch (error) {
+//     console.log(
+//       '⚠️  Pre-test cleanup had some issues, but continuing with tests...'
+//     );
+//   }
+
+//   const command = `npx playwright test --config=config/playwright/playwright.config.ts${
+//     grep ? ` --grep='${grep}'` : ''
+//   }${prj ? ` --project=${prj}` : ''}`;
+
+//   const result = spawnSync(command, {
+//     stdio: 'inherit',
+//     shell: true,
+//     env: { ...process.env, RUN_ENV: env, PROJECT: prj },
+//   });
+
+//   try {
+//     execSync('npm run posttest:playwright', { stdio: 'inherit' });
+//   } catch (error) {
+//     console.log(
+//       '⚠️  Post-test reporting had some issues, but test execution completed.'
+//     );
+//   }
+
+//   process.exit(result.status || 0);
+// } else {
+//   console.error(`❌ Unknown runner: ${runner}`);
+//   process.exit(1);
+// }

package/src/exec/runnerCuke.js

@@ -0,0 +1,90 @@
+const { spawn } = require('child_process');
+const minimist = require('minimist');
+
+console.log("🧪 CLI args raw in runnerCuke:", process.argv);
+
+const argsFromCLI = minimist(process.argv.slice(2));
+
+console.log("🧪 CLI args received:", argsFromCLI);
+console.log("🔍 Resolved variables:");
+console.log("  - TEST_RUNNER:", process.env.TEST_RUNNER || 'cucumber');
+console.log("  - TAGS:", 
+  argsFromCLI.tags ||
+  argsFromCLI.tag ||
+  argsFromCLI.TAGS ||
+  process.env.TAGS ||
+  process.env.npm_config_TAGS ||
+  ''
+);
+console.log("  - ENV:", argsFromCLI.env || process.env.ENV || process.env.npm_config_ENV || '');
+console.log("  - GREP:", argsFromCLI.grep || process.env.npm_config_GREP || '');
+
+const TEST_RUNNER = process.env.TEST_RUNNER || 'cucumber';
+
+// const tag =
+//   argsFromCLI.tags ||
+//   argsFromCLI.tag ||
+//   argsFromCLI.TAGS ||
+//   process.env.TAGS ||
+//   process.env.npm_config_TAGS ||
+//   '';
+// const env = argsFromCLI.env || process.env.ENV || process.env.npm_config_ENV || '';
+// const grep = argsFromCLI.grep || process.env.npm_config_GREP || '';
+
+const tag = argsFromCLI.tags || argsFromCLI.tag || '';
+const env = argsFromCLI.env || '';
+const grep = argsFromCLI.grep || '';
+
+// Set environment variables for downstream use
+process.env.TAGS = tag;
+process.env.ENV = env;
+process.env.GREP = grep;
+
+console.log(`🔧 TEST_RUNNER: ${TEST_RUNNER}`);
+console.log(`🌍 ENV: ${env}`);
+console.log(`🏷️ TAGS used: "${tag}"`);
+console.log(`🔍 GREP: ${grep}`);
+
+let run;
+
+  const cucumberArgs = ['cucumber-js', '--config', 'cucumber.js', '--profile', 'default'];
+  if (tag) cucumberArgs.push('--tags', tag);
+  console.log(`🚀 Running Cucumber with args: ${cucumberArgs.join(' ')}`);
+  console.log("📦 Final Cucumber command:", `npx ${cucumberArgs.join(' ')}`);
+
+  run = spawn('npx', cucumberArgs, {
+    stdio: 'inherit',
+    env: { ...process.env, RUN_ENV: env },
+    shell: true
+  });
+
+// if (TEST_RUNNER === 'cucumber') {
+//   const cucumberArgs = ['cucumber-js', '--config', 'cucumber.js', '--profile', 'default'];
+//   if (tag) cucumberArgs.push('--tags', tag);
+//   console.log(`🚀 Running Cucumber with args: ${cucumberArgs.join(' ')}`);
+//   console.log("📦 Final Cucumber command:", `npx ${cucumberArgs.join(' ')}`);
+
+//   run = spawn('npx', cucumberArgs, {
+//     stdio: 'inherit',
+//     env: { ...process.env, ENV: env },
+//     shell: true
+//   });
+
+// } else if (TEST_RUNNER === 'playwright') {
+//   const pwArgs = ['playwright', 'test', '--config=config/playwright/playwright.config.ts'];
+//   if (grep) pwArgs.push('--grep', grep);
+
+//   console.log("📦 Final Playwright command:", `npx ${pwArgs.join(' ')}`);
+
+//   run = spawn('npx', pwArgs, {
+//     stdio: 'inherit',
+//     env: { ...process.env, ENV: env },
+//     shell: true
+//   });
+
+// } else {
+//   console.error(`❌ Unknown TEST_RUNNER: ${TEST_RUNNER}`);
+//   process.exit(1);
+// }
+
+run.on('close', code => process.exit(code));

package/src/exec/runner_orchestrator.ts

@@ -0,0 +1,91 @@
+import fs from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import { execSync } from 'child_process';
+import yargs from 'yargs';
+
+const args = yargs(process.argv).argv as any;
+const runnerName = args.runner;
+
+if (!runnerName) {
+  console.error('❌ Missing --runner=<name>');
+  process.exit(1);
+}
+
+const runnerPath = path.resolve(`./resources/runners/${runnerName}.run.json`);
+if (!fs.existsSync(runnerPath)) {
+  console.error(`❌ Runner file not found: ${runnerPath}`);
+  process.exit(1);
+}
+
+const runnerConfig = JSON.parse(fs.readFileSync(runnerPath, 'utf-8'));
+const { runType, runs } = runnerConfig;
+
+execSync('npm run pretest:playwright', { stdio: 'inherit' });
+
+async function runOneTest(config: any) {
+const env = config.env ? config.env : ''
+const grep = config.grep ? `--grep="${config.grep}"` : '';
+//   const env = config.env ? `--env="${config.env}"` : '';
+  const prj = config.project ? `--project=${config.project}"` : '';
+
+  const command = `npx playwright test --config=config/playwright/playwright.config.js ${grep} ${prj}`;
+  console.log(`🔹 Running: ${command}`);
+  const result = spawnSync(command, {
+    stdio: 'inherit',
+    shell: true,
+    env: { ...process.env, TEST_RUNNER: "playwright", RUN_ENV: env }
+    // env: { ...process.env }
+  });
+
+  if (result.status !== 0) {
+    console.error(`❌ Test failed: ${grep}`);
+    process.exit(result.status);
+  }
+}
+
+async function runTests() {
+  if (runType === 'sequential') {
+    for (const run of runs) {
+      await runOneTest(run);
+    }
+  } else if (runType === 'parallel') {
+    const promises = runs.map(run =>
+      new Promise((resolve, reject) => {
+        const env = run.env ? run.env : ''
+        const grep = run.grep ? `--grep="${run.grep}"` : '';
+        // const env = run.env ? `--env="${run.env}"` : '';
+        const prj = run.project ? `--project=${run.project}"` : '';
+  const command = `npx playwright test --config=config/playwright/playwright.config.js ${grep} ${prj}`;
+
+        const proc = spawnSync(command, {
+          stdio: 'inherit',
+          shell: true,
+          env: { ...process.env, TEST_RUNNER: "playwright", RUN_ENV: env }
+        });
+
+        if (proc.status !== 0) {
+          reject(new Error(`Failed: ${command}`));
+        } else {
+          resolve(true);
+        }
+      })
+    );
+
+    try {
+      await Promise.all(promises);
+    } catch (err) {
+      console.error('❌ One or more test batches failed.');
+      process.exit(1);
+    }
+  } else {
+    console.error(`❌ Unknown runType: ${runType}`);
+    process.exit(1);
+  }
+}
+
+runTests().then(() => {
+  execSync('npm run posttest:playwright', { stdio: 'inherit' });
+  console.log('✅ All test runs completed.');
+  process.exit(0);
+});