quickpickle 1.6.2 → 1.7.0

package/dist/index.esm.js

@@ -3,8 +3,6 @@ import { intersection, isFunction, isString, concat, fromPairs, escapeRegExp, de
 import parse from '@cucumber/tag-expressions';
 import * as Gherkin from '@cucumber/gherkin';
 import * as Messages from '@cucumber/messages';
-import { DataTable } from '@cucumber/cucumber';
-export { DataTable } from '@cucumber/cucumber';
 
 const steps = [];
 const parameterTypeRegistry = new ParameterTypeRegistry();
@@ -433,6 +431,169 @@ function explodeTags(explodeTags, testTags) {
     return combined.length ? combined.map(arr => [...tagsToTest, ...arr]) : [testTags];
 }
 
+class DataTable {
+    constructor(sourceTable) {
+        if (sourceTable instanceof Array) {
+            this.rawTable = sourceTable;
+        }
+        else {
+            this.rawTable = sourceTable.rows.map((row) => row.cells.map((cell) => cell.value));
+        }
+    }
+    /**
+     * This method returns an array of objects of the shape { [key: string]: string }.
+     * It is intended for tables with a header row, as follows:
+     *
+     * ```
+     * | id | name   | color  | taste |
+     * | 1  | apple  | red    | sweet |
+     * | 2  | banana | yellow | sweet |
+     * | 3  | orange | orange | sour  |
+     * ```
+     *
+     * This would return the following array of objects:
+     *
+     * ```
+     * [
+     *   { id: '1', name: 'apple', color: 'red', taste: 'sweet' },
+     *   { id: '2', name: 'banana', color: 'yellow', taste: 'sweet' },
+     *   { id: '3', name: 'orange', color: 'orange', taste: 'sour' },
+     * ]
+     * ```
+     *
+     * @returns Record<string, string>[]
+     */
+    hashes() {
+        const copy = this.raw();
+        const keys = copy[0];
+        const valuesArray = copy.slice(1);
+        return valuesArray.map((values) => {
+            const rowObject = {};
+            keys.forEach((key, index) => (rowObject[key] = values[index]));
+            return rowObject;
+        });
+    }
+    /**
+     * This method returns the raw table as a two-dimensional array.
+     * It can be used for tables with or without a header row, for example:
+     *
+     * ```
+     * | id | name   | color  | taste |
+     * | 1  | apple  | red    | sweet |
+     * | 2  | banana | yellow | sweet |
+     * | 3  | orange | orange | sour  |
+     * ```
+     *
+     * would return the following array of objects:
+     *
+     * ```
+     * [
+     *   ['id', 'name', 'color', 'taste'],
+     *   ['1', 'apple', 'red', 'sweet'],
+     *   ['2', 'banana', 'yellow', 'sweet'],
+     *   ['3', 'orange', 'orange', 'sour'],
+     * ]
+     * ```
+     *
+     * @returns string[][]
+     */
+    raw() {
+        return this.rawTable.slice(0);
+    }
+    /**
+     * This method is intended for tables with a header row, and returns
+     * the value rows as a two-dimensional array, without the header row:
+     *
+     * ```
+     * | id | name   | color  | taste |
+     * | 1  | apple  | red    | sweet |
+     * | 2  | banana | yellow | sweet |
+     * | 3  | orange | orange | sour  |
+     * ```
+     *
+     * would return the following array of objects:
+     *
+     * ```
+     * [
+     *   ['1', 'apple', 'red', 'sweet'],
+     *   ['2', 'banana', 'yellow', 'sweet'],
+     *   ['3', 'orange', 'orange', 'sour'],
+     * ]
+     * ```
+     *
+     * @returns string[][]
+     */
+    rows() {
+        const copy = this.raw();
+        copy.shift();
+        return copy;
+    }
+    /**
+     * This method is intended for tables with exactly two columns.
+     * It returns a single object with the first column as keys and
+     * the second column as values.
+     *
+     * ```
+     * | id    | 1     |
+     * | name  | apple |
+     * | color | red   |
+     * | taste | sweet |
+     * ```
+     *
+     * would return the following object:
+     *
+     * ```
+     * {
+     *   id: '1',
+     *   name: 'apple',
+     *   color: 'red',
+     *   taste: 'sweet',
+     * }
+     * ```
+     *
+     * @returns Record<string, string>
+     */
+    rowsHash() {
+        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');
+        }
+        const result = {};
+        rows.forEach((x) => (result[x[0]] = x[1]));
+        return result;
+    }
+    /**
+     * This method transposes the DataTable, making the columns into rows
+     * and vice versa. For example the following raw table:
+     *
+     * ```
+     * [
+     *   ['1', 'apple', 'red', 'sweet'],
+     *   ['2', 'banana', 'yellow', 'sweet'],
+     *   ['3', 'orange', 'orange', 'sour'],
+     * ]
+     * ```
+     *
+     * would be transposed to:
+     *
+     * ```
+     * [
+     *   ['1', '2', '3'],
+     *   ['apple', 'banana', 'orange'],
+     *   ['red', 'yellow', 'orange'],
+     *   ['sweet', 'sweet', 'sour'],
+     * ]
+     * ```
+     *
+     * @returns DataTable
+     */
+    transpose() {
+        const transposed = this.rawTable[0].map((x, i) => this.rawTable.map((y) => y[i]));
+        return new DataTable(transposed);
+    }
+}
+
 class DocString extends String {
     constructor(content, mediaType = '') {
         super(content);
@@ -488,13 +649,25 @@ const featureRegex = /\.feature(?:\.md)?$/;
 const Given = addStepDefinition;
 const When = addStepDefinition;
 const Then = addStepDefinition;
+const stackRegex = /\.feature(?:\.md)?:\d+:\d+/;
 function formatStack(text, line) {
+    if (!text.match(stackRegex))
+        return text;
     let stack = text.split('\n');
-    while (!stack[0].match(/\.feature(?:\.md)?:\d+:\d+/))
+    while (!stack[0].match(stackRegex))
         stack.shift();
     stack[0] = stack[0].replace(/:\d+:\d+$/, `:${line}:1`);
     return stack.join('\n');
 }
+function raceTimeout(work, ms, errorMessage) {
+    let timerId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timerId = setTimeout(() => reject(new Error(errorMessage)), ms);
+    });
+    // make sure to clearTimeout on either success *or* failure
+    const wrapped = work.finally(() => clearTimeout(timerId));
+    return Promise.race([wrapped, timeoutPromise]);
+}
 const gherkinStep = async (stepType, step, state, line, stepIdx, explodeIdx, data) => {
     try {
         // Set the state info
@@ -513,27 +686,30 @@ const gherkinStep = async (stepType, step, state, line, stepIdx, explodeIdx, dat
             data = new DocString(data.content, data.mediaType);
             dataType = 'docString';
         }
-        await applyHooks('beforeStep', state);
-        try {
-            const stepDefinitionMatch = findStepDefinitionMatch(step, { stepType, dataType });
-            await stepDefinitionMatch.stepDefinition.f(state, ...stepDefinitionMatch.parameters, data);
-        }
-        catch (e) {
-            // Add the Cucumber info to the error message
-            e.message = `${step} (#${line})\n${e.message}`;
-            // Sort out the stack for the Feature file
-            e.stack = formatStack(e.stack, state.info.line);
-            // Set the flag that this error has been added to the state
-            e.isStepError = true;
-            // Add the error to the state
-            state.info.errors.push(e);
-            // If not in a soft fail mode, re-throw the error
-            if (state.isComplete || !state.tagsMatch(state.config.softFailTags))
-                throw e;
-        }
-        finally {
-            await applyHooks('afterStep', state);
-        }
+        const promise = async () => {
+            await applyHooks('beforeStep', state);
+            try {
+                const stepDefinitionMatch = findStepDefinitionMatch(step, { stepType, dataType });
+                await stepDefinitionMatch.stepDefinition.f(state, ...stepDefinitionMatch.parameters, data);
+            }
+            catch (e) {
+                // Add the Cucumber info to the error message
+                e.message = `${step} (#${line})\n${e.message}`;
+                // Sort out the stack for the Feature file
+                e.stack = formatStack(e.stack, state.info.line);
+                // Set the flag that this error has been added to the state
+                e.isStepError = true;
+                // Add the error to the state
+                state.info.errors.push(e);
+                // If not in a soft fail mode, re-throw the error
+                if (state.isComplete || !state.tagsMatch(state.config.softFailTags))
+                    throw e;
+            }
+            finally {
+                await applyHooks('afterStep', state);
+            }
+        };
+        await raceTimeout(promise(), state.config.stepTimeout, `Step timed out after ${state.config.stepTimeout}ms`);
     }
     catch (e) {
         // If the error hasn't already been added to the state:
@@ -548,7 +724,7 @@ const gherkinStep = async (stepType, step, state, line, stepIdx, explodeIdx, dat
             return;
         // The After hook is usually run in the rendered file, at the end of the rendered steps.
         // But, if the tests have failed, then it should run here, since the test is halted.
-        await applyHooks('after', state);
+        await raceTimeout(applyHooks('after', state), state.config.stepTimeout, `After hook timed out after ${state.config.stepTimeout}ms`);
         // Otherwise throw the error
         throw e;
     }
@@ -565,6 +741,10 @@ const defaultConfig = {
      * The root directory for the tests to run, from vite or vitest config
      */
     root: '',
+    /**
+     * The maximum time in ms to wait for a step to complete.
+     */
+    stepTimeout: 3000,
     /**
      * Tags to mark as todo, using Vitest's `test.todo` implementation.
      */
@@ -598,7 +778,7 @@ const defaultConfig = {
      * Not used by the default World class, but may be used by plugins or custom
      * implementations, like @quickpickle/playwright.
      */
-    worldConfig: {}
+    worldConfig: {},
 };
 function is2d(arr) {
     return Array.isArray(arr) && arr.every(item => Array.isArray(item));
@@ -631,5 +811,5 @@ const quickpickle = (conf = {}) => {
     };
 };
 
-export { After, AfterAll, AfterStep, Before, BeforeAll, BeforeStep, DocString, Given, QuickPickleWorld, Then, When, applyHooks, quickpickle as default, defaultConfig, defineParameterType, explodeTags, formatStack, getWorldConstructor, gherkinStep, normalizeTags, quickpickle, setWorldConstructor, tagsMatch };
+export { After, AfterAll, AfterStep, Before, BeforeAll, BeforeStep, DataTable, DocString, Given, QuickPickleWorld, Then, When, applyHooks, quickpickle as default, defaultConfig, defineParameterType, explodeTags, formatStack, getWorldConstructor, gherkinStep, normalizeTags, quickpickle, setWorldConstructor, tagsMatch };
 //# sourceMappingURL=index.esm.js.map