@testomatio/reporter 1.6.0-beta-2-artifacts → 2.0.0-beta-esm

package/src/junit-adapter/python.js

@@ -0,0 +1,42 @@
+import path from 'path';
+import fs from 'fs';
+import Adapter from './adapter.js';
+
+class PythonAdapter extends Adapter {
+  getFilePath(t) {
+    let fileName = namespaceToFileName(t.suite_title, { checkFile: true });
+    if (!fileName) fileName = namespaceToFileName(t.suite_title, { checkFile: false });
+    return fileName;
+  }
+
+  formatTest(t) {
+    const fileParts = t.suite_title.split('.');
+    const example = t.title.match(/\[(.*)\]/)?.[1];
+    if (example) t.example = { '#': example };
+
+    t.file = namespaceToFileName(t.suite_title);
+    t.title = t.title.split('[')[0];
+    t.suite_title = fileParts[fileParts.length - 1].replace(/\$/g, ' | ');
+    return t;
+  }
+
+  formatMessage(t) {
+    return t.message.split('
')[0];
+  }
+}
+
+function namespaceToFileName(fileName, opts = {}) {
+  const fileParts = fileName.split('.');
+
+  while (fileParts.length > 0) {
+    const file = `${fileParts.join(path.sep)}.py`;
+    if (!opts.checkFile) return file;
+    if (fs.existsSync(`${fileParts.join(path.sep)}.py`)) {
+      return file;
+    }
+    fileParts.pop();
+  }
+  return null;
+}
+
+export default PythonAdapter;

package/src/junit-adapter/ruby.js

@@ -0,0 +1,10 @@
+import Adapter from './adapter.js';
+
+class RubyAdapter extends Adapter {
+  formatStack(t) {
+    const stack = super.formatStack(t);
+    return stack.replace(/\[(.*?:.\d*)\]/g, '\n$1');
+  }
+}
+
+export default RubyAdapter;

package/src/output.js

@@ -0,0 +1,57 @@
+import { format } from 'util';
+
+const consoleLog = console.log;
+const consoleError = console.error;
+
+const formatArgs = args => format.apply(format, Array.prototype.slice.call(args));
+
+class Output {
+  constructor(opts = {}) {
+    this.filterFn = opts.filterFn || (() => true);
+    this.reset();
+  }
+
+  reset() {
+    this.log = [];
+    this.stop(); // resotre console log if it was overridden
+  }
+
+  start() {
+    const { filterFn } = this;
+    const self = this;
+    console.log = (...args) => {
+      const obj = {};
+      Error.captureStackTrace(obj);
+      const logString = formatArgs(args);
+      if (filterFn(obj.stack)) {
+        self.log.push(logString);
+      }
+      consoleLog(logString);
+    };
+
+    console.error = (...args) => {
+      const obj = {};
+      Error.captureStackTrace(obj);
+      const logString = formatArgs(args);
+      if (filterFn(obj.stack)) {
+        self.log.push(logString);
+      }
+      consoleError(logString);
+    };
+  }
+
+  push(line) {
+    this.log.push(line);
+  }
+
+  text() {
+    return this.log.join('\n');
+  }
+
+  stop() {
+    console.log = consoleLog;
+    console.error = consoleError;
+  }
+}
+
+export default Output;

package/src/pipe/bitbucket.js

@@ -0,0 +1,254 @@
+import { APP_PREFIX, testomatLogoURL } from '../constants.js';
+import { ansiRegExp, isSameTest } from '../utils/utils.js';
+import { statusEmoji, fullName } from '../utils/pipe_utils.js';
+import axios from 'axios';
+import pc from 'picocolors';
+import humanizeDuration from 'humanize-duration';
+import merge from 'lodash.merge';
+import path from 'path';
+import createDebugMessages from 'debug';
+
+const debug = createDebugMessages('@testomatio/reporter:pipe:bitbucket');
+
+//! BITBUCKET_ACCESS_TOKEN environment variable is required for this functionality to work
+//! and your pipeline trigger should be a pull request
+
+/**
+ * @class BitbucketPipe
+ * @typedef {import('../../types').Pipe} Pipe
+ * @typedef {import('../../types').TestData} TestData
+ */
+export class BitbucketPipe {
+  constructor(params, store = {}) {
+    this.isEnabled = false;
+    this.ENV = process.env;
+    this.store = store;
+    this.tests = [];
+    // Bitbucket PAT looks like bbpat-*****
+    this.token = params.BITBUCKET_ACCESS_TOKEN || process.env.BITBUCKET_ACCESS_TOKEN || this.ENV.BITBUCKET_ACCESS_TOKEN;
+    this.hiddenCommentData = `Testomat.io report: ${process.env.BITBUCKET_BRANCH || ''}`;
+
+    debug(
+      pc.yellow('Bitbucket Pipe:'),
+      this.token ? 'TOKEN passed' : '*no token*',
+      `Project key: ${this.ENV.BITBUCKET_PROJECT_KEY}, Pull request ID: ${this.ENV.BITBUCKET_PR_ID}`,
+    );
+
+    if (!this.token) {
+      debug(`Hint: Bitbucket CI variables are unavailable for unprotected branches by default.`);
+      return;
+    }
+
+    this.isEnabled = true;
+
+    debug('Bitbucket Pipe: Enabled');
+  }
+
+  async cleanLog(log) {
+    const stripAnsi = (await import('strip-ansi')).default;
+    return stripAnsi(log);
+  }
+
+  // Prepare the run (if needed)
+  async prepareRun() {}
+
+  // Create a new run (if needed)
+  async createRun() {}
+
+  addTest(test) {
+    if (!this.isEnabled) return;
+
+    const index = this.tests.findIndex(t => isSameTest(t, test));
+    // Update if they were already added
+    if (index >= 0) {
+      this.tests[index] = merge(this.tests[index], test);
+      return;
+    }
+
+    this.tests.push(test);
+  }
+
+  async finishRun(runParams) {
+    if (!this.isEnabled) return;
+
+    if (runParams.tests) runParams.tests.forEach(t => this.addTest(t));
+
+    // Clean up the logs from ANSI codes
+    for (let i = 0; i < this.tests.length; i++) {
+      this.tests[i].message = await this.cleanLog(this.tests[i].message || '');
+      this.tests[i].stack = await this.cleanLog(this.tests[i].stack || '');
+    }
+
+    // Create a comment on Bitbucket
+    const passedCount = this.tests.filter(t => t.status === 'passed').length;
+    const failedCount = this.tests.filter(t => t.status === 'failed').length;
+    const skippedCount = this.tests.filter(t => t.status === 'skipped').length;
+
+    // Constructing the table
+    let summary = `${this.hiddenCommentData}
+    
+  | ![Testomat.io Report](${testomatLogoURL}) | ${statusEmoji(
+    runParams.status,
+  )} ${runParams.status.toUpperCase()} ${statusEmoji(runParams.status)} |
+  | --- | --- |
+  | **Tests** | ✔️ **${this.tests.length}** tests run |
+  | **Summary** | ${statusEmoji('failed')} **${failedCount}** failed; ${statusEmoji(
+    'passed',
+  )} **${passedCount}** passed; **${statusEmoji('skipped')}** ${skippedCount} skipped |
+  | **Duration** | 🕐 **${humanizeDuration(
+    parseInt(
+      this.tests.reduce((a, t) => a + (t.run_time || 0), 0),
+      10,
+    ),
+    {
+      maxDecimalPoints: 0,
+    },
+  )}** |
+  `;
+
+    if (this.ENV.BITBUCKET_BRANCH && this.ENV.BITBUCKET_COMMIT) {
+      // eslint-disable-next-line max-len
+      summary += `| **Job** | 👷 [#${this.ENV.BITBUCKET_BUILD_NUMBER}](https://bitbucket.org/${this.ENV.BITBUCKET_REPO_FULL_NAME}/pipelines/results/${this.ENV.BITBUCKET_BUILD_NUMBER}") by commit: **${this.ENV.BITBUCKET_COMMIT}** |`;
+    }
+
+    const failures = this.tests
+      .filter(t => t.status === 'failed')
+      .slice(0, 20)
+      .map(t => {
+        let text = `${statusEmoji('failed')} ${fullName(t)}\n`;
+        if (t.message) {
+          text += `> ${t.message
+            .replace(/[^\x20-\x7E]/g, '')
+            .replace(ansiRegExp(), '')
+            .trim()}\n`;
+        }
+        if (t.stack) {
+          text += `\n\`\`\`diff\n${t.stack
+            .replace(ansiRegExp(), '')
+            .replace(
+              /^[\s\S]*################\[ Failure \]################/g,
+              '################[ Failure ]################',
+            )
+            .trim()}\n\`\`\`\n`;
+        }
+        if (t.artifacts && t.artifacts.length && !this.ENV.TESTOMATIO_PRIVATE_ARTIFACTS) {
+          t.artifacts
+            .filter(f => !!f)
+            .forEach(f => {
+              if (f.endsWith('.png')) {
+                text += `![Image](${f})\n`;
+              } else {
+                text += `[📄 ${path.basename(f)}](${f})\n`;
+              }
+            });
+        }
+        text += `\n---\n`;
+        return text;
+      });
+
+    let body = summary;
+
+    if (failures.length) {
+      body += `\n🟥 **Failures (${failures.length})**\n\n* ${failures.join('\n* ')}\n`;
+      if (failures.length > 10) {
+        body += `\n> Notice: Only the first 10 failures are shown.`;
+      }
+    }
+
+    if (this.tests.length > 0) {
+      body += `\n\n**🐢 Slowest Tests**\n\n`;
+      body += this.tests
+        .sort((a, b) => b.run_time - a.run_time)
+        .slice(0, 5)
+        .map(t => `* **${fullName(t)}** (${humanizeDuration(parseFloat(t.run_time))})`)
+        .join('\n');
+    }
+
+    // Construct Bitbucket API URL for comments
+    // eslint-disable-next-line max-len
+    const commentsRequestURL = `https://api.bitbucket.org/2.0/repositories/${this.ENV.BITBUCKET_WORKSPACE}/${this.ENV.BITBUCKET_REPO_SLUG}/pullrequests/${this.ENV.BITBUCKET_PR_ID}/comments`;
+
+    // Delete previous report
+    await deletePreviousReport(axios, commentsRequestURL, this.hiddenCommentData, this.token);
+
+    // Add current report
+    debug(`Adding comment via URL: ${commentsRequestURL}`);
+    debug(`Final Bitbucket API call body: ${body}`);
+
+    try {
+      const addCommentResponse = await axios.post(
+        commentsRequestURL,
+        { content: { raw: body } },
+        {
+          headers: {
+            Authorization: `Bearer ${this.token}`,
+            'Content-Type': 'application/json',
+          },
+        },
+      );
+
+      const commentID = addCommentResponse.data.id;
+      // eslint-disable-next-line max-len
+      const commentURL = `https://bitbucket.org/${this.ENV.BITBUCKET_WORKSPACE}/${this.ENV.BITBUCKET_REPO_SLUG}/pull-requests/${this.ENV.BITBUCKET_PR_ID}#comment-${commentID}`;
+
+      console.log(APP_PREFIX, pc.yellow('Bitbucket'), `Report created: ${pc.magenta(commentURL)}`);
+    } catch (err) {
+      console.error(
+        APP_PREFIX,
+        pc.yellow('Bitbucket'),
+        `Couldn't create Bitbucket report\n${err}.
+      Request URL: ${commentsRequestURL}
+      Request data: ${body}`,
+      );
+    }
+  }
+
+  toString() {
+    return 'Bitbucket Reporter';
+  }
+
+  updateRun() {}
+}
+
+async function deletePreviousReport(axiosInstance, commentsRequestURL, hiddenCommentData, token) {
+  if (process.env.BITBUCKET_KEEP_OUTDATED_REPORTS) return;
+
+  // Get comments
+  let comments = [];
+
+  try {
+    const response = await axiosInstance.get(commentsRequestURL, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+      },
+    });
+    comments = response.data.values;
+  } catch (e) {
+    console.error('Error while attempting to retrieve comments on Bitbucket Pull Request:\n', e);
+  }
+
+  if (!comments.length) return;
+
+  for (const comment of comments) {
+    // If comment was left by the same workflow
+    if (comment.content.raw.includes(hiddenCommentData)) {
+      try {
+        // Delete previous comment
+        const deleteCommentURL = `${commentsRequestURL}/${comment.id}`;
+        await axiosInstance.delete(deleteCommentURL, {
+          headers: {
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+          },
+        });
+      } catch (e) {
+        console.warn(`Can't delete previously added comment with testomat.io report. Ignored.`);
+      }
+      // Pass next env var if need to clear all previous reports;
+      // only the last one is removed by default
+      if (!process.env.BITBUCKET_REMOVE_ALL_OUTDATED_REPORTS) break;
+      // TODO: in case of many reports should implement pagination
+    }
+  }
+}

package/src/pipe/csv.js

@@ -0,0 +1,140 @@
+import createDebugMessages from 'debug';
+import path from 'path';
+import fs from 'fs';
+import {createObjectCsvWriter} from 'csv-writer';
+import pc from 'picocolors';
+import merge from 'lodash.merge';
+import { isSameTest, getCurrentDateTime, ansiRegExp } from '../utils/utils.js';
+import { CSV_HEADERS } from '../constants.js';
+
+const debug = createDebugMessages('@testomatio/reporter:pipe:csv');
+/**
+ * @typedef {import('../../types').Pipe} Pipe
+ * @typedef {import('../../types').TestData} TestData
+ * @class CsvPipe
+ * @implements {Pipe}
+ */
+class CsvPipe {
+  constructor(params, store) {
+    this.store = store || {};
+    this.title = params.title || process.env.TESTOMATIO_TITLE;
+    this.results = [];
+
+    this.outputDir = 'export';
+    this.defaultReportName = 'report.csv';
+    this.csvFilename = process.env.TESTOMATIO_CSV_FILENAME;
+    this.isEnabled = false;
+
+    if (this.csvFilename) {
+      const filenameParts = this.csvFilename.split('.');
+
+      if (filenameParts.length > 0) {
+        this.isEnabled = true;
+        const baseFilename = filenameParts[0];
+        const defaultOutputFile = path.resolve(process.cwd(), this.outputDir, this.defaultReportName);
+
+        const outputFile =
+          baseFilename === this.defaultReportName.split('.')[0] // = 'report'
+            ? defaultOutputFile
+            : path.resolve(process.cwd(), this.outputDir, `${getCurrentDateTime()}_${baseFilename}.csv`);
+
+        this.outputFile = outputFile;
+      }
+    }
+  }
+
+  // TODO: to using SET opts as argument => prepareRun(opts)
+  async prepareRun() {}
+
+  async createRun() {
+    // empty
+  }
+
+  updateRun() {}
+
+  /**
+   * Create a folder that will contain the exported files
+   */
+  checkExportDir() {
+    if (!fs.existsSync(this.outputDir)) {
+      return fs.mkdirSync(this.outputDir);
+    }
+  }
+
+  /**
+   * Save data to the csv file.
+   * @param {Object} data - data that will be added to the CSV file.
+   * Example: [{suite_title: "Suite #1", test: "Test-case-1", message: "Test msg"}]
+   * @param {Object} headers - csv file headers. Example: [{ id: 'suite_title', title: 'Suite_title' }]
+   */
+  async saveToCsv(data, headers) {
+    debug('Data', data);
+    // First, we check whether the export directory exists: if yes - OK, no - create it.
+    this.checkExportDir();
+
+    if (!this.outputFile) {
+      console.log(pc.yellow(`⚠️  CSV file is not set, ignoring`));
+      return;
+    }
+
+    console.log(pc.yellow(`⏳ The test results will be added to the csv. It will take some time...`));
+
+    try {
+      // Create csv writer object
+      const writer = createObjectCsvWriter({
+        path: this.outputFile,
+        header: headers,
+      });
+      // Save csv file based on the current data
+      return await writer.writeRecords(data);
+    } catch (e) {
+      console.log('Unknown csv error: ', e);
+    }
+  }
+
+  /**
+   * Add test data to the result array for saving. As a result of this function, we get a result object to save.
+   * @param {Object} test - object which includes each test entry.
+   */
+  addTest(test) {
+    if (!this.isEnabled) return;
+
+    const index = this.results.findIndex(t => isSameTest(t, test));
+    // update if they were already added
+    if (index >= 0) {
+      this.results[index] = merge(this.results[index], test);
+      return;
+    }
+
+    const { suite_title, title, status, message, stack } = test;
+
+    this.results.push({
+      suite_title,
+      title,
+      status,
+      message: message.replace(ansiRegExp(), ''),
+      stack: stack.replace(ansiRegExp(), ''),
+    });
+  }
+
+  /**
+   * @param {{ tests?: TestData[] }} runParams
+   * @returns {Promise<void>}
+   */
+  async finishRun(runParams) {
+    if (!this.isEnabled) return;
+
+    if (runParams.tests) runParams.tests.forEach(t => this.addTest(t));
+    // Save results based on the default headers
+    if (this.isEnabled) {
+      await this.saveToCsv(this.results, CSV_HEADERS);
+      console.log(pc.green(`🗃️  Recording completed! You can check the result in file = ${this.outputFile}`));
+    }
+  }
+
+  toString() {
+    return 'csv exporter';
+  }
+}
+
+export default CsvPipe;