@testomatio/reporter 2.0.0-beta-esm → 2.0.1-beta-esm

package/src/uploader.js

@@ -0,0 +1,371 @@
+import createDebugMessages from 'debug';
+import { S3 } from '@aws-sdk/client-s3';
+import { Upload } from '@aws-sdk/lib-storage';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import promiseRetry from 'promise-retry';
+import pc from 'picocolors';
+import { APP_PREFIX } from './constants.js';
+import { filesize as prettyBytes } from 'filesize';
+
+const debug = createDebugMessages('@testomatio/reporter:file-uploader');
+
+export class S3Uploader {
+  constructor() {
+    this.isEnabled = undefined;
+    this.storeEnabled = true;
+    this.config = undefined;
+
+    /**
+     * @type {{path: string, size: number}[]}
+     */
+    this.skippedUploads = [];
+    this.failedUploads = [];
+    /**
+     * @type {{path: string, size: number, link: string}[]}
+     */
+    this.successfulUploads = [];
+
+    this.configKeys = [
+      'S3_ENDPOINT',
+      'S3_REGION',
+      'S3_BUCKET',
+      'S3_ACCESS_KEY_ID',
+      'S3_SECRET_ACCESS_KEY',
+      'S3_SESSION_TOKEN',
+      'S3_FORCE_PATH_STYLE',
+      'TESTOMATIO_DISABLE_ARTIFACTS',
+      'TESTOMATIO_PRIVATE_ARTIFACTS',
+      'TESTOMATIO_ARTIFACT_MAX_SIZE_MB',
+    ];
+  }
+
+  resetConfig() {
+    this.config = undefined;
+    this.isEnabled = undefined;
+  }
+
+  /**
+   *
+   * @returns {Record<string, string>}
+   */
+  getConfig() {
+    if (this.config) return this.config;
+    this.config = this.configKeys.reduce((acc, key) => {
+      acc[key] = process.env[key];
+      return acc;
+    }, {});
+    return this.config;
+  }
+
+  getMaskedConfig() {
+    return Object.fromEntries(
+      Object.entries(this.getConfig()).map(([key, value]) => [
+        key,
+        key === 'S3_SECRET_ACCESS_KEY' || key === 'S3_ACCESS_KEY_ID' ? '***' : value,
+      ]),
+    );
+  }
+
+  checkEnabled() {
+    if (this.isEnabled !== undefined) return this.isEnabled;
+
+    const { S3_BUCKET, TESTOMATIO_DISABLE_ARTIFACTS } = this.getConfig();
+    if (!S3_BUCKET) debug(`Artifacts uploading is disabled because S3_BUCKET is not set`);
+    this.isEnabled = !!(S3_BUCKET && !TESTOMATIO_DISABLE_ARTIFACTS);
+
+    if (this.isEnabled) debug('S3 uploader is enabled');
+    debug(this.getMaskedConfig());
+
+    return this.isEnabled;
+  }
+
+  enableLogStorage() {
+    this.storeEnabled = true;
+  }
+
+  disableLogStorage() {
+    this.storeEnabled = false;
+  }
+
+  /**
+   *
+   * @param {*} Body
+   * @param {*} Key
+   * @param {{path: string, size?: number}} file
+   * @returns
+   */
+  async #uploadToS3(Body, Key, file) {
+    const { S3_BUCKET, TESTOMATIO_PRIVATE_ARTIFACTS } = this.getConfig();
+    const ACL = TESTOMATIO_PRIVATE_ARTIFACTS ? 'private' : 'public-read';
+
+    if (!S3_BUCKET || !Body) {
+      console.log(
+        APP_PREFIX,
+        pc.bold(pc.red(`Failed uploading '${Key}'. Please check S3 credentials`)),
+        this.getMaskedConfig(),
+      );
+      return;
+    }
+
+    debug('Uploading to S3:', Key);
+
+    const s3Config = this.#getS3Config();
+    const s3 = new S3(s3Config);
+    const params = {
+      Bucket: S3_BUCKET,
+      Key,
+      Body,
+    };
+    // disable ACL for I AM roles
+    if (!s3Config.credentials.sessionToken) {
+      params.ACL = ACL;
+    }
+
+    try {
+      const upload = new Upload({ client: s3, params });
+
+      const link = await this.getS3LocationLink(upload);
+      this.successfulUploads.push({ path: file.path, size: file.size, link });
+      debug(`📤 Uploaded artifact. File: ${file.path}, size: ${prettyBytes(file.size)}, link: ${link}`);
+      return link;
+    } catch (e) {
+      this.failedUploads.push({ path: file.path, size: file.size });
+      debug('S3 uploading error:', e);
+      console.log(APP_PREFIX, 'Upload failed:', e.message, '\nConfig:\n', this.getMaskedConfig());
+    }
+  }
+
+  /**
+   * Returns an array of uploaded files
+   *
+   * @returns {{rid: string, file: string, uploaded: boolean}[]}
+   */
+  readUploadedFiles(runId) {
+    const tempFilePath = this.#getFilePathWithUploadsList(runId);
+
+    debug('Reading file', tempFilePath);
+
+    if (!fs.existsSync(tempFilePath)) {
+      debug('File not found:', tempFilePath);
+      return [];
+    }
+
+    const stats = fs.statSync(tempFilePath);
+    debug('Artifacts file stats:', +stats.mtime);
+    debug('Current time:', +new Date());
+    const diff = +new Date() - +stats.mtime;
+    debug('Diff:', diff);
+    const diffHours = diff / 1000 / 60 / 60;
+    debug('Diff hours:', diffHours);
+    if (diffHours > 3) {
+      console.log(APP_PREFIX, "Artifacts file is too old, can't process artifacts. Please re-run the tests.");
+      return [];
+    }
+
+    const data = fs.readFileSync(tempFilePath, 'utf8');
+    debug('Artifacts file contents:', data);
+    const lines = data.split('\n').filter(Boolean);
+    return lines.map(line => JSON.parse(line));
+  }
+
+  #getFilePathWithUploadsList(runId) {
+    const tempFilePath = path.join(os.tmpdir(), `testomatio.run.${runId}.json`);
+    if (!fs.existsSync(tempFilePath)) {
+      debug('Creating artifacts file:', tempFilePath);
+      fs.writeFileSync(tempFilePath, '');
+    }
+    return tempFilePath;
+  }
+
+  storeUploadedFile(filePath, runId, rid, uploaded = false) {
+    if (!this.storeEnabled) return;
+
+    if (!filePath || !runId || !rid) return;
+
+    const tempFilePath = this.#getFilePathWithUploadsList(runId);
+
+    if (typeof filePath === 'object') {
+      filePath = filePath.path;
+    }
+
+    if (typeof filePath === 'string' && !path.isAbsolute(filePath)) {
+      filePath = path.join(process.cwd(), filePath);
+    }
+
+    const data = { rid, file: filePath, uploaded };
+    const jsonLine = `${JSON.stringify(data)}\n`;
+    fs.appendFileSync(tempFilePath, jsonLine);
+  }
+
+  /**
+   * @param {*} filePath
+   * @param {*} pathInS3 contains runId, rid and filename
+   * @returns
+   */
+  async uploadFileByPath(filePath, pathInS3) {
+    // sometimes artifacts uploading started before createRun function completion
+    this.isEnabled = this.isEnabled ?? this.checkEnabled();
+
+    const [runId, rid] = pathInS3;
+
+    if (!filePath) return;
+
+    let fileSize = null;
+    let fileSizeInMb = null;
+
+    try {
+      // file may not exist
+      fileSize = fs.statSync(filePath).size;
+      fileSizeInMb = Number((fileSize / (1024 * 1024)).toFixed(2));
+    } catch (e) {
+      debug(`File ${filePath} does not exist`);
+    }
+
+    if (!this.isEnabled) {
+      this.storeUploadedFile(filePath, runId, rid, false);
+      this.skippedUploads.push({ path: filePath, size: fileSize });
+      return;
+    }
+
+    const { S3_BUCKET, TESTOMATIO_ARTIFACT_MAX_SIZE_MB } = this.getConfig();
+
+    debug('Started upload', filePath, 'to', S3_BUCKET);
+
+    const isFileExist = await this.checkArtifactExistsInFileSystem(filePath, 20, 500);
+
+    if (!isFileExist) {
+      console.error(pc.yellow(`Artifacts file ${filePath} does not exist. Skipping...`));
+      return;
+    }
+
+    // skipping artifact only if: 1. storing to file is enabled, 2. max size is set and 3. file size exceeds the limit
+    if (
+      this.storeEnabled &&
+      TESTOMATIO_ARTIFACT_MAX_SIZE_MB &&
+      fileSizeInMb > parseFloat(TESTOMATIO_ARTIFACT_MAX_SIZE_MB)
+    ) {
+      const skippedArtifact = { path: filePath, size: fileSize };
+      this.storeUploadedFile(filePath, runId, rid, false);
+      this.skippedUploads.push(skippedArtifact);
+      debug(pc.yellow(`Artifacts file ${JSON.stringify(skippedArtifact)} exceeds the maximum allowed size. Skipping.`));
+      return;
+    }
+    debug('File:', filePath, 'exists, size:', prettyBytes(fileSize));
+
+    const fileStream = fs.createReadStream(filePath);
+    const Key = pathInS3.join('/');
+
+    const link = await this.#uploadToS3(fileStream, Key, { path: filePath, size: fileSize });
+
+    this.storeUploadedFile(filePath, runId, rid, !!link);
+
+    return link;
+  }
+
+  /**
+   * @param {Buffer} buffer
+   * @param {string[]} pathInS3
+   * @returns
+   */
+  async uploadFileAsBuffer(buffer, pathInS3) {
+    if (!this.isEnabled) return;
+
+    let Key = pathInS3.join('/');
+    const ext = this.#getFileExtBase64(buffer);
+
+    if (ext) {
+      Key = `${Key}.${ext}`;
+    }
+
+    return this.#uploadToS3(buffer, Key, { path: Key });
+  }
+
+  async checkArtifactExistsInFileSystem(filePath, attempts = 5, intervalMs = 500) {
+    return promiseRetry(
+      async (retry, number) => {
+        try {
+          fs.accessSync(filePath);
+          return true;
+        } catch (err) {
+          if (number === attempts) {
+            return false;
+          }
+          debug(`File not found, retrying (attempt ${number}/${attempts})`);
+          await new Promise(resolve => {
+            setTimeout(resolve, intervalMs);
+          });
+          retry(err);
+        }
+      },
+      {
+        retries: attempts,
+        minTimeout: intervalMs,
+        maxTimeout: intervalMs,
+      },
+    );
+  }
+
+  async getS3LocationLink(out) {
+    const response = await out.done();
+
+    let s3Location = response?.Location?.trim();
+
+    if (!s3Location) {
+      s3Location = out?.singleUploadResult?.Location;
+      debug('Uploaded singleUploadResult.Location', s3Location);
+
+      if (!s3Location) {
+        throw new Error("Problems getting the S3 artifact's link. Please check S3 permissions!");
+      }
+    }
+
+    // Normalize the URL
+    if (!s3Location.startsWith('http')) {
+      s3Location = `https://${s3Location}`;
+    }
+
+    return s3Location;
+  }
+
+  #getFileExtBase64(str) {
+    const type = str.charAt(0);
+
+    return (
+      {
+        '/': 'jpg',
+        i: 'png',
+        R: 'gif',
+        U: 'webp',
+      }[type] || ''
+    );
+  }
+
+  #getS3Config() {
+    const { S3_REGION, S3_SESSION_TOKEN, S3_ACCESS_KEY_ID, S3_SECRET_ACCESS_KEY, S3_FORCE_PATH_STYLE, S3_ENDPOINT } =
+      this.getConfig();
+
+    const cfg = {
+      region: S3_REGION,
+      credentials: {
+        accessKeyId: S3_ACCESS_KEY_ID,
+        secretAccessKey: S3_SECRET_ACCESS_KEY,
+      },
+    };
+
+    if (S3_FORCE_PATH_STYLE) {
+      cfg.forcePathStyle = !['false', '0'].includes(String(S3_FORCE_PATH_STYLE || '').toLowerCase());
+    }
+
+    if (S3_SESSION_TOKEN) {
+      cfg.credentials.sessionToken = S3_SESSION_TOKEN;
+    }
+
+    if (S3_ENDPOINT) {
+      cfg.endpoint = S3_ENDPOINT;
+    }
+
+    return cfg;
+  }
+}

package/src/utils/pipe_utils.js

@@ -1,4 +1,3 @@
-import { upload } from '../fileUploader.js';
 import { APP_PREFIX } from '../constants.js';
 
 /**
@@ -8,16 +7,16 @@ import { APP_PREFIX } from '../constants.js';
 function setS3Credentials(artifacts) {
   if (!Object.keys(artifacts).length) return;
 
-  console.log(APP_PREFIX, 'S3 were credentials obtained from Testomat.io...');
+  console.log(APP_PREFIX, 'S3 credentials obtained from Testomat.io...');
 
   if (artifacts.ACCESS_KEY_ID) process.env.S3_ACCESS_KEY_ID = artifacts.ACCESS_KEY_ID;
   if (artifacts.SECRET_ACCESS_KEY) process.env.S3_SECRET_ACCESS_KEY = artifacts.SECRET_ACCESS_KEY;
   if (artifacts.REGION) process.env.S3_REGION = artifacts.REGION;
   if (artifacts.BUCKET) process.env.S3_BUCKET = artifacts.BUCKET;
-  if (artifacts.ENDPOINT) process.env.S3_ENDPOINT = artifacts.ENDPOINT;
   if (artifacts.SESSION_TOKEN) process.env.S3_SESSION_TOKEN = artifacts.SESSION_TOKEN;
   if (artifacts.presign) process.env.TESTOMATIO_PRIVATE_ARTIFACTS = '1';
-  upload.resetConfig();
+  // endpoint is not received from the server; and shuld be empty if IAM used (credentails obtained from the testomat)
+  process.env.S3_ENDPOINT = artifacts.ENDPOINT || '';
 }
 
 /**
@@ -117,11 +116,4 @@ function fullName(t) {
   return line;
 }
 
-export {
-  updateFilterType,
-  parseFilterParams,
-  generateFilterRequestParams,
-  setS3Credentials,
-  statusEmoji,
-  fullName,
-};
+export { updateFilterType, parseFilterParams, generateFilterRequestParams, setS3Credentials, statusEmoji, fullName };

package/src/utils/utils.js

@@ -1,9 +1,10 @@
 import { URL } from 'url';
-import { sep, basename } from 'path';
+import path, { sep, basename } from 'path';
 import pc from 'picocolors';
 import fs from 'fs';
 import isValid from 'is-valid-path';
 import createDebugMessages from 'debug';
+import os from 'os';
 
 const debug = createDebugMessages('@testomatio/reporter:util');
 
@@ -320,7 +321,46 @@ const testRunnerHelper = {
   },
 };
 
+function storeRunId(runId) {
+  if (!runId || runId === 'undefined') return;
+  const filePath = path.join(os.tmpdir(), `testomatio.latest.run`);
+  fs.writeFileSync(filePath, runId);
+}
+
+function readLatestRunId() {
+  try {
+    const filePath = path.join(os.tmpdir(), `testomatio.latest.run`);
+    const stats = fs.statSync(filePath);
+    const diff = +new Date() - +stats.mtime;
+    const diffHours = diff / 1000 / 60 / 60;
+    if (diffHours > 1) return;
+
+    return fs.readFileSync(filePath)?.toString()?.trim();
+  } catch (e) {
+    return null;
+  }
+}
+
+function formatStep(step, shift = 0) {
+  const prefix = ' '.repeat(shift);
+
+  const lines = [];
+
+  if (step.error) {
+    lines.push(`${prefix}${pc.red(step.title)} ${pc.gray(`${step.duration}ms`)}`);
+  } else {
+    lines.push(`${prefix}${step.title} ${pc.gray(`${step.duration}ms`)}`);
+  }
+
+  for (const child of step.steps || []) {
+    lines.push(...formatStep(child, shift + 2));
+  }
+
+  return lines;
+}
+
 export {
+  ansiRegExp,
   isSameTest,
   fetchSourceCode,
   fetchSourceCodeFromStackTrace,
@@ -328,14 +368,16 @@ export {
   fetchIdFromOutput,
   fetchFilesFromStackTrace,
   fileSystem,
+  foundedTestLog,
+  formatStep,
   getCurrentDateTime,
-  specificTestInfo,
-  isValidUrl,
-  ansiRegExp,
   getTestomatIdFromTestTitle,
-  parseSuite,
   humanize,
+  isValidUrl,
+  parseSuite,
+  readLatestRunId,
   removeColorCodes,
-  foundedTestLog,
+  specificTestInfo,
+  storeRunId,
   testRunnerHelper,
 };

package/src/xmlReader.js

@@ -14,10 +14,10 @@ import {
   fetchIdFromCode,
   humanize,
 } from './utils/utils.js';
-import {pipesFactory} from './pipe/index.js';
+import { pipesFactory } from './pipe/index.js';
 import adapterFactory from './junit-adapter/index.js';
-import {config} from './config.js';
-import { upload } from './fileUploader.js';
+import { config } from './config.js';
+import { S3Uploader } from './uploader.js';
 
 // @ts-ignore this line will be removed in compiled code, because __dirname is defined in commonjs
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -26,7 +26,8 @@ const debug = createDebugMessages('@testomatio/reporter:xml');
 const ridRunId = randomUUID();
 
 const TESTOMATIO_URL = process.env.TESTOMATIO_URL || 'https://app.testomat.io';
-const { TESTOMATIO_RUNGROUP_TITLE, TESTOMATIO_TITLE, TESTOMATIO_ENV, TESTOMATIO_RUN } = process.env;
+const { TESTOMATIO_RUNGROUP_TITLE, TESTOMATIO_TITLE, TESTOMATIO_ENV, TESTOMATIO_RUN, TESTOMATIO_MARK_DETACHED } =
+  process.env;
 
 const options = {
   ignoreDeclaration: true,
@@ -46,6 +47,7 @@ class XmlReader {
       title: TESTOMATIO_TITLE,
       env: TESTOMATIO_ENV,
       group_title: TESTOMATIO_RUNGROUP_TITLE,
+      detach: TESTOMATIO_MARK_DETACHED,
       // batch uploading is implemented for xml already
       isBatchEnabled: false,
     };
@@ -61,7 +63,7 @@ class XmlReader {
     this.tests = [];
     this.stats = {};
     this.stats.language = opts.lang?.toLowerCase();
-    this.filesToUpload = {};
+    this.uploader = new S3Uploader();
 
     // @ts-ignore
     const packageJsonPath = path.resolve(__dirname, '..', 'package.json');
@@ -122,17 +124,25 @@ class XmlReader {
     const hasFailures = resultTests.filter(t => t.status === 'failed').length > 0;
     const status = failures > 0 || errors > 0 || hasFailures ? 'failed' : 'passed';
 
+    const time = testsuite.time || 0;
+    // debug('time', jsonSuite, time)
+    if (time) {
+      if (!this.stats.duration) this.stats.duration = 0;
+      this.stats.duration += parseFloat(time);
+    }
+
     this.tests = this.tests.concat(resultTests);
 
     return {
-      status,
       create_tests: true,
+      duration: parseFloat(time),
+      failed_count: parseInt(failures, 10),
       name,
-      tests_count: parseInt(tests, 10),
       passed_count: parseInt(tests, 10) - parseInt(failures, 10),
-      failed_count: parseInt(failures, 10),
       skipped_count: 0,
+      status,
       tests: resultTests,
+      tests_count: parseInt(tests, 10),
     };
   }
 
@@ -300,6 +310,7 @@ class XmlReader {
   calculateStats() {
     this.stats = {
       ...this.stats,
+      detach: this.requestParams.detach,
       status: 'passed',
       create_tests: true,
       tests_count: 0,
@@ -389,7 +400,7 @@ class XmlReader {
       if (!files.length) continue;
 
       const runId = this.runId || this.store.runId || Date.now().toString();
-      test.artifacts = await Promise.all(files.map(f => upload.uploadFileByPath(f, runId)));
+      test.artifacts = await Promise.all(files.map(f => this.uploader.uploadFileByPath(f, [runId])));
       console.log(APP_PREFIX, `🗄️ Uploaded ${pc.bold(`${files.length} artifacts`)} for test ${test.title}`);
     }
   }
@@ -406,7 +417,9 @@ class XmlReader {
     debug('Run', runParams);
     this.pipes = this.pipes || (await this.pipesPromise);
 
-    return Promise.all(this.pipes.map(p => p.createRun(runParams)));
+    const run = await Promise.all(this.pipes.map(p => p.createRun(runParams)));
+    this.uploader.checkEnabled();
+    return run;
   }
 
   async uploadData() {
@@ -417,18 +430,16 @@ class XmlReader {
     this.formatErrors();
     this.formatTests();
 
-    debug('Uploading data', {
-      ...this.stats,
-      tests: this.tests,
-    });
-
     const dataString = {
       ...this.stats,
       api_key: this.requestParams.apiKey,
       status: 'finished',
+      duration: this.stats.duration,
       tests: this.tests,
     };
 
+    debug('Uploading data', dataString);
+
     this.pipes = this.pipes || (await this.pipesPromise);
     return Promise.all(this.pipes.map(p => p.finishRun(dataString)));
   }

package/lib/adapter/jasmine/jasmine.js

@@ -1,63 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JasmineReporter = void 0;
-const client_js_1 = __importDefault(require("../../client.js"));
-const utils_js_1 = require("../../utils/utils.js");
-const constants_js_1 = require("../../constants.js");
-class JasmineReporter {
-    constructor(options) {
-        this.testTimeMap = {};
-        this.client = new client_js_1.default({ apiKey: options?.apiKey });
-        this.client.createRun();
-    }
-    getDuration(test) {
-        if (this.testTimeMap[test.id]) {
-            return Date.now() - this.testTimeMap[test.id];
-        }
-        return 0;
-    }
-    specStarted(result) {
-        this.testTimeMap[result.id] = Date.now();
-    }
-    specDone(result) {
-        if (!this.client)
-            return;
-        const title = result.description;
-        const { status } = result;
-        let errorMessage = '';
-        for (let i = 0; i < result.failedExpectations.length; i += 1) {
-            errorMessage = `${errorMessage}Failure: ${result.failedExpectations[i].message}\n`;
-            errorMessage = `${errorMessage}\n ${result.failedExpectations[i].stack}`;
-        }
-        console.log(`${title} : ${constants_js_1.STATUS.PASSED}`);
-        console.log(errorMessage);
-        const testId = (0, utils_js_1.getTestomatIdFromTestTitle)(title);
-        errorMessage = errorMessage.replace((0, utils_js_1.ansiRegExp)(), '');
-        this.client.addTestRun(status, {
-            error: result.failedExpectations[0],
-            message: errorMessage,
-            test_id: testId,
-            title,
-            time: this.getDuration(result),
-        });
-    }
-    jasmineDone(suiteInfo, done) {
-        if (!this.client)
-            return;
-        const { overallStatus } = suiteInfo;
-        const status = overallStatus === 'failed' ? constants_js_1.STATUS.FAILED : constants_js_1.STATUS.PASSED;
-        // @ts-ignore
-        this.client.updateRunStatus(status).then(() => done);
-    }
-}
-exports.JasmineReporter = JasmineReporter;
-module.exports = JasmineReporter;
-
-module.exports.JasmineReporter = JasmineReporter;
-
-module.exports.JasmineReporter = JasmineReporter;
-
-module.exports.exports = exports;