@testomatio/reporter 0.6.9 → 0.7.0-beta.1

package/Changelog.md

@@ -1,3 +1,7 @@
+# 0.6.10
+
+* Fixed uploading multilpe artifacts in Playwright
+
 # 0.6.9
 
 * Fixed pending tests reports for Cypress

package/lib/adapter/cucumber/current.js

@@ -0,0 +1,187 @@
+const { Formatter, Status, formatterHelpers } = require("@cucumber/cucumber");
+const chalk = require('chalk');
+const fs = require('fs');
+const { TestomatClient, TRConstants } = require('../../reporter');
+const { parseTest } = require('../../util');
+const { formatLocation, GherkinDocumentParser, PickleParser } = formatterHelpers
+const {
+  getGherkinScenarioMap,
+  getGherkinScenarioLocationMap,
+  getGherkinStepMap,
+} = GherkinDocumentParser
+const { getPickleStepMap } = PickleParser
+
+class CucumberReporter extends Formatter {
+  constructor(options) {
+    super(options);
+    options.eventBroadcaster.on('envelope', this.parseEnvelope.bind(this))
+    this.failures = [];
+    this.cases = [];
+
+    const apiKey = process.env.TESTOMATIO;
+    if (!apiKey || apiKey === '') {
+      console.log(chalk.red('TESTOMATIO key is empty, ignoring reports'));
+      return;
+    }
+
+    this.client = new TestomatClient({ apiKey });
+    this.status = TRConstants.PASSED;
+
+  }
+
+  parseEnvelope(envelope) {
+    if (envelope.testCaseStarted && this.client) this.client.createRun()
+    if (envelope.testCaseFinished) this.onTestCaseFinished(envelope.testCaseFinished);
+    if (envelope.testRunFinished) this.onTestRunFinished(envelope);
+  }
+
+  onTestCaseFinished(testCaseFinished) {
+    const testCaseAttempt = this.eventDataCollector.getTestCaseAttempt(testCaseFinished.testCaseStartedId);
+    const statuses = [...new Set(Object.values(testCaseAttempt.stepResults || {}).map(r => r.status))]
+
+    let example;
+    let status = TRConstants.PASSED;
+    let color = 'green';
+    let message;
+
+    this.cases.push(testCaseAttempt);
+
+    if (testCaseAttempt.worstTestStepResult) {
+      if (testCaseAttempt.worstTestStepResult.status === 'SKIPPED') {
+        status = TRConstants.SKIPPED;
+      }
+      if (testCaseAttempt.worstTestStepResult.status === 'UNDEFINED') {
+        status = TRConstants.SKIPPED;
+        message = 'Undefined steps. Implement missing steps and rerun this scenario';
+      }
+      if (testCaseAttempt.worstTestStepResult.status === 'FAILED') {
+        message = testCaseAttempt?.worstTestStepResult?.message;
+        status = TRConstants.FAILED;
+      }
+      color = getStatusColor(testCaseAttempt.worstTestStepResult.status);
+      if (status !== TRConstants.PASSED) this.failures.push(testCaseAttempt);
+    }
+
+    if (testCaseAttempt.pickle.astNodeIds.length > 1) {
+      example = getExample(testCaseAttempt);
+      testCaseAttempt.example = example;
+    }
+
+    const scenario = testCaseAttempt.pickle.name;
+    const testId = testCaseAttempt.pickle.id;
+
+    let exampleString = '';
+    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]);
+    console.log(cliMessage);
+
+    if (status !== TRConstants.PASSED && status !== TRConstants.SKIPPED) {
+      this.status = TRConstants.FAILED;
+    }
+
+    const time = Object.values(testCaseAttempt.stepResults)
+      .map(t => t.duration)
+      .reduce((sum, duration) => {
+         return sum + (duration.seconds * 1000)  + (duration.nanos / 1000000)
+      }, 0)
+
+    if (!this.client) return;
+
+    this.client.addTestRun(testId, status, {
+      // error: testCaseAttempt.worstTestStepResult.message,
+      message,
+      steps: getSteps(testCaseAttempt).map(s => s.toString()).join('\n').trim(),
+      example: Object.assign({}, example),
+      title: scenario,
+      time,
+    });
+  }
+
+  onTestRunFinished(envelope) {
+    if (this.failures.length > 0) {
+      console.log(chalk.bold('\nSUMMARY:\n\n'));
+
+      this.failures.forEach((tc, i) => {
+        let message = `  ${i+1}) ${tc.pickle.name}\n`;
+
+        const steps = getSteps(tc);
+
+        steps.forEach(s => {
+          message += `     ${s.toString()}\n`
+        })
+
+        console.log(message);
+        if (tc?.worstTestStepResult?.message) {
+          console.log(chalk.red(tc?.worstTestStepResult?.message));
+        }
+        console.log();
+
+      })
+    }
+
+    const { testRunFinished } = envelope;
+
+    const bgColor = testRunFinished.success ? 'bgGreen' : 'bgRed';
+    console.log();
+    console.log(chalk[bgColor](chalk.bold(testRunFinished.success ? ' SUCCESS ' : ' FALIURE ') + `| Total Scenarios: ${chalk.bold(this.cases.length)} `));
+
+    if (!this.client) return;
+
+    this.client.updateRunStatus(testRunFinished.success ? TRConstants.PASSED : TRConstants.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(ts => ts.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() {
+      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'
+}
+
+function getExample(testCaseAttempt) {
+  const nodesMap = getGherkinScenarioLocationMap(testCaseAttempt.gherkinDocument);
+  const exampleNodeId = testCaseAttempt.pickle.astNodeIds[1];
+  if (!nodesMap[exampleNodeId]) return;
+  const featureDoc = fs.readFileSync(testCaseAttempt.gherkinDocument.uri).toString();
+  const { line } = nodesMap[exampleNodeId];
+  const example = featureDoc.split('\n')[line-1];
+  if (example) {
+    return example.trim().split('|').filter(r => !!r).map(r => r.trim());
+  };
+
+}
+
+module.exports = CucumberReporter;

package/lib/adapter/cucumber/legacy.js

@@ -0,0 +1,136 @@
+// eslint-disable-next-line import/no-unresolved
+const { Formatter } = require('cucumber');
+const chalk = require('chalk');
+const { TestomatClient, TRConstants } = require('../../eporter');
+const { parseTest } = require('../../util');
+
+const createTestomatFormatter = apiKey => {
+  if (!apiKey || apiKey === '') {
+    console.log(chalk.red('TESTOMATIO key is empty, ignoring reports'));
+  }
+
+  const documents = {};
+  const dataTableMap = {};
+
+  const addDocument = gherkinDocument => {
+    documents[gherkinDocument.uri] = gherkinDocument.document;
+  };
+
+  const getTitle = scenario => {
+    let { name } = scenario;
+    if (scenario.tags.length) {
+      let tags = '';
+      for (const tag of scenario.tags) {
+        tags = `${tags} ${tag.name}`;
+      }
+      name = `${name}${tags}`;
+    }
+    return name;
+  };
+
+  const getFeature = uri => documents[uri].feature;
+
+  const getScenario = location => {
+    const { children } = getFeature(location.uri);
+    for (const scenario of children) {
+      if (scenario.type === 'Scenario' && scenario.location.line === location.line) {
+        return scenario;
+      }
+      if (scenario.type === 'ScenarioOutline') {
+        for (const example of scenario.examples) {
+          for (const tableBody of example.tableBody) {
+            if (tableBody.location.line === location.line) {
+              return scenario;
+            }
+          }
+        }
+      }
+    }
+
+    return null;
+  };
+
+  const loadDataTable = (scenario, uri) => {
+    if (scenario.type === 'ScenarioOutline') {
+      for (const example of scenario.examples) {
+        for (const tableBody of example.tableBody) {
+          const dataMap = example.tableHeader.cells.reduce((acc, cell, index) => {
+            acc[cell.value] = tableBody.cells[index].value;
+            return acc;
+          }, {});
+
+          dataTableMap[`${uri}:${tableBody.location.line}`] = JSON.stringify(dataMap);
+        }
+      }
+    }
+  };
+
+  const getDataTableMap = (scenario, sourceLocation) => {
+    const key = `${sourceLocation.uri}:${sourceLocation.line}`;
+    if (!dataTableMap[key]) {
+      loadDataTable(scenario, sourceLocation.uri);
+    }
+
+    return dataTableMap[key] || '';
+  };
+
+  const getTestId = scenario => {
+    if (scenario) {
+      for (const tag of scenario.tags) {
+        const testId = parseTest(tag.name);
+        if (testId) return testId;
+      }
+    }
+
+    return null;
+  };
+
+  return class TestomatFormatter extends Formatter {
+    constructor(options) {
+      super(options);
+
+      if (!apiKey) return;
+
+      this.client = new TestomatClient({ apiKey });
+      this.status = TRConstants.PASSED;
+
+      options.eventBroadcaster.on('gherkin-document', addDocument);
+      options.eventBroadcaster.on('test-run-started', () => this.client.createRun());
+      options.eventBroadcaster.on('test-case-finished', this.onTestCaseFinished.bind(this));
+      options.eventBroadcaster.on('test-run-finished', () => this.client.updateRunStatus(this.status));
+    }
+
+    onTestCaseFinished(event) {
+      const scenario = getScenario(event.sourceLocation);
+      const testId = getTestId(scenario);
+      const status = event.result.status === 'undefined' ? TRConstants.SKIPPED : event.result.status;
+
+      let example = getDataTableMap(scenario, event.sourceLocation);
+      if (example) example = JSON.parse(example);
+
+      if (!scenario.name) return;
+
+      let message = '';
+      let 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';
+      }
+      console.log(cliMessage);
+      if (status !== TRConstants.PASSED && status !== TRConstants.SKIPPED) {
+        this.status = TRConstants.FAILED;
+      }
+      this.client.addTestRun(testId, status, {
+        error: event.result.exception,
+        message,
+        example,
+        title: getTitle(scenario),
+      });
+    }
+  };
+};
+
+module.exports = createTestomatFormatter(process.env.TESTOMATIO);

package/lib/adapter/cucumber.js

@@ -1,136 +1,13 @@
 // eslint-disable-next-line import/no-unresolved
-const { Formatter } = require('cucumber');
-const chalk = require('chalk');
-const { TestomatClient, TRConstants } = require('../reporter');
-const { parseTest } = require('../util');
-
-const createTestomatFormatter = apiKey => {
-  if (!apiKey || apiKey === '') {
-    console.log(chalk.red('TESTOMATIO key is empty, ignoring reports'));
+try {
+  require.resolve('cucumber');
+  module.exports = require('./cucumber/legacy');
+} catch (err) {
+  try {
+    require.resolve("@cucumber/cucumber");
+    module.exports = require('./cucumber/current');
+  } catch (err) {
+    console.error('Cucumber was not detected. Report won\'t be sent', err);
+    module.exports = {}
   }
-
-  const documents = {};
-  const dataTableMap = {};
-
-  const addDocument = gherkinDocument => {
-    documents[gherkinDocument.uri] = gherkinDocument.document;
-  };
-
-  const getTitle = scenario => {
-    let { name } = scenario;
-    if (scenario.tags.length) {
-      let tags = '';
-      for (const tag of scenario.tags) {
-        tags = `${tags} ${tag.name}`;
-      }
-      name = `${name}${tags}`;
-    }
-    return name;
-  };
-
-  const getFeature = uri => documents[uri].feature;
-
-  const getScenario = location => {
-    const { children } = getFeature(location.uri);
-    for (const scenario of children) {
-      if (scenario.type === 'Scenario' && scenario.location.line === location.line) {
-        return scenario;
-      }
-      if (scenario.type === 'ScenarioOutline') {
-        for (const example of scenario.examples) {
-          for (const tableBody of example.tableBody) {
-            if (tableBody.location.line === location.line) {
-              return scenario;
-            }
-          }
-        }
-      }
-    }
-
-    return null;
-  };
-
-  const loadDataTable = (scenario, uri) => {
-    if (scenario.type === 'ScenarioOutline') {
-      for (const example of scenario.examples) {
-        for (const tableBody of example.tableBody) {
-          const dataMap = example.tableHeader.cells.reduce((acc, cell, index) => {
-            acc[cell.value] = tableBody.cells[index].value;
-            return acc;
-          }, {});
-
-          dataTableMap[`${uri}:${tableBody.location.line}`] = JSON.stringify(dataMap);
-        }
-      }
-    }
-  };
-
-  const getDataTableMap = (scenario, sourceLocation) => {
-    const key = `${sourceLocation.uri}:${sourceLocation.line}`;
-    if (!dataTableMap[key]) {
-      loadDataTable(scenario, sourceLocation.uri);
-    }
-
-    return dataTableMap[key] || '';
-  };
-
-  const getTestId = scenario => {
-    if (scenario) {
-      for (const tag of scenario.tags) {
-        const testId = parseTest(tag.name);
-        if (testId) return testId;
-      }
-    }
-
-    return null;
-  };
-
-  return class TestomatFormatter extends Formatter {
-    constructor(options) {
-      super(options);
-
-      if (!apiKey) return;
-
-      this.client = new TestomatClient({ apiKey });
-      this.status = TRConstants.PASSED;
-
-      options.eventBroadcaster.on('gherkin-document', addDocument);
-      options.eventBroadcaster.on('test-run-started', () => this.client.createRun());
-      options.eventBroadcaster.on('test-case-finished', this.onTestCaseFinished.bind(this));
-      options.eventBroadcaster.on('test-run-finished', () => this.client.updateRunStatus(this.status));
-    }
-
-    onTestCaseFinished(event) {
-      const scenario = getScenario(event.sourceLocation);
-      const testId = getTestId(scenario);
-      const status = event.result.status === 'undefined' ? TRConstants.SKIPPED : event.result.status;
-
-      let example = getDataTableMap(scenario, event.sourceLocation);
-      if (example) example = JSON.parse(example);
-
-      if (!scenario.name) return;
-
-      let message = '';
-      let 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';
-      }
-      console.log(cliMessage);
-      if (status !== TRConstants.PASSED && status !== TRConstants.SKIPPED) {
-        this.status = TRConstants.FAILED;
-      }
-      this.client.addTestRun(testId, status, {
-        error: event.result.exception,
-        message,
-        example,
-        title: getTitle(scenario),
-      });
-    }
-  };
-};
-
-module.exports = createTestomatFormatter(process.env.TESTOMATIO);
+}

package/lib/fileUploader.js

@@ -2,6 +2,7 @@ const AWS = require('aws-sdk');
 const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
+const { randomUUID } = require('crypto');
 const memoize = require('lodash.memoize');
 const { APP_PREFIX } = require('./constants');
 
@@ -55,7 +56,7 @@ const uploadUsingS3 = async (filePath, runId) => {
   const s3 = new AWS.S3(config);
   const file = fs.readFileSync(filePath);
 
-  Key = `${runId}/${Key || path.basename(filePath)}`;
+  Key = `${runId}/${randomUUID()}-${Key || path.basename(filePath)}`;
   const ACL = TESTOMATIO_PRIVATE_ARTIFACTS ? 'private' : 'public-read';
 
   try {

package/lib/xmlReader.js

@@ -8,7 +8,6 @@ const { XMLParser } = require("fast-xml-parser");
 const { APP_PREFIX } = require('./constants');
 const { isValidUrl, fetchFilesFromStackTrace, fetchSourceCode, fetchSourceCodeFromStackTrace } = require('./util');
 const upload = require('./fileUploader');
-
 const Adapter = require('./junit-adapter/adapter');
 const JavaScriptAdapter = require('./junit-adapter/javascript');
 const JavaAdapter = require('./junit-adapter/java');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testomatio/reporter",
-  "version": "0.6.9",
+  "version": "0.7.0-beta.1",
   "description": "Testomatio Reporter Client",
   "main": "./lib/reporter.js",
   "repository": "git@github.com:testomatio/reporter.git",
@@ -30,15 +30,16 @@
     "test:adapter:jest:example": "jest './tests/adapter/examples/jest/index.test.js' --config='./tests/adapter/examples/jest/jest.config.js'",
     "test:adapter:mocha:example": "mocha './tests/adapter/examples/mocha/index.test.js' --config='./tests/adapter/examples/mocha/mocha.config.js'",
     "test:adapter:jasmine:example": "./tests/adapter/examples/jasmine/passReporterOpts.sh && jasmine './tests/adapter/examples/jasmine/index.test.js' --reporter=./../../../lib/adapter/jasmine.js",
-    "test:adapter:codecept:example": "codeceptjs run --config='./tests/adapter/examples/codecept/codecept.conf.js'"
+    "test:adapter:codecept:example": "codeceptjs run --config='./tests/adapter/examples/codecept/codecept.conf.js'",
+    "test:adapter:cucumber:example": "cd ./tests/adapter/examples/cucumber && cucumber-js"
   },
   "peerDependencies": {
     "@wdio/reporter": "*",
     "codeceptjs": "*",
-    "cucumber": "*",
     "mocha": "*"
   },
   "devDependencies": {
+    "@cucumber/cucumber": "^8.6.0",
     "@wdio/reporter": "^7.16.13",
     "chai": "^4.3.6",
     "codeceptjs": "^3.2.3",

package/tests/adapter/examples/cucumber/cucumber.js

@@ -0,0 +1,4 @@
+module.exports = {
+  default: `--publish-quiet -f ../../../../lib/adapter/cucumber.js`,
+  // format: ['progress', 'node_modules/@testomatio/reporter/lib/adapter/cucumber.js']
+}

package/tests/adapter/examples/cucumber/features/dummy.feature

@@ -0,0 +1,9 @@
+Feature: One feature
+
+Background:
+  Given I do something
+
+Scenario: do it once
+  When I do something
+  Then I do something
+  But I fail

package/tests/adapter/examples/cucumber/features/steps/steps.js

@@ -0,0 +1,9 @@
+const {Given, When, Then} = require("@cucumber/cucumber");
+
+Given("I do something", function() {
+  // actually nothing
+});
+
+Then("I fail", function() {
+  throw new Error('fail');
+})

package/tests/adapter/index.test.js

@@ -5,6 +5,7 @@ const JestReporter = require('../../lib/adapter/jest');
 const MochaReporter = require('../../lib/adapter/mocha');
 const JasmineReporter = require('../../lib/adapter/jasmine');
 const CodeceptReporter = require('../../lib/adapter/codecept');
+const CucumberReporter = require('../../lib/adapter/cucumber');
 const { registerHandlers } = require('./utils');
 const { host, port, TESTOMATIO_URL, TESTOMATIO, RUN_ID } = require('./config');
 
@@ -29,6 +30,11 @@ const params = [
     positiveCmd: `TESTOMATIO_URL=${TESTOMATIO_URL} TESTOMATIO=${TESTOMATIO} npm run test:adapter:jasmine:example`,
     negativeCmd: `TESTOMATIO_URL=${TESTOMATIO_URL} npm run test:adapter:jasmine:example`,
   },
+  {
+    adapterName: CucumberReporter.name,
+    positiveCmd: `TESTOMATIO_URL=${TESTOMATIO_URL} TESTOMATIO=${TESTOMATIO} npm run test:adapter:cucumber:example`,
+    negativeCmd: `TESTOMATIO_URL=${TESTOMATIO_URL} npm run test:adapter:cucumber:example`,
+  },
 ];
 
 describe('Adapters', () => {