ff-automationv2 2.1.3 → 2.2.0

package/src/automation/actions/interaction/get/getHourFromCurrentSystemTime.ts

@@ -0,0 +1,18 @@
+import { getHourFromCurrentSystemTimeInterface } from "../../interface/getActionInterface.js";
+
+export const getHourFromCurrentSystemTime = async (
+  args: getHourFromCurrentSystemTimeInterface
+) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetHourFromCurrentSystemTime",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetHourFromCurrentSystemTime");
+    throw new Error("GetHourFromCurrentSystemTime action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getImplicitTimeOut.ts

@@ -0,0 +1,36 @@
+import { getImplicitTimeOutInterface } from "../../interface/getActionInterface.js";
+
+export const getImplicitTimeOut = async (
+  args: getImplicitTimeOutInterface
+) => {
+  switch (args.platform) {
+    case "android":
+      try {
+        args.scriptDataAppender.add(async () => ({
+          nlpName: "MOB_GetImplicitTimeOut",
+          stepInputs: [],
+          elementsData: []
+        }));
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GetImplicitTimeOut");
+        throw new Error("GetImplicitTimeOut action failed", { cause: error });
+      }
+      break;
+    case "web":
+    default:
+      try {
+        args.scriptDataAppender.add(async () => ({
+          nlpName: "GetImplicitTimeOut",
+          stepInputs: [],
+          elementsData: []
+        }));
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetImplicitTimeOut");
+        throw new Error("GetImplicitTimeOut action failed", { cause: error });
+      }
+      break;
+  }
+
+};

package/src/automation/actions/interaction/get/getLargestContentfulPaint.ts

@@ -0,0 +1,16 @@
+import { getLargestContentfulPaintInterface } from "../../interface/getActionInterface.js";
+
+export const getLargestContentfulPaint = async (args: getLargestContentfulPaintInterface) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetLargestContentfulPaint",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetLargestContentfulPaint");
+    throw new Error("GetLargestContentfulPaint action failed", { cause: error })
+  }
+};

package/src/automation/actions/interaction/get/getListBoxSize.ts

@@ -0,0 +1,41 @@
+import { getListBoxSizeInterface } from "../../interface/getActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function getListBoxSize(
+    args: getListBoxSizeInterface
+): Promise<number> {
+    try {
+        // Get dropdown element
+        const element = await args.driver.$(args.selector);
+
+        // Get all <option> elements inside dropdown
+        const options = await element.$$("option");
+
+        const size = options.length;
+
+        logger.info("ListBox size in getListBoxSize:", { size });
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: "GetListBoxSize",
+                stepInputs: [], // No inputs required
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+        return size;
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("GetListBoxSize");
+        throw new Error("GetListBoxSize action failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/get/getListOfElementsFromLocatorTypeLocatorValue.ts

@@ -0,0 +1,63 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { getListOfElementsFromLocatorTypeLocatorValueInterface } from "../../interface/getActionInterface.js";
+
+export const getListOfElementsFromLocatorTypeLocatorValue = async (
+    args: getListOfElementsFromLocatorTypeLocatorValueInterface
+): Promise<void> => {
+
+    try {
+
+        if (!args.value) {
+            throw new Error("Locator input not provided");
+        }
+
+        const parts = args.value.split(",");
+        if (parts.length < 2) {
+            throw new Error("Invalid locator format. Expected 'type,value'");
+        }
+
+        const locatorType = parts[0].trim().toLowerCase();
+        const locatorValue = parts[1].trim();
+
+        let finalSelector = "";
+
+        switch (locatorType) {
+            case "id":
+                finalSelector = `#${locatorValue}`;
+                break;
+            case "css":
+                finalSelector = locatorValue;
+                break;
+            case "xpath":
+                finalSelector = `xpath=${locatorValue}`;
+                break;
+            case "name":
+                finalSelector = `[name="${locatorValue}"]`;
+                break;
+            case "class":
+                finalSelector = `.${locatorValue}`;
+                break;
+            case "tag":
+                finalSelector = locatorValue;
+                break;
+            default:
+                throw new Error(`Unsupported locator type: ${locatorType}`);
+        }
+
+        const _elements = await args.driver.$$(finalSelector);
+        logger.info(`Found ${_elements.length} elements`);
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetListOfElementsFromLocatorTypeLocatorValue",
+            stepInputs: [locatorType, locatorValue],
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetListOfElementsFromLocatorTypeLocatorValue");
+        throw new Error(
+            "GetListOfElementsFromLocatorTypeLocatorValue action failed",
+            { cause: error }
+        );
+    }
+};

package/src/automation/actions/interaction/get/getLocation.ts

@@ -0,0 +1,68 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { getLocationInterface } from "../../interface/getActionInterface.js";
+
+export const getLocation = async (
+  args: getLocationInterface
+): Promise<void> => {
+  switch (args.platform) {
+    case "android":
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _location = await element.getLocation();
+
+        logger.info(`Location of element: ${_location}`);
+
+        args.scriptDataAppender.add(async () => {
+
+          return {
+            nlpName: "MOB_GetLocation",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: [{ "xpath": args.selector }],
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GetLocation");
+        throw new Error("GetLocation action failed", { cause: error });
+      }
+      break;
+    case "web":
+    default:
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _location = await element.getLocation();
+
+        logger.info(`Location of element: ${_location}`);
+
+        args.scriptDataAppender.add(async () => {
+          const ffElement: any = await args.elementGetter.getFireFlinkElement(
+            args.pageDOM,
+            `[ff-inspect="${args.fireflinkIndex}"]`
+          );
+          return {
+            nlpName: "GetLocation",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: ffElement.locators,
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetLocation");
+        throw new Error("GetLocation action failed", { cause: error });
+      }
+      break;
+  }
+
+};

package/src/automation/actions/interaction/get/getMinuteFromCurrentSystemTime.ts

@@ -0,0 +1,18 @@
+import { getMinuteFromCurrentSystemTimeInterface } from "../../interface/getActionInterface.js";
+
+export const getMinuteFromCurrentSystemTime = async (
+  args: getMinuteFromCurrentSystemTimeInterface
+) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetMinuteFromCurrentSystemTime",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetMinuteFromCurrentSystemTime");
+    throw new Error("GetMinuteFromCurrentSystemTime action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getNetworkRouteTime.ts

@@ -0,0 +1,16 @@
+import { getNetworkRouteTimeInterface } from "../../interface/getActionInterface.js";
+
+export const getNetworkRouteTime = async (args: getNetworkRouteTimeInterface) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetNetworkRouteTime",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetNetworkRouteTime");
+    throw new Error("GetNetworkRouteTime action failed", { cause: error })
+  }
+};

package/src/automation/actions/interaction/get/getNumberOfBrokenImages.ts

@@ -0,0 +1,16 @@
+import { getNumberOfBrokenImagesInterface } from "../../interface/getActionInterface.js";
+
+export const getNumberOfBrokenImages = async (args: getNumberOfBrokenImagesInterface) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetNumberOfBrokenImages",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetNumberOfBrokenImages");
+    throw new Error("GetNumberOfBrokenImages action failed", { cause: error })
+  }
+};

package/src/automation/actions/interaction/get/getNumberOfLinksPresentInCurrentPage.ts

@@ -0,0 +1,18 @@
+import { getNumberOfLinksPresentInCurrentPageInterface } from "../../interface/getActionInterface.js";
+
+export const getNumberOfLinksPresentInCurrentPage = async (
+  args: getNumberOfLinksPresentInCurrentPageInterface
+) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetNumberOfLinksPresentInCurrentPage",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetNumberOfLinksPresentInCurrentPage");
+    throw new Error("GetNumberOfLinksPresentInCurrentPage action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getNumberOfWorkingLinksFromCurrentPage.ts

@@ -0,0 +1,15 @@
+import { getNumberOfWorkingLinksFromCurrentPageInterface } from "../../interface/getActionInterface.js";
+
+export const getNumberOfWorkingLinksFromCurrentPage = async (args: getNumberOfWorkingLinksFromCurrentPageInterface) => {
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetNumberOfWorkingLinksFromCurrentPage",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetNumberOfWorkingLinksFromCurrentPage");
+    throw new Error("GetNumberOfWorkingLinksFromCurrentPage action failed", { cause: error })
+  }
+};

package/src/automation/actions/interaction/get/getOptions.ts

@@ -0,0 +1,35 @@
+import { getOptionsInterface } from "../../interface/getActionInterface.js";
+
+export const getOptions = async (
+  args: getOptionsInterface
+): Promise<void> => {
+
+  try {
+    const selectElement = await args.driver.$(args.selector);
+
+    const _options = await selectElement.$$('option');
+
+
+
+    args.scriptDataAppender.add(async () => {
+      const ffElement: any = await args.elementGetter.getFireFlinkElement(
+        args.pageDOM,
+        `[ff-inspect="${args.fireflinkIndex}"]`
+      );
+      return {
+        nlpName: "GetOptions",
+        stepInputs: [],
+        elementsData: [{
+          name: args.elementName,
+          type: args.elementType,
+          locators: ffElement.locators,
+          platform: args.platform
+        }]
+      };
+    });
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetOptions");
+    throw new Error("GetOptions action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getPageTitle.ts

@@ -0,0 +1,18 @@
+import { getPageTitleInterface } from "../../interface/getActionInterface.js";
+
+export const getPageTitle = async (
+  args: getPageTitleInterface
+) => {
+
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetPageTitle",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetPageTitle");
+    throw new Error("GetPageTitle action failed", { cause: error });
+  }
+};

package/src/automation/actions/interaction/get/getPerformanceMetrics.ts

@@ -0,0 +1,15 @@
+import { getPerformanceMetricsInterface } from "../../interface/getActionInterface.js";
+
+export const getPerformanceMetrics = async (args: getPerformanceMetricsInterface) => {
+  try {
+    args.scriptDataAppender.add(async () => ({
+      nlpName: "GetPerformanceMetrics",
+      stepInputs: [],
+      elementsData: []
+    }));
+
+  } catch (error) {
+    args.scriptDataAppender.setErrorNLP("GetPerformanceMetrics");
+    throw new Error("GetPerformanceMetrics action failed", { cause: error })
+  }
+};

package/src/automation/actions/interaction/get/getPwaScore.ts

@@ -0,0 +1,20 @@
+import { getPwaScoreInterface } from "../../interface/getActionInterface.js";
+
+export const getPwaScore = async (
+    args: getPwaScoreInterface
+) => {
+    try {
+        const inputs = (args.value || "").split(",").map(v => v.trim());
+        const stepInputs = [inputs[0] || "", inputs[1] || ""];
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetPwaScore",
+            stepInputs: stepInputs,
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetPwaScore");
+        throw new Error("GetPwaScore action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getRect.ts

@@ -0,0 +1,87 @@
+import { logger } from "../../../../utils/logger/logData.js";
+import { getRectInterface } from "../../interface/getActionInterface.js";
+
+export const getRect = async (
+  args: getRectInterface
+): Promise<void> => {
+  switch (args.platform) {
+    case "android":
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _location = await element.getLocation();
+        const _size = await element.getSize();
+
+        const _rect = {
+          x: _location.x,
+          y: _location.y,
+          width: _size.width,
+          height: _size.height
+        };
+        logger.info("Rect->", _rect)
+
+
+        args.scriptDataAppender.add(async () => {
+          const ffElement: any = await args.elementGetter.getFireFlinkElement(
+            args.pageDOM,
+            `[ff-inspect="${args.fireflinkIndex}"]`
+          );
+          return {
+            nlpName: "MOB_GetRect",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: ffElement.locators,
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GetRect");
+        throw new Error("GetRect action failed", { cause: error });
+      }
+      break;
+    case "web":
+    default:
+      try {
+        const element = await args.driver.$(args.selector);
+
+        const _location = await element.getLocation();
+        const _size = await element.getSize();
+
+        const _rect = {
+          x: _location.x,
+          y: _location.y,
+          width: _size.width,
+          height: _size.height
+        };
+        logger.info("Rect->", _rect)
+
+
+        args.scriptDataAppender.add(async () => {
+          const ffElement: any = await args.elementGetter.getFireFlinkElement(
+            args.pageDOM,
+            `[ff-inspect="${args.fireflinkIndex}"]`
+          );
+          return {
+            nlpName: "GetRect",
+            stepInputs: [],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: ffElement.locators,
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetRect");
+        throw new Error("GetRect action failed", { cause: error });
+      }
+      break;
+  }
+
+};

package/src/automation/actions/interaction/get/getScreenshot.ts

@@ -0,0 +1,41 @@
+import { getScreenshotInterface } from "../../interface/getActionInterface.js";
+
+export const getScreenshot = async (
+  args: getScreenshotInterface
+): Promise<void> => {
+  switch (args.platform) {
+    case "android":
+      try {
+        const timestamp = new Date().toISOString();
+        const fileName = args.value ? args.value : `Screenshot_${timestamp}.png`;
+        args.scriptDataAppender.add(async () => ({
+          nlpName: "MOB_GetScreenshot",
+          stepInputs: [fileName],
+          elementsData: []
+        }));
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GetScreenshot");
+        throw new Error("GetScreenshot action failed", { cause: error });
+      }
+      break;
+    case "web":
+    default:
+      try {
+        const timestamp = new Date().toISOString();
+        const fileName = args.value ? args.value : `Screenshot_${timestamp}.png`;
+        args.scriptDataAppender.add(async () => ({
+          nlpName: "GetScreenshot",
+          stepInputs: [fileName],
+          elementsData: []
+        }));
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetScreenshot");
+        throw new Error("GetScreenshot action failed", { cause: error });
+      }
+      break;
+  }
+
+
+};

package/src/automation/actions/interaction/get/getScreenshotAs.ts

@@ -0,0 +1,64 @@
+import { getScreenshotAsInterface } from "../../interface/getActionInterface.js";
+
+export const getScreenshotAs = async (
+  args: getScreenshotAsInterface
+): Promise<void> => {
+  switch (args.platform) {
+    case "android":
+      try {
+        const timestamp = new Date().toISOString();
+        const fileName = args.value ? args.value : `Screenshot_${timestamp}.png`;
+        args.scriptDataAppender.add(async () => {
+
+          return {
+            nlpName: "MOB_GetScreenshotAs",
+            stepInputs: [fileName],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: [{ "xpath": args.selector }],
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("MOB_GetScreenshotAs");
+        throw new Error("GetScreenshotAs action failed", { cause: error });
+      }
+      break;
+    case "web":
+    default:
+      try {
+        if (!args.value) {
+          throw new Error("Screenshot file name not provided");
+        }
+        const timestamp = new Date().toISOString();
+        const fileName = args.value ? args.value : `Screenshot_${timestamp}.png`;
+
+        args.scriptDataAppender.add(async () => {
+          const ffElement: any = await args.elementGetter.getFireFlinkElement(
+            args.pageDOM,
+            `[ff-inspect="${args.fireflinkIndex}"]`
+          );
+          return {
+            nlpName: "GetScreenshotAs",
+            stepInputs: [fileName],
+            elementsData: [{
+              name: args.elementName,
+              type: args.elementType,
+              locators: ffElement.locators,
+              platform: args.platform
+            }]
+          };
+        });
+
+      } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetScreenshotAs");
+        throw new Error("GetScreenshotAs action failed", { cause: error });
+      }
+
+      break;
+  }
+
+};

package/src/automation/actions/interaction/get/getSeoScore.ts

@@ -0,0 +1,20 @@
+import { getSeoScoreInterface } from "../../interface/getActionInterface.js";
+
+export const getSeoScore = async (
+    args: getSeoScoreInterface
+) => {
+    try {
+        const inputs = (args.value || "").split(",").map(v => v.trim());
+        const stepInputs = [inputs[0] || "", inputs[1] || ""];
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetSeoScore",
+            stepInputs: stepInputs,
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetSeoScore");
+        throw new Error("GetSeoScore action failed", { cause: error });
+    }
+};

package/src/automation/actions/interaction/get/getSingleApiRequestPayload.ts

@@ -0,0 +1,22 @@
+import { getSingleApiRequestPayloadInterface } from "../../interface/getActionInterface.js";
+
+export const getSingleApiRequestPayload = async (
+    args: getSingleApiRequestPayloadInterface
+) => {
+    try {
+
+
+        const inputs = (args.value || "").split(",").map(v => v.trim());
+        const stepInputs = [inputs[0] || "", inputs[1] || ""];
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetSingleApiRequestPayload",
+            stepInputs: stepInputs,
+            elementsData: []
+        }));
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("GetSingleApiRequestPayload");
+        throw new Error("GetSingleApiRequestPayload action failed", { cause: error });
+    }
+};