@dev-blinq/cucumber-js 1.0.0 → 1.0.1-amdocs

package/lib/formatter/helpers/report_generator.js

@@ -0,0 +1,590 @@
+"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 };
+};
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+const messages = __importStar(require("@cucumber/messages"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const upload_serivce_1 = require("./upload_serivce");
+const fs_2 = require("fs");
+const URL = process.env.NODE_ENV_BLINQ === 'dev'
+    ? 'https://dev.api.blinq.io/api/runs'
+    : process.env.NODE_ENV_BLINQ === 'local'
+        ? 'http://localhost:5001/api/runs'
+        : process.env.NODE_ENV_BLINQ === 'stage'
+            ? 'https://stage.api.blinq.io/api/runs'
+            : process.env.NODE_ENV_BLINQ === 'prod'
+                ? 'https://api.blinq.io/api/runs'
+                : !process.env.NODE_ENV_BLINQ
+                    ? 'https://api.blinq.io/api/runs'
+                    : `${process.env.NODE_ENV_BLINQ}/api/runs`;
+const REPORT_SERVICE_URL = (_a = process.env.REPORT_SERVICE_URL) !== null && _a !== void 0 ? _a : URL;
+const BATCH_SIZE = 10;
+const MAX_RETRIES = 3;
+const REPORT_SERVICE_TOKEN = (_b = process.env.TOKEN) !== null && _b !== void 0 ? _b : process.env.REPORT_SERVICE_TOKEN;
+class ReportGenerator {
+    constructor() {
+        this.report = {
+            result: {
+                status: 'UNKNOWN',
+            },
+            testCases: [],
+            env: {
+                name: '',
+                baseUrl: '',
+            },
+        };
+        this.gherkinDocumentMap = new Map();
+        this.stepMap = new Map();
+        this.pickleMap = new Map();
+        this.testCaseMap = new Map();
+        this.testStepMap = new Map();
+        this.stepReportMap = new Map();
+        this.testCaseReportMap = new Map();
+        this.scenarioIterationCountMap = new Map();
+        this.logs = [];
+        this.networkLog = [];
+        this.stepLogs = [];
+        this.stepNetworkLogs = [];
+        this.runName = '';
+        this.ariaSnapshot = '';
+        this.initialAriaSnapshot = '';
+        this.reportFolder = null;
+        this.uploadService = new upload_serivce_1.RunUploadService(REPORT_SERVICE_URL, REPORT_SERVICE_TOKEN);
+    }
+    async handleMessage(envelope, reRunId) {
+        if (envelope.meta && 'runName' in envelope.meta) {
+            this.runName = envelope.meta.runName;
+        }
+        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];
+                return await this.onTestCaseFinished(testCaseFinished, reRunId);
+            }
+            // 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 } = 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);
+        doc.feature.children.forEach((child) => {
+            if (child.scenario) {
+                child.scenario.steps.forEach((step) => {
+                    this.stepMap.set(step.id, step);
+                });
+            }
+            else if (child.background) {
+                child.background.steps.forEach((step) => {
+                    this.stepMap.set(step.id, step);
+                });
+            }
+            else if (child.rule) {
+                child.rule.children.forEach((child) => {
+                    if (child.scenario) {
+                        child.scenario.steps.forEach((step) => {
+                            this.stepMap.set(step.id, step);
+                        });
+                    }
+                    else if (child.background) {
+                        child.background.steps.forEach((step) => {
+                            this.stepMap.set(step.id, step);
+                        });
+                    }
+                });
+            }
+        });
+    }
+    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);
+        });
+    }
+    _findScenario(doc, scenarioId) {
+        for (const child of doc.feature.children) {
+            if (child.scenario && child.scenario.id === scenarioId) {
+                return child.scenario;
+            }
+            if (child.rule) {
+                for (const scenario of child.rule.children) {
+                    if (scenario.scenario && scenario.scenario.id === scenarioId) {
+                        return scenario.scenario;
+                    }
+                }
+            }
+        }
+        throw new Error(`scenario "${scenarioId}" not found`);
+    }
+    _getParameters(scenario, exampleId) {
+        const parameters = {};
+        if (scenario.examples.length === 0)
+            return parameters;
+        for (const examples of scenario.examples) {
+            for (const tableRow of examples.tableBody) {
+                if (tableRow.id === exampleId) {
+                    for (let i = 0; i < examples.tableHeader.cells.length; i++) {
+                        parameters[examples.tableHeader.cells[i].value] =
+                            tableRow.cells[i].value;
+                    }
+                }
+            }
+        }
+        return parameters;
+    }
+    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 scenarioId = pickle.astNodeIds[0];
+        const scenario = this._findScenario(doc, scenarioId);
+        const scenarioName = scenario.name;
+        if (!this.scenarioIterationCountMap.has(scenarioId)) {
+            this.scenarioIterationCountMap.set(scenarioId, 1);
+        }
+        const parameters = this._getParameters(scenario, pickle.astNodeIds[1]);
+        console.log(`Running scenario ${scenarioName} iteration ${this.scenarioIterationCountMap.get(scenarioId)} with parameters:\n${JSON.stringify(parameters, null, 4)}\n 
+      `);
+        this.scenarioIterationCountMap.set(scenarioId, this.scenarioIterationCountMap.get(scenarioId) + 1);
+        const steps = pickle.steps.map((pickleStep) => {
+            const stepId = pickleStep.astNodeIds[0];
+            const step = this.stepMap.get(stepId);
+            this.stepReportMap.set(pickleStep.id, {
+                type: step.keywordType,
+                keyword: step.keyword,
+                text: step.text,
+                commands: [],
+                result: {
+                    status: 'UNKNOWN',
+                },
+                networkData: [],
+                webLog: [],
+                data: {},
+                ariaSnapshot: this.ariaSnapshot,
+            });
+            return this.stepReportMap.get(pickleStep.id);
+        });
+        this.testCaseReportMap.set(id, {
+            id,
+            uri: pickle.uri,
+            featureName,
+            scenarioName,
+            parameters,
+            steps,
+            result: {
+                status: 'STARTED',
+                startTime: this.getTimeStamp(timestamp),
+            },
+            webLog: [],
+            networkLog: [],
+            env: {
+                name: this.report.env.name,
+                baseUrl: this.report.env.baseUrl,
+            },
+        });
+        this.report.testCases.push(this.testCaseReportMap.get(id));
+    }
+    onTestStepStarted(testStepStarted) {
+        const { testStepId, timestamp } = 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.stepReportMap.get(testStep.pickleStepId);
+        stepProgess.result = {
+            status: 'STARTED',
+            startTime: this.getTimeStamp(timestamp),
+        };
+    }
+    onAttachment(attachment) {
+        const { testStepId, body, mediaType } = attachment;
+        if (mediaType === 'text/plain') {
+            this.reportFolder = body.replaceAll('\\', '/');
+            return;
+        }
+        if (mediaType === 'application/json+snapshot-before') {
+            this.initialAriaSnapshot = body;
+            return;
+        }
+        if (mediaType === 'application/json+snapshot-after') {
+            this.ariaSnapshot = body;
+            return;
+        }
+        if (mediaType === 'application/json+env') {
+            const data = JSON.parse(body);
+            this.report.env = data;
+            this.report.testCases.map((testCase) => {
+                testCase.env = data;
+                return testCase;
+            });
+        }
+        if (mediaType === 'application/json+log') {
+            const log = JSON.parse(body);
+            if (this.logs.length < 1000) {
+                this.logs.push(log);
+                this.stepLogs.push(log);
+            }
+        }
+        if (mediaType === 'application/json+network') {
+            const networkLog = JSON.parse(body);
+            if (this.networkLog.length < 1000)
+                this.networkLog.push(networkLog);
+            this.stepNetworkLogs.push(networkLog);
+        }
+        const testStep = this.testStepMap.get(testStepId);
+        if (testStep.pickleStepId === undefined)
+            return;
+        const stepProgess = this.stepReportMap.get(testStep.pickleStepId);
+        if (mediaType === 'application/json') {
+            const command = JSON.parse(body);
+            stepProgess.commands.push(command);
+        }
+    }
+    getFailedTestStepResult({ commands, startTime, endTime, result, }) {
+        for (const command of commands) {
+            if (command.result.status === 'FAILED') {
+                return {
+                    status: 'FAILED',
+                    message: command.result.message,
+                    startTime,
+                    endTime,
+                };
+            }
+        }
+        return {
+            status: 'FAILED',
+            startTime,
+            endTime,
+            message: result.message,
+        };
+    }
+    onTestStepFinished(testStepFinished) {
+        const { testStepId, testStepResult, timestamp } = testStepFinished;
+        const testStep = this.testStepMap.get(testStepId);
+        if (testStep.pickleStepId === undefined) {
+            if (testStepResult.status === 'FAILED') {
+                console.error(`Before/After hook failed with message: ${testStepResult.message}`);
+            }
+            return;
+        }
+        if (testStepResult.status === 'UNDEFINED') {
+            const step = this.stepReportMap.get(testStep.pickleStepId);
+            const stepName = step ? step.keyword + ' ' + step.text : 'Undefined step';
+            const undefinedCommand = {
+                testStepId: testStepId,
+                body: JSON.stringify({
+                    type: 'error',
+                    text: 'Undefined step: ' + stepName,
+                    result: {
+                        status: 'FAILED',
+                        startTime: this.getTimeStamp(timestamp),
+                        endTime: this.getTimeStamp(timestamp),
+                    },
+                }),
+                mediaType: 'application/json',
+                contentEncoding: messages.AttachmentContentEncoding.IDENTITY,
+            };
+            this.onAttachment(undefinedCommand);
+        }
+        const stepProgess = this.stepReportMap.get(testStep.pickleStepId);
+        const prevStepResult = stepProgess.result;
+        let data = {};
+        try {
+            const reportFolder = this.reportFolder;
+            if (reportFolder === null) {
+                throw new Error('"reportFolder" is "null". Failed to run BVT hooks. Please retry after running "Generate All" or "Record Scenario" ');
+            }
+            if (fs_1.default.existsSync(path_1.default.join(reportFolder, 'data.json'))) {
+                data = JSON.parse(fs_1.default.readFileSync(path_1.default.join(reportFolder, 'data.json'), 'utf8'));
+            }
+        }
+        catch (error) {
+            console.log('Error reading data.json');
+        }
+        if (testStepResult.status === 'FAILED') {
+            stepProgess.result = this.getFailedTestStepResult({
+                commands: stepProgess.commands,
+                startTime: prevStepResult.startTime,
+                endTime: this.getTimeStamp(timestamp),
+                result: testStepResult,
+            });
+        }
+        else {
+            stepProgess.result = {
+                status: testStepResult.status,
+                startTime: prevStepResult.startTime,
+                endTime: this.getTimeStamp(timestamp),
+            };
+        }
+        stepProgess.webLog = this.stepLogs;
+        stepProgess.networkData = this.stepNetworkLogs;
+        stepProgess.ariaSnapshot = this.ariaSnapshot;
+        this.ariaSnapshot = '';
+        this.stepNetworkLogs = [];
+        this.stepLogs = [];
+        if (Object.keys(data).length > 0) {
+            stepProgess.data = data;
+        }
+    }
+    getLogFileContent() {
+        let projectPath = process.cwd();
+        if (process.env.PROJECT_PATH) {
+            projectPath = process.env.PROJECT_PATH;
+        }
+        const logFolder = path_1.default.join(projectPath, 'logs', 'web');
+        if (!fs_1.default.existsSync(logFolder)) {
+            return [];
+        }
+        let nextId = 1;
+        while (fs_1.default.existsSync(path_1.default.join(logFolder, `${nextId}.json`))) {
+            nextId++;
+        }
+        if (nextId === 1) {
+            return [];
+        }
+        try {
+            const logFileContent = fs_1.default.readFileSync(path_1.default.join(logFolder, `${nextId - 1}.json`), 'utf8');
+            return JSON.parse(logFileContent);
+        }
+        catch (error) {
+            return [];
+        }
+    }
+    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',
+        };
+    }
+    async onTestCaseFinished(testCaseFinished, reRunId) {
+        const { testCaseStartedId, timestamp } = testCaseFinished;
+        const testProgress = this.testCaseReportMap.get(testCaseStartedId);
+        const prevResult = testProgress.result;
+        const steps = Object.values(testProgress.steps);
+        const result = this.getTestCaseResult(steps);
+        const endTime = this.getTimeStamp(timestamp);
+        testProgress.result = {
+            ...result,
+            startTime: prevResult.startTime,
+            endTime,
+        };
+        testProgress.webLog = this.logs;
+        testProgress.networkLog = this.networkLog;
+        testProgress.initialAriaSnapshot = this.initialAriaSnapshot;
+        this.initialAriaSnapshot = '';
+        this.networkLog = [];
+        this.logs = [];
+        if (process.env.TESTCASE_REPORT_FOLDER_PATH) {
+            this.reportFolder = process.env.TESTCASE_REPORT_FOLDER_PATH;
+            if (!fs_1.default.existsSync(this.reportFolder)) {
+                fs_1.default.mkdirSync(this.reportFolder);
+            }
+            const reportFilePath = path_1.default.join(this.reportFolder, `${endTime}_${testProgress.scenarioName}.json`);
+            (0, fs_2.writeFileSync)(reportFilePath, JSON.stringify(testProgress, null, 2));
+            return undefined;
+        }
+        else {
+            return await this.uploadTestCase(testProgress, reRunId);
+        }
+    }
+    async uploadTestCase(testCase, rerunId) {
+        let runId = '';
+        let projectId = '';
+        if (!process.env.UPLOADING_TEST_CASE) {
+            process.env.UPLOADING_TEST_CASE = '[]';
+        }
+        const anyRemArr = JSON.parse(process.env.UPLOADING_TEST_CASE);
+        const randomID = Math.random().toString(36).substring(7);
+        anyRemArr.push(randomID);
+        let data;
+        process.env.UPLOADING_TEST_CASE = JSON.stringify(anyRemArr);
+        try {
+            if (process.env.RUN_ID &&
+                process.env.PROJECT_ID &&
+                !process.env.IGNORE_ENV_VARIABLES) {
+                runId = process.env.RUN_ID;
+                projectId = process.env.PROJECT_ID;
+            }
+            else {
+                const runDoc = await this.uploadService.createRunDocument(this.runName);
+                runId = runDoc._id;
+                projectId = runDoc.project_id;
+                if (!process.env.IGNORE_ENV_VARIABLES) {
+                    process.env.RUN_ID = runId;
+                    process.env.PROJECT_ID = projectId;
+                }
+            }
+            data = await this.uploadService.uploadTestCase(testCase, runId, projectId, this.reportFolder, rerunId);
+            this.writeTestCaseReportToDisk(testCase);
+        }
+        catch (e) {
+            console.error('Error uploading test case:', e);
+        }
+        finally {
+            const arrRem = JSON.parse(process.env.UPLOADING_TEST_CASE);
+            arrRem.splice(arrRem.indexOf(randomID), 1);
+            process.env.UPLOADING_TEST_CASE = JSON.stringify(arrRem);
+        }
+        return data ? data : null;
+    }
+    writeTestCaseReportToDisk(testCase) {
+        try {
+            let i = 0;
+            while (fs_1.default.existsSync(path_1.default.join(this.reportFolder, `${i}`))) {
+                i++;
+            }
+            fs_1.default.mkdirSync(path_1.default.join(this.reportFolder, `${i}`));
+            //exclude network log from the saved report
+            const networkLog = testCase.networkLog;
+            delete testCase.networkLog;
+            fs_1.default.writeFileSync(path_1.default.join(this.reportFolder, `${i}`, `report.json`), JSON.stringify(testCase, null, 2));
+            fs_1.default.writeFileSync(path_1.default.join(this.reportFolder, `${i}`, `network.json`), JSON.stringify(networkLog, null, 2));
+        }
+        catch (error) {
+            console.error('Error writing test case report to disk:', error);
+        }
+    }
+    onTestRunFinished(testRunFinished) {
+        const { timestamp, success, 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