testomatio-reporter-cli 2.8.4 → 2.8.5-beta.2-yarn

package/src/bin/uploadArtifacts.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import pc from 'picocolors';
+import createDebugMessages from 'debug';
+import TestomatClient from '../client.js';
+import { getPackageVersion } from '../utils/utils.js';
+import { config } from '../config.js';
+import { readLatestRunId } from '../utils/utils.js';
+import dotenv from 'dotenv';
+import { log } from '../utils/log.js';
+
+const debug = createDebugMessages('@testomatio/reporter:upload-cli');
+const version = getPackageVersion();
+console.log(pc.cyan(pc.bold(` 🤩 Testomat.io Reporter v${version}`)));
+const program = new Command();
+
+program
+  .option('--env-file <envfile>', 'Load environment variables from env file')
+  .option('--force', 'Re-upload artifacts even if they were uploaded before')
+  .action(async opts => {
+    if (opts.envFile) {
+      dotenv.config({ path: opts.envFile });
+    } else {
+      dotenv.config();
+    }
+
+    const apiKey = config.TESTOMATIO;
+    process.env.TESTOMATIO_DISABLE_ARTIFACTS = '';
+    const runId = process.env.TESTOMATIO_RUN || process.env.runId || readLatestRunId();
+
+    if (!runId) {
+      console.log('TESTOMATIO_RUN environment variable must be set or restored from a previous run.');
+      return process.exit(1);
+    }
+
+    const client = new TestomatClient({
+      apiKey,
+      runId,
+      isBatchEnabled: false,
+    });
+    let testruns = client.uploader.readUploadedFiles(process.env.TESTOMATIO_RUN);
+
+    const numTotalArtifacts = testruns.length;
+
+    debug('Found testruns:', testruns);
+
+    if (!opts.force) testruns = testruns.filter(tr => !tr.uploaded);
+
+    if (!testruns.length) {
+      log.info('Total artifacts:', numTotalArtifacts);
+      if (numTotalArtifacts) {
+        log.info('No new artifacts to upload');
+        log.info('To re-upload artifacts run this command with --force flag');
+      }
+      process.exit(0);
+    }
+
+    const testrunsByRid = testruns.reduce((acc, { rid, file }) => {
+      if (!acc[rid]) {
+        acc[rid] = [];
+      }
+      if (!acc[rid].includes(file)) acc[rid].push(file);
+      return acc;
+    }, {});
+
+    // we need to obtain S3 credentials
+    await client.createRun();
+
+    client.uploader.checkEnabled();
+    client.uploader.disableLogStorage();
+
+    for (const rid in testrunsByRid) {
+      const files = testrunsByRid[rid];
+      await client.addTestRun(undefined, {
+        rid,
+        files,
+      });
+    }
+
+    log.info(client.uploader.successfulUploads.length, 'artifacts uploaded');
+    if (client.uploader.failedUploads.length) {
+      log.info(client.uploader.failedUploads.length, 'artifacts failed to upload');
+    }
+  });
+
+if (process.argv.length <= 1) {
+  program.outputHelp();
+}
+
+program.parse(process.argv);

package/src/client.js

@@ -0,0 +1,524 @@
+import createDebugMessages from 'debug';
+import fs from 'fs';
+import pc from 'picocolors';
+import { APP_PREFIX, STATUS, SCREENSHOTS_ON_STEPS } from './constants.js';
+import { pipesFactory } from './pipe/index.js';
+import { glob } from 'glob';
+import path from 'path';
+import { fileURLToPath } from 'node:url';
+import { S3Uploader } from './uploader.js';
+import { readLatestRunId, storeRunId, validateSuiteId, transformEnvVarToBoolean, isHttpUrl } from './utils/utils.js';
+import { generateShortFilename } from './adapter/utils/step-formatter.js';
+import { filesize as prettyBytes } from 'filesize';
+import { formatLogs, formatError, stripColors } from './utils/log-formatter.js';
+import { log } from './utils/log.js';
+
+const debug = createDebugMessages('@testomatio/reporter:client');
+
+// removed __dirname usage, because:
+// 1. replaced with ESM syntax (import.meta.url), but it throws an error on tsc compilation;
+// 2. got error "__dirname already defined" in compiles js code (cjs dir)
+
+let listOfTestFilesToExcludeFromReport = null;
+
+/**
+ * @typedef {import('../types/types.js').TestData} TestData
+ * @typedef {import('../types/types.js').PipeResult} PipeResult
+ */
+
+class Client {
+  /**
+   * Create a Testomat client instance
+   * @returns
+   */
+  constructor(params = {}) {
+    this.paramsForPipesFactory = params;
+    this.pipeStore = {};
+    this.runId = '';
+    this.queue = Promise.resolve();
+
+    // @ts-ignore this line will be removed in compiled code, because __dirname is defined in commonjs
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const pathToPackageJSON = path.join(__dirname, '../package.json');
+    try {
+      this.version = JSON.parse(fs.readFileSync(pathToPackageJSON).toString()).version;
+      log.info(`Testomatio Reporter v${this.version}`);
+    } catch (e) {
+      // do nothing
+    }
+    this.executionList = Promise.resolve();
+
+    this.uploader = new S3Uploader();
+  }
+
+  /**
+   * Asynchronously prepares the execution list for running tests through various pipes.
+   * Each pipe in the client is checked for enablement,
+   * and if all pipes are disabled, the function returns a resolved Promise.
+   * Otherwise, it executes the `prepareRun` method for each enabled pipe and collects the results.
+   * The results are then filtered to remove any undefined values.
+   * If no valid results are found, the function returns undefined.
+   * Otherwise, it returns the first non-empty array from the filtered results.
+   *
+   * @param {Object} params - The options for preparing the test execution list.
+   * @param {string} params.pipe - Name of the executed pipe.
+   * @param {string} params.pipeOptions - Filter option.
+   * @returns {Promise<any>} - A Promise that resolves to an
+   * array containing the prepared execution list,
+   * or resolves to undefined if no valid results are found or if all pipes are disabled.
+   */
+
+  async prepareRun(params) {
+    const { pipe, pipeOptions } = params;
+
+    // ❗ Validation: pipe is required
+    if (!pipe || !pipeOptions) {
+      log.warn(`❗ No valid pipe found in filter cmd. Expected format: <pipe>:<options>
+      Examples:
+        --filter "testomatio:tag-name=frontend"
+        --filter "coverage:file=coverage.yml"
+        --filter-list "coverage:file=coverage.yml"
+      Received: "${params}"`);
+      return;
+    }
+
+    this.pipes = await pipesFactory(params || this.paramsForPipesFactory || {}, this.pipeStore);
+
+    // all pipes disabled, skipping
+    if (!this.pipes.some(p => p.isEnabled)) {
+      return Promise.resolve();
+    }
+
+    try {
+      const p = this.pipes.find(p => p.constructor.name.toLowerCase() === `${pipe.toLowerCase()}pipe`);
+      // const p = this.pipes.find(p => p.id === `${pipe.toLowerCase()}`); TODO: as future updates
+
+      if (!p?.isEnabled) {
+        log.warn('🚫 No active pipes were found in the system. Execution aborted!');
+        return;
+      }
+
+      // Run only the selected pipe
+      const rawResult = await p.prepareRun(pipeOptions);
+      const result = Array.isArray(rawResult) ? rawResult : [];
+
+      debug('Execution tests list', result);
+
+      return result;
+    } catch (err) {
+      log.error(err);
+    }
+  }
+
+  /**
+   * Used to create a new Test run
+   *
+   * @returns {Promise<any>} - resolves to Run id which should be used to update / add test
+   */
+  async createRun(params = {}) {
+    const pipeParams = { ...(this.paramsForPipesFactory || {}), ...(params || {}) };
+    if (!this.pipes || !this.pipes.length)
+      this.pipes = await pipesFactory(pipeParams, this.pipeStore);
+    debug('Creating run...');
+    // all pipes disabled, skipping
+    if (!this.pipes?.filter(p => p.isEnabled).length) return Promise.resolve();
+
+    this.queue = this.queue
+      .then(() => Promise.all(this.pipes.map(p => p.createRun(params))))
+      .catch(err => log.info(err))
+      .then(() => {
+        const runId = this.pipeStore?.runId;
+        if (runId) this.runId = runId;
+        storeRunId(this.runId);
+      })
+      .then(() => this.uploader.checkEnabled())
+      .then(() => undefined); // fixes return type
+    // debug('Run', this.queue);
+    return this.queue;
+  }
+
+  /**
+   * Recursively uploads artifacts from steps
+   *
+   * @param {*} steps - Steps payload (validated inside function)
+   * @param {string} testRid - Test/result ID
+   * @returns {Promise<void>}
+   */
+  async uploadStepArtifacts(steps, testRid) {
+    if (!steps || !Array.isArray(steps)) return;
+    if (!this.uploader.isEnabled || !SCREENSHOTS_ON_STEPS) return;
+
+    try {
+      for (const step of steps) {
+        if (!(step.artifacts && Array.isArray(step.artifacts))) {
+          if (step.steps) {
+            await this.uploadStepArtifacts(step.steps, testRid);
+          }
+          continue;
+        }
+
+        const uploadedArtifacts = [];
+        for (const artifact of step.artifacts) {
+          if (typeof artifact === 'string' && !isHttpUrl(artifact)) {
+            const filename = generateShortFilename(artifact);
+            try {
+              const uploadResult = await this.uploader.uploadFileByPath(
+                artifact, 
+                [this.runId, testRid, 'steps', filename]
+              );
+              if (uploadResult) {
+                uploadedArtifacts.push(uploadResult);
+              } else {
+                uploadedArtifacts.push(artifact);
+              }
+            } catch (uploadErr) {
+              uploadedArtifacts.push(artifact);
+            }
+          } else {
+            uploadedArtifacts.push(artifact);
+          }
+        }
+        step.artifacts = uploadedArtifacts;
+
+        if (step.steps) {
+          await this.uploadStepArtifacts(step.steps, testRid);
+        }
+      }
+
+    } catch (err) {
+      console.error(APP_PREFIX, 'Error in uploadStepArtifacts for testRid', testRid, ':', err);
+      throw err;
+    }
+  }
+
+  /**
+   * Updates test status and its data
+   *
+   * @param {string|undefined} status
+   * @param {TestData} [testData]
+   * @returns {Promise<PipeResult[]>}
+   */
+  async addTestRun(status, testData) {
+    if (!testData)
+      testData = {
+        title: 'Unknown test',
+        suite_title: 'Unknown suite',
+      };
+
+    // Add timestamp if not already present (microseconds since Unix epoch)
+    if (!testData.timestamp && !process.env.TESTOMATIO_NO_TIMESTAMP) {
+      testData.timestamp = Math.floor((performance.timeOrigin + performance.now()) * 1000);
+    }
+
+    /**
+     * @type {TestData}
+     */
+    const { rid, error = null, steps: originalSteps, title, suite_title } = testData;
+    let steps = originalSteps;
+
+    // Capture step artifact paths BEFORE uploadStepArtifacts mutates them to URLs,
+    // so we can exclude them from the test-level artifacts list later.
+    const stepArtifactPaths = collectStepArtifactPaths(steps);
+
+    // Upload artifacts from steps
+    try {
+      await this.uploadStepArtifacts(steps, rid);
+    } catch (err) {
+      console.log(APP_PREFIX, 'Failed to upload step artifacts:', err);
+    }
+
+    const uploadedFiles = [];
+    const stackArtifactsEnabled = transformEnvVarToBoolean(process.env.TESTOMATIO_STACK_ARTIFACTS);
+
+    const {
+      time = 0,
+      example = null,
+      filesBuffers = [],
+      code = null,
+      file,
+      suite_id,
+      test_id,
+      timestamp,
+      links,
+      overwrite,
+      tags,
+    } = testData;
+    let { files = [], manuallyAttachedArtifacts, message = '', meta = {} } = testData;
+
+    if (stepArtifactPaths.size) {
+      const isStepArtifact = item => stepArtifactPaths.has(typeof item === 'object' ? item?.path : item);
+      files = files.filter(f => !isStepArtifact(f));
+      if (Array.isArray(manuallyAttachedArtifacts)) {
+        manuallyAttachedArtifacts = manuallyAttachedArtifacts.filter(a => !isStepArtifact(a));
+      }
+    }
+
+    meta = Object.entries(meta)
+      .filter(([, value]) => value !== null && value !== undefined)
+      .reduce((acc, [key, value]) => {
+        if (key) acc[key] = value;
+        return acc;
+      }, {});
+
+    const testContext = suite_title ? `${suite_title} ${title}` : title;
+
+    let errorFormatted = '';
+    if (error) {
+      errorFormatted += formatError(error) || '';
+      message = error?.message;
+    }
+
+    let fullLogs = formatLogs({ error: errorFormatted, logs: testData.logs });
+
+    if (stackArtifactsEnabled && fullLogs?.trim()?.length > 0) {
+      uploadedFiles.push(
+        this.uploader.uploadFileAsBuffer(Buffer.from(stripColors(fullLogs), 'utf8'), [
+          this.runId,
+          rid,
+          `logs_${+new Date()}.log`,
+        ]),
+      );
+      fullLogs = '';
+      steps = null;
+    }
+
+    if (!this.pipes || !this.pipes.length)
+      this.pipes = await pipesFactory(this.paramsForPipesFactory || {}, this.pipeStore);
+
+    if (!this.pipes?.filter(p => p.isEnabled).length) {
+      if (uploadedFiles.length > 0) {
+        await Promise.all(uploadedFiles);
+      }
+      return [];
+    }
+
+    if (isTestShouldBeExcludedFromReport(testData)) return [];
+
+    if (status === STATUS.SKIPPED && process.env.TESTOMATIO_EXCLUDE_SKIPPED) {
+      debug('Skipping test from report', testData?.title);
+      return [];
+    }
+
+    if (manuallyAttachedArtifacts?.length) files.push(...manuallyAttachedArtifacts);
+
+    for (let f of files) {
+      if (!f) continue; // f === null
+      if (typeof f === 'object') {
+        if (!f.path) continue;
+
+        f = f.path;
+      }
+
+      uploadedFiles.push(this.uploader.uploadFileByPath(f, [this.runId, rid, path.basename(f)]));
+    }
+
+    for (const [idx, buffer] of filesBuffers.entries()) {
+      const fileName = `${idx + 1}-${title.replace(/\s+/g, '-')}`;
+      uploadedFiles.push(this.uploader.uploadFileAsBuffer(buffer, [this.runId, rid, fileName]));
+    }
+
+    const artifacts = (await Promise.all(uploadedFiles)).filter(n => !!n);
+
+    const workspaceDir = process.env.TESTOMATIO_WORKDIR || process.cwd();
+    const relativeFile = file ? path.relative(workspaceDir, file) : file;
+    const rootSuiteId = validateSuiteId(process.env.TESTOMATIO_SUITE);
+
+    const data = {
+      rid,
+      files,
+      steps,
+      status,
+      stack: fullLogs,
+      example,
+      file: relativeFile,
+      code,
+      title,
+      suite_title,
+      suite_id,
+      test_id,
+      message,
+      run_time: typeof time === 'number' ? time : parseFloat(time),
+      timestamp,
+      artifacts,
+      meta,
+      links,
+      overwrite,
+      tags,
+      ...(rootSuiteId && { root_suite_id: rootSuiteId }),
+    };
+
+    // debug('Adding test run...', data);
+
+    // @ts-ignore
+    this.queue = this.queue.then(() =>
+      Promise.all(
+        this.pipes.map(async pipe => {
+          try {
+            const result = await pipe.addTest(data);
+            return { pipe: pipe.toString(), result };
+          } catch (err) {
+            log.info(pipe.toString(), err);
+          }
+        }),
+      ),
+    );
+
+    // @ts-ignore
+    return this.queue;
+  }
+
+  /**
+   *
+   * Updates the status of the current test run and finishes the run.
+   * @param {'passed' | 'failed' | 'skipped' | 'finished'} status - The status of the current test run.
+   * @param {Partial<import('../types/types.js').RunData>} [params] - Additional run params (e.g. duration).
+   * Must be one of "passed", "failed", or "finished"
+   * @returns {Promise<any>} - A Promise that resolves when finishes the run.
+   */
+  async updateRunStatus(status, params = {}) {
+    this.pipes ||= await pipesFactory(this.paramsForPipesFactory || {}, this.pipeStore);
+    this.runId ||= readLatestRunId();
+
+    debug('Updating run status...');
+    // all pipes disabled, skipping
+    if (!this.pipes?.filter(p => p.isEnabled).length) return Promise.resolve();
+
+    const runParams = { ...params, status };
+
+    this.queue = this.queue
+      .then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))))
+      .then(() => {
+        if (!this.uploader.isEnabled) return;
+
+        const filesizeStrMaxLength = 7;
+
+        if (this.uploader.successfulUploads.length) {
+          debug('\n', APP_PREFIX, `🗄️ ${this.uploader.successfulUploads.length} artifacts uploaded to S3 bucket`);
+          const uploadedArtifacts = this.uploader.successfulUploads.map(file => ({
+            relativePath: file.path.replace(process.cwd(), ''),
+            link: file.link,
+            sizePretty: file.size == null ? 'unknown' : prettyBytes(file.size, { round: 0 }).toString(),
+          }));
+
+          uploadedArtifacts.forEach(upload => {
+            debug(
+              `🟢Uploaded artifact`,
+              `${upload.relativePath},`,
+              'size:',
+              `${upload.sizePretty},`,
+              'link:',
+              `${upload.link}`,
+            );
+          });
+        }
+
+        if (this.uploader.failedUploads.length) {
+          log.info(`🗄️ ${this.uploader.failedUploads.length} artifacts 🔴${pc.bold('failed')} to upload`);
+          const failedUploads = this.uploader.failedUploads.map(file => ({
+            relativePath: file.path.replace(process.cwd(), ''),
+            sizePretty: file.size == null ? 'unknown' : prettyBytes(file.size, { round: 0 }).toString(),
+          }));
+
+          const pathPadding = Math.max(...failedUploads.map(upload => upload.relativePath.length)) + 1;
+
+          failedUploads.forEach(upload => {
+            console.log(
+              `  ${pc.gray('|')} 🔴 ${upload.relativePath.padEnd(pathPadding)} ${pc.gray(
+                `| ${upload.sizePretty.padStart(filesizeStrMaxLength)} |`,
+              )}`,
+            );
+          });
+        }
+
+        if (this.uploader.skippedUploads.length) {
+          log.info(`🗄️ ${pc.bold(this.uploader.skippedUploads.length)} artifacts uploading 🟡${pc.bold('skipped')}`);
+          const skippedUploads = this.uploader.skippedUploads.map(file => ({
+            relativePath: file.path.replace(process.cwd(), ''),
+            sizePretty: file.size === null ? 'unknown' : prettyBytes(file.size, { round: 0 }).toString(),
+          }));
+          const pathPadding = Math.max(...skippedUploads.map(upload => upload.relativePath.length)) + 1;
+          skippedUploads.forEach(upload => {
+            console.log(
+              `  ${pc.gray('|')} 🟡 ${upload.relativePath.padEnd(pathPadding)} ${pc.gray(
+                `| ${upload.sizePretty.padStart(filesizeStrMaxLength)} |`,
+              )}`,
+            );
+          });
+        }
+
+        if (this.uploader.skippedUploads.length || this.uploader.failedUploads.length) {
+          const command = `TESTOMATIO=<your_api_key> TESTOMATIO_RUN=${
+            this.runId
+          } npx @testomatio/reporter upload-artifacts`;
+          const numberOfNotUploadedArtifacts = this.uploader.skippedUploads.length + this.uploader.failedUploads.length;
+          log.info(`${numberOfNotUploadedArtifacts} artifacts were not uploaded.
+            Run "${pc.magenta(command)}" with valid S3 credentials to upload skipped & failed artifacts`);
+        }
+      })
+      .catch(err => log.info(err));
+
+    return this.queue;
+  }
+}
+
+/**
+ * Walks the step tree and returns the set of artifact path/url values
+ * referenced by `step.artifacts` at any depth.
+ *
+ * @param {any} steps
+ * @param {Set<string>} [paths]
+ * @returns {Set<string>}
+ */
+function collectStepArtifactPaths(steps, paths = new Set()) {
+  if (!Array.isArray(steps)) return paths;
+  for (const step of steps) {
+    if (!step) continue;
+    if (Array.isArray(step.artifacts)) {
+      for (const a of step.artifacts) {
+        if (typeof a === 'string') paths.add(a);
+        else if (a && typeof a === 'object' && typeof a.path === 'string') paths.add(a.path);
+      }
+    }
+    collectStepArtifactPaths(step.steps, paths);
+  }
+  return paths;
+}
+
+/**
+ *
+ * @param {TestData} testData
+ * @returns boolean
+ */
+function isTestShouldBeExcludedFromReport(testData) {
+  // const fileName = path.basename(test.location?.file || '');
+  const globExcludeFilesPattern = process.env.TESTOMATIO_EXCLUDE_FILES_FROM_REPORT_GLOB_PATTERN;
+  if (!globExcludeFilesPattern) return false;
+
+  if (!testData.file) {
+    debug('No "file" property found for test ', testData.title);
+    return false;
+  }
+
+  const excludePatternsList = globExcludeFilesPattern.split(';');
+
+  // as scanning files is time consuming operation, just save the result in variable to avoid multiple scans
+  if (!listOfTestFilesToExcludeFromReport) {
+    // list of files with relative paths
+    listOfTestFilesToExcludeFromReport = glob.sync(excludePatternsList, { ignore: '**/node_modules/**' });
+    debug('Tests from next files will not be reported:', listOfTestFilesToExcludeFromReport);
+  }
+
+  const testFileRelativePath = path.relative(process.cwd(), testData.file);
+
+  // no files found matching the exclusion pattern
+  if (!listOfTestFilesToExcludeFromReport.length) return false;
+
+  if (listOfTestFilesToExcludeFromReport.includes(testFileRelativePath)) {
+    debug(`Excluding test '${testData.title}' <${testFileRelativePath}> from reporting`);
+    return true;
+  }
+  return false;
+}
+
+export { Client };
+export default Client;

package/src/config.js

@@ -0,0 +1,30 @@
+// This file is used to read environment variables from .env file
+import createDebugMessages from 'debug';
+
+const debug = createDebugMessages('@testomatio/reporter:config');
+
+/* for possibility to use multiple env files (reading different paths)
+const envFileVars = dotenv.config({ path: '.env' }).parsed; */
+
+if (process.env.TESTOMATIO_API_KEY && !process.env.TESTOMATIO) {
+  process.env.TESTOMATIO = process.env.TESTOMATIO_API_KEY;
+}
+if (process.env.TESTOMATIO_TOKEN && !process.env.TESTOMATIO) {
+  process.env.TESTOMATIO = process.env.TESTOMATIO_TOKEN;
+}
+
+if (process.env.TESTOMATIO === 'undefined')
+  console.error('TESTOMATIO is "undefined". Something went wrong. Contact dev team.');
+
+// select only TESTOMATIO related variables (only to print them in debug)
+const testomatioEnvVars =
+  Object.keys(process.env)
+    .filter(key => key.startsWith('TESTOMATIO') || key.startsWith('S3_'))
+    .reduce((obj, key) => {
+      obj[key] = process.env[key];
+      return obj;
+    }, {}) || {};
+debug('TESTOMATIO variables:', testomatioEnvVars);
+
+// includes variables from .env file and process.env
+export const config = process.env;