@dev-blinq/cucumber-js 1.0.36 → 1.0.37-stage

package/lib/runtime/assemble_test_cases.js

@@ -1,88 +1,88 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assembleTestCases = void 0;
-const value_checker_1 = require("../value_checker");
-async function assembleTestCases({ eventBroadcaster, newId, pickles, supportCodeLibrary, }) {
-    const result = {};
-    for (const pickle of pickles) {
-        const { id: pickleId } = pickle;
-        const testCaseId = newId();
-        const fromBeforeHooks = makeBeforeHookSteps({
-            supportCodeLibrary,
-            pickle,
-            newId,
-        });
-        const fromStepDefinitions = makeSteps({
-            pickle,
-            supportCodeLibrary,
-            newId,
-        });
-        const fromAfterHooks = makeAfterHookSteps({
-            supportCodeLibrary,
-            pickle,
-            newId,
-        });
-        const testCase = {
-            pickleId,
-            id: testCaseId,
-            testSteps: [
-                ...fromBeforeHooks,
-                ...fromStepDefinitions,
-                ...fromAfterHooks,
-            ],
-        };
-        eventBroadcaster.emit('envelope', { testCase });
-        result[pickleId] = testCase;
-    }
-    return result;
-}
-exports.assembleTestCases = assembleTestCases;
-function makeAfterHookSteps({ supportCodeLibrary, pickle, newId, }) {
-    return supportCodeLibrary.afterTestCaseHookDefinitions
-        .slice(0)
-        .reverse()
-        .filter((hookDefinition) => hookDefinition.appliesToTestCase(pickle))
-        .map((hookDefinition) => ({
-        id: newId(),
-        hookId: hookDefinition.id,
-    }));
-}
-function makeBeforeHookSteps({ supportCodeLibrary, pickle, newId, }) {
-    return supportCodeLibrary.beforeTestCaseHookDefinitions
-        .filter((hookDefinition) => hookDefinition.appliesToTestCase(pickle))
-        .map((hookDefinition) => ({
-        id: newId(),
-        hookId: hookDefinition.id,
-    }));
-}
-function makeSteps({ pickle, supportCodeLibrary, newId, }) {
-    return pickle.steps.map((pickleStep) => {
-        const stepDefinitions = supportCodeLibrary.stepDefinitions.filter((stepDefinition) => stepDefinition.matchesStepName(pickleStep.text));
-        return {
-            id: newId(),
-            pickleStepId: pickleStep.id,
-            stepDefinitionIds: stepDefinitions.map((stepDefinition) => stepDefinition.id),
-            stepMatchArgumentsLists: stepDefinitions.map((stepDefinition) => {
-                const result = stepDefinition.expression.match(pickleStep.text);
-                return {
-                    stepMatchArguments: result.map((arg) => {
-                        return {
-                            group: mapArgumentGroup(arg.group),
-                            parameterTypeName: arg.parameterType.name,
-                        };
-                    }),
-                };
-            }),
-        };
-    });
-}
-function mapArgumentGroup(group) {
-    return {
-        start: group.start,
-        value: group.value,
-        children: (0, value_checker_1.doesHaveValue)(group.children)
-            ? group.children.map((child) => mapArgumentGroup(child))
-            : undefined,
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assembleTestCases = void 0;
+const value_checker_1 = require("../value_checker");
+async function assembleTestCases({ eventBroadcaster, newId, pickles, supportCodeLibrary, }) {
+    const result = {};
+    for (const pickle of pickles) {
+        const { id: pickleId } = pickle;
+        const testCaseId = newId();
+        const fromBeforeHooks = makeBeforeHookSteps({
+            supportCodeLibrary,
+            pickle,
+            newId,
+        });
+        const fromStepDefinitions = makeSteps({
+            pickle,
+            supportCodeLibrary,
+            newId,
+        });
+        const fromAfterHooks = makeAfterHookSteps({
+            supportCodeLibrary,
+            pickle,
+            newId,
+        });
+        const testCase = {
+            pickleId,
+            id: testCaseId,
+            testSteps: [
+                ...fromBeforeHooks,
+                ...fromStepDefinitions,
+                ...fromAfterHooks,
+            ],
+        };
+        eventBroadcaster.emit('envelope', { testCase });
+        result[pickleId] = testCase;
+    }
+    return result;
+}
+exports.assembleTestCases = assembleTestCases;
+function makeAfterHookSteps({ supportCodeLibrary, pickle, newId, }) {
+    return supportCodeLibrary.afterTestCaseHookDefinitions
+        .slice(0)
+        .reverse()
+        .filter((hookDefinition) => hookDefinition.appliesToTestCase(pickle))
+        .map((hookDefinition) => ({
+        id: newId(),
+        hookId: hookDefinition.id,
+    }));
+}
+function makeBeforeHookSteps({ supportCodeLibrary, pickle, newId, }) {
+    return supportCodeLibrary.beforeTestCaseHookDefinitions
+        .filter((hookDefinition) => hookDefinition.appliesToTestCase(pickle))
+        .map((hookDefinition) => ({
+        id: newId(),
+        hookId: hookDefinition.id,
+    }));
+}
+function makeSteps({ pickle, supportCodeLibrary, newId, }) {
+    return pickle.steps.map((pickleStep) => {
+        const stepDefinitions = supportCodeLibrary.stepDefinitions.filter((stepDefinition) => stepDefinition.matchesStepName(pickleStep.text));
+        return {
+            id: newId(),
+            pickleStepId: pickleStep.id,
+            stepDefinitionIds: stepDefinitions.map((stepDefinition) => stepDefinition.id),
+            stepMatchArgumentsLists: stepDefinitions.map((stepDefinition) => {
+                const result = stepDefinition.expression.match(pickleStep.text);
+                return {
+                    stepMatchArguments: result.map((arg) => {
+                        return {
+                            group: mapArgumentGroup(arg.group),
+                            parameterTypeName: arg.parameterType.name,
+                        };
+                    }),
+                };
+            }),
+        };
+    });
+}
+function mapArgumentGroup(group) {
+    return {
+        start: group.start,
+        value: group.value,
+        children: (0, value_checker_1.doesHaveValue)(group.children)
+            ? group.children.map((child) => mapArgumentGroup(child))
+            : undefined,
+    };
+}
 //# sourceMappingURL=assemble_test_cases.js.map

package/lib/runtime/attachment_manager/index.d.ts

@@ -1,33 +1,33 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { Readable } from 'stream';
-import * as messages from '@cucumber/messages';
-export interface IAttachmentMedia {
-    encoding: messages.AttachmentContentEncoding;
-    contentType: string;
-}
-export interface IAttachment {
-    data: string;
-    media: IAttachmentMedia;
-    fileName?: string;
-}
-export type IAttachFunction = (attachment: IAttachment) => void;
-export interface ICreateAttachmentOptions {
-    mediaType: string;
-    fileName?: string;
-}
-export type ICreateStringAttachment = (data: string, mediaTypeOrOptions?: string | ICreateAttachmentOptions) => void;
-export type ICreateBufferAttachment = (data: Buffer, mediaTypeOrOptions: string | ICreateAttachmentOptions) => void;
-export type ICreateStreamAttachment = (data: Readable, mediaTypeOrOptions: string | ICreateAttachmentOptions) => Promise<void>;
-export type ICreateStreamAttachmentWithCallback = (data: Readable, mediaTypeOrOptions: string | ICreateAttachmentOptions, callback: () => void) => void;
-export type ICreateAttachment = ICreateStringAttachment & ICreateBufferAttachment & ICreateStreamAttachment & ICreateStreamAttachmentWithCallback;
-export type ICreateLog = (text: string) => void;
-export default class AttachmentManager {
-    private readonly onAttachment;
-    constructor(onAttachment: IAttachFunction);
-    log(text: string): void | Promise<void>;
-    create(data: Buffer | Readable | string, mediaTypeOrOptions?: string | ICreateAttachmentOptions, callback?: () => void): void | Promise<void>;
-    createBufferAttachment(data: Buffer, mediaType: string, fileName?: string): void;
-    createStreamAttachment(data: Readable, mediaType: string, fileName?: string, callback?: () => void): void | Promise<void>;
-    createStringAttachment(data: string, media: IAttachmentMedia, fileName?: string): void;
-}
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+import * as messages from '@cucumber/messages';
+export interface IAttachmentMedia {
+    encoding: messages.AttachmentContentEncoding;
+    contentType: string;
+}
+export interface IAttachment {
+    data: string;
+    media: IAttachmentMedia;
+    fileName?: string;
+}
+export type IAttachFunction = (attachment: IAttachment) => void;
+export interface ICreateAttachmentOptions {
+    mediaType: string;
+    fileName?: string;
+}
+export type ICreateStringAttachment = (data: string, mediaTypeOrOptions?: string | ICreateAttachmentOptions) => void;
+export type ICreateBufferAttachment = (data: Buffer, mediaTypeOrOptions: string | ICreateAttachmentOptions) => void;
+export type ICreateStreamAttachment = (data: Readable, mediaTypeOrOptions: string | ICreateAttachmentOptions) => Promise<void>;
+export type ICreateStreamAttachmentWithCallback = (data: Readable, mediaTypeOrOptions: string | ICreateAttachmentOptions, callback: () => void) => void;
+export type ICreateAttachment = ICreateStringAttachment & ICreateBufferAttachment & ICreateStreamAttachment & ICreateStreamAttachmentWithCallback;
+export type ICreateLog = (text: string) => void;
+export default class AttachmentManager {
+    private readonly onAttachment;
+    constructor(onAttachment: IAttachFunction);
+    log(text: string): void | Promise<void>;
+    create(data: Buffer | Readable | string, mediaTypeOrOptions?: string | ICreateAttachmentOptions, callback?: () => void): void | Promise<void>;
+    createBufferAttachment(data: Buffer, mediaType: string, fileName?: string): void;
+    createStreamAttachment(data: Readable, mediaType: string, fileName?: string, callback?: () => void): void | Promise<void>;
+    createStringAttachment(data: string, media: IAttachmentMedia, fileName?: string): void;
+}

package/lib/runtime/attachment_manager/index.js

@@ -1,119 +1,119 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const is_stream_1 = __importDefault(require("is-stream"));
-const messages = __importStar(require("@cucumber/messages"));
-const value_checker_1 = require("../../value_checker");
-class AttachmentManager {
-    constructor(onAttachment) {
-        this.onAttachment = onAttachment;
-    }
-    log(text) {
-        return this.create(text, 'text/x.cucumber.log+plain');
-    }
-    create(data, mediaTypeOrOptions, callback) {
-        const options = normaliseOptions(mediaTypeOrOptions);
-        if (Buffer.isBuffer(data)) {
-            if ((0, value_checker_1.doesNotHaveValue)(options.mediaType)) {
-                throw Error('Buffer attachments must specify a media type');
-            }
-            this.createBufferAttachment(data, options.mediaType, options.fileName);
-        }
-        else if (is_stream_1.default.readable(data)) {
-            if ((0, value_checker_1.doesNotHaveValue)(options.mediaType)) {
-                throw Error('Stream attachments must specify a media type');
-            }
-            return this.createStreamAttachment(data, options.mediaType, options.fileName, callback);
-        }
-        else if (typeof data === 'string') {
-            if ((0, value_checker_1.doesNotHaveValue)(options.mediaType)) {
-                options.mediaType = 'text/plain';
-            }
-            if (options.mediaType.startsWith('base64:')) {
-                this.createStringAttachment(data, {
-                    encoding: messages.AttachmentContentEncoding.BASE64,
-                    contentType: options.mediaType.replace('base64:', ''),
-                }, options.fileName);
-            }
-            else {
-                this.createStringAttachment(data, {
-                    encoding: messages.AttachmentContentEncoding.IDENTITY,
-                    contentType: options.mediaType,
-                }, options.fileName);
-            }
-        }
-        else {
-            throw Error('Invalid attachment data: must be a buffer, readable stream, or string');
-        }
-    }
-    createBufferAttachment(data, mediaType, fileName) {
-        this.createStringAttachment(data.toString('base64'), {
-            encoding: messages.AttachmentContentEncoding.BASE64,
-            contentType: mediaType,
-        }, fileName);
-    }
-    createStreamAttachment(data, mediaType, fileName, callback) {
-        const promise = new Promise((resolve, reject) => {
-            const buffers = [];
-            data.on('data', (chunk) => {
-                buffers.push(chunk);
-            });
-            data.on('end', () => {
-                this.createBufferAttachment(Buffer.concat(buffers), mediaType, fileName);
-                resolve();
-            });
-            data.on('error', reject);
-        });
-        if ((0, value_checker_1.doesHaveValue)(callback)) {
-            promise.then(callback, callback);
-        }
-        else {
-            return promise;
-        }
-    }
-    createStringAttachment(data, media, fileName) {
-        this.onAttachment({
-            data,
-            media,
-            ...(fileName ? { fileName } : {}),
-        });
-    }
-}
-exports.default = AttachmentManager;
-function normaliseOptions(mediaTypeOrOptions) {
-    if (!mediaTypeOrOptions) {
-        return {};
-    }
-    if (typeof mediaTypeOrOptions === 'string') {
-        return {
-            mediaType: mediaTypeOrOptions,
-        };
-    }
-    return mediaTypeOrOptions;
-}
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_stream_1 = __importDefault(require("is-stream"));
+const messages = __importStar(require("@cucumber/messages"));
+const value_checker_1 = require("../../value_checker");
+class AttachmentManager {
+    constructor(onAttachment) {
+        this.onAttachment = onAttachment;
+    }
+    log(text) {
+        return this.create(text, 'text/x.cucumber.log+plain');
+    }
+    create(data, mediaTypeOrOptions, callback) {
+        const options = normaliseOptions(mediaTypeOrOptions);
+        if (Buffer.isBuffer(data)) {
+            if ((0, value_checker_1.doesNotHaveValue)(options.mediaType)) {
+                throw Error('Buffer attachments must specify a media type');
+            }
+            this.createBufferAttachment(data, options.mediaType, options.fileName);
+        }
+        else if (is_stream_1.default.readable(data)) {
+            if ((0, value_checker_1.doesNotHaveValue)(options.mediaType)) {
+                throw Error('Stream attachments must specify a media type');
+            }
+            return this.createStreamAttachment(data, options.mediaType, options.fileName, callback);
+        }
+        else if (typeof data === 'string') {
+            if ((0, value_checker_1.doesNotHaveValue)(options.mediaType)) {
+                options.mediaType = 'text/plain';
+            }
+            if (options.mediaType.startsWith('base64:')) {
+                this.createStringAttachment(data, {
+                    encoding: messages.AttachmentContentEncoding.BASE64,
+                    contentType: options.mediaType.replace('base64:', ''),
+                }, options.fileName);
+            }
+            else {
+                this.createStringAttachment(data, {
+                    encoding: messages.AttachmentContentEncoding.IDENTITY,
+                    contentType: options.mediaType,
+                }, options.fileName);
+            }
+        }
+        else {
+            throw Error('Invalid attachment data: must be a buffer, readable stream, or string');
+        }
+    }
+    createBufferAttachment(data, mediaType, fileName) {
+        this.createStringAttachment(data.toString('base64'), {
+            encoding: messages.AttachmentContentEncoding.BASE64,
+            contentType: mediaType,
+        }, fileName);
+    }
+    createStreamAttachment(data, mediaType, fileName, callback) {
+        const promise = new Promise((resolve, reject) => {
+            const buffers = [];
+            data.on('data', (chunk) => {
+                buffers.push(chunk);
+            });
+            data.on('end', () => {
+                this.createBufferAttachment(Buffer.concat(buffers), mediaType, fileName);
+                resolve();
+            });
+            data.on('error', reject);
+        });
+        if ((0, value_checker_1.doesHaveValue)(callback)) {
+            promise.then(callback, callback);
+        }
+        else {
+            return promise;
+        }
+    }
+    createStringAttachment(data, media, fileName) {
+        this.onAttachment({
+            data,
+            media,
+            ...(fileName ? { fileName } : {}),
+        });
+    }
+}
+exports.default = AttachmentManager;
+function normaliseOptions(mediaTypeOrOptions) {
+    if (!mediaTypeOrOptions) {
+        return {};
+    }
+    if (typeof mediaTypeOrOptions === 'string') {
+        return {
+            mediaType: mediaTypeOrOptions,
+        };
+    }
+    return mediaTypeOrOptions;
+}
 //# sourceMappingURL=index.js.map

package/lib/runtime/format_error.d.ts

@@ -1,2 +1,2 @@
-import { TestStepResult } from '@cucumber/messages';
-export declare function formatError(error: Error, filterStackTraces: boolean): Pick<TestStepResult, 'message' | 'exception'>;
+import { TestStepResult } from '@cucumber/messages';
+export declare function formatError(error: Error, filterStackTraces: boolean): Pick<TestStepResult, 'message' | 'exception'>;

package/lib/runtime/format_error.js

@@ -1,36 +1,36 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatError = void 0;
-const assertion_error_formatter_1 = require("assertion-error-formatter");
-const error_stack_parser_1 = __importDefault(require("error-stack-parser"));
-const filter_stack_trace_1 = require("../filter_stack_trace");
-function formatError(error, filterStackTraces) {
-    let filteredStack;
-    if (filterStackTraces) {
-        try {
-            filteredStack = (0, filter_stack_trace_1.filterStackTrace)(error_stack_parser_1.default.parse(error))
-                .map((f) => f.source)
-                .join('\n');
-        }
-        catch (_a) {
-            // if we weren't able to parse and filter, we'll settle for the original
-        }
-    }
-    const message = (0, assertion_error_formatter_1.format)(error, {
-        colorFns: {
-            errorStack: (stack) => filteredStack ? `\n${filteredStack}` : stack,
-        },
-    });
-    return {
-        message,
-        exception: {
-            type: error.name || 'Error',
-            message: typeof error === 'string' ? error : error.message,
-        },
-    };
-}
-exports.formatError = formatError;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatError = void 0;
+const assertion_error_formatter_1 = require("assertion-error-formatter");
+const error_stack_parser_1 = __importDefault(require("error-stack-parser"));
+const filter_stack_trace_1 = require("../filter_stack_trace");
+function formatError(error, filterStackTraces) {
+    let filteredStack;
+    if (filterStackTraces) {
+        try {
+            filteredStack = (0, filter_stack_trace_1.filterStackTrace)(error_stack_parser_1.default.parse(error))
+                .map((f) => f.source)
+                .join('\n');
+        }
+        catch (_a) {
+            // if we weren't able to parse and filter, we'll settle for the original
+        }
+    }
+    const message = (0, assertion_error_formatter_1.format)(error, {
+        colorFns: {
+            errorStack: (stack) => filteredStack ? `\n${filteredStack}` : stack,
+        },
+    });
+    return {
+        message,
+        exception: {
+            type: error.name || 'Error',
+            message: typeof error === 'string' ? error : error.message,
+        },
+    };
+}
+exports.formatError = formatError;
 //# sourceMappingURL=format_error.js.map

package/lib/runtime/helpers.d.ts

@@ -1,6 +1,6 @@
-import StepDefinition from '../models/step_definition';
-import * as messages from '@cucumber/messages';
-import { IRuntimeOptions } from '.';
-export declare function getAmbiguousStepException(stepDefinitions: StepDefinition[]): string;
-export declare function retriesForPickle(pickle: messages.Pickle, options: IRuntimeOptions): number;
-export declare function shouldCauseFailure(status: messages.TestStepResultStatus, options: IRuntimeOptions): boolean;
+import StepDefinition from '../models/step_definition';
+import * as messages from '@cucumber/messages';
+import { IRuntimeOptions } from '.';
+export declare function getAmbiguousStepException(stepDefinitions: StepDefinition[]): string;
+export declare function retriesForPickle(pickle: messages.Pickle, options: IRuntimeOptions): number;
+export declare function shouldCauseFailure(status: messages.TestStepResultStatus, options: IRuntimeOptions): boolean;