ff-automationv2 2.1.3 → 2.2.0

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

@@ -0,0 +1,35 @@
+import { VerifyBrowserHtmlCodeContainsStringInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyBrowserHtmlCodeContainsString(
+    args: VerifyBrowserHtmlCodeContainsStringInterface
+): Promise<void> {
+    try {
+
+
+
+        const expectedText = args.value.trim().toLowerCase();
+        const pageSource = (await args.driver.getPageSource()).toLowerCase();
+
+        const isMatched = pageSource.includes(expectedText);
+
+        logger.info("Browser HTML contains string verification result:", {
+            isMatched,
+            expectedText
+        });
+        if (isMatched === false) {
+            throw new Error(`Browser HTML does not contain the expected string: ${args.value}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserHtmlCodeContainsString',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserHtmlCodeContainsString");
+        throw new Error(`VerifyBrowserHtmlCodeContainsString action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,35 @@
+import { VerifyBrowserWindowHeightInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyBrowserWindowHeight(
+    args: VerifyBrowserWindowHeightInterface
+): Promise<void> {
+    try {
+
+
+
+        const expectedHeight = parseInt(args.value, 10);
+        const windowSize = await args.driver.getWindowSize();
+
+        const isMatched = windowSize.height === expectedHeight;
+
+        logger.info("Browser window height verification result:", {
+            isMatched,
+            actualHeight: windowSize.height,
+            expectedHeight
+        });
+        if (isMatched === false) {
+            throw new Error(`Browser window height does not match. Expected: ${expectedHeight}, Actual: ${windowSize.height}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserWindowHeight',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserWindowHeight");
+        throw new Error(`VerifyBrowserWindowHeight action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,31 @@
+import { VerifyBrowserWindowTitleContainsStringInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyBrowserWindowTitleContainsString(
+    args: VerifyBrowserWindowTitleContainsStringInterface
+): Promise<void> {
+    try {
+        logger.info(args.value);
+
+        const expectedText = args.value.trim().toLowerCase();
+        const actualTitle = (await args.driver.getTitle()).toLowerCase();
+
+        logger.info("Actual title:", actualTitle);
+        logger.info("Expected fragment:", expectedText);
+
+        if (!actualTitle.includes(expectedText)) {
+            logger.info("Title does not contain expected fragment:", expectedText);
+            throw new Error(`Title does not contain expected value.`);
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserWindowTitleContainsString',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserWindowTitleContainsString");
+        throw new Error(`VerifyBrowserWindowTitleContainsString action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,30 @@
+import { VerifyBrowserWindowTitleIsStringInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyBrowserWindowTitleIsString(
+    args: VerifyBrowserWindowTitleIsStringInterface
+): Promise<void> {
+    try {
+
+        const expectedTitle = args.value.trim().toLowerCase();
+        const actualTitle = (await args.driver.getTitle()).toLowerCase();
+
+        logger.info("Actual title:", actualTitle);
+        logger.info("Expected title:", expectedTitle);
+
+        if (actualTitle !== expectedTitle) {
+            logger.info("Browser title does not exactly match expected value.");
+            throw new Error("Browser title does not exactly match expected value.");
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserWindowTitleIsString',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserWindowTitleIsString");
+        throw new Error("VerifyBrowserWindowTitleIsString action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,30 @@
+import { VerifyBrowserWindowUrlContainsExpectedUrlInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyBrowserWindowUrlContainsExpectedUrl(
+    args: VerifyBrowserWindowUrlContainsExpectedUrlInterface
+): Promise<void> {
+    try {
+
+        const expectedUrl = args.value.trim().toLowerCase();
+        const actualUrl = (await args.driver.getUrl()).toLowerCase();
+
+        logger.info("Actual URL:", actualUrl);
+        logger.info("Expected URL fragment:", expectedUrl);
+
+        if (!actualUrl.includes(expectedUrl)) {
+            logger.info("URL does not contain expected fragment:", expectedUrl);
+            throw new Error(`URL does not contain expected value.`);
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserWindowUrlContainsExpectedUrl',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserWindowUrlContainsExpectedUrl");
+        throw new Error(`VerifyBrowserWindowUrlContainsExpectedUrl action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,30 @@
+import { VerifyBrowserWindowUrlIsStringInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyBrowserWindowUrlIsString(
+    args: VerifyBrowserWindowUrlIsStringInterface
+): Promise<void> {
+    try {
+
+        const expectedUrl = args.value.trim().toLowerCase();
+        const actualUrl = (await args.driver.getUrl()).toLowerCase();
+
+        logger.info("Actual URL:", actualUrl);
+        logger.info("Expected URL:", expectedUrl);
+
+        if (actualUrl !== expectedUrl) {
+            logger.info("URL does not exactly match expected value. Actual URL:", actualUrl, "Expected URL:", expectedUrl);
+            throw new Error(`URL does not exactly match expected value.`);
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserWindowUrlIsString',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserWindowUrlIsString");
+        throw new Error(`VerifyBrowserWindowUrlIsString action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,35 @@
+import { VerifyBrowserWindowWidthInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyBrowserWindowWidth(
+    args: VerifyBrowserWindowWidthInterface
+): Promise<void> {
+    try {
+
+
+
+        const expectedWidth = parseInt(args.value, 10);
+        const windowSize = await args.driver.getWindowSize();
+
+        const isMatched = windowSize.width === expectedWidth;
+
+        logger.info("Browser window width verification result:", {
+            isMatched,
+            actualWidth: windowSize.width,
+            expectedWidth
+        });
+        if (isMatched === false) {
+            throw new Error(`Browser window width does not match. Expected: ${expectedWidth}, Actual: ${windowSize.width}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserWindowWidth',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserWindowWidth");
+        throw new Error(`VerifyBrowserWindowWidth action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,36 @@
+import { VerifyBrowserWindowXLocationInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyBrowserWindowXLocation(
+    args: VerifyBrowserWindowXLocationInterface
+): Promise<void> {
+    try {
+
+
+
+        const expectedX = parseInt(args.value, 10);
+        const windowRect = await args.driver.getWindowRect();
+
+        const isMatched = windowRect.x === expectedX;
+
+        logger.info("Browser window X position verification result:", {
+            isMatched,
+            actualX: windowRect.x,
+            expectedX
+        });
+        if (isMatched === false) {
+            throw new Error(`Browser window X position does not match. Expected: ${expectedX}, Actual: ${windowRect.x}`);
+
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserWindowXLocation',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserWindowXLocation");
+        throw new Error(`VerifyBrowserWindowXLocation action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,35 @@
+import { VerifyBrowserWindowYLocationInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyBrowserWindowYLocation(
+    args: VerifyBrowserWindowYLocationInterface
+): Promise<void> {
+    try {
+
+
+
+        const expectedY = parseInt(args.value, 10);
+        const windowRect = await args.driver.getWindowRect();
+
+        const isMatched = windowRect.y === expectedY;
+
+        logger.info("Browser window Y position verification result:", {
+            isMatched,
+            actualY: windowRect.y,
+            expectedY
+        });
+        if (isMatched === false) {
+            throw new Error(`Browser window Y position does not match. Expected: ${expectedY}, Actual: ${windowRect.y}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserWindowYLocation',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserWindowYLocation");
+        throw new Error(`VerifyBrowserWindowYLocation action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,46 @@
+import { VerifyCheckBoxIsNotSelectedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyCheckboxIsNotSelected(
+    args: VerifyCheckBoxIsNotSelectedInterface
+): Promise<void> {
+    try {
+
+        const element = await args.driver.$(args.selector);
+
+        if (!(await element.isExisting())) {
+            // Same logic as Python: if not existing → treat as not selected
+            throw new Error(`Element with selector '${args.selector}' does not exist, treating as not selected.`);
+        } else {
+            const isSelected = await element.isSelected();
+            logger.info("Checkbox selection status:", isSelected);
+
+            if (isSelected === true) {
+                throw new Error(`Checkbox is selected but expected to be not selected.`);
+            }
+        }
+
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyCheckBoxIsNotSelected',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyCheckBoxIsNotSelected");
+        throw new Error(`VerifyCheckBoxIsNotSelected action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,43 @@
+import { VerifyCheckBoxIsSelectedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyCheckboxIsSelected(
+    args: VerifyCheckBoxIsSelectedInterface
+): Promise<void> {
+    try {
+
+        const element = await args.driver.$(args.selector);
+
+        if (!(await element.isExisting())) {
+            throw new Error(`Element with selector '${args.selector}' does not exist.`);
+        }
+
+        const isSelected = await element.isSelected();
+        logger.info("Checkbox selection status:", isSelected);
+        if (isSelected === false) {
+            throw new Error(`Checkbox is not selected as expected.`);
+        }
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyCheckBoxIsSelected',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyCheckBoxIsSelected");
+        throw new Error(`VerifyCheckBoxIsSelected action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,62 @@
+import { VerifyCssAttributeValueInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyCssAttributeValue(
+    args: VerifyCssAttributeValueInterface
+): Promise<void> {
+    try {
+
+
+
+        const element = await args.driver.$(args.selector);
+
+
+        const parts = args.value.split(",");
+
+
+        const cssProperty = parts[0].trim();
+        const expectedValue = parts[1].trim();
+        const caseSensitive = false
+
+        const actualValue = (await element.getCSSProperty(cssProperty)).value || "";
+
+        const isMatched = caseSensitive
+            ? actualValue === expectedValue
+            : actualValue.toLowerCase() === expectedValue.toLowerCase();
+        logger.info("CSS attribute verification result:", {
+            isMatched,
+            actualValue,
+            expectedValue,
+            cssProperty,
+            caseSensitive
+        });
+        if (isMatched === false) {
+            throw new Error(`CSS attribute value does not match. Expected: ${expectedValue}, Actual: ${actualValue}`);
+        }
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyCssAttributeValue',
+                stepInputs: [cssProperty, expectedValue, caseSensitive],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyCssAttributeValue");
+        throw new Error(`VerifyCssAttributeValue action failed`, { cause: error });
+    }
+}

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

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

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

@@ -0,0 +1,91 @@
+import { VerifyElementIsDisabledInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyElementIsDisabled(
+    args: VerifyElementIsDisabledInterface
+): 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 !== "false") {
+                    throw new Error(`Element is not enabled. Expected: true, Actual: ${enabled}`);
+                }
+
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_VerifyElementIsDisabled',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_VerifyElementIsDisabled")
+                throw new Error(`VerifyElementIsDisabled 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 verifyElementIsDisabled");
+
+                }
+
+                const isEnabled = await element.isEnabled();
+                logger.info("Element enabled status in verifyElementIsDisabled:", !isEnabled);
+                if (isEnabled === true) {
+                    throw new Error(`Element is not disabled. Expected: disabled, Actual: enabled`);
+                }
+
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'VerifyElementIsDisabled',
+                        stepInputs: [],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("VerifyElementIsDisabled")
+                throw new Error(`VerifyElementIsDisabled action failed `, { cause: error });
+            }
+            break;
+    }
+
+}