ff-automationv2 2.1.3 → 2.2.0

package/src/automation/actions/interaction/alert/clickCancelOnAlertPopup.ts

@@ -0,0 +1,21 @@
+import { clickCancelOnAlertInterface } from "../../interface/alertActionInterface.js";
+
+export async function clickCancelOnAlertPopup(
+    args: clickCancelOnAlertInterface
+): Promise<void> {
+    try {
+        await args.driver.dismissAlert();
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "ClickCancelOnAlertPopup",
+            elementsData: [],
+            stepInputs: []
+        }));
+
+    } catch (error: any) {
+
+        args.scriptDataAppender.setErrorNLP("ClickCancelOnAlertPopup");
+
+        throw new Error("Click Cancel on alert popup failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/alert/clickOkOnAlertPopup.ts

@@ -0,0 +1,20 @@
+import { clickOkOnAlertInterface } from "../../interface/alertActionInterface.js";
+
+export async function clickOkOnAlertPopup(
+    args: clickOkOnAlertInterface
+): Promise<void> {
+    try {
+        await args.driver.acceptAlert();
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "ClickOkOnAlertPopup",
+            stepInputs: [],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+
+        args.scriptDataAppender.setErrorNLP("ClickOkOnAlertPopup");
+        throw new Error("Click OK on alert popup failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/alert/enterDataToAlert.ts

@@ -0,0 +1,20 @@
+import { enterDataToAlertInterface } from "../../interface/alertActionInterface.js";
+
+export async function enterDataToAlert(
+    args: enterDataToAlertInterface
+): Promise<void> {
+    try {
+        await args.driver.sendAlertText(args.value);
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "EnterDataToAlert",
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("EnterDataToAlert");
+
+        throw new Error("Enter data to alert failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/alert/getTextPresentOnAlertPopup.ts

@@ -0,0 +1,19 @@
+import { getTextPresentOnAlertPopupInterface } from "../../interface/alertActionInterface.js";
+
+export async function getTextPresentOnAlertPopup(
+    args: getTextPresentOnAlertPopupInterface
+): Promise<void> {
+    try {
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "GetTextPresentOnAlertPopup",
+            stepInputs: [],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+
+        args.scriptDataAppender.setErrorNLP("GetTextPresentOnAlertPopup");
+
+        throw new Error("Get Text Present On Alert Popup failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/alert/verifyAlertPopUpMessageContainsString.ts

@@ -0,0 +1,32 @@
+import { verifyAlertMessageInterface } from "../../interface/alertActionInterface.js";
+
+export async function verifyAlertPopUpMessageContainsString(
+    args: verifyAlertMessageInterface
+): Promise<void> {
+    try {
+        const alertText = await args.driver.getAlertText();
+
+        if (alertText.toLowerCase().includes(args.value.toLowerCase())) {
+
+            args.scriptDataAppender.add(async () => ({
+                nlpName: "VerifyAlertPopUpMessageContainsString",
+                stepInputs: [args.value],
+                elementsData: []
+            }));
+
+        } else {
+            args.scriptDataAppender.setErrorNLP(
+                "VerifyAlertPopUpMessageContainsString"
+            );
+
+            throw new Error("Alert message does not contain expected string");
+        }
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP(
+            "VerifyAlertPopUpMessageContainsString"
+        );
+
+        throw new Error("Verify alert popup message failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/alert/verifyAlertPopupIsDisplayed.ts

@@ -0,0 +1,19 @@
+import { verifyAlertPopupIsDisplayedInterface } from "../../interface/alertActionInterface.js";
+
+export async function verifyAlertPopupIsDisplayed(
+    args: verifyAlertPopupIsDisplayedInterface
+): Promise<void> {
+    try {
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "VerifyAlertPopupIsDisplayed",
+            stepInputs: [],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+
+        args.scriptDataAppender.setErrorNLP("VerifyAlertPopupIsDisplayed");
+
+        throw new Error("Verify Alert Popup Is Displayed failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/alert/verifyTextPresentOnAlertPopup.ts

@@ -0,0 +1,33 @@
+import { verifyExactAlertTextInterface } from "../../interface/alertActionInterface.js";
+
+export async function verifyTextPresentOnAlertPopup(
+    args: verifyExactAlertTextInterface
+): Promise<void> {
+    try {
+        const alertText = await args.driver.getAlertText();
+
+        if (alertText.toLowerCase() === args.value.toLowerCase()) {
+
+            args.scriptDataAppender.add(async () => ({
+                nlpName: "VerifyTextPresentOnAlertPopup",
+                stepInputs: [args.value],
+                elementsData: []
+            }));
+
+        } else {
+            args.scriptDataAppender.setErrorNLP(
+                "VerifyTextPresentOnAlertPopup"
+            );
+
+            throw new Error("Alert message does not exactly match expected string");
+        }
+
+    } catch (error: any) {
+
+        args.scriptDataAppender.setErrorNLP(
+            "VerifyTextPresentOnAlertPopup"
+        );
+
+        throw new Error("Verify text present on alert popup failed", { cause: error });
+    }
+}

package/src/automation/actions/interaction/alert/waitTillAlertIsPresent.ts

@@ -0,0 +1,25 @@
+import { waitTillAlertIsPresentInterface } from "../../interface/alertActionInterface.js";
+
+export async function waitTillAlertIsPresent(
+    args: waitTillAlertIsPresentInterface
+): Promise<void> {
+    const { timeout = 10000 } = args;
+
+    try {
+        await args.driver.waitUntil(
+            async () => await args.driver.isAlertOpen(),
+            { timeout }
+        );
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "WaitTillAlertIsPresent",
+            stepInputs: [],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("WaitTillAlertIsPresent");
+
+        throw new Error("Wait till alert is present failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,61 @@
+import { clearActionInterface } from "../../interface/clearActionInterface.js";
+export async function clear(args: clearActionInterface): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                await args.driver.$(args.selector).clearValue();
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_Clear',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            }
+            catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_Clear")
+                throw new Error("clear action failed", { cause: error });
+
+            }
+            break;
+        case "web":
+        default:
+            try {
+                await args.driver.$(args.selector).clearValue();
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'Clear',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            }
+            catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("Clear")
+                throw new Error("clear action failed", { cause: error });
+
+            }
+            break;
+    }
+
+
+}

package/src/automation/actions/interaction/clear/clearAndEnter.ts

@@ -0,0 +1,58 @@
+import { clearAndEnterActionInterface } from "../../interface/clearActionInterface.js";
+export async function clearAndEnter(args: clearAndEnterActionInterface): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                const element = args.driver.$(args.selector);
+                await element.clearValue();
+                await element.setValue(args.value);
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_ClearThenEnterInput',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_ClearThenEnterInput")
+                throw new Error("clear and enter action failed", { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const element = args.driver.$(args.selector);
+                await element.clearValue();
+                await element.setValue(args.value);
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'ClearThenEnterInput',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("ClearThenEnterInput")
+                throw new Error("clear and enter action failed", { cause: error });
+            }
+            break;
+    }
+
+}

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

@@ -0,0 +1,61 @@
+import { ClickInterface } from "../../interface/clickActionInterface.js";
+
+export async function click(args: ClickInterface): Promise<void> {
+
+    switch (args.platform) {
+
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+                await element.click();
+
+                args.scriptDataAppender.add(async () => ({
+                    nlpName: "MOB_Tap",
+                    stepInputs: [],
+                    elementsData: [{
+                        name: args.elementName,
+                        type: args.elementType,
+                        locators: [{ "xpath": args.selector }],
+                        platform: args.platform
+                    }]
+                }));
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_Tap");
+                throw new Error(`MOB_Tap action failed`, { cause: error });
+            }
+            break;
+
+
+        case "web":
+        default:
+            try {
+                const element = await args.driver.$(args.selector);
+                await element.scrollIntoView({ block: "center", inline: "center" });
+                await element.click();
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+
+                    return {
+                        nlpName: "Click",
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("Click");
+                throw new Error(`Click action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/src/automation/actions/interaction/click/clickNtimes.ts

@@ -0,0 +1,67 @@
+import { ClickNTimesInterface } from "../../interface/clickActionInterface.js";
+
+export async function clickNTimes(args: ClickNTimesInterface): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+                for (let i = 0; i < Number(args.value); i++) {
+                    await element.click();
+                }
+
+                args.scriptDataAppender.add(async () => {
+
+
+                    return {
+                        nlpName: 'MOB_TapNTimes',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+
+                });
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_TapNTimes")
+                throw new Error(`TapNTimes action failed :`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const element = await args.driver.$(args.selector);
+                await element.scrollIntoView({ block: 'center', inline: 'center' });
+                for (let i = 0; i < Number(args.value); i++) {
+                    await element.click();
+                }
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+
+                    return {
+                        nlpName: 'ClickNTimes',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+
+                });
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("ClickNTimes")
+                throw new Error(`ClickNTimes action failed :`, { cause: error });
+            }
+
+            break;
+    }
+
+}

package/src/automation/actions/interaction/click/clickUsingJs.ts

@@ -0,0 +1,33 @@
+import { ClickUsingJSInterface } from "../../interface/clickActionInterface.js";
+
+export async function clickUsingJS(args: ClickUsingJSInterface): Promise<void> {
+    try {
+        const element = await args.driver.$(args.selector);
+        await args.driver.execute((el: any) => {
+            el.click();
+        }, element);
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+
+            return {
+                nlpName: 'ClickUsingJS',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+
+        });
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("ClickUsingJS")
+        throw new Error(`ClickUsingJS action failed :`, { cause: error });
+    }
+}

package/src/automation/actions/interaction/click/doubleClick.ts

@@ -0,0 +1,66 @@
+import { DoubleClickInterface } from "../../interface/clickActionInterface.js";
+export async function doubleClick(args: DoubleClickInterface): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+                await args.driver.touchAction([
+                    { action: 'tap', element },
+                    { action: 'wait', ms: 50 },
+                    { action: 'tap', element }
+                ]);
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_DoubleTap',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_DoubleTap")
+                throw new Error(`DoubleClick action failed :`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const element = await args.driver.$(args.selector);
+                await element.scrollIntoView({ block: 'center', inline: 'center' });
+                await element.doubleClick();
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+
+                    return {
+                        nlpName: 'DoubleClick',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("DoubleClick")
+                throw new Error(`DoubleClick action failed :`, { cause: error });
+            }
+            break;
+    }
+
+}

package/src/automation/actions/interaction/click/rightClick.ts

@@ -0,0 +1,29 @@
+import { RightClickInterface } from "../../interface/clickActionInterface.js";
+export async function rightClick(args: RightClickInterface): Promise<void> {
+    try {
+        const element = await args.driver.$(args.selector);
+        await element.scrollIntoView({ block: 'center', inline: 'center' });
+        await element.click({ button: 2 });
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+
+            return {
+                nlpName: 'RightClick',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+
+        });
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("RightClick")
+        throw new Error(`RightClick action failed :`, { cause: error });
+    }
+}

package/src/automation/actions/interaction/click/waitAndClick.ts

@@ -0,0 +1,83 @@
+import { WaitAndClickInterface } from "../../interface/clickActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function waitAndClick(args: WaitAndClickInterface): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+                const element = await args.driver.$(args.selector);
+                let waitTime: number;
+                if (args.value != "") {
+                    waitTime = parseInt(args.value);
+                    await element.waitForDisplayed({ timeout: waitTime });
+                } else {
+                    await element.waitForDisplayed({ timeout: 10000 });
+                }
+
+                logger.info(`Element became visible. Clicking selector: ${args.selector}`);
+
+                await element.click();
+
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'MOB_WaitAndClick',
+                        stepInputs: [waitTime ? waitTime : 10],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_WaitAndClick");
+                throw new Error(`WaitAndClick action failed`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                let waitTime: number;
+                const element = await args.driver.$(args.selector);
+
+                if (args.value != "") {
+                    waitTime = parseInt(args.value);
+                    await element.waitForDisplayed({ timeout: waitTime });
+                } else {
+                    await element.waitForDisplayed({ timeout: 10000 });
+                }
+
+                logger.info(`Element became visible. Clicking selector: ${args.selector}`);
+
+                await element.click();
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+
+                    return {
+                        nlpName: 'WaitAndClick',
+                        stepInputs: [waitTime ? waitTime : 10],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("WaitAndClick");
+                throw new Error(`WaitAndClick action failed`, { cause: error });
+            }
+            break;
+    }
+}