artes 1.4.5 → 1.4.7

package/cucumber.config.js

@@ -14,7 +14,7 @@ try {
   console.log("Proceeding with default config.");
 }
 
-const defaultFormats = ["rerun:@rerun.txt", "progress-bar"];
+const defaultFormats = ["rerun:@rerun.txt",  "progress-bar", './status-formatter.js:null'];
 
 const userFormatsFromEnv = process.env.REPORT_FORMAT
   ? JSON.parse(process.env.REPORT_FORMAT)
@@ -55,7 +55,7 @@ function loadVariables(cliVariables, artesConfigVariables) {
 
   if (cliVariables) {
     try {
-      cliVariables = JSON.parse(process.env.VARS);
+      cliVariables = JSON.parse(cliVariables);
     } catch (err) {
       console.error("Invalid JSON in process.env.VARS:", process.env.VARS);
       envVars = {};

package/executer.js

@@ -22,6 +22,11 @@ if (fs.existsSync(artesConfigPath)) {
 
 const args = process.argv.slice(2);
 
+const getArgValue = (flag) => {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+};
+
 const flags = {
   help: args.includes("-h") || args.includes("--help"),
   version: args.includes("-v") || args.includes("--version"),
@@ -56,23 +61,25 @@ const flags = {
   slowMo: args.includes("--slowMo"),
 };
 
-const env = args[args.indexOf("--env") + 1];
-const vars = args[args.indexOf("--saveVar") + 1]
-const featureFiles = args[args.indexOf("--features") + 1];
+
+const env = getArgValue("--env");
+const vars = getArgValue("--saveVar");
+const featureFiles = getArgValue("--features");
 const features = flags.features && featureFiles;
-const stepDef = args[args.indexOf("--stepDef") + 1];
-const tags = args[args.indexOf("--tags") + 1];
-const parallel = args[args.indexOf("--parallel") + 1];
-const retry = args[args.indexOf("--retry") + 1];
-const rerun = args[args.indexOf("--rerun") + 1];
-const percentage = args[args.indexOf("--percentage") + 1];
-const browser = args[args.indexOf("--browser") + 1];
-const device = args[args.indexOf("--device") + 1];
-const baseURL = args[args.indexOf("--baseURL") + 1];
-const width = args[args.indexOf("--width") + 1];
-const height = args[args.indexOf("--height") + 1];
-const timeout = args[args.indexOf("--timeout") + 1];
-const slowMo = args[args.indexOf("--slowMo") + 1];
+const stepDef = getArgValue("--stepDef");
+const tags = getArgValue("--tags");
+const parallel = getArgValue("--parallel");
+const retry = getArgValue("--retry");
+const rerun = getArgValue("--rerun");
+const percentage = getArgValue("--percentage");
+const browser = getArgValue("--browser");
+const device = getArgValue("--device");
+const baseURL = getArgValue("--baseURL");
+const width = getArgValue("--width");
+const height = getArgValue("--height");
+const timeout = getArgValue("--timeout");
+const slowMo = getArgValue("--slowMo");
+
 
 flags.env ? (process.env.ENV = env) : "";
 
@@ -152,82 +159,243 @@ flags.timeout ? (process.env.TIMEOUT = timeout) : "";
 flags.slowMo ? (process.env.SLOWMO = slowMo) : "";
 
 
-function testCoverageCalculation(testStatusDir){
-  if(fs.existsSync(testStatusDir)){
-    const files = fs.readdirSync(testStatusDir);
+function findDuplicateTestNames() {
+  const testStatusFile = path.join(process.cwd(), "node_modules", "artes" , "test-status", 'test-status.txt');
+  
+  if (!fs.existsSync(testStatusFile)) {
+    console.error('test-status.txt not found');
+    return;
+  }
+
+  const content = fs.readFileSync(testStatusFile, 'utf8');
+  const lines = content.split('\n').filter(line => line.trim());
 
-    const map = {};
-    const retriedTests = [];
-    const uuidRegex = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+  const testNameToFiles = {};
+
+  lines.forEach(line => {
+    const parts = line.split(' | ');
+    if (parts.length < 5) return;
+
+    const testName = parts[2].trim();
+    const filePath = parts[4].trim();
+
+    if (!testNameToFiles[testName]) {
+      testNameToFiles[testName] = new Set();
+    }
+    
+    testNameToFiles[testName].add(filePath);
+  });
+
+  const duplicates = {};
+  
+  Object.entries(testNameToFiles).forEach(([testName, files]) => {
+    if (files.size > 1) {
+      duplicates[testName] = Array.from(files);
+    }
+  });
+
+  if (Object.keys(duplicates).length > 0) {
+    console.warn('\n\x1b[33m[WARNING] Duplicate scenarios names found: This will effect your reporting');    
+    Object.entries(duplicates).forEach(([testName, files]) => {
+      console.log(`\x1b[33m"${testName}" exists in:`);
+      files.forEach(file => {
+        console.log(`  - ${file}`);
+      });
+      console.log('');
+    });
+    console.log("\x1b[0m");
+  } 
+
+  return duplicates;
+}
+
+
+function testCoverageCalculation() {
+
+  const testStatusFile = path.join(process.cwd(), "node_modules", "artes" , "test-status", 'test-status.txt');
   
-    files.forEach(file => {
-     const match = file.match(uuidRegex);
-     if (!match) return;
- 
-     const id = match[0];
- 
-     const beforeId = file.substring(0, file.indexOf(id) - 1);
-     const afterId = file.substring(file.indexOf(id) + id.length + 1);
- 
-     const status = beforeId.split('-')[0];
-     const scenario = beforeId.substring(status.length + 1);
-     const timestamp = afterId;
- 
-     if (!map[id]) {
-       map[id] = {
-         count: 1,
-         latest: { status, scenario, timestamp }
-       };
-     } else {
-       map[id].count++;
-       if (timestamp > map[id].latest.timestamp) {
-         map[id].latest = { status, scenario, timestamp };
-       }
-     }
-   });
- 
-   let total = 0;
-   let notPassed = 0;
- 
-   Object.entries(map).forEach(([id, data]) => {
-     total++;
- 
-     if (data.count > 1) {
-       retriedTests.push({
-         scenario: data.latest.scenario,
-         id,
-         count: data.count
-       });
-     }
- 
-     if (data.latest.status !== 'PASSED') {
+  if (!fs.existsSync(testStatusFile)) {
+    console.error('test-status.txt not found');
+    return null;
+  }
+
+  const content = fs.readFileSync(testStatusFile, 'utf8');
+  const lines = content.split('\n').filter(line => line.trim());
+
+  const map = {};
+  const retriedTests = [];
+  const uuidRegex = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+
+  lines.forEach(line => {
+    const parts = line.split(' | ');
+    if (parts.length < 5) return;
+
+    const timestamp = parts[0].trim();
+    const status = parts[1].trim();
+    const scenario = parts[2].trim();
+    const id = parts[3].trim();
+    const uri = parts[4].trim();
+
+    if (!uuidRegex.test(id)) return;
+
+    if (!map[id]) {
+      map[id] = {
+        count: 1,
+        latest: { status, scenario, timestamp, uri }
+      };
+    } else {
+      map[id].count++;
+      if (timestamp > map[id].latest.timestamp) {
+        map[id].latest = { status, scenario, timestamp, uri };
+      }
+    }
+  });
+
+  let total = 0;
+  let notPassed = 0;
+
+  Object.entries(map).forEach(([id, data]) => {
+    total++;
+
+    if (data.count > 1) {
+      retriedTests.push({
+        scenario: data.latest.scenario,
+        id,
+        count: data.count
+      });
+    }
+
+    if (data.latest.status !== 'PASSED') {
       notPassed++;
-     }
-   });
- 
-   if (retriedTests.length > 0) {
-     console.warn('\n\x1b[33mRetried test cases:');
-     retriedTests.forEach(t => {
-       console.warn(`- "${t.scenario}" ran ${t.count} times`);
-     });
-     console.log("\x1b[0m");
-   }
- 
-   return {
-     percentage : (total - notPassed)/total*100,
-     totalTests: total,
-     notPassed,
-     passed: total - notPassed,
-     latestStatuses: Object.fromEntries(
-       Object.entries(map).map(([id, data]) => [
-         id,
-         data.latest.status
-       ])
-     )
-   };
+    }
+  });
+
+  if (retriedTests.length > 0) {
+    console.warn('\n\x1b[33mRetried test cases:');
+    retriedTests.forEach(t => {
+      console.warn(`- "${t.scenario}" ran ${t.count} times`);
+    });
+    console.log("\x1b[0m");
+  }
+
+  return {
+    percentage: (total - notPassed) / total * 100,
+    totalTests: total,
+    notPassed,
+    passed: total - notPassed,
+    latestStatuses: Object.fromEntries(
+      Object.entries(map).map(([id, data]) => [
+        id,
+        data.latest.status
+      ])
+    )
+  };
+}
+
+function getExecutor() {
+  // GitHub Actions
+  if (process.env.GITHUB_RUN_ID) {
+    return {
+      name: "GitHub Actions",
+      type: "github",
+      buildName: `Workflow #${process.env.GITHUB_RUN_NUMBER}`,
+      buildOrder: Number(process.env.GITHUB_RUN_NUMBER),
+      buildUrl: `${process.env.GITHUB_SERVER_URL}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`
+    };
+
+  // Jenkins
+  } else if (process.env.JENKINS_HOME) {
+    return {
+      name: "Jenkins",
+      type: "jenkins",
+      buildName: process.env.JOB_NAME || "Manual Run",
+      buildOrder: Number(process.env.BUILD_NUMBER) || 1,
+      buildUrl: process.env.BUILD_URL || ""
+    };
+
+  // GitLab CI
+  } else if (process.env.CI_PIPELINE_ID) {
+    return {
+      name: "GitLab CI",
+      type: "gitlab",
+      buildName: `Pipeline #${process.env.CI_PIPELINE_IID}`,
+      buildOrder: Number(process.env.CI_PIPELINE_IID) || 1,
+      buildUrl: process.env.CI_PIPELINE_URL || ""
+    };
+
+  // Bitbucket Pipelines
+  } else if (process.env.BITBUCKET_BUILD_NUMBER) {
+    return {
+      name: "Bitbucket Pipelines",
+      type: "bitbucket",
+      buildName: `Build #${process.env.BITBUCKET_BUILD_NUMBER}`,
+      buildOrder: Number(process.env.BITBUCKET_BUILD_NUMBER),
+      buildUrl: process.env.BITBUCKET_BUILD_URL || ""
+    };
+
+  // CircleCI
+  } else if (process.env.CIRCLE_WORKFLOW_ID) {
+    return {
+      name: "CircleCI",
+      type: "circleci",
+      buildName: `Workflow #${process.env.CIRCLE_WORKFLOW_ID}`,
+      buildOrder: Number(process.env.CIRCLE_BUILD_NUM) || 1,
+      buildUrl: process.env.CIRCLE_BUILD_URL || ""
+    };
+
+  // Azure Pipelines
+  } else if (process.env.BUILD_BUILDID) {
+    return {
+      name: "Azure Pipelines",
+      type: "azure",
+      buildName: `Build #${process.env.BUILD_BUILDID}`,
+      buildOrder: Number(process.env.BUILD_BUILDID) || 1,
+      buildUrl: process.env.BUILD_BUILDURI || ""
+    };
+
+  // TeamCity
+  } else if (process.env.BUILD_NUMBER && process.env.TEAMCITY_VERSION) {
+    return {
+      name: "TeamCity",
+      type: "teamcity",
+      buildName: `Build #${process.env.BUILD_NUMBER}`,
+      buildOrder: Number(process.env.BUILD_NUMBER) || 1,
+      buildUrl: process.env.BUILD_URL || ""
+    };
+
+  // Travis CI
+  } else if (process.env.TRAVIS_BUILD_NUMBER) {
+    return {
+      name: "Travis CI",
+      type: "travis",
+      buildName: `Build #${process.env.TRAVIS_BUILD_NUMBER}`,
+      buildOrder: Number(process.env.TRAVIS_BUILD_NUMBER) || 1,
+      buildUrl: process.env.TRAVIS_BUILD_WEB_URL || ""
+    };
+
+  // Bamboo
+  } else if (process.env.bamboo_buildNumber) {
+    return {
+      name: "Bamboo",
+      type: "bamboo",
+      buildName: `Build #${process.env.bamboo_buildNumber}`,
+      buildOrder: Number(process.env.bamboo_buildNumber) || 1,
+      buildUrl: process.env.bamboo_resultsUrl || ""
+    };
+
+  // Default fallback (local/manual)
+  } else {
+    return {
+      name: "Local Run",
+      type: "local",
+      buildName: "Manual Execution",
+      buildOrder: 1,
+      buildUrl: ""
+    };
   }
 }
 
+
 function main() {
   if (flags.help) return showHelp();
   if (flags.version) return showVersion();
@@ -237,7 +405,9 @@ function main() {
 
   logPomWarnings();
 
-  const testCoverage = testCoverageCalculation(path.join(process.cwd(), "node_modules", "artes" , "testsStatus"))
+  findDuplicateTestNames();
+
+  const testCoverage = testCoverageCalculation()
 
   const testPercentage = (process.env.PERCENTAGE  ? Number(process.env.PERCENTAGE)  : artesConfig.testPercentage || 0)
 
@@ -266,13 +436,22 @@ if (fs.existsSync(path.join(process.cwd(), "node_modules", "artes" , "@rerun.txt
   });
 }
 
+
+
   if (
     flags.reportWithTrace ||
     artesConfig.reportWithTrace ||
     flags.report ||
     artesConfig.report
-  )
-    generateReport();
+  ){
+    const executor = getExecutor();
+
+fs.writeFileSync(
+  path.join(process.cwd(), "node_modules", "artes",'allure-result',"executor.json"),
+  JSON.stringify(executor, null, 2)
+);
+generateReport();
+  }
 
 
     if (!( process.env.TRACE === "true"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artes",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "description": "The simplest way to automate UI and API tests using Cucumber-style steps.",
   "main": "index.js",
   "scripts": {
@@ -30,7 +30,6 @@
     "dayjs": "1.11.13",
     "deasync": "^0.1.31",
     "playwright": "^1.58.2",
-    "proper-lockfile": "^4.1.2",
     "rimraf": "6.0.1"
   },
   "repository": {

package/src/helper/executers/reportGenerator.js

@@ -30,7 +30,7 @@ function generateReport() {
     );
 
     if (fs.existsSync(moduleConfig.reportPath) && process.env.ZIP === "true") {
-      console.log(`🗜️ Zipping report folder`);
+      console.log(`🗜️ Zipping report folder...`);
 
       const zipPath = path.join(
         path.dirname(moduleConfig.reportPath),

package/src/helper/imports/commons.js

@@ -35,7 +35,7 @@ const moduleConfig = {
   stepsPath: path.join(projectPath, "/tests/steps/*.js"),
   pomPath: path.join(projectPath, "/tests/POMs"),
   cleanUpPaths:
-    "allure-result allure-results test-results @rerun.txt testsStatus pomDuplicateWarnings.json",
+    "allure-result allure-results test-results @rerun.txt test-status null pomDuplicateWarnings.json",
 };
 
 module.exports = {

package/src/hooks/hooks.js

@@ -37,33 +37,10 @@ async function attachResponse(attachFn) {
         ? `${key}:\n${JSON.stringify(value, null, 2)}`
         : `${key}:\n${value}`;
 
-    await attachFn(key, text, "text/plain");
+    await attachFn(key, text, "application/json");
   }
 }
 
-function saveTestStatus(result, pickle) {
-
-  fs.mkdirSync(statusDir, { recursive: true });
-  
-   const now = new Date();
-   const YYYY = now.getFullYear();
-   const MM = String(now.getMonth() + 1).padStart(2, '0');
-   const DD = String(now.getDate()).padStart(2, '0');
-   const hh = String(now.getHours()).padStart(2, '0');
-   const mm = String(now.getMinutes()).padStart(2, '0');
-   const ss = String(now.getSeconds()).padStart(2, '0');
-   const ms = String(now.getMilliseconds()).padStart(3, '0');
-
-   const timestamp = `${YYYY}${MM}${DD}-${hh}${mm}${ss}-${ms}`;
-
-   const fileName = `${result.status}-${pickle.name}-${pickle.id}-${timestamp}.txt`;
-
-   const filePath = path.join(statusDir, fileName);
-
-  fs.writeFileSync(filePath, "");
-
-}
-
 const projectHooksPath = path.resolve(
   moduleConfig.projectPath,
   "tests/steps/hooks.js",
@@ -169,6 +146,10 @@ After(async function ({result, pickle}) {
     await projectHooks.After();
   }
 
+  await attachResponse(allure.attachment);
+  context.response = await {};
+  allure.attachment('Variables', JSON.stringify(context.vars, null, 2), 'application/json')
+
   const shouldReport =
     cucumberConfig.default.successReport || result?.status !== Status.PASSED;
 
@@ -178,7 +159,6 @@ After(async function ({result, pickle}) {
     await allure.attachment("Screenshot", screenshotBuffer, "image/png");
   }
 
-  if(cucumberConfig.default.testPercentage>0) saveTestStatus(result, pickle);
 
   if (cucumberConfig.default.reportWithTrace || cucumberConfig.default.trace) {
     var tracePath = path.join(
@@ -202,8 +182,6 @@ After(async function ({result, pickle}) {
     }
   }
 
-  await attachResponse(allure.attachment);
-  context.response = await {};
 
   await context.page?.close();
   await context.browserContext?.close();

package/src/stepDefinitions/keyboardActions.steps.js

@@ -24,6 +24,7 @@ When(
   "User types {string} by hand in {int} th of {string}",
   async (text, order, elements) => {
     const nthElement = await frame.nth(elements, order);
+    text = resolveVariable(text)
     await nthElement.pressSequentially(text);
   },
 );
@@ -55,6 +56,7 @@ When(
   "User types {string} in {int} th of {string}",
   async (text, order, elements) => {
     const nthElement = await frame.nth(elements, order);
+    text = resolveVariable(text)
     await nthElement.fill(text);
   },
 );
@@ -65,6 +67,7 @@ When(
     const elementCount = await frame.count(selectors);
     value = await resolveVariable(value);
     for (let i = 0; i < elementCount; i++) {
+      value = resolveVariable(value)
       await frame.nth(selectors, i).fill(value);
     }
   },

package/status-formatter.js

@@ -0,0 +1,138 @@
+const { Formatter } = require('@cucumber/cucumber');
+const fs = require('fs');
+const path = require('path');
+
+class StatusFormatter extends Formatter {
+  constructor(options) {
+    super(options);
+
+    const outputDir = './test-status';
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    const workerId = process.env.CUCUMBER_WORKER_ID || '0';
+    this.workerId = workerId;
+    this.outputFile = path.join(outputDir, `test-results-${workerId}.txt`);
+    this.outputDir = outputDir;
+
+    fs.writeFileSync(this.outputFile, '', 'utf8');
+    
+    this.pickles = new Map();
+    this.testCases = new Map();
+    this.testCaseStartedIdToAttempt = new Map();
+
+    const { eventBroadcaster } = options;
+
+    eventBroadcaster.on('envelope', (envelope) => {
+      if (envelope.pickle) {
+        this.pickles.set(envelope.pickle.id, envelope.pickle);
+      }
+
+      if (envelope.testCase) {
+        this.testCases.set(envelope.testCase.id, envelope.testCase);
+      }
+
+      if (envelope.testCaseStarted) {
+        this.testCaseStartedIdToAttempt.set(
+          envelope.testCaseStarted.id,
+          envelope.testCaseStarted.testCaseId
+        );
+      }
+
+      if (envelope.testCaseFinished) {
+        this.handleTestCaseFinished(envelope.testCaseFinished);
+      }
+
+      if (envelope.testRunFinished) {
+        this.handleTestRunFinished();
+      }
+    });
+  }
+
+  getFormattedTimestamp() {
+    const now = new Date();
+    const YYYY = now.getFullYear();
+    const MM = String(now.getMonth() + 1).padStart(2, '0');
+    const DD = String(now.getDate()).padStart(2, '0');
+    const hh = String(now.getHours()).padStart(2, '0');
+    const mm = String(now.getMinutes()).padStart(2, '0');
+    const ss = String(now.getSeconds()).padStart(2, '0');
+    const ms = String(now.getMilliseconds()).padStart(3, '0');
+
+    return `${YYYY}${MM}${DD}-${hh}${mm}${ss}-${ms}`;
+  }
+
+  handleTestCaseFinished(testCaseFinished) {
+    try {
+      const timestamp = this.getFormattedTimestamp();
+      
+      const testCaseId = this.testCaseStartedIdToAttempt.get(
+        testCaseFinished.testCaseStartedId
+      );
+
+      if (!testCaseId) return;
+
+      const testCase = this.testCases.get(testCaseId);
+      if (!testCase) return;
+
+      const pickle = this.pickles.get(testCase.pickleId);
+      if (!pickle) return;
+
+      const testCaseAttempt = this.eventDataCollector.getTestCaseAttempt(
+        testCaseFinished.testCaseStartedId
+      );
+
+      const status = testCaseAttempt?.worstTestStepResult?.status || 'UNKNOWN';
+
+      const info = {
+        name: pickle.name,
+        id: pickle.id,
+        uri: pickle.uri
+      };
+
+      const line = `${timestamp} | ${status.toUpperCase()} | ${info.name} | ${info.id} | ${info.uri}\n`;
+      
+      fs.appendFileSync(this.outputFile, line, 'utf8');
+      
+    } catch (error) {
+      console.error('Error in handleTestCaseFinished:', error);
+    }
+  }
+
+  handleTestRunFinished() {
+    if (this.workerId !== '0') {
+      return;
+    }
+
+    setTimeout(() => {
+      this.mergeResults();
+    }, 1000);
+  }
+
+  mergeResults() {
+    try {
+      const testStatusFile = path.join(this.outputDir, 'test-status.txt');
+      
+      const files = fs.readdirSync(this.outputDir)
+        .filter(f => f.startsWith('test-results-') && f.endsWith('.txt'))
+        .sort();
+
+      if (files.length === 0) {
+        console.log('No result files found to merge');
+        return;
+      }
+
+      const combined = files
+        .map(f => fs.readFileSync(path.join(this.outputDir, f), 'utf8'))
+        .join('');
+
+      fs.writeFileSync(testStatusFile, combined, 'utf8');
+
+    } catch (error) {
+      console.error('Error merging results:', error);
+    }
+  }
+}
+
+module.exports = StatusFormatter;