ff-automationv2 2.1.3 → 2.2.0

package/src/automation/actions/interaction/shadowDom/shadowDomVerifyText.ts

@@ -0,0 +1,22 @@
+import { ShadowVerifyTextInterface } from "../../interface/shadowDomInterface.js";
+import { SHADOW_DOM_VERIFY_TEXT_JS } from "../../../../utils/javascript/jsForShadowRoot.js";
+export async function verifyTextShadowElement(
+  args: ShadowVerifyTextInterface
+): Promise<void> {
+  try {
+    const executableJS = SHADOW_DOM_VERIFY_TEXT_JS.replace("arguments[0]", `"${args.selector}"`).replace("arguments[1]", `"${args.value}"`);
+    await args.driver.execute(
+      SHADOW_DOM_VERIFY_TEXT_JS,
+      args.selector,
+      args.value
+    );
+    args.scriptDataAppender.add(async () => ({
+      nlpName: 'ExecuteJavaScript',
+      stepInputs: [executableJS],
+      elementsData: []
+    }));
+  } catch (error: any) {
+    args.scriptDataAppender.setErrorNLP("ExecuteJavaScript");
+    throw new Error(`Shadow Verify Text action failed`, { cause: error });
+  }
+}

package/src/automation/actions/interaction/switch/switchToNewTabBasedOnTitle.ts

@@ -0,0 +1,16 @@
+import { ISwitchToNewTabBasedOnTitle } from "../../interface/switchingActionInterface.js";
+
+export async function switchToNewTabBasedOnTitle(args: ISwitchToNewTabBasedOnTitle): Promise<void> {
+    try {
+        await args.driver.switchWindow(new RegExp(`^${args.value}$`));
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'SwitchToNewTabBasedOnTitle',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("switchToNewTabBasedOnTitle");
+        throw new Error(`Switch window action failed`, { cause: error });
+    }
+}

package/src/automation/actions/interaction/switch/switchToNewWindowBasedOnTitle.ts

@@ -0,0 +1,16 @@
+import { ISwitchToNewWindowBasedOnTitle } from "../../interface/switchingActionInterface.js";
+
+export async function switchToNewWindowBasedOnTitle(args: ISwitchToNewWindowBasedOnTitle): Promise<void> {
+    try {
+        await args.driver.switchWindow(new RegExp(`^${args.value}$`));
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'SwitchToNewWindowBasedOnTitle',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("switchToNewWindowBasedOnTitle");
+        throw new Error(`Switch window action failed`, { cause: error });
+    }
+}

package/src/automation/actions/interaction/switch/switchToParentWindow.ts

@@ -0,0 +1,19 @@
+import { ISwitchToParentWindow } from "../../interface/switchingActionInterface.js";
+
+export async function switchToParentWindow(args: ISwitchToParentWindow): Promise<void> {
+    try {
+        const windowHandles = await args.driver.getWindowHandles();
+
+        await args.driver.switchToWindow(windowHandles[0]);
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'SwitchToParentWindow',
+            stepInputs: [],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("switchToParentWindow");
+        throw new Error(`Switch to parent window failed`, { cause: error });
+    }
+}

package/src/automation/actions/interaction/switch/switchToTabBasedOnUrl.ts

@@ -0,0 +1,16 @@
+import { ISwitchToTabBasedOnUrl } from "../../interface/switchingActionInterface.js";
+
+export async function switchToNewTabBasedOnUrl(args: ISwitchToTabBasedOnUrl): Promise<void> {
+    try {
+        await args.driver.switchWindow(new RegExp(`^${args.value}$`));
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'SwitchToTabBasedOnUrl',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("switchToNewTabBasedOnUrl");
+        throw new Error(`Switch tab based on URL failed`, { cause: error });
+    }
+}

package/src/automation/actions/interaction/switch/switchToWindowBasedOnURL.ts

@@ -0,0 +1,16 @@
+import { ISwitchToWindowBasedOnURL } from "../../interface/switchingActionInterface.js";
+
+export async function switchWindowBasedOnUrl(args: ISwitchToWindowBasedOnURL): Promise<void> {
+    try {
+        await args.driver.switchWindow(new RegExp(`^${args.value}$`));
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'SwitchToWindowBasedOnURL',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("SwitchToWindowBasedOnURL");
+        throw new Error(`Switch window based on URL failed`, { cause: error });
+    }
+}

package/src/automation/actions/interaction/switch/switchToWindowIfTitleContainsString.ts

@@ -0,0 +1,18 @@
+import { ISwitchToWindowIfTitleContainsString } from "../../interface/switchingActionInterface.js";
+
+export async function switchToWindowIfTitleContainsString(args: ISwitchToWindowIfTitleContainsString): Promise<void> {
+    try {
+        // WebdriverIO matches partial title automatically
+        await args.driver.switchWindow(args.value);
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'switchToWindowIfTitleContainsString',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("switchToWindowIfTitleContainsString");
+        throw new Error(`Switch window (title contains) failed`, { cause: error });
+    }
+}

package/src/automation/actions/interaction/switch/switchToWindowIfUrlContainsString.ts

@@ -0,0 +1,18 @@
+import { ISwitchToWindowIfUrlContainsString } from "../../interface/switchingActionInterface.js";
+
+export async function switchToWindowIfUrlContainsString(args: ISwitchToWindowIfUrlContainsString): Promise<void> {
+    try {
+        // WebdriverIO automatically checks URL (and title)
+        await args.driver.switchWindow(args.value);
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'SwitchToNewWindowIfUrlContainsString',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("switchToNewWindowIfUrlContainsString");
+        throw new Error(`Switch window (URL contains) failed`, { cause: error });
+    }
+}

package/src/automation/actions/interaction/upload/uploadfile.ts

@@ -0,0 +1,41 @@
+import { uploadFilePathUsingRobotInterface } from "../../interface/uploadFile.js";
+import { enterActionHelper } from "../../../../utils/helpers/enterActionHelper.js";
+export async function uploadFilePathUsingRobot(
+    args: uploadFilePathUsingRobotInterface): Promise<void> {
+    try {
+        const { ffNumber, xpathPath } = enterActionHelper(
+            args.pageDOM,
+            args.fireflinkIndex
+        );
+
+        const fileInput = await args.driver.$(xpathPath);
+        const remoteFilePath = await args.driver.uploadFile(args.value);
+        await fileInput.setValue(remoteFilePath);
+
+        await args.scriptDataAppender.add(async () => {
+            const ffElement = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="Fire-Flink-${ffNumber}"]`
+            );
+
+            if (!ffElement) {
+                throw new Error("FireFlink element not found for upload action");
+            }
+            return {
+                nlpName: "UploadFilePathUsingRobot",
+                elementsData: [
+                    {
+                        name: args.elementName,
+                        type: args.elementType,
+                        locators: ffElement.locators,
+                        platform: args.platform
+                    }
+                ],
+                stepInputs: []
+            };
+        });
+    } catch (error) {
+        args.scriptDataAppender.setErrorNLP("UploadFilePathUsingRobot");
+        throw new Error("UploadFilePathUsingRobot action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,90 @@
+import { VerifyLighthouseScoreInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyAccessibilityScore(
+    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 html_lang =
+                document.documentElement.hasAttribute('lang');
+
+            const title_present =
+                document.title && document.title.trim().length > 0;
+
+            const img_alt =
+                Array.from(document.images)
+                    .every(img => img.hasAttribute('alt'));
+
+            const inputs_labeled =
+                Array.from(document.querySelectorAll('input,textarea,select'))
+                    .every(el =>
+                        (el as HTMLInputElement).labels && (el as HTMLInputElement).labels!.length > 0 || el.hasAttribute('aria-label')
+                    );
+
+            const buttons_accessible =
+                Array.from(document.querySelectorAll('button'))
+                    .every(btn =>
+                        btn.innerText.trim().length > 0 ||
+                        btn.hasAttribute('aria-label')
+                    );
+
+            const no_aria_hidden_focusable =
+                Array.from(document.querySelectorAll('[aria-hidden="true"]'))
+                    .every(el => (el as HTMLElement).tabIndex === -1);
+
+            const text_has_color =
+                Array.from(document.querySelectorAll('body *'))
+                    .some(el =>
+                        window.getComputedStyle(el as Element).color !== 'rgba(0, 0, 0, 0)'
+                    );
+
+            return {
+                html_lang,
+                title_present,
+                img_alt,
+                inputs_labeled,
+                buttons_accessible,
+                no_aria_hidden_focusable,
+                text_has_color
+            };
+        });
+
+        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(
+                `Accessibility score ${actualScore} is less than expected ${minScore}`
+            );
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyAccessibilityScore',
+            stepInputs: [url, device, minScore.toString()],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyAccessibilityScore")
+        throw new Error(`VerifyAccessibilityScore action failed `, { cause: error });
+    }
+
+}

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

@@ -0,0 +1,54 @@
+import { VerifyAllBrokenImagesInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyAllBrokenImages(
+    args: VerifyAllBrokenImagesInterface
+): Promise<void> {
+    try {
+
+        const images = await args.driver.$$("img");
+
+        if (images.length === 0) {
+            throw new Error("No images found on the page.");
+        }
+
+        for (const img of images) {
+
+            const src = await img.getAttribute("src");
+
+            if (!src) {
+                throw new Error("Image without src found.");
+            }
+
+            let response;
+
+            try {
+                response = await fetch(src, {
+                    method: "HEAD",
+                    redirect: "follow"
+                });
+
+            } catch {
+                logger.info("Image request failed (considered broken):", src);
+                continue; // move to next image
+            }
+
+            logger.info("Checking imageUrl,Status:", response.status);
+
+            if (response.status < 400) {
+                throw new Error(`Working image found: ${src}`);
+            }
+        }
+
+        // If loop completes → all images are broken
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyAllBrokenImages',
+            stepInputs: [],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyAllBrokenImages");
+        throw new Error("VerifyAllBrokenImages action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,27 @@
+import { VerifyAllBrowserWindowsClosedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyAllBrowserWindowsClosed(
+    args: VerifyAllBrowserWindowsClosedInterface
+): Promise<void> {
+    try {
+
+        const handles = await args.driver.getWindowHandles();
+        logger.info("Window handles:", handles);
+
+        if (handles.length !== 0) {
+            logger.info("Some browser windows are still open.");
+            throw new Error("Some browser windows are still open.");
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyAllBrowserWindowsClosed',
+            stepInputs: [],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyAllBrowserWindowsClosed");
+        throw new Error("VerifyAllBrowserWindowsClosed action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,55 @@
+import { VerifyAllOptionsAreDeselectedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyAllOptionsAreDeselected(
+    args: VerifyAllOptionsAreDeselectedInterface
+): Promise<void> {
+    try {
+        let result = true;
+
+        const element = await args.driver.$(args.selector);
+
+        const options = await element.$$("option");
+
+        for (const option of options) {
+            if (await option.isSelected()) {
+                logger.info("At least one option is selected.");
+                result = false;
+                break;
+            }
+        }
+        logger.info("All options are deselected.");
+        logger.info("All options deselection verification result:", {
+            pagedom: args.pageDOM,
+            fireflinkIndex: args.fireflinkIndex,
+            elementName: args.elementName,
+            xpath: args.selector
+        });
+        if (result === false) {
+            throw new Error("Not all options are deselected.");
+        }
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyAllOptionsAreDeSelected',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+
+    } catch (error: any) {
+        args.scriptDataAppender?.setErrorNLP("VerifyAllOptionsAreDeselected");
+        throw new Error("VerifyAllOptionsAreDeselected failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,66 @@
+import { VerifyAllOptionsAreSelectedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyAllOptionsAreSelected(
+    args: VerifyAllOptionsAreSelectedInterface
+): Promise<void> {
+    try {
+
+
+        const element = await args.driver.$(args.selector);
+
+        const options = await element.$$("option");
+
+        if (!options || options.length === 0) {
+            logger.info("No options found in dropdown.");
+        }
+
+        let selectedCount = 0;
+
+        for (const option of options) {
+            if (await option.isSelected()) {
+                selectedCount++;
+            }
+        }
+
+        const isAllSelected = selectedCount === options.length;
+
+        logger.info("Verify all options selected result:", {
+            totalOptions: options.length,
+            selectedCount,
+            isAllSelected
+        });
+        logger.info("All options deselection verification result:", {
+            pagedom: args.pageDOM,
+            fireflinkIndex: args.fireflinkIndex,
+            elementName: args.elementName,
+            xpath: args.selector
+        });
+
+        if (isAllSelected === false) {
+            throw new Error("Not all options are selected.");
+        }
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyAllOptionsAreSelected',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+    } catch (error: any) {
+        args.scriptDataAppender?.setErrorNLP("VerifyAllOptionsAreSelected");
+        throw new Error("VerifyAllOptionsAreSelected failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,96 @@
+import { VerifyAttributeValueInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyAttributeValue(
+    args: VerifyAttributeValueInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+                const element = await args.driver.$(args.selector);
+
+                const parts = args.value.split(",");
+
+                const attrName = parts[0].trim();
+                const expectedValue = parts[1].trim();
+                const caseSensitive = false
+
+                const actualValue =
+                    (await element.getAttribute(attrName)) ||
+                    "";
+                const isMatched = actualValue.toLowerCase() === expectedValue.toLowerCase();
+
+                logger.info("Attribute value verification result:", { isMatched, actualValue, expectedValue });
+                if (isMatched === false) {
+                    throw new Error(`Attribute value does not match. Expected: ${expectedValue}, Actual: ${actualValue}`);
+                }
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_VerifyAttributeValue',
+                        stepInputs: [attrName, expectedValue, caseSensitive],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_VerifyAttributeValue")
+                throw new Error(`VerifyAttributeValue action failed `, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+
+                const element = await args.driver.$(args.selector);
+
+                const parts = args.value.split(",");
+
+                const attrName = parts[0].trim();
+                const expectedValue = parts[1].trim();
+                const caseSensitive = false
+
+                const actualValue =
+                    (await element.getAttribute(attrName)) ||
+                    (await element.getText()) ||
+                    "";
+                const isMatched = actualValue.toLowerCase() === expectedValue.toLowerCase();
+
+                logger.info("Attribute value verification result:", { isMatched, actualValue, expectedValue });
+                if (isMatched === false) {
+                    throw new Error(`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: 'VerifyAttributeValue',
+                        stepInputs: [attrName, expectedValue, caseSensitive],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+
+
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("VerifyAttributeValue")
+                throw new Error(`VerifyAttributeValue action failed `, { cause: error });
+            }
+            break;
+    }
+
+}

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

@@ -0,0 +1,87 @@
+import { VerifyLighthouseScoreInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyBestPracticesScore(
+    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");
+        }
+
+
+        if (url && url.startsWith("http")) {
+            await args.driver.url(url);
+        }
+
+        const checks = await args.driver.execute(() => {
+
+            const https = window.location.href.startsWith("https");
+
+            const no_mixed_content =
+                Array.from(document.querySelectorAll('img,script,link'))
+                    .every(e => {
+                        const src = (e as HTMLImageElement).src || (e as HTMLScriptElement).src || (e as HTMLLinkElement).href;
+                        return !src || src.startsWith("https") || src.startsWith("data:");
+                    });
+
+            const no_deprecated_tags =
+                document.querySelectorAll('font,center,marquee').length === 0;
+
+            const no_inline_js =
+                Array.from(document.querySelectorAll('*'))
+                    .every(el =>
+                        !Array.from(el.attributes)
+                            .some(a => a.name.startsWith('on'))
+                    );
+
+            const no_console_errors =
+                (window as any).__jsErrors__ === undefined ||
+                (window as any).__jsErrors__.length === 0;
+
+            const secure_iframes =
+                Array.from(document.querySelectorAll('iframe'))
+                    .every(f =>
+                        !f.hasAttribute('sandbox') ||
+                        f.getAttribute('sandbox')?.includes('allow-same-origin')
+                    );
+
+            return {
+                https,
+                no_mixed_content,
+                no_deprecated_tags,
+                no_inline_js,
+                no_console_errors,
+                secure_iframes
+            };
+        });
+
+        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(
+                `Best Practices score ${actualScore} is less than expected ${minScore}`
+            );
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBestPracticesScore',
+            stepInputs: [url, device, minScore.toString()],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyBestPracticesScore")
+        throw new Error(`VerifyBestPracticesScore action failed `, { cause: error });
+    }
+
+
+}