@testomatio/reporter 1.6.13 → 2.0.1-beta-esm

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/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').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/types.js').Pipe} Pipe
+ * @typedef {import('../../types/types.js').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;

package/src/pipe/debug.js

@@ -0,0 +1,104 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import createDebugMessages from 'debug';
+import { APP_PREFIX } from '../constants.js';
+import prettyMs from 'pretty-ms';
+
+const debug = createDebugMessages('@testomatio/reporter:pipe:debug');
+
+export class DebugPipe {
+  constructor(params, store) {
+    this.params = params || {};
+    this.store = store || {};
+
+    this.isEnabled = !!process.env.TESTOMATIO_DEBUG || !!process.env.DEBUG;
+    if (this.isEnabled) {
+      this.batch = {
+        isEnabled: this.params.isBatchEnabled ?? !process.env.TESTOMATIO_DISABLE_BATCH_UPLOAD ?? true,
+        intervalFunction: null,
+        intervalTime: 5000,
+        tests: [],
+        batchIndex: 0,
+      };
+      this.logFilePath = path.join(os.tmpdir(), `testomatio.debug.${Date.now()}.json`);
+
+      debug('Creating debug file:', this.logFilePath);
+      fs.writeFileSync(this.logFilePath, '');
+      console.log(APP_PREFIX, '🪲. Debug created:');
+      this.testomatioEnvVars = Object.keys(process.env)
+        .filter(key => key.startsWith('TESTOMATIO_'))
+        .reduce((acc, key) => {
+          acc[key] = process.env[key];
+          return acc;
+        }, {});
+      this.logToFile({ datetime: new Date().toISOString(), timestamp: Date.now() });
+      this.logToFile({ data: 'variables', testomatioEnvVars: this.testomatioEnvVars });
+      this.logToFile({ data: 'store', store: this.store || {} });
+      // Bind batchUpload to the instance
+      this.batchUpload = this.batchUpload.bind(this);
+    }
+  }
+
+  /**
+   * Logs data to a file if logging is enabled.
+   *
+   * @param {Object} logData - The data to be logged.
+   * @returns {Promise<void>} A promise that resolves when the log data has been appended to the file.
+   */
+  logToFile(logData) {
+    if (!this.isEnabled) return;
+    const timePassedFromLastAction = Date.now() - (this.lastActionTimestamp || Date.now());
+    this.lastActionTimestamp = Date.now();
+
+    const logLine = JSON.stringify({ t: `+${prettyMs(timePassedFromLastAction)}`, ...logData });
+    fs.appendFileSync(this.logFilePath, `${logLine}\n`);
+  }
+
+  async prepareRun(opts) {
+    if (!this.isEnabled) return [];
+
+    this.logToFile({ action: 'prepareRun', data: opts });
+  }
+
+  async createRun(params = {}) {
+    if (!this.isEnabled) return;
+    if (params.isBatchEnabled === true || params.isBatchEnabled === false) this.batch.isEnabled = params.isBatchEnabled;
+
+    if (!this.isEnabled) return {};
+    if (this.batch.isEnabled) this.batch.intervalFunction = setInterval(this.batchUpload, this.batch.intervalTime);
+
+    this.logToFile({ action: 'createRun', params });
+  }
+
+  async addTest(data) {
+    if (!this.isEnabled) return;
+
+    if (!this.batch.isEnabled) this.logToFile({ action: 'addTest', testId: data });
+    else this.batch.tests.push(data);
+
+    if (!this.batch.intervalFunction) await this.batchUpload();
+  }
+
+  async batchUpload() {
+    this.batch.batchIndex++;
+    if (!this.batch.isEnabled) return;
+    if (!this.batch.tests.length) return;
+
+    const testsToSend = this.batch.tests.splice(0);
+
+    this.logToFile({ action: 'addTestsBatch', tests: testsToSend });
+  }
+
+  async finishRun(params) {
+    if (!this.isEnabled) return;
+    this.logToFile({ actions: 'finishRun', params });
+    await this.batchUpload();
+    if (this.batch.intervalFunction) clearInterval(this.batch.intervalFunction);
+    console.log(APP_PREFIX, '🪲. Debug Saved to', this.logFilePath);
+  }
+
+  toString() {
+    return 'Debug Reporter';
+  }
+}