artes 1.5.2 → 1.5.4

package/cucumber.config.js

@@ -14,7 +14,7 @@ try {
   console.log("Proceeding with default config.");
 }
 
-const defaultFormats = ["rerun:@rerun.txt",  "progress-bar", './status-formatter.js:null'];
+const defaultFormats = ["rerun:@rerun.txt",  "progress-bar", './src/helper/controller/status-formatter.js:null'];
 
 const userFormatsFromEnv = process.env.REPORT_FORMAT
   ? JSON.parse(process.env.REPORT_FORMAT)

package/executer.js

@@ -10,6 +10,10 @@ const {
 const { logPomWarnings } = require("./src/helper/controller/pomCollector");
 const fs = require("fs");
 const path = require("path");
+const { testCoverageCalculator } = require("./src/helper/controller/testCoverageCalculator");
+const { getExecutor } = require("./src/helper/controller/getExecutor");
+const { findDuplicateTestNames } = require("./src/helper/controller/findDuplicateTestNames");
+
 
 const artesConfigPath = path.resolve(process.cwd(), "artes.config.js");
 
@@ -168,242 +172,6 @@ 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 getExecutor() {
-
-  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}`
-    };
-
-
-  } 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 || ""
-    };
-
-
-  } 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 || ""
-    };
-
-
-  } 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 || ""
-    };
-
-
-  } 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 || ""
-    };
-
-
-  } 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 || ""
-    };
-
-
-  } 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 || ""
-    };
-
-
-  } 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 || ""
-    };
-
-
-  } 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 || ""
-    };
-
-
-  } else {
-    return {
-      name: "Local Run",
-      type: "local",
-      buildName: "Manual Execution",
-      buildOrder: 1,
-      buildUrl: ""
-    };
-  }
-}
-
 
 function main() {
   if (flags.help) return showHelp();
@@ -416,7 +184,7 @@ function main() {
 
   findDuplicateTestNames();
 
-  const testCoverage = testCoverageCalculation()
+  const testCoverage = testCoverageCalculator()
 
   const testPercentage = (process.env.PERCENTAGE  ? Number(process.env.PERCENTAGE)  : artesConfig.testPercentage || 0)
 

package/package.json

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

package/src/helper/controller/findDuplicateTestNames.js

@@ -0,0 +1,54 @@
+const fs = require("fs");
+const path = require("path");
+
+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;
+  }
+
+module.exports = {findDuplicateTestNames}

package/src/helper/controller/getExecutor.js

@@ -0,0 +1,104 @@
+function getExecutor() {
+
+    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}`
+      };
+  
+  
+    } 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 || ""
+      };
+  
+  
+    } 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 || ""
+      };
+  
+  
+    } 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 || ""
+      };
+  
+  
+    } 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 || ""
+      };
+  
+  
+    } 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 || ""
+      };
+  
+  
+    } 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 || ""
+      };
+  
+  
+    } 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 || ""
+      };
+  
+  
+    } 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 || ""
+      };
+  
+  
+    } else {
+      return {
+        name: "Local Run",
+        type: "local",
+        buildName: "Manual Execution",
+        buildOrder: 1,
+        buildUrl: ""
+      };
+    }
+  }
+
+module.exports = { getExecutor };

package/src/helper/controller/reportCustomizer.js

@@ -39,16 +39,29 @@ function applyLogo(cucumberConfig, report, today, reportName, logoBuffer, logoMi
   const logoBase64 = logoBuffer.toString("base64");
   const logoDataUrl = `data:${logoMime};base64,${logoBase64}`;
 
+  const testPercentage = cucumberConfig.default?.testPercentage ?? 0;
+  let testCoverageWidgetCss = "";
+
+  if (testPercentage > 0) {
+    const { testCoverageCalculator } = require("./testCoverageCalculator");
+    const testCoverage = testCoverageCalculator();
+
+    if (testCoverage) {
+      const meetsThreshold = testCoverage.percentage >= testPercentage;
+
+      testCoverageWidgetCss = generateTestCoverageWidgetCss(testCoverage, testPercentage, meetsThreshold);
+    }
+  }
+
   if (cucumberConfig.report.singleFileReport) {
     const htmlPath = path.resolve(__dirname, "../../../../../report/index.html");
     const srcCssPath = path.resolve(__dirname, "../../../assets/styles.css");
 
-    const dynamicCss = generateCss(report, today, reportName, logoDataUrl);
+    const dynamicCss = generateCss(report, today, reportName, logoDataUrl) + (testCoverageWidgetCss ? "\n" + testCoverageWidgetCss : "");
     const modifiedCss = injectCssAndReturn(srcCssPath, dynamicCss);
     const cssBase64 = Buffer.from(modifiedCss).toString("base64");
     const cssDataUrl = `data:text/css;base64,${cssBase64}`;
 
-
     updateSingleFileHtml(htmlPath, report, reportName, faviconDataUrl, cssDataUrl);
 
   } else {
@@ -57,13 +70,10 @@ function applyLogo(cucumberConfig, report, today, reportName, logoBuffer, logoMi
     const reportDir = path.resolve(__dirname, "../../../../../report");
     const reportCssPath = path.join(reportDir, "styles.css");
 
-
     const logoDest = path.join(reportDir, logoFilename);
     fs.writeFileSync(logoDest, logoBuffer);
 
-
-    const dynamicCss = generateCss(report, today, reportName, logoFilename);
-
+    const dynamicCss = generateCss(report, today, reportName, logoFilename) + (testCoverageWidgetCss ? "\n" + testCoverageWidgetCss : "");
     const modifiedCss = injectCssAndReturn(srcCssPath, dynamicCss);
     fs.writeFileSync(reportCssPath, modifiedCss, "utf8");
 
@@ -71,6 +81,193 @@ function applyLogo(cucumberConfig, report, today, reportName, logoBuffer, logoMi
   }
 }
 
+function generateTestCoverageWidgetCss(testCoverage, testPercentage, meetsThreshold) {
+  const fill        = Math.min(testCoverage.percentage, 100);
+  const fillPct     = fill.toFixed(4);
+  const pctLabel    = testCoverage.percentage.toFixed(2);
+  const statusColor = meetsThreshold ? "#4caf50" : "#f44336";
+  const statusBg    = meetsThreshold ? "rgba(76,175,80,.13)" : "rgba(244,67,54,.13)";
+  const statusVerb  = meetsThreshold ? "passed" : "failed";
+  const subtitleTxt = `${testCoverage.passed} / ${testCoverage.totalTests} passed`;
+  const statusLine  = `Tests ${statusVerb} \u2014 required ${testPercentage}% with ${pctLabel}%`;
+
+
+  const r1 = (fill * 0.35).toFixed(2);
+  const r2 = (fill * 0.60).toFixed(2);
+  const tm = testPercentage;
+
+  const barGradient = `linear-gradient(to right, #f44336 0%, #ff9800 35%, #ffeb3b 60%, #4caf50 100%)`;
+  const pointerX = `${fillPct}%`;
+  const svgLabels = [
+    { val: "0",   x: "0%",   anchor: "start"  },
+    { val: "20",  x: "20%",  anchor: "middle" },
+    { val: "40",  x: "40%",  anchor: "middle" },
+    { val: "60",  x: "60%",  anchor: "middle" },
+    { val: "80",  x: "80%",  anchor: "middle" },
+    { val: "100", x: "100%", anchor: "end"    },
+  ];
+
+  const labelNodes = svgLabels
+    .map(l => `<text x="${l.x}" y="10" text-anchor="${l.anchor}" font-family="sans-serif" font-size="10" fill="#bbb">${l.val}</text>`)
+    .join("");
+
+   const pointerColor = meetsThreshold ? "#4caf50" : "#f44336";
+  const px = (fill * 10).toFixed(1);
+
+  const labelPointerSvg = `<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="18">
+    <text x="${fillPct}%" y="14" text-anchor="middle" font-family="sans-serif" font-size="11" font-weight="700" fill="${pointerColor}">${pctLabel}%</text>
+  </svg>`;
+
+  const stemSvg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 18" preserveAspectRatio="none" width="100%" height="18">
+    <line x1="${px}" y1="6" x2="${px}" y2="10" stroke="${pointerColor}" stroke-width="6"/>
+    <polygon points="${parseFloat(px)-12},8 ${parseFloat(px)+12},8 ${parseFloat(px)},18" fill="${pointerColor}"/>
+  </svg>`;
+
+  const labelPointerB64 = Buffer.from(labelPointerSvg).toString("base64");
+  const labelPointerDataUrl = `data:image/svg+xml;base64,${labelPointerB64}`;
+  const stemB64 = Buffer.from(stemSvg).toString("base64");
+  const stemDataUrl = `data:image/svg+xml;base64,${stemB64}`;
+
+  const pointerDataUrl = stemDataUrl; 
+  const pointerLabelDataUrl = labelPointerDataUrl;
+
+  const labelSvg = `<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="14">${labelNodes}</svg>`;
+
+  const svgB64 = Buffer.from(labelSvg).toString("base64");
+  const svgDataUrl = `data:image/svg+xml;base64,${svgB64}`;
+
+  const CARD_H            = 180;
+  const TITLE_PAD         = 14;
+  const POINTER_FROM_CARD = 62;
+  const BAR_FROM_CARD     = 98;
+  const LABEL_FROM_CARD   = 116;
+  const STATUS_FROM_CARD  = 138;
+
+  return `
+/* ── ARTES TEST COVERAGE WIDGET ─────────────────────────────────────────── */
+
+[data-id="summary"] {
+  margin-bottom: ${CARD_H + 22}px !important;
+  position: relative;
+}
+
+/* 1. Card shell + "TEST COVERAGE" title — 21px black */
+[data-id="summary"]::after {
+  content: 'TEST COVERAGE';
+  position: absolute;
+  top: calc(100% + 10px);
+  left: 0;
+  right: 0;
+  height: ${CARD_H}px;
+  background: #fff;
+  border-radius: 3px;
+  box-shadow: 0 1px 3px rgba(0,0,0,.15);
+  padding: ${TITLE_PAD}px 16px 0;
+  box-sizing: border-box;
+  font-size: 21px;
+  font-weight: 100;
+  color: #000;
+  text-transform: uppercase;
+  line-height: 1.4;
+  pointer-events: none;
+  z-index: 1;
+}
+
+/* 2. "1 / 1 passed   100.00%" — subtitle + percentage on same line */
+[data-id="summary"] .widget__body > div {
+  position: relative;
+}
+
+[data-id="summary"] .widget__body > div::before {
+  content: '${subtitleTxt}     ${pctLabel}%';
+  position: absolute;
+  top: calc(100% + 10px + 46px);
+  left: 0;
+  font-size: 14px;
+  font-weight: 400;
+  color: #999;
+  line-height: 1;
+  letter-spacing: 0;
+  pointer-events: none;
+  z-index: 2;
+}
+
+/* 3. Pointer + threshold marker layered in one element */
+[data-id="summary"] .widget__body > div > *:first-child {
+  position: relative;
+}
+
+[data-id="summary"] .widget__body > div > *:first-child::after {
+  content: '';
+  position: absolute;
+  top: calc(100% + 10px + ${POINTER_FROM_CARD}px);
+  left: 16px;
+  right: 16px;
+  height: 36px;
+  background-image: url("${pointerLabelDataUrl}"), url("${pointerDataUrl}");
+  background-repeat: no-repeat;
+  background-size: 100% 50%, 100% 50%;
+  background-position: top, bottom;
+  pointer-events: none;
+  z-index: 3;
+}
+
+/* 4. SVG label row — perfectly aligned under bar via background-image */
+[data-id="summary"] .widget__body > div::after {
+  content: '';
+  position: absolute;
+  top: calc(100% + 10px + ${LABEL_FROM_CARD}px);
+  left: 16px;
+  right: 16px;
+  height: 14px;
+  background-image: url("${svgDataUrl}");
+  background-repeat: no-repeat;
+  background-size: 100% 100%;
+  pointer-events: none;
+  z-index: 2;
+}
+
+/* 5. Gradient bar */
+[data-id="summary"] .widget__body {
+  position: static;
+}
+
+[data-id="summary"] .widget__body::before {
+  content: '';
+  position: absolute;
+  top: calc(100% + 10px + ${BAR_FROM_CARD}px);
+  left: 16px;
+  right: 16px;
+  height: 14px;
+  border-radius: 7px;
+  background: ${barGradient};
+  box-shadow: inset 0 1px 3px rgba(0,0,0,.12);
+  pointer-events: none;
+  z-index: 2;
+}
+
+/* 5. Status pill */
+[data-id="summary"] .widget__body::after {
+  content: '${statusLine}';
+  position: absolute;
+  top: calc(100% + 10px + ${STATUS_FROM_CARD}px);
+  left: 16px;
+  right: 16px;
+  font-size: 12px;
+  font-weight: 500;
+  color: ${statusColor};
+  background: ${statusBg};
+  padding: 5px 10px;
+  border-radius: 3px;
+  box-sizing: border-box;
+  pointer-events: none;
+  z-index: 2;
+}
+
+/* ── End ARTES TEST COVERAGE WIDGET ─────────────────────────────────────── */
+`;
+}
+
 function resolveLogoPath(logoConfig) {
   if (!logoConfig) {
     return defaultLogoPath();
@@ -81,7 +278,7 @@ function resolveLogoPath(logoConfig) {
     : path.resolve(process.cwd(), logoConfig);
 
   if (!fs.existsSync(resolved)) {
-    console.warn(`[artes] Warning: logo not found at "${resolved}". Falling back to default logo.`);
+   // console.warn(`[artes] Warning: logo not found at "${resolved}". Falling back to default logo.`);
     return defaultLogoPath();
   }
 
@@ -111,7 +308,6 @@ function fetchRemoteLogo(url, redirectCount = 0) {
     const client = url.startsWith("https://") ? https : http;
 
     client.get(url, (res) => {
-
       if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location) {
         return fetchRemoteLogo(res.headers.location, redirectCount + 1).then(resolve).catch(reject);
       }
@@ -125,7 +321,7 @@ function fetchRemoteLogo(url, redirectCount = 0) {
       const mime = contentType.split(";")[0].trim();
 
       if (!mime.startsWith("image/")) {
-        res.resume(); 
+        res.resume();
         return reject(new Error(`URL did not return an image (Content-Type: "${mime || "unknown"}"). Make sure the URL points directly to an image file.`));
       }
 
@@ -185,7 +381,6 @@ function updateSingleFileHtml(htmlPath, report, reportName, faviconDataUrl, cssD
 function updateHtml(htmlPath, report, reportName, faviconDataUrl) {
   let html = fs.readFileSync(htmlPath, "utf8");
   html = html.replace(/<title>.*?<\/title>/, `<title>ARTES REPORT</title>`);
-
   html = html.replace(/<link rel="icon" href=".*?">/, `<link rel="icon" href="${faviconDataUrl}">`);
   fs.writeFileSync(htmlPath, html, "utf8");
 }

package/src/helper/controller/testCoverageCalculator.js

@@ -0,0 +1,86 @@
+const fs = require("fs");
+const path = require("path");
+
+function testCoverageCalculator() {
+
+    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
+        ])
+      )
+    };
+  }
+
+module.exports = { testCoverageCalculator };

package/src/hooks/hooks.js

@@ -197,38 +197,37 @@ After(async function ({result, pickle}) {
     context.page.url() !== "about:blank"
   ) {
     const video = context.page.video();
-    if (video) {
-      const videoPath = await video.path();
-
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-
-      if (fs.existsSync(videoPath)) {
-        const trimmedPath = videoPath.replace('.webm', '-trimmed.webm');
-        
-        const isTimeoutError = result.message?.includes('Error: function timed out, ensure the promise resolves within')
-        const webmBuffer = fs.readFileSync(videoPath);
-        await allure.attachment("Screenrecord", webmBuffer, "video/webm");
-        if (isTimeoutError) {
-          const duration = parseFloat(
-            execSync(`"${ffprobe.path}" -v error -show_entries format=duration -of csv=p=0 "${videoPath}"`).toString().trim()
-          );
-        
-          const timeoutSeconds = cucumberConfig.default.timeout / 1000; 
-          const newDuration = Math.max(duration - timeoutSeconds + 3, 1);
-        
-         execSync(`"${ffmpegPath}" -loglevel quiet -i "${videoPath}" -t ${newDuration} -c copy "${trimmedPath}" -y`);
-
-          const webmBuffer = fs.readFileSync(trimmedPath);
-          await allure.attachment("Screenrecord", webmBuffer, "video/webm");
-        } else {
-
-          const webmBuffer = fs.readFileSync(videoPath);
-          await allure.attachment("Screenrecord", webmBuffer, "video/webm");
-        }
-      }
 
+if (video) {
+  const videoPath = await video.path();
+
+  await new Promise((resolve) => setTimeout(resolve, 1000));
+
+  if (fs.existsSync(videoPath)) {
+    const trimmedPath = videoPath.replace('.webm', '-trimmed.webm');
+    
+    const isTimeoutError = result.message?.includes('Error: function timed out, ensure the promise resolves within');
+
+    if (isTimeoutError) {
+      const duration = parseFloat(
+        execSync(`"${ffprobe.path}" -v error -show_entries format=duration -of csv=p=0 "${videoPath}"`).toString().trim()
+      );
+    
+      const timeoutSeconds = cucumberConfig.default.timeout / 1000; 
+      const newDuration = Math.max(duration - timeoutSeconds + 3, 1);
+    
+      execSync(`"${ffmpegPath}" -loglevel quiet -i "${videoPath}" -t ${newDuration} -c copy "${trimmedPath}" -y`);
+
+      const webmBuffer = fs.readFileSync(trimmedPath);
+      await allure.attachment("Screenrecord", webmBuffer, "video/webm");
+    } else {
+      const webmBuffer = fs.readFileSync(videoPath);
+      await allure.attachment("Screenrecord", webmBuffer, "video/webm");
     }
   }
+}
+
+  }
 });
 
 AfterAll(async () => {