ff-automationv2 2.1.3 → 2.2.0

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

@@ -0,0 +1,87 @@
+import { VerifyElementIsDisplayedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyElementIsDisplayed(
+    args: VerifyElementIsDisplayedInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+                if (!element) {
+                    throw new Error("Element not found");
+                }
+
+                const enabled = await element.getAttribute("enabled");
+
+                logger.info("Element enabled status:", { enabled });
+
+                if (enabled !== "true") {
+                    throw new Error(`Element is not enabled. Expected: true, Actual: ${enabled}`);
+                }
+
+
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'MOB_IsDisplayed',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_IsDisplayed")
+                throw new Error(`VerifyElementIsDisplayed action failed `, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+                if (!element) {
+                    logger.info("Element not found in verifyElementIsDisplayed");
+                }
+
+                const isDisplayed = await element.isDisplayed();
+
+                logger.info("Element display status in verifyElementIsDisplayed:", { isDisplayed });
+                if (isDisplayed === false) {
+                    throw new Error(`Element is not displayed. Expected: displayed, Actual: not displayed`);
+                }
+
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'IsDisplayed',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("IsDisplayed")
+                throw new Error(`VerifyElementIsDisplayed action failed `, { cause: error });
+            }
+            break;
+    }
+}

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

@@ -0,0 +1,87 @@
+import { VerifyElementIsEnabledInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyElementIsEnabled(
+    args: VerifyElementIsEnabledInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+
+                const element = await args.driver.$(args.selector);
+
+                if (!element) {
+                    logger.info("Element not found");
+                }
+
+                const enabled = await element.getAttribute("enabled");
+
+                logger.info("Element enabled status:", { enabled });
+
+                if (enabled !== "true") {
+                    throw new Error(`Element is not enabled. Expected: true, Actual: ${enabled}`);
+                }
+
+
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'MOB_IsEnabled',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_IsEnabled")
+                throw new Error(`VerifyElementIsEnabled action failed `, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+                if (!(await element.isExisting())) {
+                    logger.info("Element not found in verifyElementIsEnabled");
+
+                }
+                const isEnabled = await element.isEnabled();
+                logger.info("Element enabled status in verifyElementIsEnabled:", { isEnabled });
+                if (isEnabled === false) {
+                    throw new Error(`Element is not enabled. Expected: enabled, Actual: disabled`);
+                }
+
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'IsEnabled',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("IsEnabled")
+                throw new Error(`VerifyElementIsEnabled action failed `, { cause: error });
+            }
+            break;
+    }
+}

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

@@ -0,0 +1,45 @@
+import { VerifyElementIsNotDisplayedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyElementIsNotDisplayed(
+    args: VerifyElementIsNotDisplayedInterface
+): Promise<void> {
+    try {
+
+        const element = await args.driver.$(args.selector);
+
+        if (!element) {
+            logger.info("Element not found in verifyElementIsNotDisplayed");
+        }
+
+        const isDisplayed = await element.isDisplayed();
+        logger.info("Element display status in verifyElementIsNotDisplayed:", { isDisplayed });
+        if (isDisplayed === true) {
+            throw new Error(`Element is displayed. Expected: not displayed, Actual: displayed`);
+        }
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyElementIsNotDisplayed',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyElementIsNotDisplayed")
+        throw new Error(`VerifyElementIsNotDisplayed action failed `, { cause: error });
+    }
+}

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

@@ -0,0 +1,83 @@
+import { VerifyElementIsSelectedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+
+export async function verifyElementIsSelected(
+    args: VerifyElementIsSelectedInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+
+                if (!element) {
+                    logger.info("Element not found");
+                }
+
+                const isSelected = await element.getAttribute("selected");
+
+                logger.info("Element selected status:", { isSelected });
+
+                if (isSelected !== "true") {
+                    throw new Error(`Element is not selected. Expected: true, Actual: ${isSelected}`);
+                }
+
+                args.scriptDataAppender.add(async () => {
+                    return {
+                        nlpName: 'MOB_IsSelected',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_IsSelected")
+                throw new Error(`VerifyElementIsSelected action failed `, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+                if (!(await element.isExisting())) {
+                    logger.info("Element not found in verifyElementIsSelected");
+                }
+                const isSelected = await element.isSelected();
+                logger.info("Element selected status in verifyElementIsSelected:", { isSelected });
+                if (isSelected === false) {
+                    throw new Error(`Element is not selected. Expected: selected, Actual: not selected`);
+                }
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'IsSelected',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("IsSelected")
+                throw new Error(`VerifyElementIsSelected action failed `, { cause: error });
+            }
+            break;
+    }
+}

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

@@ -0,0 +1,129 @@
+import { verifyElementNotContainsTextInterface } from "../../interface/verifyActionInterface.js";
+
+
+export async function verifyElementNotContainsText(
+    args: verifyElementNotContainsTextInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+
+                const expected = await element.getAttribute("text");
+
+
+                const caseSensitive = false;
+                if (expected !== args.value) {
+                    throw new Error(`Element does not contain the text. Expected: not containing "${args.value}", Actual: contains "${expected}"`);
+                }
+
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_VerifyElementNotContainsText',
+                        stepInputs: [args.value, caseSensitive],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_VerifyElementNotContainsText")
+                throw new Error(`VerifyElementNotContainsText 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);
+                }
+
+                let isMatched = false;
+
+                for (const t of texts) {
+                    const clean = normalizeText(t);
+                    if (clean.includes(expected)) {
+                        isMatched = true;
+                        break;
+                    }
+                }
+
+
+                const caseSensitive = false; // Assuming case-insensitive for logging
+                if (isMatched === true) {
+                    throw new Error(`Element contains the text. Expected: not containing "${args.value}", Actual: contains "${args.value}"`);
+                }
+
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'VerifyElementNotContainsText',
+                        stepInputs: [args.value, caseSensitive],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("VerifyElementNotContainsText")
+                throw new Error(`VerifyElementNotContainsText action failed `, { cause: error });
+            }
+            break;
+    }
+}

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

@@ -0,0 +1,101 @@
+import { VerifyHeightWebOfElementInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyHeightOfWebElement(
+    args: VerifyHeightWebOfElementInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+
+
+                const element = await args.driver.$(args.selector);
+
+
+                const expectedHeight = parseInt(args.value, 10);
+                const size = await element.getSize();
+
+                const isMatched = size.height === expectedHeight;
+
+                logger.info("Height verification result:", {
+                    isMatched,
+                    actualHeight: size.height,
+                    expectedHeight
+                });
+                if (isMatched === false) {
+                    throw new Error(`Element height does not match. Expected: ${expectedHeight}, Actual: ${size.height}`);
+                }
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_VerifyHeightOfElement',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_VerifyHeightOfElement");
+                throw new Error(`VerifyHeightOfWebElement action failed`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+
+
+                const element = await args.driver.$(args.selector);
+
+
+                const expectedHeight = parseInt(args.value, 10);
+                const size = await element.getSize();
+
+                const isMatched = size.height === expectedHeight;
+
+                logger.info("Height verification result:", {
+                    isMatched,
+                    actualHeight: size.height,
+                    expectedHeight
+                });
+                if (isMatched === false) {
+                    throw new Error(`Element height does not match. Expected: ${expectedHeight}, Actual: ${size.height}`);
+                }
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'VerifyHeightOfWebElement',
+                        stepInputs: [args.value],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("VerifyHeightOfWebElement");
+                throw new Error(`VerifyHeightOfWebElement action failed`, { cause: error });
+            }
+            break;
+    }
+
+}

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

@@ -0,0 +1,51 @@
+import { VerifyHexCodeInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyHexCodeForGivenXYCoordinates(
+    args: VerifyHexCodeInterface
+): Promise<void> {
+    try {
+        const inputs = args.value.split(',');
+        const expectedHexCode = inputs[0].trim();
+        const x = parseInt(inputs[1]);
+        const y = parseInt(inputs[2]);
+
+
+        const actualHexCode = await args.driver.execute(async (x, y) => {
+            const el = document.elementFromPoint(x, y);
+            if (!el) return "";
+
+            const style = window.getComputedStyle(el);
+            const color = style.backgroundColor || style.color;
+
+            const match = color.match(/^rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+            if (!match) return color;
+
+            const r = parseInt(match[1]);
+            const g = parseInt(match[2]);
+            const b = parseInt(match[3]);
+
+            return "#" + ((1 << 24) + (r << 16) + (g << 8) + b)
+                .toString(16)
+                .slice(1)
+                .toUpperCase();
+        }, x, y);
+
+
+        if (actualHexCode.toUpperCase() !== expectedHexCode.toUpperCase()) {
+            throw new Error(`Hex code does not match`);
+        }
+
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyHexCodeForGivenXYCoordinates',
+            stepInputs: [x.toString(), y.toString(), expectedHexCode],
+            elementsData: []
+        }));
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyHexCodeForGivenXYCoordinates")
+        throw new Error(`VerifyHexCodeForGivenXYCoordinates action failed `, { cause: error });
+    }
+
+}

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

@@ -0,0 +1,27 @@
+import { VerifyIfAllCookiesAreDeletedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyIfAllCookiesAreDeleted(
+    args: VerifyIfAllCookiesAreDeletedInterface
+): Promise<void> {
+    try {
+
+        const cookies = await args.driver.getCookies();
+        logger.info("Cookies:", cookies);
+
+        if (cookies.length !== 0) {
+            logger.info("Cookies are still present.");
+            throw new Error("Cookies are still present.");
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyIfAllCookiesAreDeleted',
+            stepInputs: [],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfAllCookiesAreDeleted");
+        throw new Error("VerifyIfAllCookiesAreDeleted action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,48 @@
+import { VerifyIfAudioEndedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyIfAudioEnded(
+    args: VerifyIfAudioEndedInterface
+): Promise<void> {
+    try {
+
+        const element = await args.driver.$(args.selector);
+
+        if (!(await element.isExisting())) {
+            throw new Error("Audio element does not exist.");
+        }
+
+        const isEnded = await args.driver.execute(
+            (el) => (el as unknown as HTMLAudioElement).ended,
+            element
+        );
+
+        if (!isEnded) {
+            logger.info("Audio ended status:", isEnded);
+            throw new Error("Audio is not ended.");
+        }
+
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyIfAudioEnded',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfAudioEnded");
+        throw new Error("VerifyIfAudioEnded action failed", { cause: error });
+    }
+}