codeceptjs 4.0.0-beta.1 → 4.0.0-beta.11.esm-aria

package/lib/command/interactive.js

@@ -1,55 +1,64 @@
-import { getConfig, getTestRoot } from './utils.js';
-import recorder from '../recorder.js';
-import Codecept from '../codecept.js';
-import Container from '../container.js';
-import * as event from '../event.js';
-import * as output from '../output.js';
-import webHelpers from '../plugin/standardActingHelpers.js';
+import { getConfig, getTestRoot } from './utils.js'
+import recorder from '../recorder.js'
+import Codecept from '../codecept.js'
+import Container from '../container.js'
+import event from '../event.js'
+import pause from '../pause.js'
+import output from '../output.js'
+const webHelpers = Container.STANDARD_ACTING_HELPERS
 
 export default async function (path, options) {
   // Backward compatibility for --profile
-  process.profile = options.profile;
-  process.env.profile = options.profile;
-  const configFile = options.config;
+  process.profile = options.profile
+  process.env.profile = options.profile
+  const configFile = options.config
 
-  const config = getConfig(configFile);
-  const testsPath = getTestRoot(configFile);
+  const config = await getConfig(configFile)
+  const testsPath = getTestRoot(configFile)
 
-  const codecept = new Codecept(config, options);
-  codecept.init(testsPath);
+  const codecept = new Codecept(config, options)
+  codecept.init(testsPath)
 
   try {
-    await codecept.bootstrap();
+    await codecept.bootstrap()
+    await Container.started()
 
-    if (options.verbose) output.level(3);
+    if (options.verbose) output.level(3)
 
-    output.print('Starting interactive shell for current suite...');
-    recorder.start();
+    let addGlobalRetries
+
+    if (config.retry) {
+      addGlobalRetries = function retries() {}
+    }
+
+    output.print('Starting interactive shell for current suite...')
+    recorder.start()
     event.emit(event.suite.before, {
       fullTitle: () => 'Interactive Shell',
       tests: [],
-    });
+      retries: addGlobalRetries,
+    })
     event.emit(event.test.before, {
       title: '',
       artifacts: {},
-    });
+      retries: addGlobalRetries,
+    })
 
-    const enabledHelpers = Container.helpers();
+    const enabledHelpers = Container.helpers()
     for (const helperName of Object.keys(enabledHelpers)) {
       if (webHelpers.includes(helperName)) {
-        const I = enabledHelpers[helperName];
-        recorder.add(() => I.amOnPage('/'));
-        recorder.catchWithoutStop(e => output.print(`Error while loading home page: ${e.message}}`));
-        break;
+        const I = enabledHelpers[helperName]
+        recorder.add(() => I.amOnPage('/'))
+        recorder.catchWithoutStop(e => output.print(`Error while loading home page: ${e.message}}`))
+        break
       }
     }
-    require('../pause')();
-    // recorder.catchWithoutStop((err) => console.log(err.stack));
-    recorder.add(() => event.emit(event.test.after, {}));
-    recorder.add(() => event.emit(event.suite.after, {}));
-    recorder.add(() => event.emit(event.all.result, {}));
-    recorder.add(() => codecept.teardown());
+    pause()
+    recorder.add(() => event.emit(event.test.after, {}))
+    recorder.add(() => event.emit(event.suite.after, {}))
+    recorder.add(() => event.emit(event.all.result, {}))
+    recorder.add(() => codecept.teardown())
   } catch (err) {
-    output.output.error(`Error while running bootstrap file :${err}`);
+    output.error(`Error while running bootstrap file :${err}`)
   }
 }

package/lib/command/list.js

@@ -1,36 +1,37 @@
-import { getConfig, getTestRoot } from './utils.js';
-import Codecept from '../codecept.js';
-import container from '../container.js';
-import { getParamsToString } from '../parser.js';
-import { methodsOfObject } from '../utils.js';
-import * as output from '../output.js';
+import { getConfig, getTestRoot } from './utils.js'
+import Codecept from '../codecept.js'
+import container from '../container.js'
+import { getParamsToString } from '../parser.js'
+import { methodsOfObject } from '../utils.js'
+import output from '../output.js'
 
-export default function (path) {
-  const testsPath = getTestRoot(path);
-  const config = getConfig(testsPath);
-  const codecept = new Codecept(config, {});
-  codecept.init(testsPath);
+export default async function (path) {
+  const testsPath = getTestRoot(path)
+  const config = await getConfig(testsPath)
+  const codecept = new Codecept(config, {})
+  await codecept.init(testsPath)
+  await container.started()
 
-  output.print('List of test actions: -- ');
-  const helpers = container.helpers();
-  const supportI = container.support('I');
-  const actions = [];
+  output.print('List of test actions: -- ')
+  const helpers = container.helpers()
+  const supportI = container.support('I')
+  const actions = []
   for (const name in helpers) {
-    const helper = helpers[name];
-    methodsOfObject(helper).forEach((action) => {
-      const params = getParamsToString(helper[action]);
-      actions[action] = 1;
-      output.print(` ${output.output.colors.grey(name)} I.${output.output.colors.bold(action)}(${params})`);
-    });
+    const helper = helpers[name]
+    methodsOfObject(helper).forEach(action => {
+      const params = getParamsToString(helper[action])
+      actions[action] = 1
+      output.print(` ${output.colors.grey(name)} I.${output.colors.bold(action)}(${params})`)
+    })
   }
   for (const name in supportI) {
     if (actions[name]) {
-      continue;
+      continue
     }
-    const actor = supportI[name];
-    const params = getParamsToString(actor);
-    output.print(` I.${output.output.colors.bold(name)}(${params})`);
+    const actor = supportI[name]
+    const params = getParamsToString(actor)
+    output.print(` I.${output.colors.bold(name)}(${params})`)
   }
-  output.print('PS: Actions are retrieved from enabled helpers. ');
-  output.print('Implement custom actions in your helper classes.');
+  output.print('PS: Actions are retrieved from enabled helpers. ')
+  output.print('Implement custom actions in your helper classes.')
 }

package/lib/command/run-multiple/chunk.js

@@ -1,91 +1,94 @@
-import glob from 'glob';
-import path from 'path';
-import fs from 'fs';
+import { globSync } from 'glob'
+import path from 'path'
+import fs from 'fs'
 
 /**
  * Splits a list to (n) parts, defined via the size argument.
  */
 const splitFiles = (list, size) => {
-  const sets = [];
-  const chunks = list.length / size;
-  let i = 0;
+  const sets = []
+  const chunks = list.length / size
+  let i = 0
 
   while (i < chunks) {
-    sets[i] = list.splice(0, size);
-    i++;
+    sets[i] = list.splice(0, size)
+    i++
   }
 
-  return sets;
-};
+  return sets
+}
 
 /**
  * Executes a glob pattern and pushes the results to a list.
  */
-const findFiles = (pattern) => {
-  const files = [];
+const findFiles = pattern => {
+  const files = []
 
-  glob.sync(pattern).forEach((file) => {
-    files.push(path.resolve(file));
-  });
+  globSync(pattern).forEach(file => {
+    files.push(path.resolve(file))
+  })
 
-  return files;
-};
+  return files
+}
 
 /**
  * Joins a list of files to a valid glob pattern
  */
-const flattenFiles = (list) => {
-  const pattern = list.join(',');
-  return pattern.indexOf(',') > -1 ? `{${pattern}}` : pattern;
-};
+const flattenFiles = list => {
+  const pattern = list.join(',')
+  return pattern.indexOf(',') > -1 ? `{${pattern}}` : pattern
+}
 
 /**
  * Greps a file by its content, checks if Scenario or Feature text'
  * matches the grep text.
  */
 const grepFile = (file, grep) => {
-  const contents = fs.readFileSync(file, 'utf8');
-  const pattern = new RegExp(`((Scenario|Feature)\(.*${grep}.*\))`, 'g'); // <- How future proof/solid is this?
-  return !!pattern.exec(contents);
-};
+  const contents = fs.readFileSync(file, 'utf8')
+  const pattern = new RegExp(`((Scenario|Feature)\(.*${grep}.*\))`, 'g') // <- How future proof/solid is this?
+  return !!pattern.exec(contents)
+}
 
-const mapFileFormats = (files) => {
+const mapFileFormats = files => {
   return {
     gherkin: files.filter(file => file.match(/\.feature$/)),
     js: files.filter(file => file.match(/\.t|js$/)),
-  };
-};
+  }
+}
 
 /**
  * Creates a list of chunks incl. configuration by either dividing a list of scenario
  * files by the passed number or executing a usder deifned function to perform
  * the splitting.
  */
-export const createChunks = (config, patterns = []) => {
-  const files = patterns.filter(pattern => !!pattern).map((pattern) => {
-    return findFiles(pattern).filter((file) => {
-      return config.grep ? grepFile(file, config.grep) : true;
-    });
-  }).reduce((acc, val) => acc.concat(val), []);
+const createChunks = (config, patterns = []) => {
+  const files = patterns
+    .filter(pattern => !!pattern)
+    .map(pattern => {
+      return findFiles(pattern).filter(file => {
+        return config.grep ? grepFile(file, config.grep) : true
+      })
+    })
+    .reduce((acc, val) => acc.concat(val), [])
 
-  let chunks = [];
+  let chunks = []
   if (typeof config.chunks === 'function') {
-    chunks = config.chunks.call(this, files);
+    chunks = config.chunks.call(this, files)
   } else if (typeof config.chunks === 'number' || typeof config.chunks === 'string') {
-    chunks = splitFiles(files, Math.ceil(files.length / config.chunks));
+    chunks = splitFiles(files, Math.ceil(files.length / config.chunks))
   } else {
-    throw new Error('chunks is neither a finite number or a valid function');
+    throw new Error('chunks is neither a finite number or a valid function')
   }
 
-  const chunkConfig = { ...config };
-  delete chunkConfig.chunks;
+  const chunkConfig = { ...config }
+  delete chunkConfig.chunks
 
-  return chunks.map((chunkFiles) => {
-    const { js, gherkin } = mapFileFormats(chunkFiles);
-    return { ...chunkConfig, tests: flattenFiles(js), gherkin: { features: flattenFiles(gherkin) } };
-  });
-};
+  return chunks.map(chunkFiles => {
+    const { js, gherkin } = mapFileFormats(chunkFiles)
+    return { ...chunkConfig, tests: flattenFiles(js), gherkin: { features: flattenFiles(gherkin) } }
+  })
+}
 
-export default {
-  createChunks,
-};
+export {
+  createChunks
+}

package/lib/command/run-multiple/collection.js

@@ -1,5 +1,5 @@
-import { createChunks } from './chunk.js';
-import { createRun } from './run.js';
+import { createChunks } from './chunk.js'
+import { createRun } from './run.js'
 
 /**
  * Bootstraps a collection of runs, it combines user defined selection of runs
@@ -190,6 +190,6 @@ function guessBrowser(config) {
   return [config.helpers[firstHelper].browser];
 }
 
-export default {
-  createRuns,
-};
+export {
+  createRuns
+}

package/lib/command/run-multiple/run.js

@@ -21,6 +21,10 @@ class Run {
   }
 }
 
-export function createRun(name, config) {
+const createRun = (name, config) => {
   return new Run(name, config);
+};
+
+export {
+  createRun
 }

package/lib/command/run-multiple.js

@@ -1,186 +1,186 @@
-import { fork } from 'child_process';
-import path, { dirname } from 'path';
-import crypto from 'crypto';
-import { fileURLToPath } from 'url';
-import runHook from '../hooks.js';
-import * as event from '../event.js';
-import collection from './run-multiple/collection.js';
-import { clearString, replaceValueDeep } from '../utils.js';
-import { getConfig, getTestRoot, fail } from './utils.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-const runner = path.join(__dirname, '../../bin/codecept.js');
-let config;
-const childOpts = {};
-const copyOptions = ['override', 'steps', 'reporter', 'verbose', 'config', 'reporter-options', 'grep', 'fgrep', 'invert', 'debug', 'plugins', 'colors'];
-let overrides = {};
+import { fork } from 'child_process'
+import path from 'path'
+import crypto from 'crypto'
+import { fileURLToPath } from 'url'
+
+import runHook from '../hooks.js'
+import event from '../event.js'
+import { createRuns } from './run-multiple/collection.js'
+import { clearString, replaceValueDeep } from '../utils.js'
+import { getConfig, getTestRoot, fail } from './utils.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const runner = path.join(__dirname, '/../../bin/codecept')
+let config
+const childOpts = {}
+const copyOptions = ['override', 'steps', 'reporter', 'verbose', 'config', 'reporter-options', 'grep', 'fgrep', 'invert', 'debug', 'plugins', 'colors']
+let overrides = {}
 
 // codeceptjs run-multiple smoke:chrome regression:firefox - will launch smoke run in chrome and regression in firefox
 // codeceptjs run-multiple smoke:chrome regression - will launch smoke run in chrome and regression in firefox and chrome
 // codeceptjs run-multiple --all - will launch all runs
 // codeceptjs run-multiple smoke regression'
 
-let runId = 1;
-let subprocessCount = 0;
-let totalSubprocessCount = 0;
-let processesDone;
+let runId = 1
+let subprocessCount = 0
+let totalSubprocessCount = 0
+let processesDone
 
 export default async function (selectedRuns, options) {
   // registering options globally to use in config
   if (options.profile) {
-    process.env.profile = options.profile;
+    process.env.profile = options.profile
   }
-  const configFile = options.config;
+  const configFile = options.config
 
-  const testRoot = getTestRoot(configFile);
-  global.codecept_dir = testRoot;
+  const testRoot = getTestRoot(configFile)
+  global.codecept_dir = testRoot
 
   // copy opts to run
   Object.keys(options)
     .filter(key => copyOptions.indexOf(key) > -1)
-    .forEach((key) => {
-      childOpts[key] = options[key];
-    });
+    .forEach(key => {
+      childOpts[key] = options[key]
+    })
 
   try {
-    overrides = JSON.parse(childOpts.override);
-    delete childOpts.override;
+    overrides = JSON.parse(childOpts.override)
+    delete childOpts.override
   } catch (e) {
-    overrides = {};
+    overrides = {}
   }
 
   config = {
-    ...getConfig(configFile),
+    ...(await getConfig(configFile)),
     ...overrides,
-  };
+  }
 
   if (!config.multiple) {
-    fail('Multiple runs not configured, add "multiple": { /../ } section to config');
+    fail('Multiple runs not configured, add "multiple": { /../ } section to config')
   }
 
-  selectedRuns = options.all ? Object.keys(config.multiple) : selectedRuns;
+  selectedRuns = options.all ? Object.keys(config.multiple) : selectedRuns
   if (!selectedRuns.length) {
-    fail('No runs provided. Use --all option to run all configured runs');
+    fail('No runs provided. Use --all option to run all configured runs')
   }
 
-  await runHook(config.bootstrapAll, 'bootstrapAll');
+  await runHook(config.bootstrapAll, 'bootstrapAll')
 
-  event.emit(event.multiple.before, null);
-  if (options.config) { // update paths to config path
+  event.emit(event.multiple.before, null)
+  if (options.config) {
+    // update paths to config path
     if (config.tests) {
-      config.tests = path.resolve(testRoot, config.tests);
+      config.tests = path.resolve(testRoot, config.tests)
     }
     if (config.gherkin && config.gherkin.features) {
-      config.gherkin.features = path.resolve(testRoot, config.gherkin.features);
+      config.gherkin.features = path.resolve(testRoot, config.gherkin.features)
     }
   }
 
   if (options.features) {
-    config.tests = '';
+    config.tests = ''
   }
 
   if (options.tests && config.gherkin) {
-    config.gherkin.features = '';
+    config.gherkin.features = ''
   }
 
-  const childProcessesPromise = new Promise((resolve) => {
-    processesDone = resolve;
-  });
+  const childProcessesPromise = new Promise(resolve => {
+    processesDone = resolve
+  })
 
-  const runsToExecute = [];
-  collection.createRuns(selectedRuns, config).forEach((run) => {
-    const runName = run.getOriginalName() || run.getName();
-    const runConfig = run.getConfig();
-    runsToExecute.push(executeRun(runName, runConfig));
-  });
+  const runsToExecute = []
+  createRuns(selectedRuns, config).forEach(run => {
+    const runName = run.getOriginalName() || run.getName()
+    const runConfig = run.getConfig()
+    runsToExecute.push(executeRun(runName, runConfig))
+  })
 
   if (!runsToExecute.length) {
-    fail('Nothing scheduled for execution');
+    fail('Nothing scheduled for execution')
   }
 
   // Execute all forks
-  totalSubprocessCount = runsToExecute.length;
-  runsToExecute.forEach(runToExecute => runToExecute.call(this));
+  totalSubprocessCount = runsToExecute.length
+  runsToExecute.forEach(runToExecute => runToExecute.call(this))
 
   return childProcessesPromise.then(async () => {
     // fire hook
-    await runHook(config.teardownAll, 'teardownAll');
-    event.emit(event.multiple.after, null);
-  });
+    await runHook(config.teardownAll, 'teardownAll')
+    event.emit(event.multiple.after, null)
+  })
 }
 
 function executeRun(runName, runConfig) {
   // clone config
-  let overriddenConfig = { ...config };
+  let overriddenConfig = { ...config }
 
   // get configuration
-  const browserConfig = runConfig.browser;
-  const browserName = browserConfig.browser;
+  const browserConfig = runConfig.browser
+  const browserName = browserConfig.browser
 
   for (const key in browserConfig) {
-    overriddenConfig.helpers = replaceValueDeep(overriddenConfig.helpers, key, browserConfig[key]);
+    overriddenConfig.helpers = replaceValueDeep(overriddenConfig.helpers, key, browserConfig[key])
   }
 
-  let outputDir = `${runName}_`;
+  let outputDir = `${runName}_`
   if (browserConfig.outputName) {
-    outputDir += typeof browserConfig.outputName === 'function' ? browserConfig.outputName() : browserConfig.outputName;
+    outputDir += typeof browserConfig.outputName === 'function' ? browserConfig.outputName() : browserConfig.outputName
   } else {
-    const hash = crypto.createHash('sha256');
-    hash.update(JSON.stringify(browserConfig));
-    outputDir += hash.digest('hex');
+    const hash = crypto.createHash('sha256')
+    hash.update(JSON.stringify(browserConfig))
+    outputDir += hash.digest('hex')
   }
-  outputDir += `_${runId}`;
+  outputDir += `_${runId}`
 
-  outputDir = clearString(outputDir);
+  outputDir = clearString(outputDir)
 
   // tweaking default output directories and for mochawesome
-  overriddenConfig = replaceValueDeep(overriddenConfig, 'output', path.join(config.output, outputDir));
-  overriddenConfig = replaceValueDeep(overriddenConfig, 'reportDir', path.join(config.output, outputDir));
-  overriddenConfig = replaceValueDeep(overriddenConfig, 'mochaFile', path.join(config.output, outputDir, `${browserName}_report.xml`));
+  overriddenConfig = replaceValueDeep(overriddenConfig, 'output', path.join(config.output, outputDir))
+  overriddenConfig = replaceValueDeep(overriddenConfig, 'reportDir', path.join(config.output, outputDir))
+  overriddenConfig = replaceValueDeep(overriddenConfig, 'mochaFile', path.join(config.output, outputDir, `${browserName}_report.xml`))
 
   // override tests configuration
   if (overriddenConfig.tests) {
-    overriddenConfig.tests = runConfig.tests;
+    overriddenConfig.tests = runConfig.tests
   }
 
   if (overriddenConfig.gherkin && runConfig.gherkin && runConfig.gherkin.features) {
-    overriddenConfig.gherkin.features = runConfig.gherkin.features;
+    overriddenConfig.gherkin.features = runConfig.gherkin.features
   }
 
   // override grep param and collect all params
-  const params = ['run',
-    '--child', `${runId++}.${runName}:${browserName}`,
-    '--override', JSON.stringify(overriddenConfig),
-  ];
+  const params = ['run', '--child', `${runId++}.${runName}:${browserName}`, '--override', JSON.stringify(overriddenConfig)]
 
-  Object.keys(childOpts).forEach((key) => {
-    params.push(`--${key}`);
-    if (childOpts[key] !== true) params.push(childOpts[key]);
-  });
+  Object.keys(childOpts).forEach(key => {
+    params.push(`--${key}`)
+    if (childOpts[key] !== true) params.push(childOpts[key])
+  })
 
   if (runConfig.grep) {
-    params.push('--grep');
-    params.push(runConfig.grep);
+    params.push('--grep')
+    params.push(runConfig.grep)
   }
 
-  const onProcessEnd = (errorCode) => {
+  const onProcessEnd = errorCode => {
     if (errorCode !== 0) {
-      process.exitCode = errorCode;
+      process.exitCode = errorCode
     }
-    subprocessCount += 1;
+    subprocessCount += 1
     if (subprocessCount === totalSubprocessCount) {
-      processesDone();
+      processesDone()
     }
-    return errorCode;
-  };
+    return errorCode
+  }
 
   // Return function of fork for later execution
-  return () => fork(runner, params, { stdio: [0, 1, 2, 'ipc'] })
-    .on('exit', (code) => {
-      return onProcessEnd(code);
-    })
-    .on('error', () => {
-      return onProcessEnd(1);
-    });
+  return () =>
+    fork(runner, params, { stdio: [0, 1, 2, 'ipc'] })
+      .on('exit', code => {
+        return onProcessEnd(code)
+      })
+      .on('error', () => {
+        return onProcessEnd(1)
+      })
 }