ff-automationv2 2.1.3 → 2.2.0

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

@@ -0,0 +1,58 @@
+import { VerifyIfVideoPlayingInMuteInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyIfVideoPlayingInMute(
+    args: VerifyIfVideoPlayingInMuteInterface
+): Promise<void> {
+    try {
+
+        const element = await args.driver.$(args.selector);
+
+        if (!(await element.isExisting())) {
+            throw new Error("Video element does not exist.");
+        }
+
+        const isPlaying = await args.driver.execute(
+            (el) => {
+                const video = el as unknown as HTMLVideoElement;
+                return (
+                    !video.paused &&
+                    !video.ended &&
+                    video.currentTime > 0 &&
+                    video.readyState > 2 &&
+                    video.muted
+                );
+            },
+            element
+        );
+
+        logger.info("Video playing in mute:", isPlaying);
+
+        if (!isPlaying) {
+            throw new Error("Video is not playing in mute mode.");
+        }
+
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyIfVideoPlayingInMute',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfVideoPlayingInMute");
+        throw new Error("VerifyIfVideoPlayingInMute action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,58 @@
+import { VerifyIfVideoPlayingInUnmuteInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyIfVideoPlayingInUnmute(
+    args: VerifyIfVideoPlayingInUnmuteInterface
+): Promise<void> {
+    try {
+
+        const element = await args.driver.$(args.selector);
+
+        if (!(await element.isExisting())) {
+            throw new Error("Video element does not exist.");
+        }
+
+        const isPlaying = await args.driver.execute(
+            (el) => {
+                const video = el as unknown as HTMLVideoElement;
+                return (
+                    !video.paused &&
+                    !video.ended &&
+                    video.currentTime > 0 &&
+                    video.readyState > 2 &&
+                    !video.muted
+                );
+            },
+            element
+        );
+
+        logger.info("Video playing in unmute:", isPlaying);
+
+        if (!isPlaying) {
+            throw new Error("Video is not playing in unmute mode.");
+        }
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+
+                nlpName: 'VerifyIfVideoPlayingInUnmute',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfVideoPlayingInUnmute");
+        throw new Error("VerifyVideoPlayingInUnmute action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,101 @@
+import { VerifyIfXAndYCoordinateOfElementInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyIfXAndYCoordinateOfElement(
+    args: VerifyIfXAndYCoordinateOfElementInterface
+): Promise<void> {
+    switch (args.platform) {
+        case "android":
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+                if (!(await element.isExisting())) {
+                    throw new Error(`Element with selector '${args.selector}' does not exist.`);
+                }
+
+                const parts = args.value.split(",");
+                if (parts.length < 2) {
+                    throw new Error("Invalid coordinate format. Expected 'x,y'.");
+                }
+
+                const expectedX = parseInt(parts[0].trim(), 10);
+                const expectedY = parseInt(parts[1].trim(), 10);
+
+                const location = await element.getLocation();
+
+
+                if (location.x !== expectedX || location.y !== expectedY) {
+                    throw new Error("Element coordinates do not match expected values.");
+                }
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+
+                        nlpName: 'MOB_VerifyIfXAndYCoordinateOfElement',
+                        stepInputs: [expectedX, expectedY],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: [{ "xpath": args.selector }],
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("MOB_VerifyIfXAndYCoordinateOfElement");
+                throw new Error("VerifyIfXAndYCoordinateOfElement action failed", { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+
+                const element = await args.driver.$(args.selector);
+
+                if (!(await element.isExisting())) {
+                    throw new Error(`Element with selector '${args.selector}' does not exist.`);
+                }
+
+                const parts = args.value.split(",");
+                if (parts.length < 2) {
+                    throw new Error("Invalid coordinate format. Expected 'x,y'.");
+                }
+
+                const expectedX = parseInt(parts[0].trim(), 10);
+                const expectedY = parseInt(parts[1].trim(), 10);
+
+                const location = await element.getLocation();
+
+
+                if (location.x !== expectedX || location.y !== expectedY) {
+                    throw new Error("Element coordinates do not match expected values.");
+                }
+
+                args.scriptDataAppender.add(async () => {
+
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+
+                        nlpName: 'VerifyIfXAndYCoordinateOfElement',
+                        stepInputs: [expectedX, expectedY],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("VerifyIfXAndYCoordinateOfElement");
+                throw new Error("VerifyIfXAndYCoordinateOfElement action failed", { cause: error });
+            }
+            break;
+    }
+}

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

@@ -0,0 +1,41 @@
+import { VerifyLinkNavigatesToTitleInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyLinkNavigatesToTitle(
+    args: VerifyLinkNavigatesToTitleInterface
+): Promise<void> {
+    try {
+
+
+
+        const parts = args.value.split(",");
+
+        const linkUrl = parts[0].trim();
+        const expectedTitle = parts[1].trim().toLowerCase();
+
+        await args.driver.url(linkUrl);
+
+        await args.driver.pause(3000); // wait for load
+
+        const actualTitle = (await args.driver.getTitle()).toLowerCase();
+        const isMatched = actualTitle === expectedTitle;
+
+
+        if (isMatched === false) {
+            throw new Error(`Navigated page title does not match expected. URL: ${linkUrl}, Expected Title: ${expectedTitle}, Actual Title: ${actualTitle}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyLinkNavigatesToTitle',
+            stepInputs: [expectedTitle, linkUrl],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender?.setErrorNLP(
+            "VerifyLinkNavigatesToTitle"
+        );
+        throw new Error(
+            "VerifyLinkNavigatesToTitle failed",
+            { cause: error }
+        );
+    }
+}

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

@@ -0,0 +1,72 @@
+import { VerifyListBoxOptionsAreSortedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyListBoxOptionsAreSorted(
+    args: VerifyListBoxOptionsAreSortedInterface
+): Promise<void> {
+    try {
+
+
+        const element = await args.driver.$(args.selector);
+
+
+        // Get all <option> elements
+        const options = await element.$$("option");
+
+        if (!options || options.length === 0) {
+            logger.info("No dropdown options found.");
+        }
+
+        // Extract visible text safely (avoids Promise.all typing issue)
+        const optionTexts: string[] = [];
+
+        for (const option of options) {
+            const text = await option.getText();
+            optionTexts.push(text.trim());
+        }
+
+        logger.info("Dropdown options:", optionTexts);
+
+        // Create sorted copy (case-insensitive alphabetical sort)
+        const sortedOptions = [...optionTexts].sort((a, b) =>
+            a.localeCompare(b, undefined, { sensitivity: "base" })
+        );
+
+        const isSorted =
+            JSON.stringify(optionTexts) === JSON.stringify(sortedOptions);
+
+        logger.info("Sorted verification result:", {
+            isSorted,
+            actual: optionTexts,
+            expectedSorted: sortedOptions
+        });
+        if (isSorted === false) {
+            throw new Error(`Dropdown options are not sorted alphabetically. Actual order: ${optionTexts.join(", ")}`);
+        }
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyListBoxOptionsAreSorted',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+    } catch (error: any) {
+        args.scriptDataAppender?.setErrorNLP("VerifyListBoxOptionsAreSorted");
+        throw new Error(
+            "VerifyListBoxOptionsAreSorted action failed",
+            { cause: error }
+        );
+    }
+}

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

@@ -0,0 +1,34 @@
+import { VerifyNavigateURLInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyNavigateUrl(
+    args: VerifyNavigateURLInterface
+): Promise<void> {
+    try {
+
+
+
+        const expectedUrl = args.value.trim();
+        const actualUrl = await args.driver.getUrl();
+
+        const isMatched = actualUrl === expectedUrl;
+
+        logger.info("Navigate URL verification result:", {
+            isMatched,
+            actualUrl,
+            expectedUrl
+        });
+        if (isMatched === false) {
+            throw new Error(`Current URL does not match expected. Expected: ${expectedUrl}, Actual: ${actualUrl}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyNavigateURL',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyNavigateUrl");
+        throw new Error(`VerifyNavigateUrl action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,35 @@
+import { VerifyNumberOfElementsByTagNameInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyNumberOfElementsByTagName(
+    args: VerifyNumberOfElementsByTagNameInterface
+): Promise<void> {
+    try {
+
+        const parts = args.value.split(",");
+        const tagName = parts[0].trim();
+        const expectedCount = parseInt(parts[1], 10);
+
+        const elements = await args.driver.$$(tagName);
+        const ismatched = elements.length === expectedCount;
+
+        logger.info("Number of elements by tag name verification result:", {
+            ismatched,
+            tagName,
+            actualCount: elements.length,
+            expectedCount
+        });
+        if (ismatched === false) {
+            throw new Error(`Number of <${tagName}> elements does not match expected. Expected: ${expectedCount}, Actual: ${elements.length}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyNumberOfElementsByTagName',
+            stepInputs: [tagName, expectedCount.toString()],
+            elementsData: []
+        }));
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyNumberOfElementsByTagName");
+        throw new Error(`VerifyNumberOfElementsByTagName action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,52 @@
+import { VerifyNumberOfElementsByXpathInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyNumberOfElementsByXpath(
+    args: VerifyNumberOfElementsByXpathInterface
+): Promise<void> {
+    try {
+
+
+
+        const parts = args.value.split(",");
+
+
+        const xpath = parts[0].trim();
+        const expectedCount = parseInt(parts[1], 10);
+
+        let elements;
+
+        try {
+            elements = await args.driver.$$(`xpath=${xpath}`);
+        } catch {
+            elements = [];
+        }
+
+        const actualCount = elements.length;
+        const ismatched = actualCount === expectedCount;
+
+        logger.info("Number of elements by XPath verification result:", {
+            ismatched,
+            xpath,
+            actualCount,
+            expectedCount
+        });
+        if (ismatched === false) {
+            throw new Error(`Number of elements matching XPath "${xpath}" does not match expected. Expected: ${expectedCount}, Actual: ${actualCount}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyNumberOfElementsByXpath',
+            stepInputs: [xpath, expectedCount.toString()],
+            elementsData: []
+        }));
+
+
+    } catch (error: any) {
+        // Only unexpected framework-level errors reach here
+        args.scriptDataAppender?.setErrorNLP("VerifyNumberOfElementsByXpath");
+        throw new Error(
+            `VerifyNumberOfElementsByXpath action failed`,
+            { cause: error }
+        );
+    }
+}

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

@@ -0,0 +1,94 @@
+import { VerifyPartialAttributeValueInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyPartialAttributeValue(
+    args: VerifyPartialAttributeValueInterface
+): 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)) ||
+                    (await element.getText()) ||
+                    "";
+                const isMatched = actualValue.toLowerCase().includes(expectedValue.toLowerCase());
+
+                logger.info("Attribute value verification result:", { isMatched, actualValue, expectedValue });
+                if (isMatched === false) {
+                    throw new Error(`Attribute "${attrName}" value does not contain expected text. Expected to contain: "${expectedValue}", Actual: "${actualValue}"`);
+                }
+
+                args.scriptDataAppender.add(async () => {
+
+                    return {
+                        nlpName: 'MOB_VerifyPartialAttributeValue',
+                        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_VerifyPartialAttributeValue")
+                throw new Error(`VerifyPartialAttributeValue 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().includes(expectedValue.toLowerCase());
+
+                logger.info("Attribute value verification result:", { isMatched, actualValue, expectedValue });
+                if (isMatched === false) {
+                    throw new Error(`Attribute "${attrName}" value does not contain expected text. Expected to contain: "${expectedValue}", Actual: "${actualValue}"`);
+                }
+
+                args.scriptDataAppender.add(async () => {
+                    const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                        args.pageDOM,
+                        `[ff-inspect="${args.fireflinkIndex}"]`
+                    );
+                    return {
+                        nlpName: 'VerifyPartialAttributeValue',
+                        stepInputs: [attrName, expectedValue, caseSensitive],
+                        elementsData: [{
+                            name: args.elementName,
+                            type: args.elementType,
+                            locators: ffElement.locators,
+                            platform: args.platform
+                        }]
+                    };
+                });
+
+            } catch (error: any) {
+                args.scriptDataAppender.setErrorNLP("VerifyPartialAttributeValue")
+                throw new Error(`VerifyPartialAttributeValue action failed `, { cause: error });
+            }
+            break;
+    }
+}

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

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

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

@@ -0,0 +1,84 @@
+import { VerifyLighthouseScoreInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyPerformanceScore(
+    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);
+        }
+
+        // -------- Performance metrics --------
+        const metrics = await args.driver.execute(() => {
+
+            const timing = performance.timing;
+            const paintEntries = performance.getEntriesByType('paint');
+
+            const fcpEntry = paintEntries.find(p => p.name === 'first-contentful-paint');
+            const fcpTime = fcpEntry ? fcpEntry.startTime : null;
+
+            const resources = performance.getEntriesByType('resource') as PerformanceResourceTiming[];
+
+            const transferSize = resources
+                .reduce((total, r) => total + (r.transferSize || 0), 0);
+
+            return {
+                domContentLoaded: timing.domContentLoadedEventEnd - timing.navigationStart,
+                loadTime: timing.loadEventEnd - timing.navigationStart,
+                firstContentfulPaint: fcpTime,
+                resourceCount: resources.length,
+                transferSize: transferSize
+            };
+        });
+
+        const checks = {
+            fcp_good:
+                metrics.firstContentfulPaint !== null &&
+                metrics.firstContentfulPaint <= 2500,
+
+            dom_ready_fast:
+                metrics.domContentLoaded <= 3000,
+
+            load_fast:
+                metrics.loadTime <= 5000,
+
+            resource_count_ok:
+                metrics.resourceCount <= 150,
+
+            payload_ok:
+                metrics.transferSize <= 5 * 1024 * 1024
+        };
+
+        const values = Object.values(checks);
+        const passed = values.filter(v => v).length;
+        const total = values.length;
+
+        const actualScore = Math.floor((passed / total) * 100);
+
+        if (actualScore < minScore) {
+            throw new Error(
+                `Performance score ${actualScore} is less than expected ${minScore}`
+            );
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyPerformanceScore',
+            stepInputs: [url, device, minScore.toString()],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyPerformanceScore")
+        throw new Error(`VerifyPerformanceScore action failed `, { cause: error });
+    }
+
+}