artes 1.1.20 → 1.1.23

package/README.md

@@ -50,6 +50,8 @@ npx artes [options]
 | ✅ `-y, --yes`     | Skip the confirmation prompt when creating an example project                      | `artes -c -y` or `artes --create --yes`                               |
 | 📊 `-r, --report`  | Run tests and generate Allure report                                               | `artes -r` or `artes --report`                                        |
 | `--reportSuccess`  | Add screenshots and video records for also Success test cases                      | `artes --reportSuccess`                                               |
+| `--trace`          |  Enable tracing | `artes --trace `                                                 |
+| `-rwt, --reportWithTrace` | Add trace to the report                                                     | ` artes -rwt ` or `artes --reportWithTrace`|
 | 📁 `--features`    | Specify one or more feature files' relative paths to run (comma-separated)         | `artes --features "tests/features/Alma,tests/features/Banan.feature"` |
 | 📜 `--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"`                                       |
@@ -295,7 +297,10 @@ You can configure Artes by editing the `artes.config.js` file. Below are the def
 | `pomPath`         | `moduleConfig.pomPath`                                                       | Path to Page Object Models.                                   |
 | `import`          | `[]`                                                                         | Support code paths.                                           |
 | `testPercentage`  | `0`                                                                          | Define test coverage percentage                               |
-| `reportSuccess`   | `true`                                                                       | Add screenshots and video records for also success test cases |
+| `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                                       | 
 | `format`          | `["rerun:@rerun.txt", "allure-cucumberjs/reporter"]`                         | Formatter names/paths.                                        |
 | `formatOptions`   | `{ "resultsDir": "allure-result" }`                                          | Formatter options.                                            |
 | `parallel`        | `1`                                                                          | Number of parallel workers.                                   |

package/cucumber.config.js

@@ -58,10 +58,23 @@ module.exports = {
       : moduleConfig.pomPath,
     import: artesConfig.import || [], // Support code paths
 
+    report:
+      process.env.REPORT_WITH_TRACE ??
+      artesConfig.reportWithTrace ??
+      process.env.REPORT ??
+      artesConfig.report ??
+      false, // Generate report
     // Formatting and output
     successReport: process.env.REPORT_SUCCESS
       ? true
       : artesConfig.reportSuccess || false, // Include successful tests in report
+
+    trace: process.env.TRACE ? process.env.TRACE : artesConfig.trace || false, // Enable tracing
+
+    reportWithTrace: process.env.REPORT_WITH_TRACE
+      ? process.env.REPORT_WITH_TRACE
+      : artesConfig.reportWithTrace || false, // Include trace in report
+
     format: finalFormats, // Formatter names/paths
     formatOptions: artesConfig.formatOptions || {
       resultsDir: `allure-result`,

package/executer.js

@@ -7,6 +7,7 @@ const {
   generateReport,
   cleanUp,
 } = require("./src/helper/executers/exporter");
+const artesConfig = require("../../artes.config");
 const fs = require("fs");
 const path = require("path");
 
@@ -20,6 +21,7 @@ const flags = {
   report: args.includes("-r") || args.includes("--report"),
   reportSuccess: args.includes("--reportSuccess"),
   trace: args.includes("-t") || args.includes("--trace"),
+  reportWithTrace: args.includes("-rwt") || args.includes("--reportWithTrace"),
   features: args.includes("--features"),
   stepDef: args.includes("--stepDef"),
   tags: args.includes("--tags"),
@@ -56,7 +58,10 @@ const slowMo = args[args.indexOf("--slowMo") + 1];
 flags.env && console.log("Running env:", env);
 flags.env ? (process.env.ENV = JSON.stringify(env)) : "";
 
-flags.report
+flags.reportWithTrace ||
+artesConfig.reportWithTrace ||
+flags.report ||
+artesConfig.report
   ? (process.env.REPORT_FORMAT = JSON.stringify([
       "allure-cucumberjs/reporter:./allure-results",
     ]))
@@ -73,8 +78,12 @@ flags.features ? (process.env.FEATURES = features) : "";
 flags.stepDef && console.log("Running step definitions:", flags.stepDef);
 flags.stepDef ? (process.env.STEP_DEFINITIONS = stepDef) : "";
 
+flags.report ? (process.env.REPORT = true) : "";
+
 flags.trace ? (process.env.TRACE = true) : "";
 
+flags.reportWithTrace ? (process.env.REPORT_WITH_TRACE = true) : "";
+
 flags.headless &&
   console.log("Running mode:", flags.headless ? "headless" : "headed");
 flags.headless ? (process.env.MODE = JSON.stringify(true)) : false;
@@ -112,27 +121,21 @@ function main() {
   if (flags.create) return createProject(flags.createYes);
 
   runTests();
-  if (flags.report) generateReport();
+  if (
+    flags.reportWithTrace ||
+    artesConfig.reportWithTrace ||
+    flags.report ||
+    artesConfig.report
+  )
+    generateReport();
 
   if (
     fs.existsSync(
-      path.join(
-        process.cwd(),
-        "node_modules",
-        "artes",
-        "testsStatus",
-        "EXIT_CODE.txt",
-      ),
+      path.join(process.cwd(), "node_modules", "artes", "EXIT_CODE.txt"),
     )
   ) {
     const data = fs.readFileSync(
-      path.join(
-        process.cwd(),
-        "node_modules",
-        "artes",
-        "testsStatus",
-        "EXIT_CODE.txt",
-      ),
+      path.join(process.cwd(), "node_modules", "artes", "EXIT_CODE.txt"),
       "utf8",
     );
     process.env.EXIT_CODE = parseInt(data, 10);

package/package.json

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

package/src/helper/executers/helper.js

@@ -27,6 +27,12 @@ function showHelp() {
 
             ✅ --reportSuccess Generate screenshot and video record with also successful tests
                 Usage:   artes --reportSuccess
+
+            --trace         Enable tracing for all tests
+                Usage:   artes --trace
+            
+            -rwt, --reportWithTrace Include trace in the report
+                Usage:   artes --reportWithTrace
       
             📁 --features      Specify one or more feature files' relative paths to run (comma-separated)
                 Usage:   artes --features "tests/features/Alma, tests/features/Banan.feature"

package/src/helper/executers/projectCreator.js

@@ -48,7 +48,10 @@ function createProject(createYes) {
     // timeout : 0,                  // number - Test timeout in seconds
     // slowMo: 0,                    // number - Slow down test execution (Default: 0 seconds)
     // parallel: 0,                  // number - Number of parallel workers
+    //report: true                   / boolean - Generate 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
     // format: [],                   // string[] - Formatter names/paths
     // formatOptions: {},            // object - Formatter options    
     // retry: 0,                     // number - Retry attempts for failing tests

package/src/helper/executers/reportGenerator.js

@@ -8,7 +8,7 @@ function generateReport() {
     spawnSync("npm", ["run", "testWithReport", moduleConfig.reportPath], {
       cwd: moduleConfig.modulePath,
       stdio: "ignore",
-      shell: true,
+      shell: true
     });
 
     console.log(

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

package/src/hooks/hooks.js

@@ -8,20 +8,47 @@ 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 } = require("../helper/controller/pomCollector");
 const cucumberConfig = require("../../cucumber.config");
 const { context } = require("./context");
 const fs = require("fs");
-const { moduleConfig } = require("artes/src/helper/imports/commons");
 const path = require("path");
+const { moduleConfig } = require("artes/src/helper/imports/commons");
 
 const statusDir = path.join(process.cwd(), "testsStatus");
+const HTTP_METHODS = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE"];
 
 setDefaultTimeout(cucumberConfig.default.timeout);
 
-BeforeAll(async function () {
+/* ------------------- Helpers ------------------- */
+
+async function attachResponse(attachFn) {
+  if (!context.response) return;
+
+  for (const [key, value] of Object.entries(context.response)) {
+    const text =
+      typeof value === "object"
+        ? `${key}:\n${JSON.stringify(value, null, 2)}`
+        : `${key}:\n${value}`;
+
+    await attachFn(text, "text/plain");
+  }
+}
+
+function saveTestStatus(result, pickle) {
+  fs.mkdirSync(statusDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(statusDir, `${result.status}-${pickle.id}.txt`),
+    "",
+  );
+}
+
+/* ------------------- Hooks ------------------- */
+
+BeforeAll(() => {
   pomCollector();
 });
 
@@ -38,130 +65,135 @@ Before(async function () {
 
   await context.page.setDefaultTimeout(cucumberConfig.default.timeout);
 
-  process.env.TRACE &&
-    (await context.browserContext.tracing.start({
+  if (
+    (cucumberConfig.default.reportWithTrace || cucumberConfig.default.trace) &&
+    !context.response
+  ) {
+    await browserContext.tracing.start({
       sources: true,
       screenshots: true,
       snapshots: true,
-    }));
+    });
+  }
 });
 
-BeforeStep(async function ({ pickleStep }) {
-  const stepText = pickleStep.text;
-
-  const methods = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE"];
-
-  if (methods.some((method) => stepText.includes(method))) {
+BeforeStep(({ pickleStep }) => {
+  if (HTTP_METHODS.some((method) => pickleStep.text.includes(method))) {
     context.response = {};
   }
 });
 
 AfterStep(async function ({ pickleStep }) {
-  const stepText = pickleStep.text;
-
-  const methods = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE"];
-
-  if (methods.some((method) => stepText.includes(method))) {
-    if (await context.response) {
-      for (const [key, value] of Object.entries(context.response)) {
-        let text = `${key}:\n`;
-
-        if (typeof value === "object") {
-          text += JSON.stringify(value, null, 2);
-        } else {
-          text += value;
-        }
-
-        await this.attach(text, "text/plain");
-      }
-    }
+  if (HTTP_METHODS.some((method) => pickleStep.text.includes(method))) {
+    await attachResponse(this.attach);
   }
 });
 
 After(async function ({ pickle, result }) {
-  if (process.env.REPORT_SUCCESS || result?.status !== Status.PASSED) {
-    let img = await context.page.screenshot({
-      path: `./test-results/visualReport/${pickle.name}/${pickle.name}.png`,
+  const shouldReport =
+    (cucumberConfig.default.successReport ||
+      result?.status !== Status.PASSED) &&
+    !context.response;
+
+  if (shouldReport) {
+    const screenshotPath = path.join(
+      "test-results",
+      "visualReport",
+      pickle.name,
+      `${pickle.name}.png`,
+    );
+
+    const img = await context.page.screenshot({
+      path: screenshotPath,
       type: "png",
     });
-    await this.attach(img, "image/png");
+    await this.attach(img, {
+      mediaType: "image/png",
+      fileName: `${pickle.name.replaceAll(" ", "_")}.png`,
+    });
   }
 
-  fs.mkdirSync(statusDir, { recursive: true });
+  saveTestStatus(result, pickle);
 
-  fs.writeFileSync(
-    path.join(statusDir, `${result.status}-${pickle.id}.txt`),
-    "",
+  const tracePath = path.join(
+    moduleConfig.projectPath,
+    `./${pickle.name.replaceAll(" ", "_")}.zip`,
   );
 
-  process.env.TRACE &&
-    (await context.browserContext.tracing.stop({
-      path: path.join(moduleConfig.projectPath, "./trace.zip"),
-    }));
+  if (
+    (cucumberConfig.default.reportWithTrace || cucumberConfig.default.trace) &&
+    !context.response &&
+    shouldReport
+  ) {
+    await context.browserContext.tracing.stop({
+      path: tracePath,
+    });
+
+    if (cucumberConfig.default.reportWithTrace) {
+      const trace = fs.readFileSync(tracePath);
 
-  if (context.response) {
-    for (const [key, value] of Object.entries(context.response)) {
-      let text = `${key}:\n`;
+      await this.attach(trace, {
+        mediaType: "application/zip",
+        fileName: `${pickle.name.replace(/\s+/g, "_")}_trace.zip`,
+      });
 
-      if (typeof value === "object") {
-        text += JSON.stringify(value, null, 2);
-      } else {
-        text += value;
+      if (!cucumberConfig.default.trace) {
+        spawnSync("npx", ["rimraf", tracePath], {
+          cwd: moduleConfig.projectPath,
+          stdio: "inherit",
+          shell: true,
+        });
       }
-
-      await this.attach(text, "text/plain");
     }
   }
 
-  await context.page?.close();
+  await attachResponse(this.attach);
 
+  await context.page?.close();
   await context.browserContext?.close();
-
   await context.browser?.close();
-
   await context.request?.dispose();
 
-  if (
-    (process.env.REPORT_SUCCESS || result?.status !== Status.PASSED) &&
-    context.page.video()
-  ) {
-    const videoPath = await context.page.video().path();
-    await new Promise((resolve) => setTimeout(resolve, 1000));
+  if (shouldReport && context.page.video) {
+    const video = context.page.video();
+    if (video) {
+      const videoPath = await video.path();
+
+      await new Promise((resolve) => setTimeout(resolve, 1000));
 
-    if (fs.existsSync(videoPath)) {
-      const webmBuffer = await fs.readFileSync(videoPath);
-      await this.attach(webmBuffer, "video/webm");
+      if (fs.existsSync(videoPath)) {
+        const webmBuffer = fs.readFileSync(videoPath);
+        await this.attach(webmBuffer, {
+          mediaType: "video/webm",
+          fileName: `${pickle.name.replaceAll(" ", "_")}.webm`,
+        });
+      }
     }
   }
 });
 
-AfterAll(async function () {
-  if (fs.existsSync(statusDir)) {
-    const files = fs.readdirSync(statusDir);
-    const passedCount = files.filter(
-      (file) => file.split("-")[0] === "PASSED",
-    ).length;
-    const totalTests = files.length;
-
-    const successPercentage = (passedCount / totalTests) * 100;
-    const successRate =
-      successPercentage.toFixed(2) >= cucumberConfig.default.testPercentage;
-
-    if (
-      cucumberConfig.default.testPercentage != undefined &&
-      !isNaN(successPercentage)
-    ) {
-      if (successRate) {
-        console.log(
-          `Tests passed required ${cucumberConfig.default.testPercentage}% success rate with ${successPercentage.toFixed(2)}% !`,
-        );
-        fs.writeFileSync(path.join(statusDir, `EXIT_CODE.txt`), "0");
-      } else {
-        console.log(
-          `Tests failed at required ${cucumberConfig.default.testPercentage}% success rate with ${successPercentage.toFixed(2)}%!`,
-        );
-        fs.writeFileSync(path.join(statusDir, `EXIT_CODE.txt`), "1");
-      }
+AfterAll(() => {
+  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;
+
+  if (cucumberConfig.default.testPercentage !== undefined) {
+    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");
     }
   }
 });