ff-automationv2 2.1.3 → 2.2.2

package/dist/automation/actions/interaction/wait/waitTillAttributeOfElementIsString.js

@@ -0,0 +1,68 @@
+export async function waitTillAttributeOfElementIsString(args) {
+    switch (args.platform) {
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+                const parts = args.value.split(",");
+                const attr = parts[0].trim();
+                const expectedValue = parts[1].trim();
+                await args.driver.waitUntil(async () => {
+                    const actualValue = await element.getAttribute(attr);
+                    return actualValue === expectedValue;
+                }, {
+                    timeout: 10000,
+                    timeoutMsg: `Attribute ${attr} did not become ${expectedValue}`
+                });
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'MOB_WaitTillAttributeOfElementIsString',
+                        stepInputs: [],
+                        elementsData: [{
+                                name: args.elementName,
+                                type: args.elementType,
+                                locators: [{ xpath: args.selector }],
+                                platform: args.platform
+                            }]
+                    };
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("MOB_WaitTillAttributeOfElementIsString");
+                throw new Error(`WaitTillAttributeOfElementIsString action failed`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                const element = await args.driver.$(args.selector);
+                const parts = args.value.split(",");
+                const attr = parts[0].trim();
+                const expectedValue = parts[1].trim();
+                await args.driver.waitUntil(async () => {
+                    const actualValue = await element.getAttribute(attr);
+                    return actualValue === expectedValue;
+                }, {
+                    timeout: 10000,
+                    timeoutMsg: `Attribute ${attr} did not become ${expectedValue}`
+                });
+                args.scriptDataAppender.add(async () => {
+                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
+                    return {
+                        nlpName: 'WaitTillAttributeOfElementIsString',
+                        stepInputs: [],
+                        elementsData: [{
+                                name: args.elementName,
+                                type: args.elementType,
+                                locators: ffElement.locators,
+                                platform: args.platform
+                            }]
+                    };
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("WaitTillAttributeOfElementIsString");
+                throw new Error(`WaitTillAttributeOfElementIsString action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/wait/waitTillElementContainsText.d.ts

@@ -0,0 +1,2 @@
+import { waitTillElementContainsTextInterface } from "../../interface/waitActionInterface.js";
+export declare function waitTillElementContainsText(args: waitTillElementContainsTextInterface): Promise<void>;

package/dist/automation/actions/interaction/wait/waitTillElementContainsText.js

@@ -0,0 +1,62 @@
+export async function waitTillElementContainsText(args) {
+    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) {
+                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 = 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) {
+                args.scriptDataAppender.setErrorNLP("WaitTillElementContainsText");
+                throw new Error(`WaitTillElementContainsText action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/wait/waitTillElementHasText.d.ts

@@ -0,0 +1,2 @@
+import { waitTillElementHasTextInterface } from "../../interface/waitActionInterface.js";
+export declare function waitTillElementHasText(args: waitTillElementHasTextInterface): Promise<void>;

package/dist/automation/actions/interaction/wait/waitTillElementHasText.js

@@ -0,0 +1,56 @@
+export async function waitTillElementHasText(args) {
+    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) {
+                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 = 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) {
+                args.scriptDataAppender.setErrorNLP("WaitTillElementHasText");
+                throw new Error(`WaitTillElementHasText action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/wait/waitTillElementIsClickable.d.ts

@@ -0,0 +1,2 @@
+import { waitTillElementIsClickableInterface } from "../../interface/waitActionInterface.js";
+export declare function waitTillElementIsClickable(args: waitTillElementIsClickableInterface): Promise<void>;

package/dist/automation/actions/interaction/wait/waitTillElementIsClickable.js

@@ -0,0 +1,56 @@
+export async function waitTillElementIsClickable(args) {
+    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) {
+                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 = 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) {
+                args.scriptDataAppender.setErrorNLP("WaitTillElementIsClickable");
+                throw new Error(`WaitTillElementIsClickable action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/wait/waitTillPresenceOfAllElements.d.ts

@@ -0,0 +1,2 @@
+import { WaitTillPresenceOfAllElementsInterface } from "../../interface/waitActionInterface.js";
+export declare function waitTillPresenceOfAllElements(args: WaitTillPresenceOfAllElementsInterface): Promise<void>;

package/dist/automation/actions/interaction/wait/waitTillPresenceOfAllElements.js

@@ -0,0 +1,55 @@
+export async function waitTillPresenceOfAllElements(args) {
+    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) {
+                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) {
+                args.scriptDataAppender.setErrorNLP("WaitTillPresenceOfAllElements");
+                throw new Error(`WaitTillPresenceOfAllElements action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/dist/automation/actions/interaction/wait/waitTillPresenceOfElement.d.ts

@@ -0,0 +1,2 @@
+import { waitTillPresenceOfElementInterface } from "../../interface/waitActionInterface.js";
+export declare function waitTillPresenceOfElement(args: waitTillPresenceOfElementInterface): Promise<void>;

package/dist/automation/actions/interaction/wait/waitTillPresenceOfElement.js

@@ -0,0 +1,50 @@
+export async function waitTillPresenceOfElement(args) {
+    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) {
+                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 = 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) {
+                args.scriptDataAppender.setErrorNLP("WaitTillPresenceOfElement");
+                throw new Error(`WaitTillPresenceOfElement action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/{src/automation/actions/interface/waitActionInterface.ts → dist/automation/actions/interface/IframeInterface.d.ts}

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

package/dist/automation/actions/interface/IframeInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/automation/actions/interface/alertActionInterface.d.ts

@@ -0,0 +1,37 @@
+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/dist/automation/actions/interface/alertActionInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/automation/actions/interface/clearActionInterface.d.ts

@@ -0,0 +1,25 @@
+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/dist/automation/actions/interface/clearActionInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/automation/actions/interface/clickActionInterface.d.ts

@@ -0,0 +1,81 @@
+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/dist/automation/actions/interface/clickActionInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/automation/actions/interface/dragAndDropToElementInterface.d.ts

@@ -0,0 +1,17 @@
+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/dist/automation/actions/interface/dragAndDropToElementInterface.js

@@ -0,0 +1 @@
+export {};

package/dist/automation/actions/interface/findActionInterface.d.ts

@@ -0,0 +1,14 @@
+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;
+}

package/dist/automation/actions/interface/findActionInterface.js

@@ -0,0 +1 @@
+export {};