ff-automationv2 2.1.3 → 2.2.0

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

@@ -0,0 +1,66 @@
+import { VerifyLighthouseScoreInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyPwaScore(
+    args: VerifyLighthouseScoreInterface
+): Promise<void> {
+    try {
+        const inputs = args.value.split(',');
+        const url = inputs[0];
+        const device = inputs[1];
+        const minScore = parseFloat(inputs[2]);
+
+        if (!args.value) {
+            throw new Error("Input value is missing");
+        }
+
+        // Navigate only if URL is provided
+        if (url && url.startsWith("http")) {
+            await args.driver.url(url);
+        }
+
+        const checks = await args.driver.execute(() => {
+
+            const https = window.location.href.startsWith("https");
+
+            const service_worker_supported =
+                'serviceWorker' in navigator;
+
+            const service_worker_registered =
+                navigator.serviceWorker &&
+                navigator.serviceWorker.controller !== null;
+
+            const manifest_present =
+                !!document.querySelector('link[rel="manifest"]');
+
+            return {
+                https,
+                service_worker_supported,
+                service_worker_registered,
+                manifest_present
+            };
+        });
+
+        const values = Object.values(checks as Record<string, boolean>);
+        const passed = values.filter(v => v).length;
+        const total = values.length;
+
+        const actualScore = Math.floor((passed / total) * 100);
+
+        if (actualScore < minScore) {
+            throw new Error(
+                `PWA score ${actualScore} is less than expected ${minScore}`
+            );
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyPwaScore',
+            stepInputs: [url, device, minScore.toString()],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyPwaScore")
+        throw new Error(`VerifyPwaScore action failed `, { cause: error });
+    }
+
+}

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

@@ -0,0 +1,42 @@
+import { VerifyRadioButtonIsNotSelectedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyRadioButtonIsNotSelected(
+    args: VerifyRadioButtonIsNotSelectedInterface
+): Promise<void> {
+    try {
+
+        const element = await args.driver.$(args.selector);
+
+        const isSelected = await element.isSelected();
+        const isMatched = !isSelected;
+
+        logger.info("Radio button NOT selected verification result:", {
+            isMatched,
+            isSelected
+        });
+        if (isMatched === false) {
+            throw new Error(`Radio button is selected. Expected: not selected, Actual: selected`);
+        }
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyRadioButtonIsNotSelected',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            }
+        });
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyRadioButtonIsNotSelected");
+        throw new Error(`VerifyRadioButtonIsNotSelected action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,42 @@
+import { VerifyRadioButtonIsSelectedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyRadioButtonIsSelected(
+    args: VerifyRadioButtonIsSelectedInterface
+): Promise<void> {
+    try {
+
+        const element = await args.driver.$(args.selector);
+
+
+        const isSelected = await element.isSelected();
+
+        logger.info("Radio button selected verification result:", {
+            isSelected
+        });
+        if (isSelected === false) {
+            throw new Error(`Radio button 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: 'VerifyRadioButtonIsSelected',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyRadioButtonIsSelected");
+        throw new Error(`VerifyRadioButtonIsSelected action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,79 @@
+import { VerifyLighthouseScoreInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifySeoScore(
+    args: VerifyLighthouseScoreInterface
+): Promise<void> {
+    try {
+        const inputs = args.value.split(',');
+        const url = inputs[0];
+        const device = inputs[1];
+        const minScore = parseFloat(inputs[2]);
+
+        if (!args.value) {
+            throw new Error("Input value is missing");
+        }
+
+        // Navigate only if URL is provided
+        if (url && url.startsWith("http")) {
+            await args.driver.url(url);
+        }
+
+        const checks = await args.driver.execute(() => {
+
+            const https =
+                window.location.href.startsWith("https");
+
+            const title_present =
+                document.title && document.title.trim().length > 0;
+
+            const meta_description = (() => {
+                const m = document.querySelector('meta[name="description"]') as HTMLMetaElement | null;
+                return m && m.content && m.content.trim().length > 0;
+            })();
+
+            const canonical =
+                !!document.querySelector('link[rel="canonical"]');
+
+            const indexable = (() => {
+                const r = document.querySelector('meta[name="robots"]') as HTMLMetaElement | null;
+                return !r || !/noindex/i.test(r.content);
+            })();
+
+            const h1_present =
+                document.querySelectorAll('h1').length > 0;
+
+            return {
+                https,
+                title_present,
+                meta_description,
+                canonical,
+                indexable,
+                h1_present
+            };
+        });
+
+        const values = Object.values(checks as Record<string, boolean>);
+        const passed = values.filter(v => v).length;
+        const total = values.length;
+
+        const actualScore = Math.floor((passed / total) * 100);
+
+        if (actualScore < minScore) {
+            throw new Error(
+                `SEO score ${actualScore} is less than expected ${minScore}`
+            );
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifySeoScore',
+            stepInputs: [url, device, minScore.toString()],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifySeoScore")
+        throw new Error(`VerifySeoScore action failed `, { cause: error });
+    }
+
+
+}

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

@@ -0,0 +1,44 @@
+import { VerifyTagNameInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyTagName(
+    args: VerifyTagNameInterface
+): Promise<void> {
+    try {
+
+
+
+        const element = await args.driver.$(args.selector);
+
+
+        const expectedTag = args.value.trim().toLowerCase();
+        const actualTag = (await element.getTagName()).toLowerCase();
+        const isMatched = actualTag === expectedTag;
+
+        logger.info("Tag name verification result:", { isMatched, actualTag, expectedTag });
+        if (isMatched === false) {
+            throw new Error(`Element tag name does not match expected. Expected: "${expectedTag}", Actual: "${actualTag}"`);
+        }
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyTagName',
+                stepInputs: [expectedTag],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyTagName")
+        throw new Error(`VerifyTagName action failed `, { cause: error });
+    }
+}

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

@@ -0,0 +1,73 @@
+import { VerifyThatSpecifiedOptionIsNotSelectedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyThatSpecifiedOptionIsNotSelected(
+    args: VerifyThatSpecifiedOptionIsNotSelectedInterface
+): Promise<void> {
+    try {
+        let result = false;
+        let parts = (args.value ?? "").split(",");
+
+        if (parts.length === 1) {
+            parts = [parts[0], "false"];
+        }
+        const expectedText = parts[0].trim();
+        const caseSensitive = parts[1].trim();
+
+        const element = await args.driver.$(args.selector);
+
+
+        const options = await element.$$("option");
+
+        for (const option of options) {
+
+            if (!(await option.isSelected())) continue;
+
+            const optionText = await option.getText();
+
+            if (caseSensitive) {
+                if (optionText === expectedText) {
+                    result = true
+
+                }
+            } else {
+                if (optionText.toLowerCase() === expectedText.toLowerCase()) {
+                    result = true
+                }
+
+            }
+        }
+        logger.info("Option selection verification result:", {
+            expectedText,
+            result
+        });
+        if (result === true) {
+            throw new Error(`A selected option matching the expected text was found. Expected no selected option with text: "${expectedText}"`);
+        }
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyThatSpecifiedOptionIsNotSelected',
+                stepInputs: [expectedText, caseSensitive],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error: any) {
+        args.scriptDataAppender?.setErrorNLP(
+            "VerifyThatSpecifiedOptionIsNotSelected"
+        );
+        throw new Error(
+            "VerifyThatSpecifiedOptionIsNotSelected failed",
+            { cause: error }
+        );
+    }
+}

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

@@ -0,0 +1,51 @@
+import { VerifyTitleInAllPageInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyTitleInAllPage(
+    args: VerifyTitleInAllPageInterface
+): Promise<void> {
+    try {
+        let result = false
+
+
+
+        const expectedTitle = args.value.trim().toLowerCase();
+        const caseSensitive = false
+
+        const currentHandle = await args.driver.getWindowHandle();
+        const handles = await args.driver.getWindowHandles();
+
+        for (const handle of handles) {
+
+            await args.driver.switchToWindow(handle);
+            const actualTitle = (await args.driver.getTitle()).toLowerCase();
+
+            if (actualTitle === expectedTitle) {
+                await args.driver.switchToWindow(currentHandle);
+                result = true
+                break;
+
+            }
+        }
+
+        await args.driver.switchToWindow(currentHandle);
+        logger.info("Title verification across all pages result: All pages have the expected title", {
+            expectedTitle,
+            pageCount: handles.length,
+            result
+        });
+        if (result === false) {
+            throw new Error(`Not all pages have the expected title. Expected: "${expectedTitle}"`);
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyTitleInAllPage',
+            stepInputs: [expectedTitle, caseSensitive],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender?.setErrorNLP("VerifyTitleInAllPage");
+        throw new Error("VerifyTitleInAllPage failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,30 @@
+import { VerifyTitleOfCurrentPageInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyTitleOfCurrentPage(
+    args: VerifyTitleOfCurrentPageInterface
+): Promise<void> {
+    try {
+
+
+
+        const expectedTitle = args.value.trim();
+        const actualTitle = await args.driver.getTitle();
+        const isMatched = actualTitle.trim() === expectedTitle;
+        const caseSensitive = false;
+        const time = 2000;
+
+        logger.info("Title verification result:", { isMatched, actualTitle, expectedTitle });
+        if (isMatched === false) {
+            throw new Error(`Page title does not match expected. Expected: "${expectedTitle}", Actual: "${actualTitle}"`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyTitleOfCurrentPage',
+            stepInputs: [expectedTitle, caseSensitive, time],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyTitleOfCurrentPage")
+        throw new Error(`VerifyTitleOfCurrentPage action failed `, { cause: error });
+    }
+}

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

@@ -0,0 +1,51 @@
+import { VerifyValueOfElementContainsStringInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyValueOfElementContainsString(
+    args: VerifyValueOfElementContainsStringInterface
+): Promise<void> {
+    try {
+
+        const element = await args.driver.$(args.selector);
+        const expectedText = args.value;
+
+        const actualValue =
+            (await element.getAttribute("value")) ||
+            (await element.getText()) ||
+            "";
+
+        const isMatched = actualValue
+            .toLowerCase()
+            .includes(expectedText.toLowerCase());
+
+        logger.info("Contains value verification result:", {
+            isMatched,
+            actualValue,
+            expectedText
+        });
+        const caseSensitive = false;
+        if (isMatched === false) {
+            throw new Error(`Element value does not contain expected text. Expected to contain: "${expectedText}", Actual: "${actualValue}"`);
+        }
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyValueOfElementContainsString',
+                stepInputs: [args.value, caseSensitive],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyValueOfElementContainsString");
+        throw new Error(`VerifyValueOfElementContainsString action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,45 @@
+import { VerifyValueOfElementIsClearedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyValueOfElementIsCleared(
+    args: VerifyValueOfElementIsClearedInterface
+): Promise<void> {
+    try {
+
+        const element = await args.driver.$(args.selector);
+
+
+        const actualValue =
+            (await element.getAttribute("value")) || "";
+
+        const isMatched = actualValue.trim().length === 0;
+
+        logger.info("Cleared value verification result:", {
+            isMatched,
+            actualValue
+        });
+        if (isMatched === false) {
+            throw new Error(`Element value is not cleared. Actual value: "${actualValue}"`);
+        }
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyValueOfElementIsCleared',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyValueOfElementIsCleared");
+        throw new Error(`VerifyValueOfElementIsCleared action failed`, { cause: error });
+    }
+}

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

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

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

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