@testomatio/reporter 1.1.0-beta-2 → 1.2.0-beta-1

package/lib/_ArtifactStorageOld.js

@@ -0,0 +1,142 @@
+const debug = require('debug')('@testomatio/reporter:storage');
+const { join, resolve } = require('path');
+const fs = require('fs');
+const os = require('os');
+const uuid = require('uuid');
+const { TESTOMAT_ARTIFACT_SUFFIX } = require('./constants');
+const { specificTestInfo } = require('./utils/utils');
+
+class ArtifactStorage {
+  
+  constructor(params) {
+    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(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));
+  }
+
+  static async artifact(artifact, context) {
+    // 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");
+
+      global.testomatioArtifacts.push(artifact);
+    }
+
+    if (global?.testomatioArtifacts === undefined) {
+      const tmpDirNames = ArtifactStorage.tmpTestomatDirNames();
+
+      const testSuffix = specificTestInfo(context.test);
+
+      if (Array.isArray(tmpDirNames) && tmpDirNames.length) {
+        debug("Saving artifacts to memory tmp folder");
+
+        return ArtifactStorage.storeToFile(tmpDirNames[tmpDirNames.length - 1], artifact, testSuffix);
+      }
+    }
+  }
+
+  async artifactByTestName(test) {
+    const list = [];
+
+    if (this.isFile && this.tmpDirFullpath) {
+      const files = fs.readdirSync(this.tmpDirFullpath);
+
+      for (const file of files) {
+        if (file.includes(test)) {
+          const buff = await fs.promises.readFile(`${this.tmpDirFullpath  }/${  file}`);
+
+          list.push(JSON.parse(buff.toString()));
+        }
+      }
+    }
+
+    return list;
+  }
+
+  // returns all the content from all files; do we really need it?
+  async tmpContents() {
+    const contents = [];
+
+    if (this.isFile && this.tmpDirFullpath) {
+      const files = fs.readdirSync(this.tmpDirFullpath);
+
+      for (const file of files) {
+        const buff = await fs.promises.readFile(`${this.tmpDirFullpath  }/${  file}`);
+        const content = buff.toString();
+
+        contents.push(content);
+      }
+    }
+
+    return contents;
+  }
+
+  createTestomatTmpDir(clientPrefix) {
+    return fs.mkdtempSync(join(os.tmpdir(), clientPrefix));
+  }
+
+  clearTmpDirByName(name) {
+    const tmpDirPath = join(os.tmpdir(), name);
+
+    if (fs.existsSync(tmpDirPath)) {
+      fs.rmSync(tmpDirPath, { recursive: true });
+      debug(` Testomat tmpDir = ${tmpDirPath} was deleted successfully!`);
+
+      
+    }
+  }
+
+  // no need to use multiple dirs; we can implement it later if required
+  static tmpTestomatDirNames() {
+    const subname = ArtifactStorage._tmpPrefix || "tsmt_reporter";
+
+    return fs.readdirSync(os.tmpdir(), { withFileTypes: true })
+      .filter((item) => item.isDirectory())
+      .map((item) => item.name)
+      .filter((name) => name.includes(subname));
+  }
+
+  cleanup() {
+    // when you do a cleanup, I know nothing about isFile param
+    if (this.isFile && this.tmpDirFullpath) {
+      const tmpDirNames = ArtifactStorage.tmpTestomatDirNames();
+
+      if (Array.isArray(tmpDirNames) && tmpDirNames.length) {
+        for (const name of tmpDirNames) {
+          this.clearTmpDirByName(name);
+        }
+      }
+    }
+    else {
+      debug("The tmp folder has not been created! Nothing to delete");
+    }
+  }
+}
+
+ArtifactStorage._tmpPrefix = "tsmt_reporter";
+
+module.exports = ArtifactStorage;

package/lib/adapter/codecept.js

@@ -1,7 +1,7 @@
 const debug = require('debug')('@testomatio/reporter:adapter:codeceptjs');
 const chalk = require('chalk');
 const TestomatClient = require('../client');
-const { STATUS, APP_PREFIX, TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
+const { STATUS, APP_PREFIX, TESTOMAT_TMP_STORAGE } = require('../constants');
 const upload = require('../fileUploader');
 const { parseTest: getIdFromTestTitle, fileSystem } = require('../utils/utils');
 
@@ -56,7 +56,7 @@ function CodeceptReporter(config) {
   // Listening to events
   event.dispatcher.on(event.all.before, () => {
     // clear tmp dir
-    fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
 
     recorder.add('Creating new run', () => client.createRun());
     videos = [];

package/lib/adapter/cucumber/current.js

@@ -2,9 +2,9 @@
 const { Formatter, formatterHelpers } = require('@cucumber/cucumber');
 const chalk = require('chalk');
 const fs = require('fs');
-const { STATUS, TESTOMAT_TMP_STORAGE_DIR } = require('../../constants');
+const { STATUS, TESTOMAT_TMP_STORAGE } = require('../../constants');
 const TestomatClient = require('../../client');
-const logger = require('../../storages/logger');
+const logger = require('../../logger');
 const { parseTest, fileSystem } = require('../../utils/utils');
 
 const { GherkinDocumentParser, PickleParser } = formatterHelpers;
@@ -37,7 +37,7 @@ class CucumberReporter extends Formatter {
 
   parseEnvelope(envelope) {
     if (envelope.testRunStarted) {
-      fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
+      fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
     }
     if (envelope.testCaseStarted && this.client) {
       this.client.createRun();

package/lib/adapter/cucumber/legacy.js

@@ -2,7 +2,7 @@
 const { Formatter } = require('cucumber');
 const chalk = require('chalk');
 const { parseTest, fileSystem } = require('../../utils/utils');
-const { STATUS, TESTOMAT_TMP_STORAGE_DIR } = require('../../constants');
+const { STATUS, TESTOMAT_TMP_STORAGE } = require('../../constants');
 const TestomatClient = require('../../client');
 
 const createTestomatFormatter = apiKey => {
@@ -97,7 +97,7 @@ const createTestomatFormatter = apiKey => {
 
       options.eventBroadcaster.on('gherkin-document', addDocument);
       options.eventBroadcaster.on('test-run-started', () => {
-        fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
+        fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
         this?.client?.createRun();
       });
       options.eventBroadcaster.on('test-case-finished', this.onTestCaseFinished.bind(this));

package/lib/adapter/jest.js

@@ -1,5 +1,5 @@
 const TestomatClient = require('../client');
-const { STATUS, TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
+const { STATUS, TESTOMAT_TMP_STORAGE } = require('../constants');
 const { parseTest, ansiRegExp, fileSystem } = require('../utils/utils');
 
 class JestReporter {
@@ -11,9 +11,20 @@ class JestReporter {
     this.client.createRun();
   }
 
+  static getIdOfCurrentlyRunningTest() {
+    if (!process.env.JEST_WORKER_ID) return null;
+    try {
+      // @ts-expect-error "expect" could only be defined inside Jest environement (forbidden to import it outside)
+      // eslint-disable-next-line no-undef
+      if (expect && expect?.getState()?.currentTestName) return parseTest(expect?.getState()?.currentTestName); 
+    } catch (e) {
+      return null; 
+    }
+  }
+
   onRunStart() {
     // clear tmp dir
-    fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
   }
 
   onTestResult(test, testResult) {
@@ -61,6 +72,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

@@ -1,9 +1,11 @@
 // eslint-disable-next-line global-require, import/no-extraneous-dependencies
 const Mocha = require('mocha');
+const debug = require('debug')('@testomatio/reporter:adapter:mocha');
 const chalk = require('chalk');
 const TestomatClient = require('../client');
-const { STATUS, TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
-const { parseTest, fileSystem } = require('../utils/utils');
+const { STATUS, TESTOMAT_TMP_STORAGE } = require('../constants');
+const { parseTest, specificTestInfo, fileSystem } = require('../utils/utils');
+const ArtifactStorage = require('../_ArtifactStorageOld');
 
 const { EVENT_RUN_BEGIN, EVENT_RUN_END, EVENT_TEST_FAIL, EVENT_TEST_PASS, EVENT_TEST_PENDING } =
   Mocha.Runner.constants;
@@ -13,7 +15,7 @@ function MochaReporter(runner, opts) {
   let passes = 0;
   let failures = 0;
   let skipped = 0;
-  // let artifactStore;
+  let artifactStore;
 
   const apiKey = opts?.reporterOptions?.apiKey || process.env.TESTOMATIO;
 
@@ -22,7 +24,13 @@ function MochaReporter(runner, opts) {
   runner.on(EVENT_RUN_BEGIN, () => {
     client.createRun();
 
-    fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
+    const params = {
+      toFile: true,
+    };
+
+    artifactStore = runner._workerReporter !== undefined ? new ArtifactStorage(params) : new ArtifactStorage();
+
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
   });
 
   runner.on(EVENT_TEST_PASS, async test => {
@@ -30,11 +38,20 @@ function MochaReporter(runner, opts) {
     console.log(chalk.bold.green('✔'), test.fullTitle());
     const testId = parseTest(test.title);
 
-    client.addTestRun(STATUS.PASSED, {
-      test_id: testId,
-      title: test.title,
-      time: test.duration,
-    });
+    const specificTest = specificTestInfo(test);
+    const content = await artifactStore.artifactByTestName(specificTest);
+
+    debug(`test=${specificTest} content = `, content);
+
+    client.addTestRun(
+      STATUS.PASSED,
+      {
+        test_id: testId,
+        title: test.title,
+        time: test.duration,
+      },
+      content,
+    );
   });
 
   runner.on(EVENT_TEST_PENDING, test => {
@@ -53,18 +70,29 @@ function MochaReporter(runner, opts) {
     console.log(chalk.bold.red('✖'), test.fullTitle(), chalk.gray(err.message));
     const testId = parseTest(test.title);
 
-    client.addTestRun(STATUS.FAILED, {
-      error: err,
-      test_id: testId,
-      title: test.title,
-      time: test.duration,
-    });
+    const specificTest = specificTestInfo(test);
+    const content = await artifactStore.artifactByTestName(specificTest);
+
+    debug(`fail test=${specificTest} content = `, content);
+
+    client.addTestRun(
+      STATUS.FAILED,
+      {
+        error: err,
+        test_id: testId,
+        title: test.title,
+        time: test.duration,
+      },
+      content,
+    );
   });
 
   runner.on(EVENT_RUN_END, () => {
     const status = failures === 0 ? STATUS.PASSED : STATUS.FAILED;
     console.log(chalk.bold(status), `${passes} passed, ${failures} failed, ${skipped} skipped`);
     client.updateRunStatus(status);
+
+    artifactStore.cleanup();
   });
 }
 

package/lib/adapter/playwright.js

@@ -3,7 +3,7 @@ const crypto = require('crypto');
 const os = require('os');
 const path = require('path');
 const fs = require('fs');
-const { APP_PREFIX, STATUS: Status, TESTOMAT_TMP_STORAGE_DIR } = require('../constants');
+const { APP_PREFIX, STATUS: Status, TESTOMAT_TMP_STORAGE } = require('../constants');
 const TestomatioClient = require('../client');
 const { isArtifactsEnabled } = require('../fileUploader');
 const { parseTest, fileSystem } = require('../utils/utils');
@@ -19,17 +19,15 @@ class PlaywrightReporter {
 
   onBegin(_config, suite) {
     // clean data storage
-    fileSystem.clearDir(TESTOMAT_TMP_STORAGE_DIR);
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
     if (!this.client) return;
     this.suite = suite;
     this.client.createRun();
   }
 
-  /*
-  onTestBegin(test) {
-    // does not work; value is not to the storage context
-    global.testTitle = test.title;
-  } */
+  // onTestBegin(test) {
+  //   const testId = parseTest(test.title);
+  // }
 
   onTestEnd(test, result) {
     if (!this.client) return;
@@ -46,33 +44,23 @@ class PlaywrightReporter {
       appendStep(step, steps);
     }
 
-    let logs = '';
-    if (result.stderr.length || result.stdout.length) {
-      logs = `\n\n${chalk.bold('Logs:')}\n${chalk.red(result.stderr.join(''))}\n${result.stdout.join('')}`;
-    }
-
-    const reportTestPromise = this.client
-      .addTestRun(checkStatus(result.status), {
-        error,
-        test_id: testId,
-        suite_title,
-        title,
-        steps: steps.join('\n'),
-        time: duration,
-        stack: logs,
-      })
-      .then(pipes => {
-        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),
-        });
-        // remove empty uploads
-        this.uploads = this.uploads.filter(upload => upload.files.length);
+    const logs = `\n\n${chalk.bold('Logs:')}\n${chalk.red(result.stderr.join(''))}\n${result.stdout.join('')}`;
+
+    const reportTestPromise = this.client.addTestRun(checkStatus(result.status), {
+      error,
+      test_id: testId,
+      suite_title,
+      title,
+      steps: steps.join('\n'),
+      time: duration,
+      stack: logs,
+    }).then(pipes => {
+      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)
       });
+    });
 
     reportTestPromises.push(reportTestPromise);
   }

package/lib/artifactStorage.js

@@ -0,0 +1,25 @@
+// const debug = require('debug')('@testomatio/reporter:logger');
+const { DataStorage } = require('./dataStorage');
+
+class ArtifactStorage {
+  constructor() {
+    this.dataStorage = new DataStorage('artifact');
+
+    // 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

@@ -8,7 +8,6 @@ const { randomUUID } = require('crypto');
 const upload = require('./fileUploader');
 const { APP_PREFIX } = require('./constants');
 const pipesFactory = require('./pipe');
-const artifactStorage = require('./storages/artifact-storage');
 
 /**
  * @typedef {import('../types').TestData} TestData
@@ -97,6 +96,9 @@ class Client {
     // all pipes disabled, skipping
     if (!this.pipes?.filter(p => p.isEnabled).length) return Promise.resolve();
 
+    global.testomatioArtifacts = [];
+    if (!global.testomatioDataStore) global.testomatioDataStore = {};
+
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.createRun())))
       .catch(err => console.log(APP_PREFIX, err))
@@ -110,9 +112,11 @@ class Client {
    *
    * @param {string|undefined} status
    * @param {TestData} [testData]
+   * @param {string[]} [storeArtifacts]
    * @returns {Promise<PipeResult[]>}
    */
-  async addTestRun(status, testData) {
+  async addTestRun(status, testData, storeArtifacts = []) {
+    debug('Adding test run for test', testData?.test_id || 'unknown test');
     // all pipes disabled, skipping
     if (!this.pipes?.filter(p => p.isEnabled).length) return [];
 
@@ -151,21 +155,23 @@ class Client {
 
     stack += testData.stack || '';
 
-    // ATTACH LOGS from storage
     // in some cases (e.g. using cucumber) logger instance becomes empty object, if import at the top of the file
-    const logger = require('./storages/logger');
+    const logger = require('./logger');
     const testLogs = logger.getLogs(test_id);
     // debug(`Test logs for ${test_id}:\n`, testLogs);
     if (stack) stack += '\n\n';
     stack += testLogs ? `${chalk.bold('Logs:')}\n${testLogs}` : '';
 
-    // GET ARTIFACTS from storage
-    const artifactFiles = artifactStorage.get(test_id);
-    if (artifactFiles) files.push(...artifactFiles);
+    if (Array.isArray(storeArtifacts) && storeArtifacts.length) {
+      debug('CLIENT storeArtifact', storeArtifacts);
+      files.push(...storeArtifacts);
+    }
 
-    // GET KEY-VALUEs from storage
-    const keyValueStorage = require('./storages/key-value-storage');
-    const keyValues = keyValueStorage.get(test_id);
+    if (Array.isArray(global.testomatioArtifacts)) {
+      debug('CLIENT global[testomatioArtifacts]', global.testomatioArtifacts);
+      files.push(...global.testomatioArtifacts);
+      global.testomatioArtifacts = [];
+    }
 
     for (const file of files) {
       uploadedFiles.push(upload.uploadFileByPath(file, this.uuid));
@@ -178,7 +184,7 @@ class Client {
 
     const artifacts = await Promise.all(uploadedFiles);
 
-    // global.testomatioArtifacts = [];
+    global.testomatioArtifacts = [];
 
     this.totalUploaded += uploadedFiles.filter(n => n).length;
 
@@ -196,7 +202,6 @@ class Client {
       message,
       run_time: parseFloat(time),
       artifacts,
-      meta: keyValues,
     };
 
     this.queue = this.queue.then(() =>
@@ -232,16 +237,14 @@ class Client {
     this.queue = this.queue
       .then(() => Promise.all(this.pipes.map(p => p.finishRun(runParams))))
       .then(() => {
-        debug('TOTAL artifacts', this.totalUploaded);
-        if (this.totalUploaded && !upload.isArtifactsEnabled())
-          debug(`${this.totalUploaded} artifacts are not uploaded, because artifacts uploading is not enabled`);
+        debug('TOTAL uploaded files', this.totalUploaded);
 
-        if (this.totalUploaded && upload.isArtifactsEnabled()) {
+        if (upload.isArtifactsEnabled() && this.totalUploaded > 0) {
           console.log(
             APP_PREFIX,
-            `🗄️ ${this.totalUploaded} artifacts ${
+            `🗄️  Total ${this.totalUploaded} artifacts ${
               process.env.TESTOMATIO_PRIVATE_ARTIFACTS ? 'privately' : chalk.bold('publicly')
-            } uploaded to S3 bucket`,
+            } uploaded to S3 bucket  `,
           );
         }
       })

package/lib/constants.js

@@ -1,10 +1,11 @@
 const chalk = require('chalk');
-const os = require('os');
-const path = require('path');
 
 const APP_PREFIX = chalk.gray('[TESTOMATIO]');
+const TESTOMAT_ARTIFACT_SUFFIX = "testomatio_artifact_";
 
-const TESTOMAT_TMP_STORAGE_DIR = path.join(os.tmpdir(), 'testomatio_tmp');
+const TESTOMAT_TMP_STORAGE = {
+  mainDir: "testomatio_tmp",
+}
 
 const CSV_HEADERS = [
   { id: 'suite_title', title: 'Suite_title' },
@@ -20,10 +21,18 @@ const STATUS = {
   SKIPPED: 'skipped',
   FINISHED: 'finished',
 };
+// html pipe var
+const HTML_REPORT = {
+  FOLDER: "html-report",
+  REPORT_DEFAULT_NAME: "testomatio-report.html",
+  TEMPLATE_NAME: 'testomatio.hbs'
+};
 
 module.exports = {
   APP_PREFIX,
-  TESTOMAT_TMP_STORAGE_DIR,
+  TESTOMAT_ARTIFACT_SUFFIX,
+  TESTOMAT_TMP_STORAGE,
   CSV_HEADERS,
   STATUS,
+  HTML_REPORT
 }