@testomatio/reporter 1.0.0-beta.4 → 1.0.1

package/lib/{ArtifactStorage.js → _ArtifactStorageOld.js}

@@ -7,24 +7,29 @@ const { TESTOMAT_ARTIFACT_SUFFIX } = require('./constants');
 const { specificTestInfo } = require('./util');
 
 class ArtifactStorage {
-
+  
   constructor(params) {
-    this._tmpPrefix = "tsmt_reporter";
     this.isFile = false;
     this.isMemory = true;
     this.storage = params?.toFile;
 
     if (this.storage) {
+      // this is fine to use when you start saving artifacts;
+      // but when you need to retrieve them, you will not know if there is "isFile" param,
+      // because you need to create a new instance of ArtifactStorage inside client
+      // so the solution is make it opposite to isMemory (which will be retrieved from global)
       this.isFile = true;
       this.isMemory = false;
-      this.tmpDirFullpath = this.createTestomatTmpDir(this._tmpPrefix);
+      this.tmpDirFullpath = this.createTestomatTmpDir(ArtifactStorage._tmpPrefix);
       debug('SAVE to tmp folder mode enabled!');
     }
   }
 
   static async storeToFile(tmpDirName, artifact, testSuffix = "test") {
+    // this assumes to use multiple files for each test. do we really want this?
     const suffix = TESTOMAT_ARTIFACT_SUFFIX + uuid.v4() + testSuffix;
     const dirpath = join(os.tmpdir(), tmpDirName);
+    // why json?
     const filepath = resolve(dirpath, `${suffix}.json`);
 
     return fs.promises.appendFile(filepath, JSON.stringify(artifact));
@@ -34,6 +39,7 @@ class ArtifactStorage {
     // TODO: mode for different pre-hooks. As variant - "all-tests" || "only_fail"
     // const mode = process.env.TESTOMAT_ARTIFACTS || "only_fail";
 
+    // you save the artifact without specifying its source - test id
     if (Array.isArray(global.testomatioArtifacts)) {
       debug("Saving artifacts to global storage");
 
@@ -71,6 +77,7 @@ class ArtifactStorage {
     return list;
   }
 
+  // returns all the content from all files; do we really need it?
   async tmpContents() {
     const contents = [];
 
@@ -103,8 +110,9 @@ class ArtifactStorage {
     }
   }
 
+  // no need to use multiple dirs; we can implement it later if required
   static tmpTestomatDirNames() {
-    const subname = this._tmpPrefix || "tsmt_reporter";
+    const subname = ArtifactStorage._tmpPrefix || "tsmt_reporter";
 
     return fs.readdirSync(os.tmpdir(), { withFileTypes: true })
       .filter((item) => item.isDirectory())
@@ -113,6 +121,7 @@ class ArtifactStorage {
   }
 
   cleanup() {
+    // when you do a cleanup, I know nothing about isFile param
     if (this.isFile && this.tmpDirFullpath) {
       const tmpDirNames = ArtifactStorage.tmpTestomatDirNames();
 
@@ -128,4 +137,6 @@ class ArtifactStorage {
   }
 }
 
+ArtifactStorage._tmpPrefix = "tsmt_reporter";
+
 module.exports = ArtifactStorage;

package/lib/adapter/codecept.js

@@ -33,6 +33,7 @@ if (MAJOR_VERSION < 3) {
 function CodeceptReporter(config) {
   let failedTests = [];
   let videos = [];
+  let traces = [];
   const reportTestPromises = [];
 
   const testTimeMap = {};
@@ -54,6 +55,7 @@ function CodeceptReporter(config) {
   event.dispatcher.on(event.all.before, () => {
     recorder.add('Creating new run', () => client.createRun());
     videos = [];
+    traces = [];
   });
 
   event.dispatcher.on(event.test.before, () => {
@@ -70,25 +72,13 @@ function CodeceptReporter(config) {
   });
 
   event.dispatcher.on(event.all.result, async () => {
+    debug('waiting for all tests to be reported');
     // all tests were reported and we can upload videos
     await Promise.all(reportTestPromises);
 
-    if (videos.length && upload.isArtifactsEnabled()) {
-      console.log(APP_PREFIX, `🎞️  Uploading ${videos.length} videos...`);
-
-      const promises = [];
-      for (const video of videos) {
-        const { testId, title, path, type } = video;
-        const file = { path, type, title };
-        promises.push(
-          client.addTestRun(undefined, {
-            ...stripExampleFromTitle(title),
-            test_id: testId,
-            files: [file],
-          }),
-        );
-      }
-      await Promise.all(promises);
+    if (upload.isArtifactsEnabled()) {
+      uploadAttachments(client, videos, '🎞️  Uploading', 'video');
+      uploadAttachments(client, traces, '📁 Uploading', 'trace');
     }
 
     const status = failedTests.length === 0 ? STATUS.PASSED : STATUS.FAILED;
@@ -164,11 +154,13 @@ function CodeceptReporter(config) {
       files,
       steps: output.text(),
     }).then(pipes => {
-      testId = pipes.filter(p => p.pipe.includes('Testomatio'))[0]?.result?.data?.test_id;
+      testId = pipes?.filter(p => p.pipe.includes('Testomatio'))[0]?.result?.data?.test_id;
 
+      debug("artifacts", artifacts);
+      
       for (const aid in artifacts) {
-        if (aid.startsWith('video')) videos.push({ testId, title, path: artifacts[aid], type: 'video/webm' }); 
-        if (aid.startsWith('trace')) files.push({ testId, title, path: artifacts[aid], type: 'application/zip' }); 
+        if (aid.startsWith('video')) videos.push({ testId, title, path: artifacts[aid], type: 'video/webm' });
+        if (aid.startsWith('trace')) traces.push({ testId, title, path: artifacts[aid], type: 'application/zip' });
       }
     });
 
@@ -242,6 +234,24 @@ function CodeceptReporter(config) {
   });
 }
 
+async function uploadAttachments(client, attachments, messagePrefix, attachmentType) {
+  if (attachments.length > 0) {
+    console.log(APP_PREFIX, `Attachments: ${messagePrefix} ${attachments.length} ${attachmentType}/-s ...`);
+
+    const promises = attachments.map(async (attachment) => {
+      const { testId, title, path, type } = attachment;
+      const file = { path, type, title };
+      return client.addTestRun(undefined, {
+        ...stripExampleFromTitle(title),
+        test_id: testId,
+        files: [file],
+      });
+    });
+
+    await Promise.all(promises);
+  }
+}
+
 function parseTest(tags) {
   if (tags) {
     for (const tag of tags) {

package/lib/adapter/cucumber/current.js

@@ -19,7 +19,7 @@ class CucumberReporter extends Formatter {
     this.failures = [];
     this.cases = [];
 
-    this.client = new TestomatClient();
+    this.client = new TestomatClient({ apiKey: process.env.TESTOMATIO || options.apiKey });
     this.status = STATUS.PASSED;
 
   }

package/lib/adapter/jest.js

@@ -1,6 +1,6 @@
 const TestomatClient = require('../client');
-const { STATUS } = require('../constants');
-const { parseTest, ansiRegExp } = require('../util');
+const { STATUS, TESTOMAT_TMP_STORAGE } = require('../constants');
+const { parseTest, ansiRegExp, fileSystem } = require('../util');
 
 class JestReporter {
   constructor(globalConfig, options) {
@@ -11,6 +11,17 @@ class JestReporter {
     this.client.createRun();
   }
 
+  static getIdOfCurrentlyRunningTest() {
+    if (!process.env.JEST_WORKER_ID) return null;
+    // @ts-expect-error "expect" could only be defined inside Jest environement (forbidden to import it outside)
+    return parseTest(expect?.getState()?.currentTestName) || null; // eslint-disable-line
+  }
+
+  onRunStart() {
+    // clear tmp dir
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+  }
+
   onTestResult(test, testResult) {
     if (!this.client) return;
 
@@ -47,6 +58,9 @@ class JestReporter {
     const { numFailedTests } = results;
     const status = numFailedTests === 0 ? STATUS.PASSED : STATUS.FAILED;
     this.client.updateRunStatus(status);
+
+    // clear tmp dir
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
   }
 }
 

package/lib/adapter/mocha.js

@@ -5,7 +5,7 @@ const chalk = require('chalk');
 const TestomatClient = require('../client');
 const { STATUS } = require('../constants');
 const { parseTest, specificTestInfo } = require('../util');
-const ArtifactStorage = require('../ArtifactStorage');
+const ArtifactStorage = require('../_ArtifactStorageOld');
 
 const { EVENT_RUN_BEGIN, EVENT_RUN_END, EVENT_TEST_FAIL, EVENT_TEST_PASS, EVENT_TEST_PENDING } = Mocha.Runner.constants;
 

package/lib/adapter/playwright.js

@@ -46,7 +46,7 @@ class TestomatioReporter {
       steps: steps.join('\n'),
       time: duration,
     }).then(pipes => {
-      testId = pipes.filter(p => p.pipe.includes('Testomatio'))[0]?.result?.data?.test_id;
+      testId = pipes?.filter(p => p.pipe.includes('Testomatio'))[0]?.result?.data?.test_id;
 
       this.uploads.push({
         testId, title, suite_title, files: result.attachments.filter((a) => a.body || a.path)

package/lib/artifactStorage.js

@@ -0,0 +1,25 @@
+// const debug = require('debug')('@testomatio/reporter:logger');
+const { DataStorage } = require('./dataStorage');
+
+class ArtifactStorage {
+  constructor(params = {}) {
+    this.dataStorage = new DataStorage('artifact', params);
+
+    // singleton
+    if (!ArtifactStorage.instance) {
+      ArtifactStorage.instance = this;
+    }
+  }
+
+  save(data, context = null) {
+    this.dataStorage.putData(data, context);
+  }
+
+  get(context) {
+    this.dataStorage.getData(context);
+  }
+}
+
+ArtifactStorage.instance = null;
+
+module.exports = new ArtifactStorage();

package/lib/client.js

@@ -7,10 +7,12 @@ const { randomUUID } = require('crypto');
 const upload = require('./fileUploader');
 const { APP_PREFIX } = require('./constants');
 const pipesFactory = require('./pipe');
+const logger = require('./logger');
 
 /**
  * @typedef {import('../types').TestData} TestData
  * @typedef {import('../types').RunStatus} RunStatus
+ * @typedef {import('../types').PipeResult} PipeResult
  */
 
 class Client {
@@ -33,11 +35,11 @@ class Client {
   /**
    * Used to create a new Test run
    *
-   * @returns {Promise<void>} - resolves to Run id which should be used to update / add test
+   * @returns {Promise<any>} - resolves to Run id which should be used to update / add test
    */
   createRun() {
     // all pipes disabled, skipping
-    if (!this.pipes.filter(p => p.isEnabled).length) return Promise.resolve();
+    if (!this.pipes || !this.pipes.filter(p => p.isEnabled).length) return Promise.resolve();
 
     const runParams = {
       title: this.title,
@@ -46,6 +48,7 @@ class Client {
     };
 
     global.testomatioArtifacts = [];
+    // TODO: create global storage
 
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.createRun(runParams))))
@@ -57,20 +60,21 @@ class Client {
 
   /**
    * Updates test status and its data
-   * 
+   *
    * @param {string|undefined} status
    * @param {TestData} [testData]
    * @param {string[]} [storeArtifacts]
-   * @returns {Promise<void>}
+   * @returns {Promise<PipeResult[]>}
    */
   async addTestRun(status, testData, storeArtifacts = []) {
     // all pipes disabled, skipping
-    if (!this.pipes.filter(p => p.isEnabled).length) return;
+    if (!this.pipes?.filter(p => p.isEnabled).length) return;
 
-    if (!testData) testData = {
-      title: 'Unknown test',
-      suite_title: 'Unknown suite',
-    }
+    if (!testData)
+      testData = {
+        title: 'Unknown test',
+        suite_title: 'Unknown suite',
+      };
 
     const {
       error = null,
@@ -99,13 +103,18 @@ class Client {
       stack = this.formatSteps(stack, steps);
     }
 
+    const testLogs = logger.getLogs(test_id);
+    debug(`Test logs for ${test_id}:\n`, testLogs);
+    if (stack) stack += '\n\n';
+    stack += testLogs;
+
     if (Array.isArray(storeArtifacts) && storeArtifacts.length) {
-      debug("CLIENT storeArtifact", storeArtifacts);
+      debug('CLIENT storeArtifact', storeArtifacts);
       files.push(...storeArtifacts);
     }
 
     if (Array.isArray(global.testomatioArtifacts)) {
-      debug("CLIENT global[testomatioArtifacts]", global.testomatioArtifacts);
+      debug('CLIENT global[testomatioArtifacts]', global.testomatioArtifacts);
       files.push(...global.testomatioArtifacts);
       global.testomatioArtifacts = [];
     }
@@ -147,7 +156,7 @@ class Client {
           const result = await p.addTest(data);
           return { pipe: p.toString(), result };
         } catch (err) {
-          console.log(APP_PREFIX, pipe.toString(), err);
+          console.log(APP_PREFIX, p.toString(), err);
         }
       }
     )));
@@ -160,19 +169,19 @@ class Client {
    * Updates the status of the current test run and finishes the run.
    * @param {RunStatus} status - The status of the current test run. Must be one of "passed", "failed", or "finished"
    * @param {boolean} [isParallel] - Whether the current test run was executed in parallel with other tests.
-   * @returns {Promise<void>} - A Promise that resolves when finishes the run.
+   * @returns {Promise<any>} - A Promise that resolves when finishes the run.
    */
   updateRunStatus(status, isParallel = false) {
     // all pipes disabled, skipping
-    if (!this.pipes.filter(p => p.isEnabled).length) return Promise.resolve();
+    if (!this.pipes?.filter(p => p.isEnabled).length) return Promise.resolve();
 
     const runParams = { status, parallel: isParallel };
 
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))))
       .then(() => {
-        debug("TOTAL uploaded files", this.totalUploaded);
-        
+        debug('TOTAL uploaded files', this.totalUploaded);
+
         if (upload.isArtifactsEnabled() && this.totalUploaded > 0) {
           console.log(
             APP_PREFIX,

package/lib/constants.js

@@ -3,6 +3,10 @@ const chalk = require('chalk');
 const APP_PREFIX = chalk.gray('[TESTOMATIO]');
 const TESTOMAT_ARTIFACT_SUFFIX = "testomatio_artifact_";
 
+const TESTOMAT_TMP_STORAGE = {
+  mainDir: "testomatio_tmp",
+}
+
 const CSV_HEADERS = [
   { id: 'suite_title', title: 'Suite_title' },
   { id: 'title', title: 'Title' },
@@ -21,6 +25,7 @@ const STATUS = {
 module.exports = {
   APP_PREFIX,
   TESTOMAT_ARTIFACT_SUFFIX,
+  TESTOMAT_TMP_STORAGE,
   CSV_HEADERS,
   STATUS,
 }

package/lib/dataStorage.js

@@ -0,0 +1,180 @@
+const debug = require('debug')('@testomatio/reporter:storage');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { join } = require('path');
+const JestReporter = require('./adapter/jest');
+const { TESTOMAT_TMP_STORAGE } = require('./constants');
+const { fileSystem } = require('./util');
+
+class DataStorage {
+  /**
+   * Creates data storage instance for specific data type.
+   * Stores data to global variable or to file depending on what is applicable for current test runner.
+   * dataType: 'log' | 'artifact' | ...
+   * @param {*} dataType storage type (like 'log', 'artifact'); could be any string, used only to define file path
+   * @param {*} params
+   */
+  constructor(dataType, params = {}) {
+    if (!dataType) throw new Error('Data type is required when creating data storage');
+    this.dataType = dataType || 'data';
+    this.dataDirName = `${dataType}s`;
+    this.isFileStorage = params?.isFileStorage ?? !global.testomatioDataStore;
+
+    /*
+      FYI:
+      If this storage instance is used within test runner, it works fine.
+      But if, for example, we create storage instance inside the testomatio client (to get stored data),
+      the environment could be different (not already a test runner env).
+      Thus, checking environment is only reasonable when you put data to starage 
+      and potentially useless when get data from storage
+    */
+    this.runningEnvironment = this.getRunningEnviroment();
+    if (this.runningEnvironment === 'jest') this.isFileStorage = true;
+
+    if (this.isFileStorage) {
+      this.dataDirPath = path.join(TESTOMAT_TMP_STORAGE.mainDir, this.dataDirName);
+      fileSystem.createDir(this.dataDirPath);
+    }
+
+    debug(`Data storage mode: ${this.isFileStorage ? 'file' : 'memory'}`);
+  }
+
+  // TODO: implement
+  getTestIdFromContext(context) { // eslint-disable-line
+    // eslint-disable-line
+    // return testId;
+  }
+
+  /**
+   * Try to define the running environment. Not 100% reliable and used as additional check
+   * @returns jest | mocha | ...
+   */
+  getRunningEnviroment() {
+    if (process.env.JEST_WORKER_ID) return 'jest';
+    try {
+      // @ts-expect-error mocha is defined only in mocha environment
+      if (typeof mocha !== 'undefined') return 'mocha';
+    } catch (e) {
+      // ignore
+    }
+    return undefined;
+  }
+
+  /**
+   * Puts any data to storage (file or global variable)
+   * @param {*} data anything you want to store
+   * @param {*} context could be testId or any context (test, suite, etc) which is used to define testId
+   * @returns
+   */
+  putData(data, context = null) {
+    // this.isFileStorage = !global.testomatioDataStore;
+
+    let testId = null;
+    if (typeof context === 'string') {
+      testId = context;
+    } else {
+      // TODO: derive testId from context
+      // testId = context...
+    }
+
+    // try to get testId for Jest
+    if (this.runningEnvironment === 'jest') testId = testId ?? JestReporter.getIdOfCurrentlyRunningTest();
+
+    // if testId is not provided, data is be saved to `{dataType}_other` file;
+    if (!testId) testId = 'other';
+
+    if (this.isFileStorage) {
+      this._putDataToFile(data, testId);
+    } else {
+      this._putDataToGlobalVar(data, testId);
+    }
+  }
+
+  /**
+   * Returns data, stored for specific testId (or data which was stored without test id specified)
+   *
+   * (Don't try to guess the execution environment (e.g. test runner) inside this method, it could be any)
+   * @param {*} context could be testId or any context (test, suite, etc) which is used to define testId
+   * @returns
+   */
+  getData(context) {
+    let testId = null;
+    if (typeof context === 'string') {
+      testId = context;
+    } else {
+      // TODO: derive testId from context
+      // testId = context...
+    }
+
+    if (!testId) {
+      debug(`Cannot get test id from passed context:\n}`, context);
+    }
+
+    if (this.isFileStorage) {
+      return this._getDataFromFile(testId);
+    }
+    if (global?.testomatioDataStore) {
+      return this._getDataFromGlobalVar(testId);
+    }
+    debug(`No ${this.dataType} data for test id ${testId} in both file and global variable`);
+    return null;
+  }
+
+  _getDataFromGlobalVar(testId) {
+    try {
+      if (global?.testomatioDataStore[this.dataDirName]) {
+        const testData = global.testomatioDataStore[this.dataDirName][testId];
+        debug(`Data for test id ${testId}:\n${testData}`);
+        return testData;
+      }
+      debug(`No ${this.dataType} data for test id ${testId}`);
+      return null;
+    } catch (e) {
+      // there could be no data, ignore
+    }
+  }
+
+  _getDataFromFile(testId) {
+    try {
+      const filepath = join(TESTOMAT_TMP_STORAGE.mainDir, `${this.dataType}_${testId}`);
+      if (fs.existsSync(filepath)) {
+        const testData = fs.readFileSync(filepath, 'utf-8');
+        debug(`Data for test id ${testId}:\n${testData}`);
+        return testData;
+      }
+      debug(`No ${this.dataType} data for test id ${testId}`);
+      return null;
+    } catch (e) {
+      // there could be no data, ignore
+    }
+    return null;
+  }
+
+  _putDataToGlobalVar(data, testId) {
+    debug('Saving data to global variable for test', testId, ':\n', data, '\n');
+    global.testomatioDataStore[this.dataDirName] = {};
+    global.testomatioDataStore[this.dataDirName][testId] = data;
+  }
+
+  _putDataToFile(data, testId) {
+    if (typeof data !== 'string') data = JSON.stringify(data);
+    const filename = `${this.dataType}_${testId}`;
+    const filepath = join(TESTOMAT_TMP_STORAGE.mainDir, filename);
+    debug('Saving data to file for test', testId, 'to', filepath, ':\n', data, '\n');
+
+    // TODO: handle multiple invocations of JSON.stringify.
+    // UPD: not actual because decided not to use it - it created extra wrapping quotes "" and // (escaped slashes)
+    fs.appendFileSync(filepath, data + os.EOL, 'utf-8');
+  }
+}
+
+module.exports.DataStorage = DataStorage;
+
+// TODO: consider using fs promises instead of writeSync/appendFileSync to
+// prevent blocking and improve performance (probably queue usage will be required)
+
+// TODO: rewrite client - everything regarding storing artifacts
+// TODO: try to define adapter inside client
+// TODO: use .env
+// TODO: ability to intercept multiple loggers