ff-automationv2 2.1.3 → 2.2.0

package/src/automation/actions/interaction/wait/waitTillElementContainsText.ts

@@ -0,0 +1,79 @@
+import { waitTillElementContainsTextInterface } from "../../interface/waitActionInterface.js";
+
+export async function waitTillElementContainsText(
+    args: waitTillElementContainsTextInterface
+): Promise<void> {
+
+
+    switch (args.platform) {
+
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+
+                await args.driver.waitUntil(async () => {
+                    const text = await element.getText();
+                    return text.includes(args.value);
+                }, {
+                    timeout: 10000,
+                    timeoutMsg: `Element ${args.elementName} text did not contain ${args.value}`
+                });
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'MOB_WaitTillElementContainsText',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ xpath: args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_WaitTillElementContainsText")
+                throw new Error(`WaitTillElementContainsText action failed`, { cause: error });
+            }
+            break;
+
+
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+                await args.driver.waitUntil(async () => {
+                    const text = await element.getText();
+                    return text.includes(args.value);
+                }, {
+                    timeout: 10000,
+                    timeoutMsg: `Element ${args.elementName} text did not contain ${args.value}`
+                });
+                args.scriptDataAppender.add(async () => {
+
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+
+                    return {
+                        nlpName: 'WaitTillElementContainsText',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("WaitTillElementContainsText")
+                throw new Error(`WaitTillElementContainsText action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/src/automation/actions/interaction/wait/waitTillElementHasText.ts

@@ -0,0 +1,71 @@
+import { waitTillElementHasTextInterface } from "../../interface/waitActionInterface.js";
+
+export async function waitTillElementHasText(
+    args: waitTillElementHasTextInterface
+): Promise<void> {
+
+
+    switch (args.platform) {
+
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+                await element.waitForDisplayed({
+                    timeout: 10000,
+                    timeoutMsg: `Element ${args.elementName} did not display`
+                });
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'MOB_WaitTillElementHasText',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ xpath: args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_WaitTillElementHasText")
+                throw new Error(`WaitTillElementHasText action failed`, { cause: error });
+            }
+            break;
+
+
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+                await element.waitForDisplayed({
+                    timeout: 10000,
+                    timeoutMsg: `Element ${args.elementName} did not display`
+                });
+                args.scriptDataAppender.add(async () => {
+
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+
+                    return {
+                        nlpName: 'WaitTillElementHasText',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("WaitTillElementHasText")
+                throw new Error(`WaitTillElementHasText action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/src/automation/actions/interaction/wait/waitTillElementIsClickable.ts

@@ -0,0 +1,72 @@
+import { waitTillElementIsClickableInterface } from "../../interface/waitActionInterface.js";
+
+export async function waitTillElementIsClickable(
+    args: waitTillElementIsClickableInterface
+): Promise<void> {
+
+
+    switch (args.platform) {
+
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+                await element.waitForClickable({
+                    timeout: 10000,
+                    timeoutMsg: `Element ${args.elementName} did not become clickable`
+                });
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'MOB_WaitTillElementIsClickable',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ xpath: args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_WaitTillElementIsClickable")
+                throw new Error(`WaitTillElementIsClickable action failed`, { cause: error });
+            }
+            break;
+
+
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+                await element.waitForClickable({
+                    timeout: 10000,
+                    timeoutMsg: `Element ${args.elementName} did not become clickable`
+                });
+                args.scriptDataAppender.add(async () => {
+
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+
+                    return {
+                        nlpName: 'WaitTillElementIsClickable',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("WaitTillElementIsClickable")
+                throw new Error(`WaitTillElementIsClickable action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/src/automation/actions/interaction/wait/waitTillPresenceOfAllElements.ts

@@ -0,0 +1,72 @@
+import { WaitTillPresenceOfAllElementsInterface } from "../../interface/waitActionInterface.js";
+
+export async function waitTillPresenceOfAllElements(
+    args: WaitTillPresenceOfAllElementsInterface
+): Promise<void> {
+
+    switch (args.platform) {
+
+        case "android":
+            try {
+                const parts = args.value.split(",");
+                const locatorType = parts[0].trim();
+                const locatorValue = parts[1].trim();
+
+                const elements = await args.driver.$$(`${locatorType}=${locatorValue}`);
+
+                await args.driver.waitUntil(async () => {
+                    return elements.length > 0;
+                }, {
+                    timeout: 10000,
+                    timeoutMsg: "Elements not present"
+                });
+
+
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'MOB_WaitTillPresenceOfAllElements',
+                        stepInputs: [locatorType, locatorValue],
+                        elementsData: []
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_WaitTillPresenceOfAllElements")
+                throw new Error(`WaitTillPresenceOfAllElements action failed`, { cause: error });
+            }
+            break;
+
+
+        case "web":
+        default:
+            try {
+
+                const parts = args.value.split(",");
+                const locatorType = parts[0].trim();
+                const locatorValue = parts[1].trim();
+
+                const elements = await args.driver.$$(`${locatorType}=${locatorValue}`);
+
+                await args.driver.waitUntil(async () => {
+                    return elements.length > 0;
+                }, {
+                    timeout: 10000,
+                    timeoutMsg: "Elements not present"
+                });
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'WaitTillPresenceOfAllElements',
+                        stepInputs: [locatorType, locatorValue],
+                        elementsData: []
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("WaitTillPresenceOfAllElements")
+                throw new Error(`WaitTillPresenceOfAllElements action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/src/automation/actions/interaction/wait/waitTillPresenceOfElement.ts

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

package/src/automation/actions/interface/IframeInterface.ts

@@ -0,0 +1,6 @@
+import { ScriptDataAppender } from "../../../fireflinkData/fireflinkScript/scriptGenrationData.js";
+
+export interface SwitchToDefaultContentInterface {
+    driver: WebdriverIO.Browser;
+    scriptDataAppender: ScriptDataAppender;
+}

package/src/automation/actions/interface/alertActionInterface.ts

@@ -0,0 +1,39 @@
+import { ScriptDataAppender } from "../../../fireflinkData/fireflinkScript/scriptGenrationData.js";
+
+export interface clickOkOnAlertInterface {
+    driver: WebdriverIO.Browser;
+    scriptDataAppender: ScriptDataAppender;
+}
+
+export interface clickCancelOnAlertInterface {
+    driver: WebdriverIO.Browser;
+    scriptDataAppender: ScriptDataAppender;
+}
+export interface enterDataToAlertInterface {
+    driver: WebdriverIO.Browser;
+    value: string;
+    scriptDataAppender: ScriptDataAppender;
+}
+export interface verifyAlertPopupIsDisplayedInterface {
+    driver: WebdriverIO.Browser;
+    scriptDataAppender: ScriptDataAppender;
+}
+export interface getTextPresentOnAlertPopupInterface {
+    driver: WebdriverIO.Browser;
+    scriptDataAppender: ScriptDataAppender;
+}
+export interface verifyAlertMessageInterface {
+    driver: WebdriverIO.Browser;
+    value: string;
+    scriptDataAppender: any;
+}
+export interface verifyExactAlertTextInterface {
+    driver: WebdriverIO.Browser;
+    value: string;
+    scriptDataAppender: any;
+}
+export interface waitTillAlertIsPresentInterface {
+    driver: WebdriverIO.Browser;
+    timeout?: number;
+    scriptDataAppender: any;
+}

package/src/automation/actions/interface/clearActionInterface.ts

@@ -0,0 +1,27 @@
+import { ScriptDataAppender } from "../../../fireflinkData/fireflinkScript/scriptGenrationData.js";
+import { ElementGetter } from "../../../fireflinkData/fireflinkLocators/getListOfLocators.js"
+
+export interface clearActionInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    scriptDataAppender: ScriptDataAppender;
+    elementGetter: ElementGetter;
+    fireflinkIndex: string;
+    pageDOM: string;
+    elementName: string;
+    elementType: any;
+    platform: string;
+}
+
+export interface clearAndEnterActionInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    value: string;
+    scriptDataAppender: ScriptDataAppender;
+    elementGetter: ElementGetter;
+    fireflinkIndex: string;
+    pageDOM: string;
+    elementName: string;
+    elementType: any;
+    platform: string;
+}

package/src/automation/actions/interface/clickActionInterface.ts

@@ -0,0 +1,87 @@
+import { ScriptDataAppender } from "../../../fireflinkData/fireflinkScript/scriptGenrationData.js";
+import { ElementGetter } from "../../../fireflinkData/fireflinkLocators/getListOfLocators.js"
+
+export interface ClickInterface {
+  driver: WebdriverIO.Browser;
+  selector: string;
+  scriptDataAppender: ScriptDataAppender;
+  elementGetter: ElementGetter;
+  fireflinkIndex: string;
+  pageDOM: string;
+  elementName: string;
+  elementType: any;
+  platform: string;
+}
+
+export interface RightClickInterface {
+  driver: WebdriverIO.Browser;
+  selector: string;
+  scriptDataAppender: ScriptDataAppender;
+  elementGetter: ElementGetter;
+  fireflinkIndex: string;
+  pageDOM: string;
+  elementName: string;
+  elementType: any;
+  platform: string;
+}
+
+export interface DoubleClickInterface {
+  driver: WebdriverIO.Browser;
+  selector: string;
+  scriptDataAppender: ScriptDataAppender;
+  elementGetter: ElementGetter;
+  fireflinkIndex: string;
+  pageDOM: string;
+  elementName: string;
+  elementType: any;
+  platform: string;
+}
+
+export interface WaitAndClickInterface {
+  driver: WebdriverIO.Browser;
+  selector: string;
+  value: string;
+  scriptDataAppender: ScriptDataAppender;
+  elementGetter: ElementGetter;
+  fireflinkIndex: string;
+  pageDOM: string;
+  elementName: string;
+  elementType: any;
+  platform: string;
+}
+
+export interface ClickNTimesInterface {
+  driver: WebdriverIO.Browser;
+  selector: string;
+  value: string;
+  scriptDataAppender: ScriptDataAppender;
+  elementGetter: ElementGetter;
+  fireflinkIndex: string;
+  pageDOM: string;
+  elementName: string;
+  elementType: any;
+  platform: string;
+}
+
+export interface ClickUsingJSInterface {
+  driver: WebdriverIO.Browser;
+  selector: string;
+  scriptDataAppender: ScriptDataAppender;
+  elementGetter: ElementGetter;
+  fireflinkIndex: string;
+  pageDOM: string;
+  elementName: string;
+  elementType: any;
+  platform: string;
+}
+export interface MOB_TapInterface {
+  driver: WebdriverIO.Browser;
+  selector: string;
+  scriptDataAppender: ScriptDataAppender;
+  elementGetter: ElementGetter;
+  fireflinkIndex: string;
+  pageDOM: string;
+  elementName: string;
+  elementType: any;
+  platform: string;
+}

package/src/automation/actions/interface/dragAndDropToElementInterface.ts

@@ -0,0 +1,18 @@
+import { ScriptDataAppender } from "../../../fireflinkData/fireflinkScript/scriptGenrationData.js";
+import { ElementGetter } from "../../../fireflinkData/fireflinkLocators/getListOfLocators.js";
+
+export interface DragAndDropToElementInterface {
+    driver: WebdriverIO.Browser;
+    selector1: string;
+    selector2: string;
+    scriptDataAppender: ScriptDataAppender;
+    elementGetter: ElementGetter;
+    fireflinkIndex1: string;
+    fireflinkIndex2: string;
+    pageDOM: string;
+    elementName1: string;
+    elementName2: string;
+    elementType1: string;
+    elementType2: string;
+    platform: string;
+}

package/src/automation/actions/interface/findActionInterface.ts

@@ -0,0 +1,15 @@
+import { ElementGetter } from "../../../fireflinkData/fireflinkLocators/getListOfLocators";
+import { ScriptDataAppender } from "../../../fireflinkData/fireflinkScript/scriptGenrationData";
+
+export interface FindElementsInterface {
+    driver: WebdriverIO.Browser;
+    selector: string;
+    elementName: string;
+    elementType: string;
+    fireflinkIndex: string;
+    pageDOM: string;
+    elementGetter: ElementGetter;
+    scriptDataAppender: ScriptDataAppender;
+    platform: string;
+    value: string;
+}