k6-cucumber-steps 1.2.26 → 2.0.0

package/lib/helpers/generateHeaders.js

@@ -1,48 +0,0 @@
-/**
- * @module generateHeaders
- * @description
- * Generates HTTP headers for API requests based on the specified authentication type.
- * Supports: api_key, bearer_token, basic, none, and alias-based token resolution.
- */
-
-export default function generateHeaders(authType, env = {}, aliases = {}) {
-  const headers = { "Content-Type": "application/json" };
-
-  const getValue = (key) => env[key] || aliases[key] || "";
-
-  switch (authType) {
-    case "api_key":
-      headers["x-api-key"] = getValue("API_KEY");
-      break;
-
-    case "bearer_token":
-      headers["Authorization"] = `Bearer ${getValue("token")}`;
-      break;
-
-    case "basic":
-      const user = getValue("BASIC_USER");
-      const pass = getValue("BASIC_PASS");
-      if (!user || !pass) {
-        throw new Error("Missing BASIC_USER or BASIC_PASS for basic auth.");
-      }
-      headers["Authorization"] = `Basic ${Buffer.from(
-        `${user}:${pass}`
-      ).toString("base64")}`;
-      break;
-
-    case "none":
-      // Only content-type
-      break;
-
-    default:
-      if (aliases[authType]) {
-        headers["Authorization"] = `Bearer ${getValue(authType)}`;
-      } else {
-        throw new Error(
-          `Unsupported authentication type or missing alias: ${authType}`
-        );
-      }
-  }
-
-  return headers;
-}

package/lib/helpers/resolveBody.d.ts

@@ -1,2 +0,0 @@
-// lib/helpers/resolveBody.d.ts
-export function resolveBody(docString: string, env: any): string | any;

package/lib/helpers/resolveBody.js

@@ -1,78 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { faker } from "@faker-js/faker";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-/**
- * Recursively resolves all placeholders in an object.
- * @param {*} data - The parsed JSON (object, array, string, etc)
- * @param {object} env - Environment variables + aliases
- * @returns {*} - Fully resolved structure
- */
-function resolveDeep(data, env) {
-  if (typeof data === "string") {
-    // 1. Resolve env vars like {{username}}
-    data = data.replace(/{{(\w+)}}/g, (_, key) => {
-      return env[key] || "";
-    });
-
-    // 2. Resolve faker like {{faker.internet.email}}
-    data = data.replace(/{{faker\.([\w.]+)}}/g, (_, methodPath) => {
-      const parts = methodPath.split(".");
-      let fn = faker;
-      for (const part of parts) {
-        fn = fn?.[part];
-        if (!fn) throw new Error(`Invalid Faker method: faker.${methodPath}`);
-      }
-      return typeof fn === "function" ? fn() : fn;
-    });
-
-    // 3. Replace JSON file includes like <address.json>
-    data = data.replace(/<([\w-]+\.json)>/g, (_, fileName) => {
-      const filePath = path.join(__dirname, "../payloads", fileName);
-      if (!fs.existsSync(filePath)) {
-        throw new Error(`Payload file not found: ${fileName}`);
-      }
-      const fileContent = fs.readFileSync(filePath, "utf-8");
-      return fileContent.trim();
-    });
-
-    return data;
-  }
-
-  if (Array.isArray(data)) {
-    return data.map((item) => resolveDeep(item, env));
-  }
-
-  if (typeof data === "object" && data !== null) {
-    const resolved = {};
-    for (const key in data) {
-      resolved[key] = resolveDeep(data[key], env);
-    }
-    return resolved;
-  }
-
-  return data;
-}
-
-/**
- * Resolves JSON templates using env vars, Faker, and JSON includes.
- * @param {string} template - The raw JSON string template
- * @param {object} env - Object containing environment variables or aliases
- * @returns {object} - Fully resolved JS object
- */
-export default function resolveBody(template, env = {}) {
-  try {
-    const parsed = JSON.parse(template);
-    return resolveDeep(parsed, env);
-  } catch (err) {
-    console.error(
-      "❌ Failed to parse input JSON before resolving:",
-      err.message
-    );
-    throw new Error("Invalid JSON template provided to resolveBody");
-  }
-}

package/lib/helpers/resolvePayloadPath.js

@@ -1,25 +0,0 @@
-import path from "path";
-import fs from "fs";
-
-/**
- * Resolves the full path to a payload file based on a root directory (e.g., from config)
- * and filename. Throws a clear error if file does not exist.
- *
- * @param {string} fileName - The file name (e.g., login.json)
- * @param {string} payloadDir - Directory path for payloads (absolute or relative)
- * @returns {string} - Full path to the resolved file
- */
-export default function resolvePayloadPath(fileName, payloadDir = "payloads") {
-  const projectRoot = path.resolve(process.cwd());
-  const baseDir = path.isAbsolute(payloadDir)
-    ? payloadDir
-    : path.join(projectRoot, payloadDir);
-
-  const fullPath = path.join(baseDir, fileName);
-
-  if (!fs.existsSync(fullPath)) {
-    throw new Error(`❌ Payload file not found: "${fullPath}"`);
-  }
-
-  return fullPath;
-}

package/lib/helpers/runK6ScriptFromWorld.js

@@ -1,26 +0,0 @@
-import { generateK6Script, runK6Script } from "../utils/k6Runner.js";
-import buildK6Script from "./buildK6Script.js";
-
-export async function runK6ScriptFromWorld(world, method, isMulti = false) {
-  const scriptContent = buildK6Script({
-    method,
-    endpoint: isMulti ? undefined : world.endpoint,
-    endpoints: isMulti ? world.endpoints : undefined,
-    body: world.body,
-    headers: world.headers,
-    options: world.k6Options,
-    baseUrl: world.baseUrl,
-    worldParameters: world.worldParameters,
-  });
-
-  const scriptPath = await generateK6Script(scriptContent, "api", true);
-  const { stdout, stderr, code } = await runK6Script(scriptPath, true);
-
-  console.log(stdout);
-  if (stderr) console.error(stderr);
-  if (code !== 0) {
-    throw new Error("❌ K6 script execution failed.");
-  }
-
-  console.log("✅ K6 script ran successfully.");
-}

package/lib/utils/k6Runner.d.ts

@@ -1,6 +0,0 @@
-// lib/utils/k6Runner.d.ts
-export function generateK6Script(
-  scriptContent: string,
-  scriptType?: string
-): string;
-export async function runK6Script(scriptPath: string): Promise<string>;

package/lib/utils/k6Runner.js

@@ -1,89 +0,0 @@
-import path from "path";
-import { exec } from "child_process";
-import { v4 as uuidv4 } from "uuid";
-import { promises as fs } from "fs";
-import { fileURLToPath } from "url";
-
-// __dirname workaround for ESM
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const pkgPath = path.resolve(__dirname, "../../package.json");
-const pkgContent = await fs.readFile(pkgPath, "utf-8");
-const packageJson = JSON.parse(pkgContent);
-/**
- * Generates a temporary k6 script file.
- * @param {string} scriptContent - The content of the k6 script.
- * @param {string} [scriptType='load'] - Type of script (e.g., 'load').
- * @param {boolean} [overwrite=false] - Whether to overwrite the report file.
- * @returns {Promise<string>} - Path to the generated k6 script file.
- */
-export async function generateK6Script(
-  scriptContent,
-  scriptType = "load",
-  overwrite = false
-) {
-  const tempDir = path.resolve(__dirname, "../../temp");
-  const scriptName = `${scriptType}_script_${uuidv4()}.js`;
-  const scriptPath = path.join(tempDir, scriptName);
-
-  try {
-    await fs.mkdir(tempDir, { recursive: true });
-
-    if (overwrite) {
-      await fs.writeFile(scriptPath, scriptContent, { flag: "w" });
-    } else {
-      await fs.appendFile(scriptPath, scriptContent);
-    }
-
-    return scriptPath;
-  } catch (error) {
-    console.error(`Error generating k6 script: ${error.message}`);
-    throw error;
-  }
-}
-
-/**
- * Introduce a delay in milliseconds.
- * @param {number} ms - Duration of the delay.
- * @returns {Promise<void>}
- */
-export const delay = (ms) => new Promise((res) => setTimeout(res, ms));
-
-/**
- * Runs the k6 script with custom branding.
- * @param {string} scriptPath - Path to the k6 script file.
- * @param {boolean} [overwrite=false] - Whether to overwrite the report file.
- * @returns {Promise<{stdout: string, stderr: string, code: number}>}
- */
-export async function runK6Script(scriptPath, overwrite = false) {
-  const chalkGreen = "\x1b[38;2;0;255;0m";
-  const chalkYellow = "\x1b[38;2;255;255;0m";
-  const resetColor = "\x1b[0m";
-
-  const customLogo = `${chalkGreen} with @qaPaschalE's ${chalkYellow}k6-cucumber-steps v${packageJson.version}${resetColor}`;
-
-  return new Promise((resolve) => {
-    exec(`k6 run "${scriptPath}"`, async (error, stdout, stderr) => {
-      const logoLines = stdout.split("\n");
-
-      let modifiedStdout = "";
-      for (let i = 0; i < logoLines.length; i++) {
-        modifiedStdout += logoLines[i];
-        if (i === 5) {
-          modifiedStdout += `   ${customLogo}\n`;
-        }
-        modifiedStdout += "\n";
-      }
-
-      fs.unlink(scriptPath).catch((err) =>
-        console.error("Error deleting temporary k6 script:", err)
-      );
-
-      resolve({
-        stdout: modifiedStdout,
-        stderr,
-        code: error ? error.code ?? 1 : 0,
-      });
-    });
-  });
-}

package/scripts/cucumber.js

@@ -1,18 +0,0 @@
-module.exports = {
-  default: {
-    require: ["./step_definitions/**/*.js"],
-    format: [
-      "summary",
-      "json:./reports/load-report.json",
-      "html:./reports/cucumber-report.html",
-    ],
-    paths: ["./features/bsp.feature"],
-    tags: "@get",
-    cleanReports: true,
-    worldParameters: {
-      payloadPath: "payloads",
-    },
-    overwrite: true,
-    reporter: true,
-  },
-};

package/scripts/linkReports.js

@@ -1,107 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { minify } from "html-minifier-terser";
-import { fileURLToPath } from "url";
-import { exec } from "child_process";
-import os from "os";
-
-// ESM __dirname workaround
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const reportsDir = path.resolve(__dirname, "../reports");
-
-/**
- * Opens a file in the default browser based on OS.
- * @param {string} filePath - Absolute file path to open.
- */
-function openInBrowser(filePath) {
-  const platform = os.platform();
-  const command =
-    platform === "darwin"
-      ? `open "${filePath}"`
-      : platform === "win32"
-      ? `start "" "${filePath}"`
-      : `xdg-open "${filePath}"`; // Linux
-
-  exec(command, (err) => {
-    if (err) {
-      console.error("⚠️ Failed to open the report in browser:", err.message);
-    } else {
-      console.log("🌐 Report opened in your default browser.");
-    }
-  });
-}
-
-export async function linkReports() {
-  if (!fs.existsSync(reportsDir)) {
-    console.warn("⚠️ No reports directory found.");
-    return;
-  }
-
-  const htmlFiles = fs
-    .readdirSync(reportsDir)
-    .filter((f) => f.endsWith(".html") && !f.includes("combined-"))
-    .map((f) => ({
-      name: f,
-      path: path.join(reportsDir, f),
-      mtime: fs.statSync(path.join(reportsDir, f)).mtime.getTime(),
-    }));
-
-  if (htmlFiles.length === 0) {
-    console.warn("⚠️ No HTML reports found.");
-    return;
-  }
-
-  let k6Report = htmlFiles.find((f) => f.name.startsWith("k6-"));
-  if (!k6Report) {
-    k6Report = htmlFiles.reduce((a, b) => (a.mtime > b.mtime ? a : b));
-  }
-
-  const otherReports = htmlFiles.filter((f) => f.name !== k6Report.name);
-  if (!k6Report || otherReports.length === 0) {
-    console.warn("⚠️ K6 or any other HTML report not found.");
-    return;
-  }
-
-  let content = fs.readFileSync(k6Report.path, "utf8");
-
-  const tabs = otherReports
-    .map(
-      (report, idx) => `
-    <input type="radio" name="tabs" id="tab${idx + 2}">
-    <label for="tab${idx + 2}"><i class="fas fa-file-alt"></i> &nbsp; ${
-        report.name
-      }</label>
-    <div class="tab">
-      <iframe src="${
-        report.name
-      }" style="width:100%; height:600px; border:none;"></iframe>
-    </div>
-  `
-    )
-    .join("\n");
-
-  content = content.replace(
-    /<input type="radio" name="tabs" id="tabone"/,
-    `${tabs}\n<input type="radio" name="tabs" id="tabone"`
-  );
-
-  content = content.replace(
-    /<div style="padding:10px;margin-top:20px;text-align:center">[\s\S]*?<\/div>/,
-    ""
-  );
-
-  const minified = await minify(content, {
-    collapseWhitespace: true,
-    removeComments: true,
-    minifyCSS: true,
-  });
-
-  const combinedPath = path.join(reportsDir, "combined-report.html");
-  fs.writeFileSync(combinedPath, minified, "utf8");
-
-  console.log(`📄 Combined report generated at: ${combinedPath}`);
-
-  openInBrowser(combinedPath);
-}

package/step_definitions/load_test_steps.d.ts

@@ -1,89 +0,0 @@
-import { DataTable } from "@cucumber/cucumber";
-
-declare module "@cucumber/cucumber" {
-  interface World {
-    config: {
-      method?: string;
-      options?: any;
-      headers?: Record<string, string>;
-      endpoints?: string[];
-      body?: any;
-      endpoint?: string;
-    };
-  }
-}
-
-export function Given(
-  pattern: string,
-  fn: (
-    this: import("@cucumber/cucumber").World,
-    ...args: any[]
-  ) => Promise<any> | void
-): void;
-export function When(
-  pattern: string,
-  fn: (
-    this: import("@cucumber/cucumber").World,
-    ...args: any[]
-  ) => Promise<any> | void
-): void;
-export function Then(
-  pattern: string,
-  fn: (
-    this: import("@cucumber/cucumber").World,
-    ...args: any[]
-  ) => Promise<any> | void
-): void;
-
-declare function Given(
-  pattern: "I set a k6 script for {word} testing",
-  implementation: (
-    this: import("@cucumber/cucumber").World,
-    method: string
-  ) => void
-): void;
-declare function When(
-  pattern: "I set to run the k6 script with the following configurations:",
-  implementation: (
-    this: import("@cucumber/cucumber").World,
-    dataTable: DataTable
-  ) => void
-): void;
-declare function When(
-  pattern: "I set the request headers:",
-  implementation: (
-    this: import("@cucumber/cucumber").World,
-    dataTable: DataTable
-  ) => void
-): void;
-declare function When(
-  pattern: "I set the following endpoints used:",
-  implementation: (
-    this: import("@cucumber/cucumber").World,
-    docString: string
-  ) => void
-): void;
-declare function When(
-  pattern: "I set the following {word} body is used for {string}",
-  implementation: (
-    this: import("@cucumber/cucumber").World,
-    method: string,
-    endpoint: string,
-    docString: string
-  ) => void
-): void;
-declare function When(
-  pattern: "I set the authentication type to {string}",
-  implementation: (
-    this: import("@cucumber/cucumber").World,
-    authType: string
-  ) => void
-): void;
-declare function Then(
-  pattern: "I see the API should handle the {word} request successfully",
-  implementation: (
-    this: import("@cucumber/cucumber").World,
-    method: string,
-    options?: { timeout?: number }
-  ) => Promise<void>
-): void;