@testomatio/reporter 1.0.2 → 1.0.3

package/lib/adapter/cucumber/current.js

@@ -1,35 +1,59 @@
-// eslint-disable-next-line global-require, import/no-extraneous-dependencies
-const { Formatter, formatterHelpers } = require("@cucumber/cucumber");
+// eslint-disable-next-line global-require, import/no-extraneous-dependencies, import/no-unresolved
+const { Formatter, formatterHelpers } = require('@cucumber/cucumber');
 const chalk = require('chalk');
 const fs = require('fs');
-const { STATUS } = require('../../constants');
+const { STATUS, TESTOMAT_TMP_STORAGE } = require('../../constants');
 const TestomatClient = require('../../client');
+const logger = require('../../logger');
+const { parseTest, fileSystem } = require('../../util');
+
+const { GherkinDocumentParser, PickleParser } = formatterHelpers;
+const { getGherkinScenarioLocationMap, getGherkinStepMap } = GherkinDocumentParser;
+const { getPickleStepMap } = PickleParser;
+
+function getTestId(scenario) {
+  if (scenario) {
+    for (const tag of scenario.tags) {
+      const testId = parseTest(tag.name);
+      if (testId) return testId;
+    }
+  }
 
-const { GherkinDocumentParser, PickleParser } = formatterHelpers
-const {
-  getGherkinScenarioLocationMap,
-  getGherkinStepMap,
-} = GherkinDocumentParser
-const { getPickleStepMap } = PickleParser
+  return null;
+}
 
 class CucumberReporter extends Formatter {
   constructor(options) {
     super(options);
-    options.eventBroadcaster.on('envelope', this.parseEnvelope.bind(this))
+    options.eventBroadcaster.on('envelope', this.parseEnvelope.bind(this));
     this.failures = [];
     this.cases = [];
 
-    this.client = new TestomatClient({ apiKey: process.env.TESTOMATIO || options.apiKey });
+    this.client = new TestomatClient({ apiKey: options.apiKey || process.env.TESTOMATIO });
     this.status = STATUS.PASSED;
 
+    global.testomatioRunningEnvironment = 'cucumber:current';
   }
 
   parseEnvelope(envelope) {
-    if (envelope.testCaseStarted && this.client) this.client.createRun()
+    if (envelope.testRunStarted) {
+      fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+    }
+    if (envelope.testCaseStarted && this.client) {
+      this.client.createRun();
+      this.onTestCaseStarted(envelope.testCaseStarted);
+    }
     if (envelope.testCaseFinished) this.onTestCaseFinished(envelope.testCaseFinished);
     if (envelope.testRunFinished) this.onTestRunFinished(envelope);
   }
 
+  onTestCaseStarted(testCaseStarted) {
+    const testCaseAttempt = this.eventDataCollector.getTestCaseAttempt(testCaseStarted.id);
+    const testId = getTestId(testCaseAttempt.pickle);
+    if (!global.testomatioDataStore) global.testomatioDataStore = {};
+    global.testomatioDataStore.currentlyRunningTestId = testId;
+  }
+
   onTestCaseFinished(testCaseFinished) {
     const testCaseAttempt = this.eventDataCollector.getTestCaseAttempt(testCaseFinished.testCaseStartedId);
 
@@ -45,10 +69,10 @@ class CucumberReporter extends Formatter {
       if (testCaseAttempt.worstTestStepResult.status === 'SKIPPED') {
         status = STATUS.SKIPPED;
       }
-      if (testCaseAttempt.worstTestStepResult.status === 'UNDEFINED') {
-        status = STATUS.SKIPPED;
-        message = 'Undefined steps. Implement missing steps and rerun this scenario';
-      }
+      // if (testCaseAttempt.worstTestStepResult.status === 'UNDEFINED') {
+      //   status = STATUS.SKIPPED;
+      //   message = 'Undefined steps. Implement missing steps and rerun this scenario';
+      // }
       if (testCaseAttempt.worstTestStepResult.status === 'FAILED') {
         message = testCaseAttempt?.worstTestStepResult?.message;
         status = STATUS.FAILED;
@@ -64,10 +88,12 @@ class CucumberReporter extends Formatter {
     }
 
     const scenario = testCaseAttempt.pickle.name;
-    const testId = testCaseAttempt.pickle.id;
+    // this may broke something (it is supposed to work, but I am sure it did not)
+    // const testId = testCaseAttempt.pickle.id;
+    const testId = getTestId(testCaseAttempt.pickle);
 
     let exampleString = '';
-    if (example) exampleString = ` ${example.join(' | ')}`
+    if (example) exampleString = ` ${example.join(' | ')}`;
     let cliMessage = `${chalk.bold(scenario)}${exampleString}: ${chalk[color].bold(status.toUpperCase())} `;
 
     if (message) cliMessage += chalk.gray(message.split('\n')[0]);
@@ -79,15 +105,21 @@ class CucumberReporter extends Formatter {
 
     const time = Object.values(testCaseAttempt.stepResults)
       .map(t => t.duration)
-      .reduce((sum, duration) => sum + (duration.seconds * 1000)  + (duration.nanos / 1000000), 0)
+      .reduce((sum, duration) => sum + duration.seconds * 1000 + duration.nanos / 1000000, 0);
 
     if (!this.client) return;
 
+    const logs = logger.getLogs(testId);
+
     this.client.addTestRun(status, {
       // error: testCaseAttempt.worstTestStepResult.message,
       message,
-      steps: getSteps(testCaseAttempt).map(s => s.toString()).join('\n').trim(),
-      example: { ...example},
+      steps: getSteps(testCaseAttempt)
+        .map(s => s.toString())
+        .join('\n')
+        .trim(),
+      example: { ...example },
+      stack: logs,
       title: scenario,
       test_id: testId,
       time,
@@ -99,21 +131,20 @@ class CucumberReporter extends Formatter {
       console.log(chalk.bold('\nSUMMARY:\n\n'));
 
       this.failures.forEach((tc, i) => {
-        let message = `  ${i+1}) ${tc.pickle.name}\n`;
+        let message = `  ${i + 1}) ${tc.pickle.name}\n`;
 
         const steps = getSteps(tc);
 
         steps.forEach(s => {
-          message += `     ${s.toString()}\n`
-        })
+          message += `     ${s.toString()}\n`;
+        });
 
         console.log(message);
         if (tc?.worstTestStepResult?.message) {
           console.log(chalk.red(tc?.worstTestStepResult?.message));
         }
         console.log();
-
-      })
+      });
     }
 
     const { testRunFinished } = envelope;
@@ -125,46 +156,48 @@ class CucumberReporter extends Formatter {
 
     if (!this.client) return;
 
-    this.client.updateRunStatus(testRunFinished.success ? STATUS.PASSED : STATUS.FAILED)
+    this.client.updateRunStatus(testRunFinished.success ? STATUS.PASSED : STATUS.FAILED);
   }
 }
 
 function getSteps(tc) {
   const stepIds = Object.keys(tc.stepResults);
-  const pickleSteps = getPickleStepMap(tc.pickle)
-  return stepIds.map(stepId => {
-    const ts = tc.testCase.testSteps.find(t => t.id === stepId);
-    if (!ts) return;
-    if (!ts.pickleStepId) return;
-    const result = tc.stepResults[stepId];
-    const pickleStep = pickleSteps[ts.pickleStepId];
-    const sourceStepId = pickleStep.astNodeIds[0];
-    const step = {
-      text: pickleStep.text,
-      duration: result.duration,
-      status: result.status,
-    }
-    const color = getStatusColor(result.status);
-    if (sourceStepId && getGherkinStepMap(tc.gherkinDocument)[sourceStepId]) {
-      step.keyword = getGherkinStepMap(tc.gherkinDocument)[sourceStepId].keyword;
-    }
-    step.toString = function toString() {
-      const duration = step.duration.seconds * 1000 + (step.duration.nanos / 1000000)
-      const durationString = ` ${  chalk.gray(`(${Number(duration).toFixed(2)}ms)`)}`;
-      const stepString = `${chalk.bold(this.keyword)}${this.text}`.trim();
-      if (color === 'red') return chalk.red(stepString) + durationString;
-      if (color === 'yellow') return chalk.yellow(stepString) + durationString;
-      return stepString + durationString;
-    }
-    return step;
-  }).filter(s => !!s)
+  const pickleSteps = getPickleStepMap(tc.pickle);
+  return stepIds
+    .map(stepId => {
+      const ts = tc.testCase.testSteps.find(t => t.id === stepId);
+      if (!ts) return;
+      if (!ts.pickleStepId) return;
+      const result = tc.stepResults[stepId];
+      const pickleStep = pickleSteps[ts.pickleStepId];
+      const sourceStepId = pickleStep.astNodeIds[0];
+      const step = {
+        text: pickleStep.text,
+        duration: result.duration,
+        status: result.status,
+      };
+      const color = getStatusColor(result.status);
+      if (sourceStepId && getGherkinStepMap(tc.gherkinDocument)[sourceStepId]) {
+        step.keyword = getGherkinStepMap(tc.gherkinDocument)[sourceStepId].keyword;
+      }
+      step.toString = function toString() {
+        const duration = step.duration.seconds * 1000 + step.duration.nanos / 1000000;
+        const durationString = ` ${chalk.gray(`(${Number(duration).toFixed(2)}ms)`)}`;
+        const stepString = `${chalk.bold(this.keyword)}${this.text}`.trim();
+        if (color === 'red') return chalk.red(stepString) + durationString;
+        if (color === 'yellow') return chalk.yellow(stepString) + durationString;
+        return stepString + durationString;
+      };
+      return step;
+    })
+    .filter(s => !!s);
 }
 
 function getStatusColor(status) {
   if (status === 'UNDEFINED') return 'yellow';
   if (status === 'SKIPPED') return 'yellow';
   if (status === 'FAILED') return 'red';
-  return 'green'
+  return 'green';
 }
 
 function getExample(testCaseAttempt) {
@@ -173,11 +206,14 @@ function getExample(testCaseAttempt) {
   if (!nodesMap[exampleNodeId]) return;
   const featureDoc = fs.readFileSync(testCaseAttempt.gherkinDocument.uri).toString();
   const { line } = nodesMap[exampleNodeId];
-  const example = featureDoc.split('\n')[line-1];
+  const example = featureDoc.split('\n')[line - 1];
   if (example) {
-    return example.trim().split('|').filter(r => !!r).map(r => r.trim());
-  };
-
+    return example
+      .trim()
+      .split('|')
+      .filter(r => !!r)
+      .map(r => r.trim());
+  }
 }
 
 module.exports = CucumberReporter;

package/lib/adapter/cucumber/legacy.js

@@ -1,8 +1,8 @@
 // eslint-disable-next-line global-require, import/no-extraneous-dependencies, import/no-unresolved
 const { Formatter } = require('cucumber');
 const chalk = require('chalk');
-const { parseTest } = require('../../util');
-const { STATUS } = require('../../constants');
+const { parseTest, fileSystem } = require('../../util');
+const { STATUS, TESTOMAT_TMP_STORAGE } = require('../../constants');
 const TestomatClient = require('../../client');
 
 const createTestomatFormatter = apiKey => {
@@ -96,9 +96,23 @@ const createTestomatFormatter = apiKey => {
       this.status = STATUS.PASSED.toString();
 
       options.eventBroadcaster.on('gherkin-document', addDocument);
-      options.eventBroadcaster.on('test-run-started', () => this?.client?.createRun());
+      options.eventBroadcaster.on('test-run-started', () => {
+        fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
+        this?.client?.createRun();
+      });
       options.eventBroadcaster.on('test-case-finished', this.onTestCaseFinished.bind(this));
+      options.eventBroadcaster.on('test-case-started', this.onTestCaseStarted.bind(this));
       options.eventBroadcaster.on('test-run-finished', () => this?.client?.updateRunStatus(this.status));
+
+      global.testomatioRunningEnvironment = 'cucumber:legacy';
+    }
+
+    onTestCaseStarted(event) {
+      const scenario = getScenario(event.sourceLocation);
+      const testId = getTestId(scenario);
+      
+      if (!global.testomatioDataStore) global.testomatioDataStore = {};
+      global.testomatioDataStore.currentlyRunningTestId = testId;
     }
 
     onTestCaseFinished(event) {
@@ -111,15 +125,15 @@ const createTestomatFormatter = apiKey => {
 
       if (!scenario.name) return;
 
-      let message = '';
-      let cliMessage = `- ${scenario.name}: ${chalk.bold(status.toUpperCase())}`;
+      const message = '';
+      const cliMessage = `- ${scenario.name}: ${chalk.bold(status.toUpperCase())}`;
 
-      if (event.result.status === 'undefined') {
-        cliMessage += chalk.yellow(
-          ' (undefined steps. Run Cucumber without this formatter and implement missing steps)',
-        );
-        message = 'Undefined steps. Implement missing steps and rerun this scenario';
-      }
+      // if (event.result.status === 'undefined') {
+      //   cliMessage += chalk.yellow(
+      //     ' (undefined steps. Run Cucumber without this formatter and implement missing steps)',
+      //   );
+      //   message = 'Undefined steps. Implement missing steps and rerun this scenario';
+      // }
       console.log(cliMessage);
       if (status !== STATUS.PASSED && status !== STATUS.SKIPPED) {
         this.status = STATUS.FAILED;

package/lib/adapter/jest.js

@@ -13,8 +13,13 @@ class JestReporter {
 
   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
+    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() {

package/lib/adapter/playwright.js

@@ -3,14 +3,14 @@ const crypto = require('crypto');
 const os = require('os');
 const path = require('path');
 const fs = require('fs');
-const { APP_PREFIX, STATUS: Status } = require('../constants');
+const { APP_PREFIX, STATUS: Status, TESTOMAT_TMP_STORAGE } = require('../constants');
 const TestomatioClient = require('../client');
 const { isArtifactsEnabled } = require('../fileUploader');
-const { parseTest } = require('../util');
+const { parseTest, fileSystem } = require('../util');
 
 const reportTestPromises = [];
 
-class TestomatioReporter {
+class PlaywrightReporter {
   constructor(config = {}) {
     this.client = new TestomatioClient({ apiKey: config?.apiKey });
 
@@ -18,11 +18,17 @@ class TestomatioReporter {
   }
 
   onBegin(_config, suite) {
+    // clean data storage
+    fileSystem.clearDir(TESTOMAT_TMP_STORAGE.mainDir);
     if (!this.client) return;
     this.suite = suite;
     this.client.createRun();
   }
 
+  // onTestBegin(test) {
+  //   const testId = parseTest(test.title);
+  // }
+
   onTestEnd(test, result) {
     if (!this.client) return;
 
@@ -37,7 +43,9 @@ class TestomatioReporter {
     for (const step of result.steps) {
       appendStep(step, steps);
     }
-    
+
+    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,
@@ -45,13 +53,14 @@ class TestomatioReporter {
       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);
   }
@@ -67,10 +76,9 @@ class TestomatioReporter {
       const promises = [];
 
       for (const upload of this.uploads) {
-
         const { title, testId, suite_title } = upload;
 
-        const files = upload.files.map((attachment) => {
+        const files = upload.files.map(attachment => {
           if (attachment.body) {
             const fileName = tmpFile();
             fs.writeFileSync(fileName, attachment.body);
@@ -78,7 +86,6 @@ class TestomatioReporter {
           return { path: attachment.path, title, type: attachment.contentType };
         });
 
-
         promises.push(
           this.client.addTestRun(undefined, {
             test_id: testId,
@@ -124,4 +131,4 @@ function tmpFile(prefix = 'tmp.') {
   return path.join(tmpdir, prefix + crypto.randomBytes(16).toString('hex'));
 }
 
-module.exports = TestomatioReporter;
+module.exports = PlaywrightReporter;

package/lib/client.js

@@ -21,7 +21,6 @@ class Client {
    * @param {*} params
    */
   constructor(params = {}) {
-    this.parallel = params.parallel;
     const store = {};
     this.uuid = randomUUID();
     this.pipes = pipesFactory(params, store);
@@ -40,20 +39,14 @@ class Client {
     // all pipes disabled, skipping
     if (!this.pipes?.filter(p => p.isEnabled).length) return Promise.resolve();
 
-    const runParams = {
-      title: this.title,
-      parallel: this.parallel,
-      env: this.env,
-    };
-
     global.testomatioArtifacts = [];
-    // TODO: create global storage
+    if (!global.testomatioDataStore) global.testomatioDataStore = {};
 
     this.queue = this.queue
-      .then(() => Promise.all(this.pipes.map(p => p.createRun(runParams))))
+      .then(() => Promise.all(this.pipes.map(p => p.createRun())))
       .catch(err => console.log(APP_PREFIX, err))
       .then(() => undefined); // fixes return type
-    debug('Run', this.queue);
+    // debug('Run', this.queue);
     return this.queue;
   }
 
@@ -99,14 +92,17 @@ class Client {
       message = error?.message;
     }
     if (steps) {
-      stack = this.formatSteps(stack, steps);
+      stack += this.formatSteps(stack, steps);
     }
 
+    stack += testData.stack || '';
+
+    // in some cases (e.g. using cucumber) logger instance becomes empty object, if import at the top of the file
     const logger = require('./logger');
     const testLogs = logger.getLogs(test_id);
-    debug(`Test logs for ${test_id}:\n`, testLogs);
+    // debug(`Test logs for ${test_id}:\n`, testLogs);
     if (stack) stack += '\n\n';
-    stack += testLogs;
+    stack += testLogs ? `${chalk.bold('Logs:')}\n${testLogs}` : '';
 
     if (Array.isArray(storeArtifacts) && storeArtifacts.length) {
       debug('CLIENT storeArtifact', storeArtifacts);