artes 1.4.4 → 1.4.6

package/README.md

@@ -119,6 +119,7 @@ npx artes [options]
 | 📜 `--stepDef`            | Specify one or more step definition files' relative paths to use (comma-separated) | `artes --stepDef "tests/steps/login.js,tests/steps/home.js"`          |
 | 🔖 `--tags`               | Run tests with specified Cucumber tags                                             | `artes --tags "@smoke or @wip"`                                       |
 | 🌐 `--env`                | Set the environment for the test run                                               | `artes --env "dev"`                                                   |
+| `--saveVar`              |  Set the variables from CLI                                                         | `artes --saveVar '{"armud":20,"banana":200}'` |  
 | 🕶️ `--headless`           | Run browser in headless mode                                                       | `artes --headless`                                                    |
 | ⚡ `--parallel`           | Run tests in parallel mode                                                         | `artes --parallel 2`                                                  |
 | 🔁 `--retry`              | Retry failed tests                                                                 | `artes --retry 3`                                                     |
@@ -482,23 +483,34 @@ You can configure Artes by editing the `artes.config.js` file. Below are the def
 
 | **Option**        | **Default Value**                                                            | **Description**                                               |
 | ----------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------- |
+| `headless`        | `false`                                                                      | Run browser in headless mode.                                 |
+| `env`             | `""`                                                                         | Environment name for tests.                                   |
+| `variables`       | `{}`                                                                         | Variables for tests.                                          |
+| `baseURL`         | `""`                                                                         | Base URL for API or web tests.                                |
 | `timeout`         | `30`                                                                         | Default timeout in seconds.                                   |
-| `slowMo`          | `0`                                                                          | Default slow motion in seconds                                |
+| `slowMo`          | `0`                                                                          | Default slow motion in seconds.                               |
 | `paths`           | `[moduleConfig.featuresPath]`                                                | Paths to feature files.                                       |
 | `require`         | `[moduleConfig.stepsPath, "src/stepDefinitions/*.js", "src/hooks/hooks.js"]` | Support code paths (CommonJS).                                |
 | `pomPath`         | `moduleConfig.pomPath`                                                       | Path to Page Object Models.                                   |
 | `import`          | `[]`                                                                         | Support code paths.                                           |
 | `testPercentage`  | `0`                                                                          | Define test coverage percentage                               |
 | `report`          | `false`                                                                      | Generate report                                               |
-| `reportSuccess`   | `false`                                                                      | Add screenshots and video records for also success test cases |
-| `trace`           | `false`                                                                      | Enable trace                                                  |
-| `reportWithTrace` | `false`                                                                      | Add trace to the report                                       |
+| `zip`             |  `false`                                                                     | Generate zip of report |
+| `reportSuccess`   | `false`                                                                      | Add screenshots and video records also for success test cases |
+| `trace`           | `false`                                                                      | Enable tracing                                                |
+| `reportWithTrace` | `false`                                                                      | Include trace in report                                       |
 | `format`          | `["rerun:@rerun.txt", "allure-cucumberjs/reporter"]`                         | Formatter names/paths.                                        |
 | `formatOptions`   | `{ "resultsDir": "allure-result" }`                                          | Formatter options.                                            |
 | `parallel`        | `1`                                                                          | Number of parallel workers.                                   |
+| `browser`         | `"chrome"`                                                                   | Browser to use: "chrome", "firefox", "webkit".                |
+| `offline`         | `false`                                                                      | Run browser in offline mode.                                  |
+| `device`          | `""`                                                                         | Emulate specific device (e.g., "iPhone 13").                  |
+| `width`           | `1280`                                                                       | Browser width in pixels.                                      |
+| `height`          | `720`                                                                        | Browser height in pixels.                                     |
+| `maximizeScreen`  | `true`                                                                       | Maximize browser window on start.                             |
 | `dryRun`          | `false`                                                                      | Prepare test run without execution.                           |
 | `failFast`        | `false`                                                                      | Stop on first test failure.                                   |
-| `forceExit`       | `false`                                                                      | Force `process.exit()` after tests.                           |
+| `forceExit`       | `false`                                                                      | Force `process.exit()` after tests                            |
 | `strict`          | `true`                                                                       | Fail on pending steps.                                        |
 | `backtrace`       | `false`                                                                      | Show full backtrace for errors.                               |
 | `tags`            | `""`                                                                         | Tag expression to filter scenarios.                           |

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)
@@ -51,6 +51,25 @@ function resolveEnv(artesConfig) {
 }
 const env = resolveEnv(artesConfig);
 
+function loadVariables(cliVariables, artesConfigVariables) {
+
+  if (cliVariables) {
+    try {
+      cliVariables = JSON.parse(cliVariables);
+    } catch (err) {
+      console.error("Invalid JSON in process.env.VARS:", process.env.VARS);
+      envVars = {};
+    }
+  }
+
+  const mergedVars = {
+    ...(artesConfigVariables || {}),
+    ...cliVariables,
+  };
+
+  return mergedVars;
+}
+
 const resolveFeaturePaths = (basePath, value) => {
   return value
     .split(',')
@@ -162,6 +181,7 @@ module.exports = {
     zip: process.env.ZIP == "true" ? true : artesConfig.zip ? true : false,
   },
   env: env,
+  variables: loadVariables(process.env.VARS, artesConfig.variables),
   baseURL: process.env.BASE_URL
     ? JSON.parse(process.env.BASE_URL)
     : artesConfig?.baseURL

package/executer.js

@@ -10,17 +10,23 @@ const {
 const { logPomWarnings } = require("./src/helper/controller/pomCollector");
 const fs = require("fs");
 const path = require("path");
+const { spawnSync } = require("child_process");
 
-const configPath = path.resolve(process.cwd(), "artes.config.js");
+const artesConfigPath = path.resolve(process.cwd(), "artes.config.js");
 
 let artesConfig = {};
 
-if (fs.existsSync(configPath)) {
-  artesConfig = require(configPath);
+if (fs.existsSync(artesConfigPath)) {
+  artesConfig = require(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"),
@@ -37,6 +43,7 @@ const flags = {
   stepDef: args.includes("--stepDef"),
   tags: args.includes("--tags"),
   env: args.includes("--env"),
+  saveVar: args.includes("--saveVar"),
   headless: args.includes("--headless"),
   parallel: args.includes("--parallel"),
   retry: args.includes("--retry"),
@@ -54,25 +61,30 @@ const flags = {
   slowMo: args.includes("--slowMo"),
 };
 
-const env = args[args.indexOf("--env") + 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) : "";
 
+vars ? (process.env.VARS = vars) : "";
+
 flags.reportWithTrace ||
 artesConfig.reportWithTrace ||
 flags.report ||
@@ -146,6 +158,140 @@ flags.timeout ? (process.env.TIMEOUT = timeout) : "";
 
 flags.slowMo ? (process.env.SLOWMO = slowMo) : "";
 
+
+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 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');
+  
+  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
+      ])
+    )
+  };
+}
+
 function main() {
   if (flags.help) return showHelp();
   if (flags.version) return showVersion();
@@ -155,6 +301,37 @@ function main() {
 
   logPomWarnings();
 
+  findDuplicateTestNames();
+
+  const testCoverage = testCoverageCalculation()
+
+  const testPercentage = (process.env.PERCENTAGE  ? Number(process.env.PERCENTAGE)  : artesConfig.testPercentage || 0)
+
+  if (testPercentage > 0) {
+
+    const meetsThreshold = testCoverage.percentage >= testPercentage
+
+    if (meetsThreshold) {
+      console.log(
+        `✅ Tests passed required ${testPercentage}% success rate with ${testCoverage.percentage.toFixed(2)}%!`,
+      );
+      process.env.EXIT_CODE = parseInt(0, 10);
+    } else {
+      console.log(
+        `❌ Tests failed required ${testPercentage}% success rate with ${testCoverage.percentage.toFixed(2)}%!`,
+      );
+      process.env.EXIT_CODE = parseInt(1, 10);
+    }
+  }
+
+if (fs.existsSync(path.join(process.cwd(), "node_modules", "artes" , "@rerun.txt"))) {
+  spawnSync("mv", ["@rerun.txt", process.cwd()], {
+    cwd: path.join(process.cwd(), "node_modules", "artes"),
+    stdio: "inherit",
+    shell: true,
+  });
+}
+
   if (
     flags.reportWithTrace ||
     artesConfig.reportWithTrace ||
@@ -163,18 +340,25 @@ function main() {
   )
     generateReport();
 
-  if (
-    fs.existsSync(
-      path.join(process.cwd(), "node_modules", "artes", "EXIT_CODE.txt"),
-    )
-  ) {
-    const data = fs.readFileSync(
-      path.join(process.cwd(), "node_modules", "artes", "EXIT_CODE.txt"),
-      "utf8",
-    );
-    process.env.EXIT_CODE = parseInt(data, 10);
-  }
 
+    if (!( process.env.TRACE === "true"
+      ? process.env.TRACE
+      : artesConfig.trace || false)) {
+      spawnSync(
+        "npx",
+        [
+          "rimraf",
+          "--no-glob",
+          path.join(process.cwd(), "traces"),
+        ],
+        {
+          cwd: process.cwd(),
+          stdio: "inherit",
+          shell: false,
+        },
+      );
+    }
+    
   cleanUp();
   process.exit(process.env.EXIT_CODE);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artes",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "description": "The simplest way to automate UI and API tests using Cucumber-style steps.",
   "main": "index.js",
   "scripts": {

package/src/helper/executers/helper.js

@@ -54,6 +54,9 @@ function showHelp() {
       
             🌐 --env           Set environment for the test run
                 Usage:   artes --env "dev"
+
+            --saveVar         Set variables from cli
+                        artes --saveVar '{"armud":20,"banana":200}'
       
             🕶️ --headless      Run browser in headless mode
                 Usage:   artes --headless

package/src/helper/executers/projectCreator.js

@@ -47,6 +47,7 @@ function createProject(createYes, noDeps) {
 
     // Configuration options:
     // env: "",                      // string - Environment name for tests
+    // variables: {}                 // object - Variables for tests
     // testPercentage: 0,            // number - Minimum success rate percentage(Default: 0)
     // baseURL: "",                  // string - Base URL for API tests
     // paths: [],                    // string[] - Paths to feature files
@@ -56,6 +57,7 @@ function createProject(createYes, noDeps) {
     // slowMo: 0,                    // number - Slow down test execution (Default: 0 seconds)
     // parallel: 0,                  // number - Number of parallel workers
     // report: true                  // boolean - Generate report
+    // zip: false                    // boolean - Generate zip of report
     // reportSuccess: false,         // boolean - Add screenshots and video records to report also for success test cases
     // trace: false,                 // boolean - Enable tracing
     // reportWithTrace: false,       // boolean - Include trace in report

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 EXIT_CODE.txt pomDuplicateWarnings.json",
+    "allure-result allure-results test-results @rerun.txt test-status null pomDuplicateWarnings.json",
 };
 
 module.exports = {

package/src/hooks/hooks.js

@@ -8,18 +8,16 @@ const {
   BeforeStep,
   AfterAll,
 } = require("@cucumber/cucumber");
-const { spawnSync } = require("child_process");
 const { invokeBrowser } = require("../helper/contextManager/browserManager");
 const { invokeRequest } = require("../helper/contextManager/requestManager");
 const {
-  pomCollector,
-  logPomWarnings,
+  pomCollector
 } = require("../helper/controller/pomCollector");
 const cucumberConfig = require("../../cucumber.config");
 const { context } = require("./context");
 const fs = require("fs");
 const path = require("path");
-const { moduleConfig } = require("artes/src/helper/imports/commons");
+const { moduleConfig, saveVar } = require("artes/src/helper/imports/commons");
 require("allure-cucumberjs");
 const allure = require("allure-js-commons");
 
@@ -43,14 +41,6 @@ async function attachResponse(attachFn) {
   }
 }
 
-function saveTestStatus(result, pickle) {
-  fs.mkdirSync(statusDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(statusDir, `${result.status}-${pickle.id}.txt`),
-    "",
-  );
-}
-
 const projectHooksPath = path.resolve(
   moduleConfig.projectPath,
   "tests/steps/hooks.js",
@@ -81,6 +71,15 @@ BeforeAll(async () => {
 Before(async function ({pickle}) {
   context.vars = {};
 
+  const vars = await cucumberConfig.variables
+
+  if (vars && typeof vars === "object") {
+    for (let [key, value] of Object.entries(vars)) {
+
+       saveVar(value, key);
+    }
+  }
+
   const envFilePath = path.join(
     moduleConfig.projectPath,
     "tests",
@@ -142,7 +141,7 @@ AfterStep(async function ({ pickleStep }) {
   }
 });
 
-After(async function ({ pickle, result }) {
+After(async function ({result, pickle}) {
   if (typeof projectHooks.After === "function") {
     await projectHooks.After();
   }
@@ -156,12 +155,11 @@ After(async function ({ pickle, result }) {
     await allure.attachment("Screenshot", screenshotBuffer, "image/png");
   }
 
-  saveTestStatus(result, pickle);
 
   if (cucumberConfig.default.reportWithTrace || cucumberConfig.default.trace) {
     var tracePath = path.join(
       moduleConfig.projectPath,
-      `./traces/${pickle.name.replaceAll(" ", "_")}.zip`,
+      `./traces/${pickle.name.replaceAll(" ", "_")}-${pickle.id}.zip`,
     );
   }
 
@@ -212,55 +210,4 @@ AfterAll(async () => {
     await projectHooks.AfterAll();
   }
 
-  logPomWarnings();
-
-  if (!cucumberConfig.default.trace) {
-    spawnSync(
-      "npx",
-      [
-        "rimraf",
-        "--no-glob",
-        path.join(moduleConfig.projectPath, "./traces"),
-      ],
-      {
-        cwd: moduleConfig.projectPath,
-        stdio: "inherit",
-        shell: false,
-      },
-    );
-  }
-
-  if (!fs.existsSync(statusDir)) return;
-
-  const files = fs.readdirSync(statusDir);
-  const passedCount = files.filter((f) => f.split("-")[0] === "PASSED").length;
-  const totalTests = files.length;
-  const successPercentage = (passedCount / totalTests) * 100;
-
-  const failed = files.filter((f) => f.split("-")[0] === "FAILED").length;
-
-  if (failed > 0) {
-    spawnSync("mv", ["@rerun.txt", moduleConfig.projectPath], {
-      cwd: path.join(moduleConfig.projectPath, "node_modules", "artes"),
-      stdio: "ignore",
-      shell: true,
-    });
-  }
-
-  if (cucumberConfig.default.testPercentage > 0) {
-    const meetsThreshold =
-      successPercentage >= cucumberConfig.default.testPercentage;
-
-    if (meetsThreshold) {
-      console.log(
-        `✅ Tests passed required ${cucumberConfig.default.testPercentage}% success rate with ${successPercentage.toFixed(2)}%!`,
-      );
-      fs.writeFileSync(path.join(process.cwd(), "EXIT_CODE.txt"), "0");
-    } else {
-      console.log(
-        `❌ Tests failed required ${cucumberConfig.default.testPercentage}% success rate with ${successPercentage.toFixed(2)}%!`,
-      );
-      fs.writeFileSync(path.join(process.cwd(), "EXIT_CODE.txt"), "1");
-    }
-  }
 });

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;