ff-automationv2 2.1.3 → 2.2.0

package/src/automation/actions/interaction/dragAndDrop/dragAndDrop.ts

@@ -0,0 +1,46 @@
+import { DragAndDropToElementInterface } from "../../interface/dragAndDropToElementInterface.js";
+
+export async function dragAndDropToElement(args: DragAndDropToElementInterface): Promise<void> {
+    try {
+
+        const source = await args.driver.$(args.selector1);
+        const target = await args.driver.$(args.selector2);
+
+        await source.dragAndDrop(target);
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement1: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex1}"]`
+            );
+
+            const ffElement2: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex2}"]`
+            );
+            return {
+                nlpName: "Builtin_DragAndDropToElement",
+                elementsData: [
+                    {
+                        name: args.elementName1,
+                        type: args.elementType1,
+                        locators: ffElement1.locators,
+                        platform: args.platform
+                    },
+                    {
+                        name: args.elementName2,
+                        type: args.elementType2,
+                        locators: ffElement2.locators,
+                        platform: args.platform
+                    }
+                ],
+                stepInputs: [args.elementName1, args.elementName2]
+            };
+
+        });
+
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("Builtin_DragAndDropToElement");
+        throw new Error("Builtin_DragAndDropToElement action failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/enterActions/enterInput.ts

@@ -0,0 +1,81 @@
+import { EnterInputInterface } from "../../interface/interactionActionInterface.js";
+import { enterActionHelper,enterActionHelperMob } from "../../../../utils/helpers/enterActionHelper.js";
+
+export async function enterInput(args: EnterInputInterface): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+                const { xpathPath } = enterActionHelperMob(
+                    args.pageDOM,
+                    args.fireflinkIndex
+                );
+                const element = await args.driver.$(xpathPath);
+                await element.setValue(args.value);
+
+                const text = await element.getAttribute("text");
+                if (text !== args.value) {
+                    const { execSync } = await import("child_process");
+                    execSync(`adb shell input text ${args.value}`);
+                }
+
+
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_SendKeys',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            }
+            catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_SendKeys")
+                throw new Error(`enter action failed:`, { cause: error });
+            }
+            break;
+
+        case "web":
+        default:
+            try {
+
+                const { ffNumber, xpathPath } = enterActionHelper(
+                    args.pageDOM,
+                    args.fireflinkIndex
+                );
+                const element = await args.driver.$(xpathPath);
+                await element.setValue(args.value);
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="Fire-Flink-${ffNumber}"]`
+                    );
+                    return {
+                        nlpName: 'SendKeys',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            }
+            catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("SendKeys")
+                throw new Error(`enter action failed:`, { cause: error });
+            }
+            break;
+    }
+
+}

package/src/automation/actions/interaction/enterActions/enterInputAndPress.ts

@@ -0,0 +1,134 @@
+import { EnterInputAndPressInterface } from "../../interface/interactionActionInterface.js";
+import { enterActionHelper, enterActionHelperMob } from "../../../../utils/helpers/enterActionHelper.js";
+
+export async function enterInputAndPress(
+    args: EnterInputAndPressInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                const { xpathPath } = enterActionHelperMob(
+                    args.pageDOM,
+                    args.fireflinkIndex
+                );
+
+                const element = await args.driver.$(xpathPath);
+
+                const parts = String(args.value).split(",");
+
+                const inputValue = parts[0]?.trim() || "";
+                const keyValue = parts[1]?.trim().toLowerCase() || "";
+
+                if (inputValue) {
+                    await element.setValue(inputValue);
+                }
+                if (keyValue) {
+                    switch (keyValue) {
+                        case "enter":
+                            await element.addValue("\uE007");
+                            break;
+
+                        case "tab":
+                            await element.addValue("\uE004");
+                            break;
+
+                        case "escape":
+                            await element.addValue("\uE00C");
+                            break;
+
+                        default:
+                            await args.driver.keys(keyValue);
+                    }
+                }
+                else {
+                    throw new Error("Please Mention Key in step")
+                }
+
+
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: "MOB_EnterDataAndPressKey",
+                        stepInputs: [inputValue, keyValue],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_EnterDataAndPressKey");
+                throw new Error("enter action failed", { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const { ffNumber, xpathPath } = enterActionHelper(
+                    args.pageDOM,
+                    args.fireflinkIndex
+                );
+
+                const element = await args.driver.$(xpathPath);
+
+                const parts = String(args.value).split(",");
+
+                const inputValue = parts[0]?.trim() || "";
+                const keyValue = parts[1]?.trim().toLowerCase() || "";
+
+                if (inputValue) {
+                    await element.setValue(inputValue);
+                }
+                if (keyValue) {
+                    switch (keyValue) {
+                        case "enter":
+                            await element.addValue("\uE007");
+                            break;
+
+                        case "tab":
+                            await element.addValue("\uE004");
+                            break;
+
+                        case "escape":
+                            await element.addValue("\uE00C");
+                            break;
+
+                        default:
+                            await args.driver.keys(keyValue);
+                    }
+                }
+                else {
+                    throw new Error("Please Mention Key in step")
+                }
+
+
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="Fire-Flink-${ffNumber}"]`
+                    );
+                    return {
+                        nlpName: "EnterDataAndPressKey",
+                        stepInputs: [inputValue, keyValue],   // Always array
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("EnterDataAndPressKey");
+                throw new Error("enter action failed", { cause: error });
+            }
+            break;
+    }
+
+}

package/src/automation/actions/interaction/enterActions/enterUrl.ts

@@ -0,0 +1,52 @@
+import { EnterUrlInterface } from "../../interface/interactionActionInterface.js";
+
+export async function enterUrl(args: EnterUrlInterface): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+                await args.driver.execute(`mobile: shell`, {
+                    command: "input",
+                    args: ["text", args.value]
+                });
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_EnterUrl',
+                        stepInputs: [args.value],
+                        elementsData: []
+                    };
+                });
+
+            }
+            catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_EnterUrl")
+                throw new Error(`enter action failed:`, { cause: error });
+            }
+            break;
+
+        case "web":
+        default:
+            try {
+
+                await args.driver.keys(args.value);
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'EnterURL',
+                        stepInputs: [args.value],
+                        elementsData: []
+                    };
+                });
+
+            }
+            catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("EnterURL")
+                throw new Error(`enter action failed:`, { cause: error });
+            }
+            break;
+    }
+
+}

package/src/automation/actions/interaction/enterActions/enterusingJs.ts

@@ -0,0 +1,41 @@
+import { EnterInputUsingJSInterface } from "../../interface/interactionActionInterface.js";
+import { enterActionHelper } from "../../../../utils/helpers/enterActionHelper.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+
+export async function enterInputUsingJs(args: EnterInputUsingJSInterface): Promise<void> {
+    try {
+
+        const { ffNumber, xpathPath } = enterActionHelper(
+            args.pageDOM,
+            args.fireflinkIndex
+        );
+        logger.info(`Enter input using JS for element with ffNumber: ${ffNumber}, xpathPath: ${xpathPath}`);
+
+        const element = await args.driver.$(xpathPath);
+        await element.scrollIntoView({ block: 'center', inline: 'center' });
+        await element.setValue(args.value);
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="Fire-Flink-${ffNumber}"]`
+            );
+            return {
+                nlpName: "EnterInputUsingJS",
+                stepInputs: [args.value],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("EnterInputUsingJS");
+        throw new Error("Enter input using JS failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/enterActions/waitAndEnter.ts

@@ -0,0 +1,106 @@
+import { WaitAndEnterInterface } from "../../interface/interactionActionInterface.js";
+import { enterActionHelper, enterActionHelperMob } from "../../../../utils/helpers/enterActionHelper.js";
+
+export async function waitAndEnter(args: WaitAndEnterInterface): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+                const { xpathPath } = enterActionHelperMob(
+                    args.pageDOM,
+                    args.fireflinkIndex
+                );
+
+                const [inputValueRaw, waitTimeRaw] = args.value.split(",");
+
+                const inputValue = inputValueRaw?.trim();
+                const waitTimeSeconds = Number(waitTimeRaw?.trim());
+
+                if (isNaN(waitTimeSeconds)) {
+                    throw new Error("Invalid wait time provided");
+                }
+
+                const element = await args.driver.$(xpathPath);
+
+                // Wait for specified seconds
+                await args.driver.pause(waitTimeSeconds * 1000);
+
+                await element.setValue(inputValue);
+
+
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_WaitAndSendKeys',
+                        stepInputs: [inputValue, waitTimeSeconds.toString()],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            }
+            catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_WaitAndSendKeys");
+                throw new Error(`WaitAndSendKeys action failed`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+                const { ffNumber, xpathPath } = enterActionHelper(
+                    args.pageDOM,
+                    args.fireflinkIndex
+                );
+
+                // Split value into input and wait time
+                const [inputValueRaw, waitTimeRaw] = args.value.split(",");
+
+                const inputValue = inputValueRaw?.trim();
+                const waitTimeSeconds = Number(waitTimeRaw?.trim());
+
+                if (isNaN(waitTimeSeconds)) {
+                    throw new Error("Invalid wait time provided");
+                }
+
+                const element = await args.driver.$(xpathPath);
+
+                // Wait for specified seconds
+                await args.driver.pause(waitTimeSeconds * 1000);
+
+                await element.scrollIntoView({ block: 'center', inline: 'center' });
+                await element.setValue(inputValue);
+
+
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="Fire-Flink-${ffNumber}"]`
+                    );
+                    return {
+                        nlpName: 'WaitAndSendKeys',
+                        stepInputs: [inputValue, waitTimeSeconds.toString()],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            }
+            catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("WaitAndSendKeys");
+                throw new Error(`WaitAndSendKeys action failed`, { cause: error });
+            }
+            break;
+    }
+
+}

package/src/automation/actions/interaction/find/findElements.ts

@@ -0,0 +1,57 @@
+import { FindElementsInterface } from "../../interface/findActionInterface.js";
+
+export async function findElements(
+    args: FindElementsInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: "MOB_FindElements",
+                        stepInputs: ["xpath", args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_FindElements");
+                throw new Error("find elements action failed", { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="Fire-Flink-${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: "FindElements",
+                        stepInputs: ["xpath", args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("FindElements");
+                throw new Error("find elements action failed", { cause: error });
+            }
+            break;
+    }
+
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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