artes 1.7.24 → 1.7.26

package/package.json

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

package/src/helper/controller/elementController.js

@@ -1,230 +1,265 @@
-const { context } = require("../../hooks/context");
-const path = require("path");
-
-let elements = {};
-
-function addElements(newElements) {
-  elements = { ...elements, ...newElements };
-}
-
-// async function locatorExistenceChecker(locator){
-//   const locatorCount = await locator.count();
-//   console.log(locator, locatorCount)
-//   return locatorCount ==0 ? false : true;
-// }
-
-function selectorSeparator(element) {
-  if (typeof element !== "string") return element;
-
-  const selector = element?.split("=");
-  const validTypes = [
-    "xpath",
-    "name",
-    "placeholder",
-    "text",
-    "label",
-    "role",
-    "alt",
-    "title",
-    "testid",
-  ];
-
-  if (selector && validTypes.includes(selector[0]?.trim())) {
-    return [
-      selector[0].trim(),
-      selector[1] !== undefined ? selector[1].trim() : "",
-    ];
-  } else {
-    return selector.join("=");
-  }
-}
-
-function getSelector(element) {
-  element = resolveVariable(element);
-
-  const selector =
-    elements?.[element]?.selector || elements?.[element] || element;
-  return resolveVariable(selectorSeparator(selector));
-}
-
-function getElement(element) {
-  if (!context.page) {
-    throw new Error("Page context is not initialized.");
-  }
-
-  const selector = getSelector(element);
-  const waitTime = elements[element]?.waitTime * 1000 || 0;
-
-  let locator;
-  switch (selector[0]) {
-    case "xpath":
-      locator = context.page.locator(`xpath=${selector[1]}`, { exact: true });
-      break;
-    case "name":
-      locator = context.page.locator(`[name="${selector[1]}"]`, {
-        exact: true,
-      });
-      break;
-    case "placeholder":
-      locator = context.page.getByPlaceholder(selector[1], { exact: true });
-      break;
-    case "text":
-      locator = context.page.getByText(selector[1], { exact: true });
-      break;
-    case "label":
-      locator = context.page.getByLabel(selector[1], { exact: true });
-      break;
-    case "role":
-      locator = context.page.getByRole(selector[1], { exact: true });
-      break;
-    case "alt":
-      locator = context.page.getByAltText(selector[1], { exact: true });
-      break;
-    case "title":
-      locator = context.page.getByTitle(selector[1], { exact: true });
-      break;
-    case "testid":
-      locator = context.page.getByTestId(selector[1], { exact: true });
-      break;
-    default:
-      locator = context.page.locator(selector, { exact: true });
-      break;
-  }
-
-  return locator;
-}
-
-   function normalizeCrossplatformPath(inputPath) {
-    return path.normalize(inputPath.replace(/\\/g, "/"));
-  }
-
-  function pathToCamelCase(path) {
-    const cleaned = path.replace(/\[(\d+)\]/g, "_$1");
-    const parts = cleaned.split(".");
-    return parts
-      .map((part, index) => {
-        if (index === 0) return part;
-        return part.charAt(0).toUpperCase() + part.slice(1);
-      })
-      .join("");
-  }
-
-function extractVarsFromResponse(responseBody, vars, customVarNames) {
-  function getValueByPath(obj, path) {
-    if (typeof obj === "string") return obj;
-
-    const keys = path.split(".").flatMap((key) => {
-      const arrayMatch = key.match(/^([^\[]+)\[(\d+)\]$/);
-      if (arrayMatch) {
-        return [arrayMatch[1], parseInt(arrayMatch[2])];
-      }
-      return [key];
-    });
-
-    let current = obj;
-    for (const key of keys) {
-      if (current == null) return undefined;
-
-      if (typeof key === "number") {
-        if (!Array.isArray(current)) return undefined;
-        current = current[key];
-      } else if (typeof current === "object" && key in current) {
-        current = current[key];
-      } else {
-        return undefined;
-      }
-    }
-
-    return current;
-  }
-
-
-  const varPaths = vars.split(",").map((v) => v.trim());
-  let customNames = [];
-
-  if (!customVarNames) {
-    customNames = varPaths.map(pathToCamelCase);
-  } else if (typeof customVarNames === "string") {
-    customNames = customVarNames.split(",").map((n) => n.trim());
-  } else if (Array.isArray(customVarNames)) {
-    customNames = customVarNames;
-  } else {
-    throw new Error("customVarNames must be a string or an array");
-  }
-
-  if (customNames.length !== varPaths.length) {
-    customNames = varPaths.map(pathToCamelCase);
-  }
-
-  varPaths.forEach((path, index) => {
-    const value = getValueByPath(responseBody, path);
-    if (value !== undefined) {
-      saveVar(value, customNames[index], path);
-    }
-  });
-}
-
-function saveVar(value, customName, path) {
-  if (!customName) {
-    const flatKey = path
-      .split(".")
-      .map((part, i) =>
-        i === 0 ? part : part[0].toUpperCase() + part.slice(1),
-      )
-      .join("");
-
-    context.vars[flatKey] = value;
-  } else {
-    context.vars[customName] = value;
-  }
-}
-
-function resolveVariable(template) {
-  if (typeof template === "string") {
-    return template.replace(/{{\s*(\w+)\s*}}/g, (_, varName) => {
-      let value = context.vars[varName];
-
-      if (value !== undefined) {
-        if (typeof value !== "string") {
-          try {
-            value = JSON.stringify(value);
-          } catch {
-            value = String(value);
-          }
-        }
-
-        return value
-          .replace(/\n/g, "\\n")
-          .replace(/\r/g, "\\r")
-          .replace(/\t/g, "\\t");
-      }
-
-      return `{{${varName}}}`;
-    });
-  }
-
-  if (Array.isArray(template)) {
-    return template.map((item) => resolveVariable(item));
-  }
-
-  if (template && typeof template === "object") {
-    const result = {};
-    for (const key in template) {
-      result[key] = resolveVariable(template[key]);
-    }
-    return result;
-  }
-
-  return template;
-}
-
-module.exports = {
-  getElement,
-  addElements,
-  getSelector,
-  extractVarsFromResponse,
-  pathToCamelCase,
-  normalizeCrossplatformPath,
-  saveVar,
-  resolveVariable,
-};
+const { context } = require("../../hooks/context");
+const path = require("path");
+
+let elements = {};
+
+function addElements(newElements) {
+  elements = { ...elements, ...newElements };
+}
+
+// async function locatorExistenceChecker(locator){
+//   const locatorCount = await locator.count();
+//   console.log(locator, locatorCount)
+//   return locatorCount ==0 ? false : true;
+// }
+
+function isPlaywrightCallSyntax(str) {
+  return typeof str === "string" && /^[a-zA-Z]+\(.*\)\s*;?\s*$/s.test(str.trim());
+}
+
+function parsePlaywrightCall(str) {
+  const match = str.trim().match(/^([a-zA-Z]+)\((.*)\)\s*;?\s*$/s);
+  if (!match) return null;
+
+  const [, method, argsStr] = match;
+
+  // Safely evaluate the argument list as a JS array literal
+  // e.g. "'button', { name: 'Decline' }" -> ['button', { name: 'Decline' }]
+  let args;
+  try {
+    args = Function(`"use strict"; return [${argsStr}];`)();
+  } catch (err) {
+    throw new Error(`Failed to parse locator arguments in "${str}": ${err.message}`);
+  }
+
+  return { method, args };
+}
+
+function selectorSeparator(element) {
+  if (typeof element !== "string") return element;
+
+  const selector = element?.split("=");
+  const validTypes = [
+    "xpath",
+    "name",
+    "placeholder",
+    "text",
+    "label",
+    "role",
+    "alt",
+    "title",
+    "testid",
+  ];
+
+  if (selector && validTypes.includes(selector[0]?.trim())) {
+    return [
+      selector[0].trim(),
+      selector[1] !== undefined ? selector[1].trim() : "",
+    ];
+  } else {
+    return selector.join("=");
+  }
+}
+
+function getSelector(element) {
+  element = resolveVariable(element);
+
+  const selector =
+    elements?.[element]?.selector || elements?.[element] || element;
+  return resolveVariable(selectorSeparator(selector));
+}
+
+function getElement(element) {
+  if (!context.page) {
+    throw new Error("Page context is not initialized.");
+  }
+
+  const rawValue = resolveVariable(
+    elements?.[element]?.selector || elements?.[element] || element
+  );
+
+  // NEW: handle raw Playwright method-call syntax, e.g. getByRole('button', { name: 'Decline' })
+  if (isPlaywrightCallSyntax(rawValue)) {
+    const parsed = parsePlaywrightCall(rawValue);
+    if (!parsed || typeof context.page[parsed.method] !== "function") {
+      throw new Error(`Unsupported or invalid Playwright locator call: "${rawValue}"`);
+    }
+    return context.page[parsed.method](...parsed.args);
+  }
+  
+  const selector = getSelector(element);
+  const waitTime = elements[element]?.waitTime * 1000 || 0;
+
+  let locator;
+  switch (selector[0]) {
+    case "xpath":
+      locator = context.page.locator(`xpath=${selector[1]}`, { exact: true });
+      break;
+    case "name":
+      locator = context.page.locator(`[name="${selector[1]}"]`, {
+        exact: true,
+      });
+      break;
+    case "placeholder":
+      locator = context.page.getByPlaceholder(selector[1], { exact: true });
+      break;
+    case "text":
+      locator = context.page.getByText(selector[1], { exact: true });
+      break;
+    case "label":
+      locator = context.page.getByLabel(selector[1], { exact: true });
+      break;
+    case "role":
+      locator = context.page.getByRole(selector[1], { exact: true });
+      break;
+    case "alt":
+      locator = context.page.getByAltText(selector[1], { exact: true });
+      break;
+    case "title":
+      locator = context.page.getByTitle(selector[1], { exact: true });
+      break;
+    case "testid":
+      locator = context.page.getByTestId(selector[1], { exact: true });
+      break;
+    default:
+      locator = context.page.locator(selector, { exact: true });
+      break;
+  }
+
+  return locator;
+}
+
+   function normalizeCrossplatformPath(inputPath) {
+    return path.normalize(inputPath.replace(/\\/g, "/"));
+  }
+
+  function pathToCamelCase(path) {
+    const cleaned = path.replace(/\[(\d+)\]/g, "_$1");
+    const parts = cleaned.split(".");
+    return parts
+      .map((part, index) => {
+        if (index === 0) return part;
+        return part.charAt(0).toUpperCase() + part.slice(1);
+      })
+      .join("");
+  }
+
+function extractVarsFromResponse(responseBody, vars, customVarNames) {
+  function getValueByPath(obj, path) {
+    if (typeof obj === "string") return obj;
+
+    const keys = path.split(".").flatMap((key) => {
+      const arrayMatch = key.match(/^([^\[]+)\[(\d+)\]$/);
+      if (arrayMatch) {
+        return [arrayMatch[1], parseInt(arrayMatch[2])];
+      }
+      return [key];
+    });
+
+    let current = obj;
+    for (const key of keys) {
+      if (current == null) return undefined;
+
+      if (typeof key === "number") {
+        if (!Array.isArray(current)) return undefined;
+        current = current[key];
+      } else if (typeof current === "object" && key in current) {
+        current = current[key];
+      } else {
+        return undefined;
+      }
+    }
+
+    return current;
+  }
+
+
+  const varPaths = vars.split(",").map((v) => v.trim());
+  let customNames = [];
+
+  if (!customVarNames) {
+    customNames = varPaths.map(pathToCamelCase);
+  } else if (typeof customVarNames === "string") {
+    customNames = customVarNames.split(",").map((n) => n.trim());
+  } else if (Array.isArray(customVarNames)) {
+    customNames = customVarNames;
+  } else {
+    throw new Error("customVarNames must be a string or an array");
+  }
+
+  if (customNames.length !== varPaths.length) {
+    customNames = varPaths.map(pathToCamelCase);
+  }
+
+  varPaths.forEach((path, index) => {
+    const value = getValueByPath(responseBody, path);
+    if (value !== undefined) {
+      saveVar(value, customNames[index], path);
+    }
+  });
+}
+
+function saveVar(value, customName, path) {
+  if (!customName) {
+    const flatKey = path
+      .split(".")
+      .map((part, i) =>
+        i === 0 ? part : part[0].toUpperCase() + part.slice(1),
+      )
+      .join("");
+
+    context.vars[flatKey] = value;
+  } else {
+    context.vars[customName] = value;
+  }
+}
+
+function resolveVariable(template) {
+  if (typeof template === "string") {
+    return template.replace(/{{\s*(\w+)\s*}}/g, (_, varName) => {
+      let value = context.vars[varName];
+
+      if (value !== undefined) {
+        if (typeof value !== "string") {
+          try {
+            value = JSON.stringify(value);
+          } catch {
+            value = String(value);
+          }
+        }
+
+        return value
+          .replace(/\n/g, "\\n")
+          .replace(/\r/g, "\\r")
+          .replace(/\t/g, "\\t");
+      }
+
+      return `{{${varName}}}`;
+    });
+  }
+
+  if (Array.isArray(template)) {
+    return template.map((item) => resolveVariable(item));
+  }
+
+  if (template && typeof template === "object") {
+    const result = {};
+    for (const key in template) {
+      result[key] = resolveVariable(template[key]);
+    }
+    return result;
+  }
+
+  return template;
+}
+
+module.exports = {
+  getElement,
+  addElements,
+  getSelector,
+  extractVarsFromResponse,
+  pathToCamelCase,
+  normalizeCrossplatformPath,
+  saveVar,
+  resolveVariable,
+};

package/src/stepDefinitions/assertions.steps.js

@@ -1364,3 +1364,27 @@ Then(
   },
 );
 
+Then(
+  "User expects that response has {string} field that contains {string} value",
+  async (field, value) => {
+      extractVarsFromResponse(context.response["Response Body"], field);
+      const key = pathToCamelCase(field);
+      expect(String(context.vars[key])).toContain(resolveVariable(value));
+  },
+);
+
+
+Then('User expects that response has {string} header with {string} value',   async (field, value) => {
+      extractVarsFromResponse(context.response["Response Headers"], field);
+      const key = pathToCamelCase(field);
+      expect(String(context.vars[key])).toBe(resolveVariable(value));
+})
+
+Then(
+  "User expects that response does not have {string} field with {string} value",
+  async (field, value) => {
+      extractVarsFromResponse(context.response["Response Body"], field);
+      const key = pathToCamelCase(field);
+      expect(String(context.vars[key])).not.toBe(resolveVariable(value));
+  },
+);

package/src/stepDefinitions/frameActions.steps.js

@@ -1,76 +1,208 @@
-const { When } = require("../helper/imports/commons");
-const { frame } = require("../helper/stepFunctions/exporter");
-
-// User takes a screenshot of a specific selector
-When("User takes a screenshot of {string}", async function (selector) {
-  await frame.screenshot(selector);
-});
-
-// User gets the content frame of a specific selector
-When("User gets the content frame of {string}", async function (selector) {
-  await frame.contentFrame(selector);
-});
-
-// User gets the frame locator of a specific selector
-When("User gets the frame locator of {string}", async function (selector) {
-  await frame.frameLocator(selector);
-});
-
-// User gets the nth element of a specific selector
-When(
-  "User gets the {int} th element of {string}",
-  async function (index, selector) {
-    await frame.nth(selector, index);
-  },
-);
-
-// User gets the first element of a specific selector
-When("User gets the first element of {string}", async function (selector) {
-  await frame.first(selector);
-});
-
-// User gets the last element of a specific selector
-When("User gets the last element of {string}", async function (selector) {
-  await frame.last(selector);
-});
-
-// User filters elements of a specific selector
-When(
-  "User filters elements of {string} with filter {string}",
-  async function (selector, filter) {
-    await frame.filter(selector, filter);
-  },
-);
-
-// User counts the number of elements of a specific selector
-When("User counts the elements of {string}", async function (selector) {
-  await frame.count(selector);
-});
-
-// User gets an element by its alt text
-When("User gets the element with alt text {string}", async function (text) {
-  await frame.getByAltText(text);
-});
-
-// User gets an element by its label
-When("User gets the element with label {string}", async function (label) {
-  await frame.getByLabel(label);
-});
-
-// User gets an element by its placeholder
-When(
-  "User gets the element with placeholder {string}",
-  async function (placeholder) {
-    await frame.getByPlaceholder(placeholder);
-  },
-);
-
-// User gets an element by its role
-When("User gets the element with role {string}", async function (role) {
-  await frame.getByRole(role);
-});
-
-// User gets an element by its testId
-When("User gets the element with testId {string}", async function (testId) {
-  await frame.getByTestId(testId);
-});
+const { When } = require("../helper/imports/commons");
+const { frame } = require("../helper/stepFunctions/exporter");
+const { saveVar, element} = require("artes");
+
+// User takes a screenshot of a specific selector
+When("User takes a screenshot of {string}", async function (selector) {
+  await frame.screenshot(selector);
+});
+
+// User gets the content frame of a specific selector
+When("User gets the content frame of {string}", async function (selector) {
+  await frame.contentFrame(selector);
+});
+
+// User gets the frame locator of a specific selector
+When("User gets the frame locator of {string}", async function (selector) {
+  await frame.frameLocator(selector);
+});
+
+// User gets the nth element of a specific selector
+When(
+  "User gets the {int} th element of {string}",
+  async function (index, selector) {
+    await frame.nth(selector, index);
+  },
+);
+
+// User gets the first element of a specific selector
+When("User gets the first element of {string}", async function (selector) {
+  await frame.first(selector);
+});
+
+// User gets the last element of a specific selector
+When("User gets the last element of {string}", async function (selector) {
+  await frame.last(selector);
+});
+
+// User filters elements of a specific selector
+When(
+  "User filters elements of {string} with filter {string}",
+  async function (selector, filter) {
+    await frame.filter(selector, filter);
+  },
+);
+
+// User counts the number of elements of a specific selector
+When("User counts the elements of {string}", async function (selector) {
+  await frame.count(selector);
+});
+
+// User gets an element by its alt text
+When("User gets the element with alt text {string}", async function (text) {
+  await frame.getByAltText(text);
+});
+
+// User gets an element by its label
+When("User gets the element with label {string}", async function (label) {
+  await frame.getByLabel(label);
+});
+
+// User gets an element by its placeholder
+When(
+  "User gets the element with placeholder {string}",
+  async function (placeholder) {
+    await frame.getByPlaceholder(placeholder);
+  },
+);
+
+// User gets an element by its role
+When("User gets the element with role {string}", async function (role) {
+  await frame.getByRole(role);
+});
+
+// User gets an element by its testId
+When("User gets the element with testId {string}", async function (testId) {
+  await frame.getByTestId(testId);
+});
+
+
+
+
+When("User saves the value of {string} as {string}", async function (selector, varName) {
+
+async function extractElementValue(locator) {
+  await locator.waitFor({ state: "visible" });
+
+  const tagName = await locator.evaluate((el) => el.tagName.toLowerCase());
+  const normalize = (str) => str?.replace(/\s+/g, " ").trim();
+
+  if (["input", "textarea"].includes(tagName)) {
+    return normalize(await locator.inputValue());
+  }
+
+  if (tagName === "select") {
+    return normalize(
+      await locator.evaluate((el) => el.options[el.selectedIndex]?.text)
+    );
+  }
+
+  if (tagName === "img") {
+    return normalize(await locator.getAttribute("alt"));
+  }
+
+  // Try several strategies in order, use the first non-empty result
+  const strategies = [
+    () => locator.innerText(),
+    () => locator.textContent(),
+    () => locator.getAttribute("value"),
+    () => locator.getAttribute("aria-label"),
+    () => locator.getAttribute("title"),
+    () => locator.getAttribute("placeholder"),
+    () => locator.getAttribute("alt"),
+  ];
+
+  for (const strategy of strategies) {
+    try {
+      const result = normalize(await strategy());
+      if (result) return result;
+    } catch {
+      // strategy not applicable to this element, try next
+      continue;
+    }
+  }
+
+  return "";
+}
+
+  const locator = element(selector);
+  const value = await extractElementValue(locator);
+    console.log( typeof locator)
+
+    saveVar(value, varName);
+
+});
+
+
+When(
+  "User saves the value of {int} th of {string} as {string}",
+  async function (ordinal, selector, varName) {
+
+
+async function extractElementValue(locator) {
+  await locator.waitFor({ state: "visible" });
+
+  const tagName = await locator.evaluate((el) => el.tagName.toLowerCase());
+  const normalize = (str) => str?.replace(/\s+/g, " ").trim();
+
+  if (["input", "textarea"].includes(tagName)) {
+    return normalize(await locator.inputValue());
+  }
+
+  if (tagName === "select") {
+    return normalize(
+      await locator.evaluate((el) => el.options[el.selectedIndex]?.text)
+    );
+  }
+
+  if (tagName === "img") {
+    return normalize(await locator.getAttribute("alt"));
+  }
+
+  const strategies = [
+    () => locator.innerText(),
+    () => locator.textContent(),
+    () => locator.getAttribute("value"),
+    () => locator.getAttribute("aria-label"),
+    () => locator.getAttribute("title"),
+    () => locator.getAttribute("placeholder"),
+    () => locator.getAttribute("alt"),
+  ];
+
+  for (const strategy of strategies) {
+    try {
+      const result = normalize(await strategy());
+      if (result) return result;
+    } catch {
+      continue;
+    }
+  }
+
+  return "";
+}
+
+function ordinalToIndex(ordinal) {
+  const num = parseInt(ordinal, 10);
+  if (isNaN(num) || num < 1) {
+    throw new Error(`Invalid ordinal "${ordinal}" — must be like "1st", "2nd", "3rd", "4th"...`);
+  }
+  return num - 1;
+}
+
+
+    const index = ordinalToIndex(ordinal);
+    const baseLocator = element(selector);
+
+    const count = await baseLocator.count();
+    if (index >= count) {
+      throw new Error(
+        `Requested ${ordinal} match for "${selector}", but only ${count} element(s) found.`
+      );
+    }
+
+    const locator = baseLocator.nth(index);
+    const value = await extractElementValue(locator);
+
+    saveVar(value, varName);
+  }
+);