@qavajs/playwright-runner-adapter 2.3.3 → 2.5.0

package/adapter/js/cucumberAdapter.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTagFilter = createTagFilter;
 exports.defineConfig = defineConfig;
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const node_util_1 = require("node:util");
+const filter_1 = require("./filter");
 const loader_1 = require("./loader");
-const ANNOTATION_TYPES = {
-    NAME: 'name',
-    URI: 'uri',
-    TAGS: 'tags'
-};
+const testDetails_1 = require("./testDetails");
+const timeout_1 = require("./timeout");
+const gherkin_1 = require("./gherkin");
 const HOOK_NAMES = {
     BEFORE_ALL: 'Before All',
     AFTER_ALL: 'After All',
@@ -14,21 +17,28 @@ const HOOK_NAMES = {
     AFTER: 'After',
     BEFORE_STEP: 'Before Step',
     AFTER_STEP: 'After Step',
-    WORLD: 'World',
-    BEFORE_HOOKS: 'Before Hooks',
-    AFTER_HOOKS: 'After Hooks'
 };
 const DEFAULT_VALUES = {
     ATTACHMENT_FILENAME: 'attachment',
-    CONTENT_TYPE: 'text/plain',
+    LOG_ATTACHMENT_NAME: 'log',
+    TEXT_CONTENT_TYPE: 'text/plain',
+    BINARY_CONTENT_TYPE: 'application/octet-stream',
     COLUMN: 1,
     TEST_CASE_ID: '0',
     TEST_STEP_ID: '0'
 };
-const STEP_ARGUMENT_LABELS = {
-    DOC_STRING: ' [MultiLine]',
-    DATA_TABLE: ' [DataTable]'
-};
+const BASE64_SUFFIX = ';base64';
+/**
+ * Error raised for undefined, ambiguous and pending steps
+ */
+class StepStatusError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'StepStatusError';
+    }
+}
 function getLine(step) {
     if (!step.uri)
         return {};
@@ -40,22 +50,42 @@ function getLine(step) {
         }
     };
 }
+/**
+ * Log data to the report as `log` attachment of the current step (same as cucumber `this.log`)
+ */
 function log(data) {
-    console.log(data);
-}
-function attach(body, details) {
-    const fileName = details?.fileName ?? DEFAULT_VALUES.ATTACHMENT_FILENAME;
-    const contentType = details?.mediaType ?? DEFAULT_VALUES.CONTENT_TYPE;
-    return this.test.info().attach(fileName, { body: body, contentType });
-}
-function stepName(pickleStep) {
-    let step = pickleStep.text;
-    if (pickleStep.argument) {
-        step += pickleStep.argument.docString
-            ? STEP_ARGUMENT_LABELS.DOC_STRING
-            : STEP_ARGUMENT_LABELS.DATA_TABLE;
+    const body = typeof data === 'string' ? data : (0, node_util_1.inspect)(data);
+    this.test.info()
+        .attach(DEFAULT_VALUES.LOG_ATTACHMENT_NAME, { body, contentType: DEFAULT_VALUES.TEXT_CONTENT_TYPE })
+        .catch(() => console.log(body));
+}
+async function streamToBuffer(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
     }
-    return step;
+    return Buffer.concat(chunks);
+}
+/**
+ * Attach data to the report. Compatible with cucumber `this.attach`:
+ * - `attach(data, 'image/png')` or `attach(data, { mediaType, fileName })`
+ * - `attach(base64String, 'image/png;base64')` decodes base64 data
+ * - readable streams are buffered
+ */
+async function attach(data, mediaTypeOrOptions) {
+    const options = typeof mediaTypeOrOptions === 'string'
+        ? { mediaType: mediaTypeOrOptions }
+        : mediaTypeOrOptions ?? {};
+    let body = data instanceof node_stream_1.Readable ? await streamToBuffer(data) : data;
+    let contentType = options.mediaType;
+    if (contentType?.endsWith(BASE64_SUFFIX)) {
+        contentType = contentType.slice(0, -BASE64_SUFFIX.length);
+        if (typeof body === 'string')
+            body = Buffer.from(body, 'base64');
+    }
+    contentType ??= typeof body === 'string' ? DEFAULT_VALUES.TEXT_CONTENT_TYPE : DEFAULT_VALUES.BINARY_CONTENT_TYPE;
+    const fileName = options.fileName ?? DEFAULT_VALUES.ATTACHMENT_FILENAME;
+    return this.test.info().attach(fileName, { body, contentType });
 }
 function createTestExecutionResult() {
     return {
@@ -71,17 +101,6 @@ function createHookResult(result) {
         exception: result.error
     };
 }
-function createScenarioAnnotation(testCase) {
-    const tag = [...new Set(testCase.tags.map(item => item.name))];
-    return [
-        { type: ANNOTATION_TYPES.NAME, description: testCase.name },
-        { type: ANNOTATION_TYPES.URI, description: testCase.uri },
-        { type: ANNOTATION_TYPES.TAGS, description: JSON.stringify(tag) }
-    ];
-}
-function createScenarioTags(testCase) {
-    return [...new Set(testCase.tags.map(item => item.name))];
-}
 function createCaseHookPayload(feature, testCase) {
     return {
         gherkinDocument: feature.gherkinDocument,
@@ -89,24 +108,29 @@ function createCaseHookPayload(feature, testCase) {
         testCaseStartedId: DEFAULT_VALUES.TEST_CASE_ID
     };
 }
-async function executeCaseHooks(test, hooks, world, testCase, defaultHookName, createPayload) {
-    for (const hook of hooks) {
-        if (!hook.appliesToTestCase(testCase)) {
-            continue;
-        }
-        const hookName = hook.name ?? defaultHookName;
-        const location = getLine(hook);
-        await test.step(hookName, () => hook.code.apply(world, [createPayload(hook)]), location);
-    }
+/**
+ * Invoke hook code applying `{ timeout }` option or default timeout
+ */
+function invokeHook(hook, thisArg, args, hookName, defaultTimeout) {
+    return (0, timeout_1.runWithTimeout)(() => hook.code.apply(thisArg, args), (0, timeout_1.resolveTimeout)(hook, defaultTimeout), `${hookName} hook timed out after {timeout} ms\n  at ${hook.uri}:${hook.line}`);
 }
-async function executeStepHooks(test, hooks, world, testCase, hookName, createPayload) {
+/**
+ * Execute hooks applicable to the test case.
+ * @returns `'skipped'` if any hook returned `'skipped'` (cucumber semantics)
+ */
+async function executeHooks(test, hooks, world, testCase, defaultHookName, createPayload, defaultTimeout) {
+    let status;
     for (const hook of hooks) {
         if (!hook.appliesToTestCase(testCase)) {
             continue;
         }
+        const hookName = hook.name ?? defaultHookName;
         const location = getLine(hook);
-        await test.step(hookName, () => hook.code.apply(world, [createPayload(hook)]), location);
+        const returned = await test.step(hookName, () => invokeHook(hook, world, [createPayload(hook)], hookName, defaultTimeout), location);
+        if (returned === 'skipped')
+            status = 'skipped';
     }
+    return status;
 }
 function createStepHookParameter(feature, testCase, pickleStep, result) {
     return {
@@ -126,103 +150,219 @@ function createCaseHookParameter(feature, testCase, result) {
         result: createHookResult(result)
     };
 }
-function findSingleStepDefinition(supportCodeLibrary, pickleStep, featureUri) {
+function findSingleStepDefinition(supportCodeLibrary, pickleStep, stepLocation) {
     const matchingSteps = supportCodeLibrary.stepDefinitions
         .filter(stepDefinition => stepDefinition.matchesStepName(pickleStep.text));
     if (matchingSteps.length === 0) {
-        throw new Error(`Step '${pickleStep.text}' is not defined\n  at ${featureUri}`);
+        const snippet = (0, gherkin_1.buildSnippet)(supportCodeLibrary, pickleStep);
+        throw new StepStatusError([
+            `Step '${pickleStep.text}' is not defined`,
+            `  at ${stepLocation}`,
+            ...(snippet ? ['', 'Implement it with the following snippet:', '', snippet] : [])
+        ].join('\n'), 'undefined');
     }
     if (matchingSteps.length > 1) {
         const locations = matchingSteps
-            .map(s => `  ${s.uri}:${s.line}`)
+            .map(s => `  ${String(s.pattern ?? '')} - ${s.uri}:${s.line}`)
             .join('\n');
-        throw new Error(`Step '${pickleStep.text}' matches multiple step definitions:\n${locations}`);
+        throw new StepStatusError(`Step '${pickleStep.text}' matches multiple step definitions:\n${locations}\n  at ${stepLocation}`, 'ambiguous');
     }
     return matchingSteps[0];
 }
-function executeBeforeAllHooks(test, hooks) {
+function executeBeforeAllHooks(test, hooks, defaultTimeout) {
     if (hooks.length === 0)
         return;
     test.beforeAll(async () => {
         for (const hook of hooks) {
             const location = getLine(hook);
-            await test.step(HOOK_NAMES.BEFORE_ALL, () => hook.code.apply({}), location);
+            await test.step(HOOK_NAMES.BEFORE_ALL, () => invokeHook(hook, {}, [], HOOK_NAMES.BEFORE_ALL, defaultTimeout), location);
         }
     });
 }
-function executeAfterAllHooks(test, hooks) {
+function executeAfterAllHooks(test, hooks, defaultTimeout) {
     if (hooks.length === 0)
         return;
     test.afterAll(async () => {
         for (const hook of hooks) {
             const location = getLine(hook);
-            await test.step(HOOK_NAMES.AFTER_ALL, () => hook.code.apply({}), location);
+            await test.step(HOOK_NAMES.AFTER_ALL, () => invokeHook(hook, {}, [], HOOK_NAMES.AFTER_ALL, defaultTimeout), location);
         }
     });
 }
+/**
+ * Create scenario filter from tag expressions keyed by their source (used in error messages),
+ * e.g. `{ 'tags option': config.tags, 'CUCUMBER_TAGS env variable': process.env.CUCUMBER_TAGS }`.
+ * All expressions must match.
+ */
+function createTagFilter(sources) {
+    const nodes = Object.entries(sources)
+        .map(([source, expression]) => [source, expression?.trim()])
+        .filter((entry) => !!entry[1])
+        .map(([source, expression]) => (0, filter_1.parseTagExpression)(expression, source));
+    return pickle => {
+        const tagNames = pickle.tags.map(tag => tag.name);
+        return nodes.every(node => node.evaluate(tagNames));
+    };
+}
+/**
+ * `@retries(n)` is applied with `test.describe.configure`, which works per feature only
+ */
+function assertRetriesOnFeatureOnly(feature, featureTags) {
+    const featureTagNames = new Set(featureTags.map(tag => tag.name));
+    for (const testCase of feature.tests) {
+        const misplaced = testCase.tags.find(tag => tag.name.startsWith('@retries(') && !featureTagNames.has(tag.name));
+        if (misplaced) {
+            throw new Error(`${misplaced.name} is supported only on Feature, found on '${testCase.name}' in ${feature.uri}`);
+        }
+    }
+}
+/**
+ * Make feature titles unique, so scenarios from features with the same name do not clash
+ */
+function uniqueFeatureTitles(features) {
+    const titles = features.map(feature => (0, gherkin_1.featureTitle)(feature.feature, (0, node_path_1.relative)(process.cwd(), feature.uri)));
+    return titles.map((title, index) => titles.indexOf(title) === index
+        ? title
+        : `${title} (${(0, node_path_1.relative)(process.cwd(), features[index].uri)})`);
+}
 function defineConfig(config) {
     const { features, supportCodeLibrary } = (0, loader_1.load)(config);
-    const fixture = new supportCodeLibrary.World({ config });
+    const strict = config.strict ?? true;
+    const worldParameters = config.worldParameters ?? {};
+    const tagFilter = createTagFilter({
+        '`tags` config option': config.tags,
+        'CUCUMBER_TAGS env variable': process.env.CUCUMBER_TAGS
+    });
+    const stepLocationMode = config.stepLocation ?? 'definition';
+    const fixture = new supportCodeLibrary.World({ config, parameters: worldParameters });
     const test = fixture.test;
-    executeBeforeAllHooks(test, supportCodeLibrary.beforeTestRunHookDefinitions);
-    for (const feature of features) {
-        const tests = feature.tests;
-        test.describe(feature.feature, () => {
-            for (const testCase of tests) {
-                const tag = createScenarioTags(testCase);
-                const annotation = createScenarioAnnotation(testCase);
-                const testBody = async (fixtures) => {
-                    const world = new supportCodeLibrary.World({
-                        log,
-                        attach,
-                        supportCodeLibrary,
-                        config
-                    });
-                    world.init(fixtures);
-                    const result = createTestExecutionResult();
-                    await executeCaseHooks(test, supportCodeLibrary.beforeTestCaseHookDefinitions, world, testCase, HOOK_NAMES.BEFORE, () => createCaseHookPayload(feature, testCase));
-                    try {
-                        for (const pickleStep of testCase.steps) {
-                            if (result.status !== 'passed') {
-                                break;
-                            }
-                            const step = findSingleStepDefinition(supportCodeLibrary, pickleStep, feature.uri);
-                            const location = getLine(step);
-                            await test.step(stepName(pickleStep), async () => {
-                                await executeStepHooks(test, supportCodeLibrary.beforeTestStepHookDefinitions, world, testCase, HOOK_NAMES.BEFORE_STEP, () => ({
-                                    gherkinDocument: feature.gherkinDocument,
-                                    pickle: testCase,
-                                    pickleStep
-                                }));
-                                const { parameters } = await step.getInvocationParameters({
-                                    step: {
-                                        text: pickleStep.text,
-                                        argument: pickleStep.argument
-                                    },
-                                    world
-                                });
+    const defaultTimeout = supportCodeLibrary.defaultTimeout;
+    executeBeforeAllHooks(test, supportCodeLibrary.beforeTestRunHookDefinitions, defaultTimeout);
+    const titles = uniqueFeatureTitles(features);
+    features.forEach((feature, featureIndex) => {
+        const tests = feature.tests.filter(tagFilter);
+        if (tests.length === 0)
+            return;
+        const positions = (0, gherkin_1.collectPositions)(feature.gherkinDocument);
+        const featureTags = feature.gherkinDocument.feature?.tags ?? [];
+        const retries = (0, testDetails_1.resolveRetries)(featureTags);
+        assertRetriesOnFeatureOnly(feature, featureTags);
+        const featureLocation = feature.gherkinDocument.feature
+            ? { file: feature.uri, ...feature.gherkinDocument.feature.location, column: feature.gherkinDocument.feature.location.column ?? 1 }
+            : undefined;
+        (0, gherkin_1.callAt)(featureLocation, test.describe, [titles[featureIndex], () => {
+                if (retries !== undefined)
+                    test.describe.configure({ retries });
+                for (const testCase of tests) {
+                    const { tag, annotation, lock, timeout } = (0, testDetails_1.resolveTestDetails)(testCase);
+                    const testBody = async (fixtures) => {
+                        const world = new supportCodeLibrary.World({
+                            log,
+                            attach,
+                            supportCodeLibrary,
+                            config,
+                            parameters: worldParameters
+                        });
+                        world.init(fixtures);
+                        const testInfo = world.test.info();
+                        if (timeout !== undefined)
+                            testInfo.setTimeout(timeout);
+                        const result = createTestExecutionResult();
+                        const markStatus = (status, error) => {
+                            if (result.status !== 'passed')
+                                return;
+                            result.status = status;
+                            result.error = error;
+                        };
+                        // soft assertions do not throw, but fail the test
+                        const markSoftErrors = () => {
+                            const softError = testInfo.errors[0];
+                            if (softError)
+                                markStatus('failed', new Error(softError.message ?? softError.value));
+                        };
+                        const markError = (err) => {
+                            if (testInfo.expectedStatus === 'skipped')
+                                return markStatus('skipped', err);
+                            markStatus(err instanceof StepStatusError ? err.status : 'failed', err);
+                        };
+                        try {
+                            const beforeStatus = await executeHooks(test, supportCodeLibrary.beforeTestCaseHookDefinitions, world, testCase, HOOK_NAMES.BEFORE, () => createCaseHookPayload(feature, testCase), defaultTimeout);
+                            if (beforeStatus)
+                                markStatus(beforeStatus);
+                            for (const pickleStep of testCase.steps) {
+                                if (result.status === 'skipped' || result.status === 'pending') {
+                                    break;
+                                }
+                                const stepLocation = (0, gherkin_1.resolveLocation)(positions, feature.uri, pickleStep.astNodeIds);
+                                let step;
+                                let lookupError;
                                 try {
-                                    await step.code.apply(world, parameters);
+                                    step = findSingleStepDefinition(supportCodeLibrary, pickleStep, (0, gherkin_1.formatLocation)(stepLocation));
                                 }
                                 catch (err) {
-                                    result.status = 'failed';
-                                    result.error = err;
-                                    throw err;
+                                    // undefined or ambiguous: reported as a failed step pointing to the feature file
+                                    lookupError = err;
                                 }
-                                finally {
-                                    await executeStepHooks(test, supportCodeLibrary.afterTestStepHookDefinitions, world, testCase, HOOK_NAMES.AFTER_STEP, () => createStepHookParameter(feature, testCase, pickleStep, result));
-                                }
-                            }, location);
+                                const location = step && stepLocationMode === 'definition' ? getLine(step) : { location: stepLocation };
+                                await test.step((0, gherkin_1.stepTitle)(pickleStep), async () => {
+                                    if (!step)
+                                        throw lookupError;
+                                    await executeHooks(test, supportCodeLibrary.beforeTestStepHookDefinitions, world, testCase, HOOK_NAMES.BEFORE_STEP, () => ({
+                                        gherkinDocument: feature.gherkinDocument,
+                                        pickle: testCase,
+                                        pickleStep
+                                    }), defaultTimeout);
+                                    try {
+                                        const { parameters } = await step.getInvocationParameters({
+                                            step: {
+                                                text: pickleStep.text,
+                                                argument: pickleStep.argument
+                                            },
+                                            world
+                                        });
+                                        const returned = await (0, timeout_1.runWithTimeout)(() => step.code.apply(world, parameters), (0, timeout_1.resolveTimeout)(step, defaultTimeout), `Step '${pickleStep.text}' timed out after {timeout} ms\n  at ${step.uri}:${step.line}`);
+                                        if (returned === 'skipped') {
+                                            markStatus('skipped');
+                                        }
+                                        else if (returned === 'pending') {
+                                            const error = new StepStatusError(`Step '${pickleStep.text}' is pending\n  at ${(0, gherkin_1.formatLocation)(stepLocation)}`, 'pending');
+                                            markStatus('pending', error);
+                                            if (strict)
+                                                throw error;
+                                        }
+                                        markSoftErrors();
+                                    }
+                                    catch (err) {
+                                        markError(err);
+                                        throw err;
+                                    }
+                                    finally {
+                                        await executeHooks(test, supportCodeLibrary.afterTestStepHookDefinitions, world, testCase, HOOK_NAMES.AFTER_STEP, () => createStepHookParameter(feature, testCase, pickleStep, result), defaultTimeout);
+                                    }
+                                }, location);
+                            }
                         }
-                    }
-                    finally {
-                        await executeCaseHooks(test, supportCodeLibrary.afterTestCaseHookDefinitions, world, testCase, HOOK_NAMES.AFTER, () => createCaseHookParameter(feature, testCase, result));
-                    }
-                };
-                testBody.toString = () => fixture.init.toString();
-                test(testCase.name, { tag, annotation }, testBody);
-            }
-        });
-    }
-    executeAfterAllHooks(test, supportCodeLibrary.afterTestRunHookDefinitions);
+                        catch (err) {
+                            markError(err);
+                            throw err;
+                        }
+                        finally {
+                            markSoftErrors();
+                            await executeHooks(test, supportCodeLibrary.afterTestCaseHookDefinitions, world, testCase, HOOK_NAMES.AFTER, () => createCaseHookParameter(feature, testCase, result), defaultTimeout);
+                        }
+                        if (result.status === 'skipped') {
+                            world.test.skip(true, 'Scenario skipped by step or hook');
+                        }
+                        if (result.status === 'pending') {
+                            world.test.fixme(true, result.error?.message);
+                        }
+                    };
+                    testBody.toString = () => fixture.init.toString();
+                    const details = lock.length > 0 ? { tag, annotation, lock } : { tag, annotation };
+                    const testLocation = (0, gherkin_1.resolveLocation)(positions, feature.uri, testCase.astNodeIds);
+                    (0, gherkin_1.callAt)(testLocation, test, [testCase.name, details, testBody]);
+                }
+            }]);
+    });
+    executeAfterAllHooks(test, supportCodeLibrary.afterTestRunHookDefinitions, defaultTimeout);
 }

package/adapter/js/filter.d.ts

@@ -1,3 +1,11 @@
+import { parse } from '@cucumber/tag-expressions';
+/**
+ * Parse cucumber tag expression with an error naming its source.
+ * Also rejects tags without `@` (e.g. `smoke`), which parse fine but never match any scenario.
+ * @param expression - tag expression
+ * @param source - where the expression comes from, used in error messages
+ */
+export declare function parseTagExpression(expression: string, source: string): ReturnType<typeof parse>;
 /**
  * Translate cucumber tag expression to playwright grep
  * @param {string} tagExpression

package/adapter/js/filter.js

@@ -1,15 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTagExpression = parseTagExpression;
 exports.tags = tags;
 exports.filter = filter;
 const tag_expressions_1 = require("@cucumber/tag-expressions");
+const OPERATORS = new Set(['and', 'or', 'not']);
+/**
+ * Parse cucumber tag expression with an error naming its source.
+ * Also rejects tags without `@` (e.g. `smoke`), which parse fine but never match any scenario.
+ * @param expression - tag expression
+ * @param source - where the expression comes from, used in error messages
+ */
+function parseTagExpression(expression, source) {
+    let node;
+    try {
+        node = (0, tag_expressions_1.parse)(expression);
+    }
+    catch (err) {
+        throw new Error(`Invalid tag expression in ${source}: ${err.message}`, { cause: err });
+    }
+    const invalidTags = expression
+        .replace(/\\./g, '')
+        .split(/[\s()]+/)
+        .filter(token => token && !OPERATORS.has(token) && !token.startsWith('@'));
+    if (invalidTags.length > 0) {
+        throw new Error(`Invalid tag expression in ${source}: "${expression}". ` +
+            `Tags must start with '@': ${invalidTags.map(tag => `'${tag}' → '@${tag}'`).join(', ')}`);
+    }
+    return node;
+}
 class TagExpression extends RegExp {
     tagExpression;
     expressionNode;
     constructor(tagExpression) {
         super('');
         this.tagExpression = tagExpression;
-        this.expressionNode = (0, tag_expressions_1.parse)(this.tagExpression);
+        this.expressionNode = parseTagExpression(this.tagExpression, 'tags()');
     }
     test(testName) {
         const tokens = testName.split(/\s+/);

package/adapter/js/gherkin.d.ts

@@ -0,0 +1,45 @@
+import type { GherkinDocument, PickleStep, PickleStepArgument } from '@cucumber/messages';
+import type { SupportCodeLibrary } from './types';
+export interface SourceLocation {
+    file: string;
+    line: number;
+    column: number;
+}
+type Position = Omit<SourceLocation, 'file'>;
+/**
+ * Map ast node ids (scenarios, steps, example rows, rules) of a gherkin document to their positions
+ */
+export declare function collectPositions(gherkinDocument: GherkinDocument): Map<string, Position>;
+/**
+ * Resolve location of a pickle or pickle step.
+ * The last ast node id is used, so scenario outline examples point to their example row.
+ */
+export declare function resolveLocation(positions: Map<string, Position>, file: string, astNodeIds: readonly string[]): SourceLocation | undefined;
+/**
+ * Call function so that the immediate caller frame reports the given source location.
+ * Playwright takes test and describe locations from the caller frame,
+ * so this makes reports, `--list` and IDE integrations point to the feature file instead of the adapter.
+ */
+export declare function callAt<T>(location: SourceLocation | undefined, fn: (...args: any[]) => T, args: unknown[]): T;
+/**
+ * Build step title for reports including short preview of doc string or data table argument
+ */
+export declare function stepTitle(pickleStep: Pick<PickleStep, 'text' | 'argument'>): string;
+/**
+ * Convert value passed to executeStep into a pickle step argument.
+ * Strings become doc strings, `string[][]` and DataTable instances become data tables.
+ */
+export declare function toPickleArgument(value: unknown): {
+    argument?: PickleStepArgument;
+    extra?: unknown;
+};
+/**
+ * Build cucumber-style snippet for undefined step
+ */
+export declare function buildSnippet(supportCodeLibrary: Pick<SupportCodeLibrary, 'parameterTypeRegistry'>, pickleStep: PickleStep): string | undefined;
+export declare function formatLocation(location?: SourceLocation): string;
+/**
+ * Feature title used for describe block; falls back to file path for unnamed features
+ */
+export declare function featureTitle(name: string | undefined, uri: string): string;
+export {};