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

package/lib/data/context.js

@@ -1,128 +1,127 @@
-import { isGenerator } from '../utils.js';
-import DataTable from './table.js';
-import DataScenarioConfig from './dataScenarioConfig.js';
+import { isGenerator } from '../utils.js'
+import DataTable from './table.js'
+import DataScenarioConfig from './dataScenarioConfig.js'
+import secretModule from '../secret.js'
+const Secret = secretModule.default || secretModule
 
 export default function (context) {
   context.Data = function (dataTable) {
-    const data = detectDataType(dataTable);
+    const data = detectDataType(dataTable)
     return {
       Scenario(title, opts, fn) {
-        const scenarios = [];
+        const scenarios = []
         if (typeof opts === 'function' && !fn) {
-          fn = opts;
-          opts = {};
+          fn = opts
+          opts = {}
         }
-        opts.data = data.map(dataRow => dataRow.data);
-        data.forEach((dataRow) => {
-          const dataTitle = replaceTitle(title, dataRow);
+        opts.data = data.map(dataRow => dataRow.data)
+        data.forEach(dataRow => {
+          const dataTitle = replaceTitle(title, dataRow)
           if (dataRow.skip) {
-            context.xScenario(dataTitle);
+            context.xScenario(dataTitle)
           } else {
-            scenarios.push(context.Scenario(dataTitle, opts, fn)
-              .inject({ current: dataRow.data }));
+            scenarios.push(context.Scenario(dataTitle, opts, fn).inject({ current: dataRow.data }))
           }
-        });
-        maskSecretInTitle(scenarios);
-        return new DataScenarioConfig(scenarios);
+        })
+        maskSecretInTitle(scenarios)
+        return new DataScenarioConfig(scenarios)
       },
       only: {
         Scenario(title, opts, fn) {
-          const scenarios = [];
+          const scenarios = []
           if (typeof opts === 'function' && !fn) {
-            fn = opts;
-            opts = {};
+            fn = opts
+            opts = {}
           }
-          opts.data = data.map(dataRow => dataRow.data);
-          data.forEach((dataRow) => {
-            const dataTitle = replaceTitle(title, dataRow);
+          opts.data = data.map(dataRow => dataRow.data)
+          data.forEach(dataRow => {
+            const dataTitle = replaceTitle(title, dataRow)
             if (dataRow.skip) {
-              context.xScenario(dataTitle);
+              context.xScenario(dataTitle)
             } else {
-              scenarios.push(context.Scenario.only(dataTitle, opts, fn)
-                .inject({ current: dataRow.data }));
+              scenarios.push(context.Scenario.only(dataTitle, opts, fn).inject({ current: dataRow.data }))
             }
-          });
-          maskSecretInTitle(scenarios);
-          return new DataScenarioConfig(scenarios);
+          })
+          maskSecretInTitle(scenarios)
+          return new DataScenarioConfig(scenarios)
         },
       },
-    };
-  };
+    }
+  }
 
   context.xData = function (dataTable) {
-    const data = detectDataType(dataTable);
+    const data = detectDataType(dataTable)
     return {
-      Scenario: (title) => {
-        data.forEach((dataRow) => {
-          const dataTitle = replaceTitle(title, dataRow);
-          context.xScenario(dataTitle);
-        });
-        return new DataScenarioConfig([]);
+      Scenario: title => {
+        data.forEach(dataRow => {
+          const dataTitle = replaceTitle(title, dataRow)
+          context.xScenario(dataTitle)
+        })
+        return new DataScenarioConfig([])
       },
-    };
-  };
+    }
+  }
 }
 
 function replaceTitle(title, dataRow) {
   if (typeof dataRow.data !== 'object') {
-    return `${title} | {${JSON.stringify(dataRow.data)}}`;
+    return `${title} | {${JSON.stringify(dataRow.data)}}`
   }
 
   // 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()) {
-    return `${title} | ${dataRow.data}`;
+  if (Object.prototype.toString.call(dataRow.data) === Object().toString() && dataRow.data.toString() !== Object().toString()) {
+    return `${title} | ${dataRow.data}`
   }
 
-  return `${title} | ${JSON.stringify(dataRow.data)}`;
+  return `${title} | ${JSON.stringify(dataRow.data)}`
 }
 
 function isTableDataRow(row) {
-  const has = Object.prototype.hasOwnProperty;
-  return has.call(row, 'data') && has.call(row, 'skip');
+  const has = Object.prototype.hasOwnProperty
+  return has.call(row, 'data') && has.call(row, 'skip')
 }
 
 function detectDataType(dataTable) {
   if (dataTable instanceof DataTable) {
-    return dataTable.rows;
+    return dataTable.rows
   }
 
   if (isGenerator(dataTable)) {
-    const data = [];
+    const data = []
     for (const dataRow of dataTable()) {
       data.push({
         data: dataRow,
-      });
+      })
     }
-    return data;
+    return data
   }
   if (typeof dataTable === 'function') {
-    return dataTable();
+    return dataTable()
   }
   if (Array.isArray(dataTable)) {
-    return dataTable.map((item) => {
+    return dataTable.map(item => {
       if (isTableDataRow(item)) {
-        return item;
+        return item
       }
       return {
         data: item,
         skip: false,
-      };
-    });
+      }
+    })
   }
 
-  throw new Error('Invalid data type. Data accepts either: DataTable || generator || Array || function');
+  throw new Error('Invalid data type. Data accepts either: DataTable || generator || Array || function')
 }
 
 function maskSecretInTitle(scenarios) {
   scenarios.forEach(scenario => {
-    const res = [];
+    const res = []
 
     scenario.test.title.split(',').forEach(item => {
-      res.push(item.replace(/{"_secret":"(.*)"}/, '"*****"'));
-    });
+      res.push(item.replace(/{"_secret":"(.*)"}/, '"*****"'))
+    })
 
-    scenario.test.title = res.join(',');
-  });
+    scenario.test.title = res.join(',')
+  })
 }

package/lib/data/dataScenarioConfig.js

@@ -1,84 +1,84 @@
 class DataScenarioConfig {
   constructor(scenarios) {
-    this.scenarios = scenarios;
+    this.scenarios = scenarios
   }
 
   /**
-     * Declares that test throws error.
-     * Can pass an Error object or regex matching expected message.
-     *
-     * @param {*} err
-     */
+   * Declares that test throws error.
+   * Can pass an Error object or regex matching expected message.
+   *
+   * @param {*} err
+   */
   throws(err) {
-    this.scenarios.forEach(scenario => scenario.throws(err));
-    return this;
+    this.scenarios.forEach(scenario => scenario.throws(err))
+    return this
   }
 
   /**
-     * Declares that test should fail.
-     * If test passes - throws an error.
-     * Can pass an Error object or regex matching expected message.
-     *
-     */
+   * Declares that test should fail.
+   * If test passes - throws an error.
+   * Can pass an Error object or regex matching expected message.
+   *
+   */
   fails() {
-    this.scenarios.forEach(scenario => scenario.fails());
-    return this;
+    this.scenarios.forEach(scenario => scenario.fails())
+    return this
   }
 
   /**
-     * Retry this test for x times
-     *
-     * @param {*} retries
-     */
+   * Retry this test for x times
+   *
+   * @param {*} retries
+   */
   retry(retries) {
-    this.scenarios.forEach(scenario => scenario.retry(retries));
-    return this;
+    this.scenarios.forEach(scenario => scenario.retry(retries))
+    return this
   }
 
   /**
-     * Set timeout for this test
-     * @param {*} timeout
-     */
+   * Set timeout for this test
+   * @param {*} timeout
+   */
   timeout(timeout) {
-    this.scenarios.forEach(scenario => scenario.timeout(timeout));
-    return this;
+    this.scenarios.forEach(scenario => scenario.timeout(timeout))
+    return this
   }
 
   /**
-     * Configures a helper.
-     * Helper name can be omitted and values will be applied to first helper.
-     */
+   * Configures a helper.
+   * Helper name can be omitted and values will be applied to first helper.
+   */
   config(helper, obj) {
-    this.scenarios.forEach(scenario => scenario.config(helper, obj));
-    return this;
+    this.scenarios.forEach(scenario => scenario.config(helper, obj))
+    return this
   }
 
   /**
-     * Append a tag name to scenario title
-     * @param {*} tagName
-     */
+   * Append a tag name to scenario title
+   * @param {*} tagName
+   */
   tag(tagName) {
-    this.scenarios.forEach(scenario => scenario.tag(tagName));
-    return this;
+    this.scenarios.forEach(scenario => scenario.tag(tagName))
+    return this
   }
 
   /**
-     * Pass in additional objects to inject into test
-     * @param {*} obj
-     */
+   * Pass in additional objects to inject into test
+   * @param {*} obj
+   */
   inject(obj) {
-    this.scenarios.forEach(scenario => scenario.inject(obj));
-    return this;
+    this.scenarios.forEach(scenario => scenario.inject(obj))
+    return this
   }
 
   /**
-     * Dynamically injects dependencies, see https://codecept.io/pageobjects/#dynamic-injection
-     * @param {*} dependencies
-     */
+   * Dynamically injects dependencies, see https://codecept.io/pageobjects/#dynamic-injection
+   * @param {*} dependencies
+   */
   injectDependencies(dependencies) {
-    this.scenarios.forEach(scenario => scenario.injectDependencies(dependencies));
-    return this;
+    this.scenarios.forEach(scenario => scenario.injectDependencies(dependencies))
+    return this
   }
 }
 
-export default DataScenarioConfig;
+export default DataScenarioConfig

package/lib/data/dataTableArgument.js

@@ -5,62 +5,62 @@
 class DataTableArgument {
   /** @param {*} gherkinDataTable */
   constructor(gherkinDataTable) {
-    this.rawData = gherkinDataTable.rows.map((row) => {
-      return row.cells.map((cell) => {
-        return cell.value;
-      });
-    });
+    this.rawData = gherkinDataTable.rows.map(row => {
+      return row.cells.map(cell => {
+        return cell.value
+      })
+    })
   }
 
   /** Returns the table as a 2-D array
-  * @returns {string[][]}
-  */
+   * @returns {string[][]}
+   */
   raw() {
-    return this.rawData.slice(0);
+    return this.rawData.slice(0)
   }
 
   /** Returns the table as a 2-D array, without the first row
-  * @returns {string[][]}
-  */
+   * @returns {string[][]}
+   */
   rows() {
-    const copy = this.raw();
-    copy.shift();
-    return copy;
+    const copy = this.raw()
+    copy.shift()
+    return copy
   }
 
   /** Returns an array of objects where each row is converted to an object (column header is the key)
-  * @returns {any[]}
-  */
+   * @returns {any[]}
+   */
   hashes() {
-    const copy = this.raw();
-    const header = copy.shift();
-    return copy.map((row) => {
-      const r = {};
-      row.forEach((cell, index) => r[header[index]] = cell);
-      return r;
-    });
+    const copy = this.raw()
+    const header = copy.shift()
+    return copy.map(row => {
+      const r = {}
+      row.forEach((cell, index) => (r[header[index]] = cell))
+      return r
+    })
   }
 
   /** Returns an object where each row corresponds to an entry
    * (first column is the key, second column is the value)
-  * @returns {Record<string, string>}
-  */
+   * @returns {Record<string, string>}
+   */
   rowsHash() {
-    const rows = this.raw();
-    const everyRowHasTwoColumns = rows.every((row) => row.length === 2);
+    const rows = this.raw()
+    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');
+      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]));
-    return result;
+    const result = {}
+    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]))
   }
 }
 
-export default DataTableArgument;
+export default DataTableArgument

package/lib/data/table.js

@@ -4,40 +4,40 @@
 class DataTable {
   /** @param {Array<*>} array */
   constructor(array) {
-    this.array = array;
-    this.rows = new Array(0);
+    this.array = array
+    this.rows = new Array(0)
   }
 
   /** @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}`);
-    const tempObj = {};
-    let arrayCounter = 0;
-    this.array.forEach((elem) => {
-      tempObj[elem] = array[arrayCounter];
-      tempObj.toString = () => JSON.stringify(tempObj);
-      arrayCounter++;
-    });
-    this.rows.push({ skip: false, data: tempObj });
+    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 => {
+      tempObj[elem] = array[arrayCounter]
+      tempObj.toString = () => JSON.stringify(tempObj)
+      arrayCounter++
+    })
+    this.rows.push({ skip: false, data: tempObj })
   }
 
   /** @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}`);
-    const tempObj = {};
-    let arrayCounter = 0;
-    this.array.forEach((elem) => {
-      tempObj[elem] = array[arrayCounter];
-      tempObj.toString = () => JSON.stringify(tempObj);
-      arrayCounter++;
-    });
-    this.rows.push({ skip: true, data: tempObj });
+    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 => {
+      tempObj[elem] = array[arrayCounter]
+      tempObj.toString = () => JSON.stringify(tempObj)
+      arrayCounter++
+    })
+    this.rows.push({ skip: true, data: tempObj })
   }
 
   /** @param {Function} func */
   filter(func) {
-    return this.rows.filter(row => func(row.data));
+    return this.rows.filter(row => func(row.data))
   }
 }
 
-export default DataTable;
+export default DataTable