codeceptjs 3.6.10 → 3.7.0-beta.2

package/lib/data/context.js

@@ -13,8 +13,8 @@ module.exports = function (context) {
           fn = opts
           opts = {}
         }
-        opts.data = data.map((dataRow) => dataRow.data)
-        data.forEach((dataRow) => {
+        opts.data = data.map(dataRow => dataRow.data)
+        data.forEach(dataRow => {
           const dataTitle = replaceTitle(title, dataRow)
           if (dataRow.skip) {
             context.xScenario(dataTitle)
@@ -32,8 +32,8 @@ module.exports = function (context) {
             fn = opts
             opts = {}
           }
-          opts.data = data.map((dataRow) => dataRow.data)
-          data.forEach((dataRow) => {
+          opts.data = data.map(dataRow => dataRow.data)
+          data.forEach(dataRow => {
             const dataTitle = replaceTitle(title, dataRow)
             if (dataRow.skip) {
               context.xScenario(dataTitle)
@@ -51,8 +51,8 @@ module.exports = function (context) {
   context.xData = function (dataTable) {
     const data = detectDataType(dataTable)
     return {
-      Scenario: (title) => {
-        data.forEach((dataRow) => {
+      Scenario: title => {
+        data.forEach(dataRow => {
           const dataTitle = replaceTitle(title, dataRow)
           context.xScenario(dataTitle)
         })
@@ -69,10 +69,7 @@ function replaceTitle(title, dataRow) {
 
   // if `dataRow` is object and has own `toString()` method,
   // it should be printed
-  if (
-    Object.prototype.toString.call(dataRow.data) === Object().toString() &&
-    dataRow.data.toString() !== Object().toString()
-  ) {
+  if (Object.prototype.toString.call(dataRow.data) === Object().toString() && dataRow.data.toString() !== Object().toString()) {
     return `${title} | ${dataRow.data}`
   }
 
@@ -102,7 +99,7 @@ function detectDataType(dataTable) {
     return dataTable()
   }
   if (Array.isArray(dataTable)) {
-    return dataTable.map((item) => {
+    return dataTable.map(item => {
       if (isTableDataRow(item)) {
         return item
       }
@@ -117,10 +114,10 @@ function detectDataType(dataTable) {
 }
 
 function maskSecretInTitle(scenarios) {
-  scenarios.forEach((scenario) => {
+  scenarios.forEach(scenario => {
     const res = []
 
-    scenario.test.title.split(',').forEach((item) => {
+    scenario.test.title.split(',').forEach(item => {
       res.push(item.replace(/{"_secret":"(.*)"}/, '"*****"'))
     })
 

package/lib/data/dataScenarioConfig.js

@@ -10,7 +10,7 @@ class DataScenarioConfig {
    * @param {*} err
    */
   throws(err) {
-    this.scenarios.forEach((scenario) => scenario.throws(err))
+    this.scenarios.forEach(scenario => scenario.throws(err))
     return this
   }
 
@@ -21,7 +21,7 @@ class DataScenarioConfig {
    *
    */
   fails() {
-    this.scenarios.forEach((scenario) => scenario.fails())
+    this.scenarios.forEach(scenario => scenario.fails())
     return this
   }
 
@@ -31,7 +31,7 @@ class DataScenarioConfig {
    * @param {*} retries
    */
   retry(retries) {
-    this.scenarios.forEach((scenario) => scenario.retry(retries))
+    this.scenarios.forEach(scenario => scenario.retry(retries))
     return this
   }
 
@@ -40,7 +40,7 @@ class DataScenarioConfig {
    * @param {*} timeout
    */
   timeout(timeout) {
-    this.scenarios.forEach((scenario) => scenario.timeout(timeout))
+    this.scenarios.forEach(scenario => scenario.timeout(timeout))
     return this
   }
 
@@ -49,7 +49,7 @@ class DataScenarioConfig {
    * Helper name can be omitted and values will be applied to first helper.
    */
   config(helper, obj) {
-    this.scenarios.forEach((scenario) => scenario.config(helper, obj))
+    this.scenarios.forEach(scenario => scenario.config(helper, obj))
     return this
   }
 
@@ -58,7 +58,7 @@ class DataScenarioConfig {
    * @param {*} tagName
    */
   tag(tagName) {
-    this.scenarios.forEach((scenario) => scenario.tag(tagName))
+    this.scenarios.forEach(scenario => scenario.tag(tagName))
     return this
   }
 
@@ -67,7 +67,7 @@ class DataScenarioConfig {
    * @param {*} obj
    */
   inject(obj) {
-    this.scenarios.forEach((scenario) => scenario.inject(obj))
+    this.scenarios.forEach(scenario => scenario.inject(obj))
     return this
   }
 
@@ -76,7 +76,7 @@ class DataScenarioConfig {
    * @param {*} dependencies
    */
   injectDependencies(dependencies) {
-    this.scenarios.forEach((scenario) => scenario.injectDependencies(dependencies))
+    this.scenarios.forEach(scenario => scenario.injectDependencies(dependencies))
     return this
   }
 }

package/lib/data/dataTableArgument.js

@@ -5,8 +5,8 @@
 class DataTableArgument {
   /** @param {*} gherkinDataTable */
   constructor(gherkinDataTable) {
-    this.rawData = gherkinDataTable.rows.map((row) => {
-      return row.cells.map((cell) => {
+    this.rawData = gherkinDataTable.rows.map(row => {
+      return row.cells.map(cell => {
         return cell.value
       })
     })
@@ -34,7 +34,7 @@ class DataTableArgument {
   hashes() {
     const copy = this.raw()
     const header = copy.shift()
-    return copy.map((row) => {
+    return copy.map(row => {
       const r = {}
       row.forEach((cell, index) => (r[header[index]] = cell))
       return r
@@ -47,19 +47,19 @@ class DataTableArgument {
    */
   rowsHash() {
     const rows = this.raw()
-    const everyRowHasTwoColumns = rows.every((row) => row.length === 2)
+    const everyRowHasTwoColumns = rows.every(row => row.length === 2)
     if (!everyRowHasTwoColumns) {
       throw new Error('rowsHash can only be called on a data table where all rows have exactly two columns')
     }
     /** @type {Record<string, string>} */
     const result = {}
-    rows.forEach((x) => (result[x[0]] = x[1]))
+    rows.forEach(x => (result[x[0]] = x[1]))
     return result
   }
 
   /** Transposed the data */
   transpose() {
-    this.rawData = this.rawData[0].map((x, i) => this.rawData.map((y) => y[i]))
+    this.rawData = this.rawData[0].map((x, i) => this.rawData.map(y => y[i]))
   }
 }
 

package/lib/data/table.js

@@ -10,13 +10,10 @@ class DataTable {
 
   /** @param {Array<*>} array */
   add(array) {
-    if (array.length !== this.array.length)
-      throw new Error(
-        `There is too many elements in given data array. Please provide data in this format: ${this.array}`,
-      )
+    if (array.length !== this.array.length) throw new Error(`There is too many elements in given data array. Please provide data in this format: ${this.array}`)
     const tempObj = {}
     let arrayCounter = 0
-    this.array.forEach((elem) => {
+    this.array.forEach(elem => {
       tempObj[elem] = array[arrayCounter]
       tempObj.toString = () => JSON.stringify(tempObj)
       arrayCounter++
@@ -26,13 +23,10 @@ class DataTable {
 
   /** @param {Array<*>} array */
   xadd(array) {
-    if (array.length !== this.array.length)
-      throw new Error(
-        `There is too many elements in given data array. Please provide data in this format: ${this.array}`,
-      )
+    if (array.length !== this.array.length) throw new Error(`There is too many elements in given data array. Please provide data in this format: ${this.array}`)
     const tempObj = {}
     let arrayCounter = 0
-    this.array.forEach((elem) => {
+    this.array.forEach(elem => {
       tempObj[elem] = array[arrayCounter]
       tempObj.toString = () => JSON.stringify(tempObj)
       arrayCounter++
@@ -42,7 +36,7 @@ class DataTable {
 
   /** @param {Function} func */
   filter(func) {
-    return this.rows.filter((row) => func(row.data))
+    return this.rows.filter(row => func(row.data))
   }
 }
 

package/lib/els.js

@@ -0,0 +1,177 @@
+const output = require('./output');
+const store = require('./store');
+const recorder = require('./recorder');
+const container = require('./container');
+const event = require('./event');
+const Step = require('./step');
+const { truth } = require('./assert/truth');
+const { isAsyncFunction, humanizeFunction } = require('./utils');
+
+function element(purpose, locator, fn) {
+  if (!fn) {
+    fn = locator;
+    locator = purpose;
+    purpose = 'first element';
+  }
+
+  const step = prepareStep(purpose, locator, fn);
+  if (!step) return;
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator);
+    output.debug(`Found ${els.length} elements, using first element`);
+
+    return fn(els[0]);
+  });
+}
+
+function eachElement(purpose, locator, fn) {
+  if (!fn) {
+    fn = locator;
+    locator = purpose;
+    purpose = 'for each element';
+  }
+
+  const step = prepareStep(purpose, locator, fn);
+  if (!step) return;
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator);
+    output.debug(`Found ${els.length} elements for each elements to iterate`);
+
+    const errs = [];
+    let i = 0;
+    for (const el of els) {
+      try {
+        await fn(el, i);
+      } catch (err) {
+        output.error(`eachElement: failed operation on element #${i} ${el}`);
+        errs.push(err);
+      }
+      i++;
+    }
+
+    if (errs.length) {
+      throw errs[0];
+    }
+  });
+}
+
+function expectElement(locator, fn) {
+  const step = prepareStep('expect element to be', locator, fn);
+  if (!step) return;
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator);
+    output.debug(`Found ${els.length} elements, first will be used for assertion`);
+
+    const result = await fn(els[0]);
+    const assertion = truth(`element (${locator})`, fn.toString());
+    assertion.assert(result);
+  });
+}
+
+function expectAnyElement(locator, fn) {
+  const step = prepareStep('expect any element to be', locator, fn);
+  if (!step) return;
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator);
+    output.debug(`Found ${els.length} elements, at least one should pass the assertion`);
+
+    const assertion = truth(`any element of (${locator})`, fn.toString());
+
+    let found = false;
+    for (const el of els) {
+      const result = await fn(el);
+      if (result) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) throw assertion.getException();
+  });
+}
+
+function expectAllElements(locator, fn) {
+  const step = prepareStep('expect all elements', locator, fn);
+  if (!step) return;
+
+  return executeStep(step, async () => {
+    const els = await step.helper._locate(locator);
+    output.debug(`Found ${els.length} elements, all should pass the assertion`);
+
+    let i = 1;
+    for (const el of els) {
+      output.debug(`checking element #${i}: ${el}`);
+      const result = await fn(el);
+      const assertion = truth(`element #${i} of (${locator})`, humanizeFunction(fn));
+      assertion.assert(result);
+      i++;
+    }
+  });
+}
+
+module.exports = {
+  element,
+  eachElement,
+  expectElement,
+  expectAnyElement,
+  expectAllElements,
+};
+
+function prepareStep(purpose, locator, fn) {
+  if (store.dryRun) return;
+  const helpers = Object.values(container.helpers());
+
+  const helper = helpers.filter(h => !!h._locate)[0];
+
+  if (!helper) {
+    throw new Error('No helper enabled with _locate method with returns a list of elements.');
+  }
+
+  if (!isAsyncFunction(fn)) {
+    throw new Error('Async function should be passed into each element');
+  }
+
+  const isAssertion = purpose.startsWith('expect');
+
+  const step = new Step(helper, `${purpose} within "${locator}" ${isAssertion ? 'to be' : 'to'}`);
+  step.setActor('EL');
+  step.setArguments([humanizeFunction(fn)]);
+  step.helperMethod = '_locate';
+
+  return step;
+}
+
+async function executeStep(step, action) {
+  let error;
+  const promise = recorder.add('register element wrapper', async () => {
+    event.emit(event.step.started, step);
+
+    try {
+      await action();
+    } catch (err) {
+      recorder.throw(err);
+      event.emit(event.step.failed, step, err);
+      event.emit(event.step.finished, step);
+      // event.emit(event.step.after, step)
+      error = err;
+      // await recorder.promise();
+      return;
+    }
+
+    event.emit(event.step.after, step);
+    event.emit(event.step.passed, step);
+    event.emit(event.step.finished, step);
+  });
+
+  // await recorder.promise();
+
+  // if (error) {
+  //   console.log('error', error.inspect())
+  //   return recorder.throw(error);
+  // }
+
+  return promise;
+}

package/lib/event.js

@@ -60,6 +60,7 @@ module.exports = {
     passed: 'hook.passed',
     failed: 'hook.failed',
   },
+
   /**
    * @type {object}
    * @constant

package/lib/heal.js

@@ -1,122 +1,125 @@
-const debug = require('debug')('codeceptjs:heal');
-const colors = require('chalk');
-const Container = require('./container');
-const recorder = require('./recorder');
-const output = require('./output');
-const event = require('./event');
+const debug = require('debug')('codeceptjs:heal')
+const colors = require('chalk')
+const Container = require('./container')
+const recorder = require('./recorder')
+const output = require('./output')
+const event = require('./event')
 
 /**
  * @class
  */
 class Heal {
   constructor() {
-    this.recipes = {};
-    this.fixes = [];
-    this.prepareFns = [];
-    this.contextName = null;
-    this.numHealed = 0;
+    this.recipes = {}
+    this.fixes = []
+    this.prepareFns = []
+    this.contextName = null
+    this.numHealed = 0
   }
 
   clear() {
-    this.recipes = {};
-    this.fixes = [];
-    this.prepareFns = [];
-    this.contextName = null;
-    this.numHealed = 0;
+    this.recipes = {}
+    this.fixes = []
+    this.prepareFns = []
+    this.contextName = null
+    this.numHealed = 0
   }
 
   addRecipe(name, opts = {}) {
-    if (!opts.priority) opts.priority = 0;
+    if (!opts.priority) opts.priority = 0
 
-    if (!opts.fn) throw new Error(`Recipe ${name} should have a function 'fn' to execute`);
+    if (!opts.fn) throw new Error(`Recipe ${name} should have a function 'fn' to execute`)
 
-    this.recipes[name] = opts;
+    this.recipes[name] = opts
   }
 
   connectToEvents() {
-    event.dispatcher.on(event.suite.before, (suite) => {
-      this.contextName = suite.title;
-    });
+    event.dispatcher.on(event.suite.before, suite => {
+      this.contextName = suite.title
+    })
 
-    event.dispatcher.on(event.test.started, (test) => {
-      this.contextName = test.fullTitle();
-    });
+    event.dispatcher.on(event.test.started, test => {
+      this.contextName = test.fullTitle()
+    })
 
     event.dispatcher.on(event.test.finished, () => {
-      this.contextName = null;
-    });
+      this.contextName = null
+    })
   }
 
   hasCorrespondingRecipes(step) {
-    return matchRecipes(this.recipes, this.contextName)
-      .filter(r => !r.steps || r.steps.includes(step.name))
-      .length > 0;
+    return matchRecipes(this.recipes, this.contextName).filter(r => !r.steps || r.steps.includes(step.name)).length > 0
   }
 
   async getCodeSuggestions(context) {
-    const suggestions = [];
-    const recipes = matchRecipes(this.recipes, this.contextName);
+    const suggestions = []
+    const recipes = matchRecipes(this.recipes, this.contextName)
 
-    debug('Recipes', recipes);
+    debug('Recipes', recipes)
 
-    const currentOutputLevel = output.level();
-    output.level(0);
+    const currentOutputLevel = output.level()
+    output.level(0)
 
-    for (const [property, prepareFn] of Object.entries(recipes.map(r => r.prepare).filter(p => !!p).reduce((acc, obj) => ({ ...acc, ...obj }), {}))) {
-      if (!prepareFn) continue;
+    for (const [property, prepareFn] of Object.entries(
+      recipes
+        .map(r => r.prepare)
+        .filter(p => !!p)
+        .reduce((acc, obj) => ({ ...acc, ...obj }), {}),
+    )) {
+      if (!prepareFn) continue
 
-      if (context[property]) continue;
-      context[property] = await prepareFn(Container.support());
+      if (context[property]) continue
+      context[property] = await prepareFn(Container.support())
     }
 
-    output.level(currentOutputLevel);
+    output.level(currentOutputLevel)
 
     for (const recipe of recipes) {
-      let snippets = await recipe.fn(context);
-      if (!Array.isArray(snippets)) snippets = [snippets];
+      let snippets = await recipe.fn(context)
+      if (!Array.isArray(snippets)) snippets = [snippets]
 
       suggestions.push({
         name: recipe.name,
         snippets,
-      });
+      })
     }
 
-    return suggestions.filter(s => !isBlank(s.snippets));
+    return suggestions.filter(s => !isBlank(s.snippets))
   }
 
   async healStep(failedStep, error, failureContext = {}) {
-    output.debug(`Trying to heal ${failedStep.toCode()} step`);
+    output.debug(`Trying to heal ${failedStep.toCode()} step`)
 
     Object.assign(failureContext, {
       error,
       step: failedStep,
       prevSteps: failureContext?.test?.steps?.slice(0, -1) || [],
-    });
+    })
 
-    const suggestions = await this.getCodeSuggestions(failureContext);
+    const suggestions = await this.getCodeSuggestions(failureContext)
 
     if (suggestions.length === 0) {
-      debug('No healing suggestions found');
-      throw error;
+      debug('No healing suggestions found')
+      throw error
     }
 
-    output.debug(`Received ${suggestions.length} suggestion${suggestions.length === 1 ? '' : 's'}`);
+    output.debug(`Received ${suggestions.length} suggestion${suggestions.length === 1 ? '' : 's'}`)
 
-    debug(suggestions);
+    debug(suggestions)
 
     for (const suggestion of suggestions) {
       for (const codeSnippet of suggestion.snippets) {
         try {
-          debug('Executing', codeSnippet);
-          recorder.catch((e) => {
-            debug(e);
-          });
+          debug('Executing', codeSnippet)
+          recorder.catch(e => {
+            debug(e)
+          })
 
           if (typeof codeSnippet === 'string') {
-            const I = Container.support('I');
-            await eval(codeSnippet); // eslint-disable-line
+            const I = Container.support('I')
+            await eval(codeSnippet)
           } else if (typeof codeSnippet === 'function') {
-            await codeSnippet(Container.support());
+            await codeSnippet(Container.support())
           }
 
           this.fixes.push({
@@ -124,49 +127,44 @@ class Heal {
             test: failureContext?.test,
             step: failedStep,
             snippet: codeSnippet,
-          });
+          })
 
-          recorder.add('healed', () => output.print(colors.bold.green(`  Code healed successfully by ${suggestion.name}`), colors.gray('(no errors thrown)')));
-          this.numHealed++;
+          recorder.add('healed', () => output.print(colors.bold.green(`  Code healed successfully by ${suggestion.name}`), colors.gray('(no errors thrown)')))
+          this.numHealed++
           // recorder.session.restore();
-          return;
+          return
         } catch (err) {
-          debug('Failed to execute code', err);
-          recorder.ignoreErr(err); // healing did not help
-          recorder.catchWithoutStop(err);
-          await recorder.promise(); // wait for all promises to resolve
+          debug('Failed to execute code', err)
+          recorder.ignoreErr(err) // healing did not help
+          recorder.catchWithoutStop(err)
+          await recorder.promise() // wait for all promises to resolve
         }
       }
     }
-    output.debug(`Couldn't heal the code for ${failedStep.toCode()}`);
-    recorder.throw(error);
+    output.debug(`Couldn't heal the code for ${failedStep.toCode()}`)
+    recorder.throw(error)
   }
 
   static setDefaultHealers() {
-    require('./template/heal');
+    require('./template/heal')
   }
 }
 
-const heal = new Heal();
+const heal = new Heal()
 
-module.exports = heal;
+module.exports = heal
 
 function matchRecipes(recipes, contextName) {
   return Object.entries(recipes)
     .filter(([, recipe]) => !contextName || !recipe.grep || new RegExp(recipe.grep).test(contextName))
     .sort(([, a], [, b]) => a.priority - b.priority)
     .map(([name, recipe]) => {
-      recipe.name = name;
-      return recipe;
+      recipe.name = name
+      return recipe
     })
-    .filter(r => !!r.fn);
+    .filter(r => !!r.fn)
 }
 
 function isBlank(value) {
-  return (
-    value == null
-      || (Array.isArray(value) && value.length === 0)
-      || (typeof value === 'object' && Object.keys(value).length === 0)
-      || (typeof value === 'string' && value.trim() === '')
-  );
+  return value == null || (Array.isArray(value) && value.length === 0) || (typeof value === 'object' && Object.keys(value).length === 0) || (typeof value === 'string' && value.trim() === '')
 }

package/lib/helper/ApiDataFactory.js

@@ -217,7 +217,7 @@ class ApiDataFactory extends Helper {
     }
 
     this.created = {}
-    Object.keys(this.factories).forEach((f) => (this.created[f] = []))
+    Object.keys(this.factories).forEach(f => (this.created[f] = []))
   }
 
   static _checkRequirements() {
@@ -357,7 +357,7 @@ Current file error: ${err.message}`)
 
     request.baseURL = this.config.endpoint
 
-    return this.restHelper._executeRequest(request).then((resp) => {
+    return this.restHelper._executeRequest(request).then(resp => {
       const id = this._fetchId(resp.data, factory)
       this.created[factory].push(id)
       this.debugSection('Created', `Id: ${id}`)
@@ -391,10 +391,7 @@ Current file error: ${err.message}`)
     request.baseURL = this.config.endpoint
 
     if (request.url.match(/^undefined/)) {
-      return this.debugSection(
-        'Please configure the delete request in your ApiDataFactory helper',
-        "delete: () => ({ method: 'DELETE',  url: '/api/users' })",
-      )
+      return this.debugSection('Please configure the delete request in your ApiDataFactory helper', "delete: () => ({ method: 'DELETE',  url: '/api/users' })")
     }
 
     return this.restHelper._executeRequest(request).then(() => {