@dev-blinq/cucumber-js 1.0.35 → 1.0.36

package/lib/formatter/helpers/report_generator.js

@@ -1,248 +1,248 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class ReportGenerator {
-    constructor() {
-        this.report = {
-            result: {
-                status: 'UNKNOWN',
-            },
-            testCases: [],
-        };
-        this.gherkinDocumentMap = new Map();
-        this.pickleMap = new Map();
-        this.testCaseMap = new Map();
-        this.testStepMap = new Map();
-        this.stepProgressMap = new Map();
-        this.testProgressMap = new Map();
-        this.reportFolder = null;
-    }
-    handleMessage(envelope) {
-        const type = Object.keys(envelope)[0];
-        switch (type) {
-            // case "meta": { break}
-            // case "source": { break}
-            case 'parseError': {
-                const parseError = envelope[type];
-                this.handleParseError(parseError);
-                break;
-            }
-            case 'gherkinDocument': {
-                const doc = envelope[type];
-                this.onGherkinDocument(doc);
-                break;
-            }
-            case 'pickle': {
-                const pickle = envelope[type];
-                this.onPickle(pickle);
-                break;
-            }
-            // case "stepDefinition": { break}
-            // case "hook": { break} // Before Hook
-            case 'testRunStarted': {
-                const testRunStarted = envelope[type];
-                this.onTestRunStarted(testRunStarted);
-                break;
-            }
-            case 'testCase': {
-                const testCase = envelope[type];
-                this.onTestCase(testCase);
-                break;
-            }
-            case 'testCaseStarted': {
-                const testCaseStarted = envelope[type];
-                this.onTestCaseStarted(testCaseStarted);
-                break;
-            }
-            case 'testStepStarted': {
-                const testStepStarted = envelope[type];
-                this.onTestStepStarted(testStepStarted);
-                break;
-            }
-            case 'attachment': {
-                const attachment = envelope[type];
-                this.onAttachment(attachment);
-                break;
-            }
-            case 'testStepFinished': {
-                const testStepFinished = envelope[type];
-                this.onTestStepFinished(testStepFinished);
-                break;
-            }
-            case 'testCaseFinished': {
-                const testCaseFinished = envelope[type];
-                this.onTestCaseFinished(testCaseFinished);
-                break;
-            }
-            // case "hook": { break} // After Hook
-            case 'testRunFinished': {
-                const testRunFinished = envelope[type];
-                this.onTestRunFinished(testRunFinished);
-                break;
-            }
-            // case "parameterType" : { break}
-            // case "undefinedParameterType": { break}
-        }
-    }
-    getReport() {
-        return this.report;
-    }
-    handleParseError(parseError) {
-        const { message, source } = parseError;
-        const timestamp = new Date().getTime();
-        this.report.result = {
-            status: 'FAILED',
-            startTime: timestamp,
-            endTime: timestamp,
-            message: message,
-        };
-    }
-    onGherkinDocument(doc) {
-        this.gherkinDocumentMap.set(doc.uri, doc);
-    }
-    onPickle(pickle) {
-        this.pickleMap.set(pickle.id, pickle);
-    }
-    getTimeStamp(timestamp) {
-        return timestamp.seconds * 1000 + timestamp.nanos / 1000000;
-    }
-    onTestRunStarted(testRunStarted) {
-        this.report.result = {
-            status: 'STARTED',
-            startTime: this.getTimeStamp(testRunStarted.timestamp),
-        };
-    }
-    onTestCase(testCase) {
-        this.testCaseMap.set(testCase.id, testCase);
-        testCase.testSteps.forEach((testStep) => {
-            this.testStepMap.set(testStep.id, testStep);
-        });
-    }
-    onTestCaseStarted(testCaseStarted) {
-        const { testCaseId, id, timestamp } = testCaseStarted;
-        const testCase = this.testCaseMap.get(testCaseId);
-        if (testCase === undefined)
-            throw new Error(`testCase with id ${testCaseId} not found`);
-        const pickle = this.pickleMap.get(testCase.pickleId);
-        if (pickle === undefined)
-            throw new Error(`pickle with id ${testCase.pickleId} not found`);
-        const doc = this.gherkinDocumentMap.get(pickle.uri);
-        if (doc === undefined)
-            throw new Error(`gherkinDocument with uri ${pickle.uri} not found`);
-        const featureName = doc.feature.name;
-        const scenarioName = pickle.name;
-        const steps = pickle.steps.map((step) => {
-            this.stepProgressMap.set(step.id, {
-                type: step.type,
-                text: step.text,
-                commands: [],
-                result: {
-                    status: 'UNKNOWN',
-                },
-            });
-            return this.stepProgressMap.get(step.id);
-        });
-        this.testProgressMap.set(id, {
-            id,
-            uri: pickle.uri,
-            featureName,
-            scenarioName,
-            // TODO: compute parameters
-            parameters: {},
-            steps,
-            result: {
-                status: 'STARTED',
-                startTime: this.getTimeStamp(timestamp),
-            },
-        });
-        this.report.testCases.push(this.testProgressMap.get(id));
-    }
-    onTestStepStarted(testStepStarted) {
-        const { testStepId, timestamp, testCaseStartedId } = testStepStarted;
-        const testStep = this.testStepMap.get(testStepId);
-        if (testStep === undefined)
-            throw new Error(`testStep with id ${testStepId} not found`);
-        if (testStep.pickleStepId === undefined)
-            return;
-        const stepProgess = this.stepProgressMap.get(testStep.pickleStepId);
-        stepProgess.result = {
-            status: 'STARTED',
-            startTime: this.getTimeStamp(timestamp),
-        };
-    }
-    onAttachment(attachment) {
-        const { testCaseStartedId, testStepId, body, mediaType, contentEncoding, fileName, source, url, } = attachment;
-        if (mediaType === 'text/plain') {
-            this.reportFolder = body.replaceAll('\\', '/');
-        }
-        const testStep = this.testStepMap.get(testStepId);
-        if (testStep.pickleStepId === undefined)
-            return;
-        const stepProgess = this.stepProgressMap.get(testStep.pickleStepId);
-        if (mediaType === 'application/json') {
-            const command = JSON.parse(body);
-            stepProgess.commands.push(command);
-        }
-    }
-    onTestStepFinished(testStepFinished) {
-        const { testStepId, testCaseStartedId, testStepResult, timestamp } = testStepFinished;
-        const testStep = this.testStepMap.get(testStepId);
-        if (testStep.pickleStepId === undefined)
-            return;
-        const stepProgess = this.stepProgressMap.get(testStep.pickleStepId);
-        const prevStepResult = stepProgess.result;
-        stepProgess.result = {
-            status: testStepResult.status,
-            startTime: prevStepResult.startTime,
-            endTime: this.getTimeStamp(timestamp),
-            message: testStepResult.message,
-            // exception: testStepResult.exception,
-        };
-    }
-    getTestCaseResult(steps) {
-        for (const step of steps) {
-            switch (step.result.status) {
-                case 'FAILED':
-                    return {
-                        status: step.result.status,
-                        message: step.result.message,
-                        // exception: step.result.exception,
-                    };
-                case 'AMBIGUOUS':
-                case 'UNDEFINED':
-                case 'PENDING':
-                    return {
-                        status: 'FAILED',
-                        message: `step "${step.text}" is ${step.result.status}`,
-                    };
-            }
-        }
-        return {
-            status: 'PASSED',
-        };
-    }
-    onTestCaseFinished(testCaseFinished) {
-        const { testCaseStartedId, timestamp } = testCaseFinished;
-        const testProgress = this.testProgressMap.get(testCaseStartedId);
-        const prevResult = testProgress.result;
-        const steps = Object.values(testProgress.steps);
-        const result = this.getTestCaseResult(steps);
-        testProgress.result = {
-            ...result,
-            startTime: prevResult.startTime,
-            endTime: this.getTimeStamp(timestamp),
-        };
-    }
-    onTestRunFinished(testRunFinished) {
-        const { timestamp, success, exception, message } = testRunFinished;
-        const prevResult = this.report.result;
-        this.report.result = {
-            status: success ? 'PASSED' : 'FAILED',
-            startTime: prevResult.startTime,
-            endTime: this.getTimeStamp(timestamp),
-            message,
-            // exception,
-        };
-    }
-}
-exports.default = ReportGenerator;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ReportGenerator {
+    constructor() {
+        this.report = {
+            result: {
+                status: 'UNKNOWN',
+            },
+            testCases: [],
+        };
+        this.gherkinDocumentMap = new Map();
+        this.pickleMap = new Map();
+        this.testCaseMap = new Map();
+        this.testStepMap = new Map();
+        this.stepProgressMap = new Map();
+        this.testProgressMap = new Map();
+        this.reportFolder = null;
+    }
+    handleMessage(envelope) {
+        const type = Object.keys(envelope)[0];
+        switch (type) {
+            // case "meta": { break}
+            // case "source": { break}
+            case 'parseError': {
+                const parseError = envelope[type];
+                this.handleParseError(parseError);
+                break;
+            }
+            case 'gherkinDocument': {
+                const doc = envelope[type];
+                this.onGherkinDocument(doc);
+                break;
+            }
+            case 'pickle': {
+                const pickle = envelope[type];
+                this.onPickle(pickle);
+                break;
+            }
+            // case "stepDefinition": { break}
+            // case "hook": { break} // Before Hook
+            case 'testRunStarted': {
+                const testRunStarted = envelope[type];
+                this.onTestRunStarted(testRunStarted);
+                break;
+            }
+            case 'testCase': {
+                const testCase = envelope[type];
+                this.onTestCase(testCase);
+                break;
+            }
+            case 'testCaseStarted': {
+                const testCaseStarted = envelope[type];
+                this.onTestCaseStarted(testCaseStarted);
+                break;
+            }
+            case 'testStepStarted': {
+                const testStepStarted = envelope[type];
+                this.onTestStepStarted(testStepStarted);
+                break;
+            }
+            case 'attachment': {
+                const attachment = envelope[type];
+                this.onAttachment(attachment);
+                break;
+            }
+            case 'testStepFinished': {
+                const testStepFinished = envelope[type];
+                this.onTestStepFinished(testStepFinished);
+                break;
+            }
+            case 'testCaseFinished': {
+                const testCaseFinished = envelope[type];
+                this.onTestCaseFinished(testCaseFinished);
+                break;
+            }
+            // case "hook": { break} // After Hook
+            case 'testRunFinished': {
+                const testRunFinished = envelope[type];
+                this.onTestRunFinished(testRunFinished);
+                break;
+            }
+            // case "parameterType" : { break}
+            // case "undefinedParameterType": { break}
+        }
+    }
+    getReport() {
+        return this.report;
+    }
+    handleParseError(parseError) {
+        const { message, source } = parseError;
+        const timestamp = new Date().getTime();
+        this.report.result = {
+            status: 'FAILED',
+            startTime: timestamp,
+            endTime: timestamp,
+            message: message,
+        };
+    }
+    onGherkinDocument(doc) {
+        this.gherkinDocumentMap.set(doc.uri, doc);
+    }
+    onPickle(pickle) {
+        this.pickleMap.set(pickle.id, pickle);
+    }
+    getTimeStamp(timestamp) {
+        return timestamp.seconds * 1000 + timestamp.nanos / 1000000;
+    }
+    onTestRunStarted(testRunStarted) {
+        this.report.result = {
+            status: 'STARTED',
+            startTime: this.getTimeStamp(testRunStarted.timestamp),
+        };
+    }
+    onTestCase(testCase) {
+        this.testCaseMap.set(testCase.id, testCase);
+        testCase.testSteps.forEach((testStep) => {
+            this.testStepMap.set(testStep.id, testStep);
+        });
+    }
+    onTestCaseStarted(testCaseStarted) {
+        const { testCaseId, id, timestamp } = testCaseStarted;
+        const testCase = this.testCaseMap.get(testCaseId);
+        if (testCase === undefined)
+            throw new Error(`testCase with id ${testCaseId} not found`);
+        const pickle = this.pickleMap.get(testCase.pickleId);
+        if (pickle === undefined)
+            throw new Error(`pickle with id ${testCase.pickleId} not found`);
+        const doc = this.gherkinDocumentMap.get(pickle.uri);
+        if (doc === undefined)
+            throw new Error(`gherkinDocument with uri ${pickle.uri} not found`);
+        const featureName = doc.feature.name;
+        const scenarioName = pickle.name;
+        const steps = pickle.steps.map((step) => {
+            this.stepProgressMap.set(step.id, {
+                type: step.type,
+                text: step.text,
+                commands: [],
+                result: {
+                    status: 'UNKNOWN',
+                },
+            });
+            return this.stepProgressMap.get(step.id);
+        });
+        this.testProgressMap.set(id, {
+            id,
+            uri: pickle.uri,
+            featureName,
+            scenarioName,
+            // TODO: compute parameters
+            parameters: {},
+            steps,
+            result: {
+                status: 'STARTED',
+                startTime: this.getTimeStamp(timestamp),
+            },
+        });
+        this.report.testCases.push(this.testProgressMap.get(id));
+    }
+    onTestStepStarted(testStepStarted) {
+        const { testStepId, timestamp, testCaseStartedId } = testStepStarted;
+        const testStep = this.testStepMap.get(testStepId);
+        if (testStep === undefined)
+            throw new Error(`testStep with id ${testStepId} not found`);
+        if (testStep.pickleStepId === undefined)
+            return;
+        const stepProgess = this.stepProgressMap.get(testStep.pickleStepId);
+        stepProgess.result = {
+            status: 'STARTED',
+            startTime: this.getTimeStamp(timestamp),
+        };
+    }
+    onAttachment(attachment) {
+        const { testCaseStartedId, testStepId, body, mediaType, contentEncoding, fileName, source, url, } = attachment;
+        if (mediaType === 'text/plain') {
+            this.reportFolder = body.replaceAll('\\', '/');
+        }
+        const testStep = this.testStepMap.get(testStepId);
+        if (testStep.pickleStepId === undefined)
+            return;
+        const stepProgess = this.stepProgressMap.get(testStep.pickleStepId);
+        if (mediaType === 'application/json') {
+            const command = JSON.parse(body);
+            stepProgess.commands.push(command);
+        }
+    }
+    onTestStepFinished(testStepFinished) {
+        const { testStepId, testCaseStartedId, testStepResult, timestamp } = testStepFinished;
+        const testStep = this.testStepMap.get(testStepId);
+        if (testStep.pickleStepId === undefined)
+            return;
+        const stepProgess = this.stepProgressMap.get(testStep.pickleStepId);
+        const prevStepResult = stepProgess.result;
+        stepProgess.result = {
+            status: testStepResult.status,
+            startTime: prevStepResult.startTime,
+            endTime: this.getTimeStamp(timestamp),
+            message: testStepResult.message,
+            // exception: testStepResult.exception,
+        };
+    }
+    getTestCaseResult(steps) {
+        for (const step of steps) {
+            switch (step.result.status) {
+                case 'FAILED':
+                    return {
+                        status: step.result.status,
+                        message: step.result.message,
+                        // exception: step.result.exception,
+                    };
+                case 'AMBIGUOUS':
+                case 'UNDEFINED':
+                case 'PENDING':
+                    return {
+                        status: 'FAILED',
+                        message: `step "${step.text}" is ${step.result.status}`,
+                    };
+            }
+        }
+        return {
+            status: 'PASSED',
+        };
+    }
+    onTestCaseFinished(testCaseFinished) {
+        const { testCaseStartedId, timestamp } = testCaseFinished;
+        const testProgress = this.testProgressMap.get(testCaseStartedId);
+        const prevResult = testProgress.result;
+        const steps = Object.values(testProgress.steps);
+        const result = this.getTestCaseResult(steps);
+        testProgress.result = {
+            ...result,
+            startTime: prevResult.startTime,
+            endTime: this.getTimeStamp(timestamp),
+        };
+    }
+    onTestRunFinished(testRunFinished) {
+        const { timestamp, success, exception, message } = testRunFinished;
+        const prevResult = this.report.result;
+        this.report.result = {
+            status: success ? 'PASSED' : 'FAILED',
+            startTime: prevResult.startTime,
+            endTime: this.getTimeStamp(timestamp),
+            message,
+            // exception,
+        };
+    }
+}
+exports.default = ReportGenerator;
 //# sourceMappingURL=report_generator.js.map

package/lib/formatter/helpers/step_argument_formatter.d.ts

@@ -1,2 +1,2 @@
-import * as messages from '@cucumber/messages';
-export declare function formatStepArgument(arg: messages.PickleStepArgument): string;
+import * as messages from '@cucumber/messages';
+export declare function formatStepArgument(arg: messages.PickleStepArgument): string;

package/lib/formatter/helpers/step_argument_formatter.js

@@ -1,48 +1,48 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatStepArgument = void 0;
-const cli_table3_1 = __importDefault(require("cli-table3"));
-const step_arguments_1 = require("../../step_arguments");
-function formatDataTable(dataTable) {
-    const table = new cli_table3_1.default({
-        chars: {
-            bottom: '',
-            'bottom-left': '',
-            'bottom-mid': '',
-            'bottom-right': '',
-            left: '|',
-            'left-mid': '',
-            mid: '',
-            'mid-mid': '',
-            middle: '|',
-            right: '|',
-            'right-mid': '',
-            top: '',
-            'top-left': '',
-            'top-mid': '',
-            'top-right': '',
-        },
-        style: {
-            border: [],
-            'padding-left': 1,
-            'padding-right': 1,
-        },
-    });
-    const rows = dataTable.rows.map((row) => row.cells.map((cell) => cell.value.replace(/\\/g, '\\\\').replace(/\n/g, '\\n')));
-    table.push(...rows);
-    return table.toString();
-}
-function formatDocString(docString) {
-    return `"""\n${docString.content}\n"""`;
-}
-function formatStepArgument(arg) {
-    return (0, step_arguments_1.parseStepArgument)(arg, {
-        dataTable: formatDataTable,
-        docString: formatDocString,
-    });
-}
-exports.formatStepArgument = formatStepArgument;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatStepArgument = void 0;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const step_arguments_1 = require("../../step_arguments");
+function formatDataTable(dataTable) {
+    const table = new cli_table3_1.default({
+        chars: {
+            bottom: '',
+            'bottom-left': '',
+            'bottom-mid': '',
+            'bottom-right': '',
+            left: '|',
+            'left-mid': '',
+            mid: '',
+            'mid-mid': '',
+            middle: '|',
+            right: '|',
+            'right-mid': '',
+            top: '',
+            'top-left': '',
+            'top-mid': '',
+            'top-right': '',
+        },
+        style: {
+            border: [],
+            'padding-left': 1,
+            'padding-right': 1,
+        },
+    });
+    const rows = dataTable.rows.map((row) => row.cells.map((cell) => cell.value.replace(/\\/g, '\\\\').replace(/\n/g, '\\n')));
+    table.push(...rows);
+    return table.toString();
+}
+function formatDocString(docString) {
+    return `"""\n${docString.content}\n"""`;
+}
+function formatStepArgument(arg) {
+    return (0, step_arguments_1.parseStepArgument)(arg, {
+        dataTable: formatDataTable,
+        docString: formatDocString,
+    });
+}
+exports.formatStepArgument = formatStepArgument;
 //# sourceMappingURL=step_argument_formatter.js.map

package/lib/formatter/helpers/summary_helpers.d.ts

@@ -1,9 +1,9 @@
-import { IColorFns } from '../get_color_fns';
-import { ITestCaseAttempt } from './event_data_collector';
-import * as messages from '@cucumber/messages';
-export interface IFormatSummaryRequest {
-    colorFns: IColorFns;
-    testCaseAttempts: ITestCaseAttempt[];
-    testRunDuration: messages.Duration;
-}
-export declare function formatSummary({ colorFns, testCaseAttempts, testRunDuration, }: IFormatSummaryRequest): string;
+import { IColorFns } from '../get_color_fns';
+import { ITestCaseAttempt } from './event_data_collector';
+import * as messages from '@cucumber/messages';
+export interface IFormatSummaryRequest {
+    colorFns: IColorFns;
+    testCaseAttempts: ITestCaseAttempt[];
+    testRunDuration: messages.Duration;
+}
+export declare function formatSummary({ colorFns, testCaseAttempts, testRunDuration, }: IFormatSummaryRequest): string;