ff-automationv2 2.1.3 → 2.2.0

package/src/automation/actions/interaction/verify/VerifyXLocationOfElement.ts

@@ -0,0 +1,89 @@
+import { VerifyXLocationOfElementInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyXLocationOfElement(
+    args: VerifyXLocationOfElementInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+
+                const expectedX = parseInt(args.value, 10);
+                const location = await element.getLocation();
+
+                const isMatched = location.x === expectedX;
+
+                logger.info("X location verification result:", {
+                    isMatched,
+                    actualX: location.x,
+                    expectedX
+                });
+                if (isMatched === false) {
+                    throw new Error(`Element X location does not match expected. Expected: ${expectedX}px, Actual: ${location.x}px`);
+                }
+
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'MOB_VerifyXLocationOfAndroidElement',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_VerifyXLocationOfAndroidElement");
+                throw new Error(`VerifyXLocationOfAndroidElement action failed`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+
+                const expectedX = parseInt(args.value, 10);
+                const location = await element.getLocation();
+
+                const isMatched = location.x === expectedX;
+
+                logger.info("X location verification result:", {
+                    isMatched,
+                    actualX: location.x,
+                    expectedX
+                });
+                if (isMatched === false) {
+                    throw new Error(`Element X location does not match expected. Expected: ${expectedX}px, Actual: ${location.x}px`);
+                }
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'VerifyXLocationOfElement',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("VerifyXLocationOfElement");
+                throw new Error(`VerifyXLocationOfElement action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/src/automation/actions/interaction/verify/VerifyYLocationOfElement.ts

@@ -0,0 +1,90 @@
+import { VerifyYLocationOfElementInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyYLocationOfElement(
+    args: VerifyYLocationOfElementInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+
+                const expectedY = parseInt(args.value, 10);
+                const location = await element.getLocation();
+
+                const isMatched = location.y === expectedY;
+
+                logger.info("Y location verification result:", {
+                    isMatched,
+                    actualY: location.y,
+                    expectedY
+                });
+
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_VerifyYLocationOfAndroidElement',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_VerifyYLocationOfAndroidElement");
+                throw new Error(`VerifyYLocationOfAndroidElement action failed`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+
+                const expectedY = parseInt(args.value, 10);
+                const location = await element.getLocation();
+
+                const isMatched = location.y === expectedY;
+
+                logger.info("Y location verification result:", {
+                    isMatched,
+                    actualY: location.y,
+                    expectedY
+                });
+
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'VerifyYLocationOfElement',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("VerifyYLocationOfElement");
+                throw new Error(`VerifyYLocationOfElement action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/src/automation/actions/interaction/verify/checkIfElementIsDisplayed.ts

@@ -0,0 +1,83 @@
+import { CheckIfElementIsDisplayedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function checkIfElementIsDisplayed(
+    args: CheckIfElementIsDisplayedInterface
+): Promise<void> {
+
+
+
+    switch (args.platform) {
+
+        case "android":
+            try {
+
+                const element = await args.driver.$(args.selector);
+                const timeout = parseInt(args.value || "10000", 10);
+                await args.driver.waitUntil(async () => {
+                    return await element.isDisplayed();
+                }, {
+                    timeout,
+                    timeoutMsg: "Element not displayed within given time"
+                });
+
+                logger.info("Element displayed successfully");
+
+                args.scriptDataAppender.add(async () => ({
+                    nlpName: 'MOB_CheckIfElementIsDisplayed',
+                    stepInputs: [args.value],
+                    elementsData: [{
+                        name: args.elementName,
+                        type: args.elementType,
+                        locators: [{ xpath: args.selector }],
+                        platform: args.platform
+                    }]
+                }));
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_CheckIfElementIsDisplayed");
+                throw new Error(`CheckIfElementIsDisplayed action failed`, { cause: error });
+            }
+            break;
+
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+                const timeout = parseInt(args.value || "10000", 10);
+                await args.driver.waitUntil(async () => {
+                    return await element.isDisplayed();
+                }, {
+                    timeout,
+                    timeoutMsg: "Element not displayed within given time"
+                });
+
+                logger.info("Element displayed successfully");
+
+                args.scriptDataAppender.add(async () => {
+
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+
+                    return {
+                        nlpName: 'CheckIfElementIsDisplayed',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("CheckIfElementIsDisplayed");
+                throw new Error(`CheckIfElementIsDisplayed action failed`, { cause: error });
+            }
+            break;
+    }
+}

package/src/automation/actions/interaction/verify/verifypartialtext.ts

@@ -0,0 +1,131 @@
+import { VerifyPartialTextInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyPartialText(
+    args: VerifyPartialTextInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+                const element = await args.driver.$(args.selector);
+                const actual = await element.getAttribute("text");
+                const expected = args.value;
+                if (actual !== expected) {
+                    throw new Error(`Element does not contain the expected text. Expected to contain: "${args.value}", Actual: "${actual}"`);
+                }
+                const caseSensitive = false
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_VerifyPartialText',
+                        stepInputs: [expected, caseSensitive],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_VerifyPartialText")
+                throw new Error(`VerifyPartialText action failed `, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+
+                const normalizeText = (text?: string | null): string => {
+                    if (!text) return "";
+
+                    // Remove zero-width characters
+                    text = text.replace(/\p{Cf}/gu, "");
+
+                    // Normalize spaces
+                    text = text.replace(/\s+/g, " ");
+
+                    return text.trim().toLowerCase();
+                };
+
+                const expected = normalizeText(args.value);
+
+                const texts: string[] = [];
+
+                // Visible text
+                const visibleText = await element.getText();
+                if (visibleText) texts.push(visibleText);
+
+                // Input value
+                const value = await element.getAttribute("value");
+                if (value) texts.push(value);
+
+                // Accessibility attributes
+                const attributes = ["placeholder", "aria-label", "name", "id"];
+                for (const attr of attributes) {
+                    const v = await element.getAttribute(attr);
+                    if (v) texts.push(v);
+                }
+
+                // Fallback attributes
+                const fallbackAttrs = ["textContent", "innerText"];
+                for (const attr of fallbackAttrs) {
+                    const v = await element.getAttribute(attr);
+                    if (v) texts.push(v);
+                }
+
+                // Debug (limited text logging)
+                const limited = texts.map(t =>
+                    t.length > 50 ? t.substring(0, 50) + "..." : t
+                );
+                logger.info("Extracted texts for verification:", { extractedTexts: limited });
+                logger.info("Expected text for verification:", { expectedText: expected });
+
+                let isMatched = false;
+
+                for (const t of texts) {
+                    const clean = normalizeText(t);
+                    if (clean.includes(expected)) {
+                        isMatched = true;
+                        break;
+                    }
+                }
+                const caseSensitive = false
+
+                // FireFlink Logging
+                logger.info("result of verify text:", { isMatched });
+                if (isMatched === false) {
+                    throw new Error(`Element does not contain the expected text. Expected to contain: "${args.value}", Actual texts: ${limited.join(" | ")}`);
+                }
+
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'VerifyPartialText',
+                        stepInputs: [expected, caseSensitive],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("VerifyPartialText")
+                throw new Error(`VerifyPartialText action failed `, { cause: error });
+            }
+            break;
+    }
+
+}
+

package/src/automation/actions/interaction/verify/verifytext.ts

@@ -0,0 +1,143 @@
+import { VerifyTextInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyText(
+    args: VerifyTextInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+
+                const text = (await element.getAttribute("text")) || "";
+                const contentDesc = (await element.getAttribute("content-desc")) || "";
+
+                const expected = (args.value || "").toLowerCase();
+
+                const isMatched =
+                    text.toLowerCase() === expected ||
+                    contentDesc.toLowerCase() === expected;
+
+                logger.info("result of verify text:", { isMatched });
+                const caseSensitive = false; // Assuming case-insensitive for logging
+                if (isMatched === false) {
+                    throw new Error(`Element text does not match expected. Expected: "${args.value}", Actual: "${expected}"`);
+                }
+
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_VerifyText',
+                        stepInputs: [expected, caseSensitive],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_VerifyText")
+                throw new Error(`VerifyText action failed `, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+
+                const normalizeText = (text?: string | null): string => {
+                    if (!text) return "";
+
+                    // Remove zero-width characters
+                    text = text.replace(/\p{Cf}/gu, "");
+
+                    // Normalize spaces
+                    text = text.replace(/\s+/g, " ");
+
+                    return text.trim().toLowerCase();
+                };
+
+                const expected = normalizeText(args.value);
+
+                const texts: string[] = [];
+
+                // Visible text
+                const visibleText = await element.getText();
+                if (visibleText) texts.push(visibleText);
+
+                // Input value
+                const value = await element.getAttribute("value");
+                logger.info("Extracted value attribute for verification:", { value });
+                if (value) texts.push(value);
+
+                // Accessibility attributes
+                const attributes = ["placeholder", "aria-label", "name", "id"];
+                for (const attr of attributes) {
+                    const v = await element.getAttribute(attr);
+                    if (v) texts.push(v);
+                }
+
+                // Fallback attributes
+                const fallbackAttrs = ["textContent", "innerText"];
+                for (const attr of fallbackAttrs) {
+                    const v = await element.getAttribute(attr);
+                    if (v) texts.push(v);
+                }
+
+                // Debug (limited text logging)
+                const limited = texts.map(t =>
+                    t.length > 50 ? t.substring(0, 50) + "..." : t
+                );
+                logger.info("Extracted texts for verification:", { extractedTexts: limited });
+                logger.info("Expected text for verification:", { expectedText: expected });
+
+                let isMatched = false;
+
+                for (const t of texts) {
+                    const clean = normalizeText(t);
+                    if (expected === clean) {
+                        isMatched = true;
+                        break;
+                    }
+                }
+
+                // FireFlink Logging
+                logger.info("result of verify text:", { isMatched });
+                const caseSensitive = false; // Assuming case-insensitive for logging
+                if (isMatched === false) {
+                    throw new Error(`Element text does not match expected. Expected: "${args.value}", Actual: "${texts.join(" | ")}"`);
+                }
+
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'VerifyText',
+                        stepInputs: [expected, caseSensitive],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("VerifyText")
+                throw new Error(`VerifyText action failed `, { cause: error });
+            }
+            break;
+    }
+}
+

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

@@ -0,0 +1,16 @@
+import { waitInterface } from "../../interface/waitActionInterface.js";
+export async function wait(args: waitInterface): Promise<void> {
+    try {
+        await args.driver.pause(Number(args.time) * 1000);
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'Sleep',
+            elementsData: [],
+            stepInputs: [args.time]
+
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("Sleep")
+        throw new Error("Wait action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,88 @@
+import { waitTillAttributeOfElementIsStringInterface } from "../../interface/waitActionInterface.js";
+
+export async function waitTillAttributeOfElementIsString(
+    args: waitTillAttributeOfElementIsStringInterface
+): Promise<void> {
+
+
+    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: any) {
+                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: any = 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: any) {
+                args.scriptDataAppender.setErrorNLP("WaitTillAttributeOfElementIsString")
+                throw new Error(`WaitTillAttributeOfElementIsString action failed`, { cause: error });
+            }
+            break;
+    }
+}