ff-automationv2 2.1.3 → 2.2.0

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

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

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

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

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

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

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

@@ -0,0 +1,27 @@
+import { VerifyIfBrowserWindowIsClosedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyIfBrowserWindowIsClosed(
+    args: VerifyIfBrowserWindowIsClosedInterface
+): Promise<void> {
+    try {
+
+        try {
+            await args.driver.getWindowHandle();
+            logger.info("Browser window is still open.");
+            throw new Error("Browser window is still open.");
+        } catch {
+            logger.info("Browser window is closed as expected.");
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyIfBrowserWindowIsClosed',
+            stepInputs: [],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfBrowserWindowIsClosed");
+        throw new Error("VerifyIfBrowserWindowIsClosed action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,38 @@
+import { VerifyIfCookieNameIsAddedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyIfCookieNameIsAdded(
+    args: VerifyIfCookieNameIsAddedInterface
+): Promise<void> {
+    try {
+
+
+
+        const cookieName = args.value.trim();
+        const cookies = await args.driver.getCookies();
+        logger.info("Current cookies:", { cookies });
+
+        const isMatched = cookies.some(
+            (cookie: any) => cookie.name === cookieName
+        );
+        if (isMatched === false) {
+            throw new Error(`Cookie name is not added. Expected: ${cookieName}, Actual: Cookie not found`);
+        }
+        logger.info("Cookie added verification result:", {
+            isMatched,
+            cookieName
+        });
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyIfCookieNameIsAdded',
+            stepInputs: [cookieName],
+            elementsData: []
+        }));
+
+
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfCookieNameIsAdded");
+        throw new Error(`VerifyIfCookieNameIsAdded action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,33 @@
+import { VerifyIfCookieNameIsDeletedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyIfCookieNameIsDeleted(
+    args: VerifyIfCookieNameIsDeletedInterface
+): Promise<void> {
+    try {
+
+
+
+        const cookie = await args.driver.getCookies([args.value.trim()]);
+        const isMatched = cookie.length === 0;
+
+        logger.info("Cookie deleted verification result:", {
+            isMatched
+        });
+        if (isMatched === false) {
+            throw new Error(`Cookie name is not deleted. Expected: ${args.value.trim()}, Actual: Cookie still exists`);
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyIfCookieNameIsDeleted',
+            stepInputs: [args.value.trim()],
+            elementsData: []
+        }));
+
+
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfCookieNameIsDeleted");
+        throw new Error(`VerifyIfCookieNameIsDeleted action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,49 @@
+import { VerifyIfCookieObjectIsPresentInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyIfCookieObjectIsPresent(
+    args: VerifyIfCookieObjectIsPresentInterface
+): Promise<void> {
+    try {
+
+        const cookies = await args.driver.getCookies();
+        logger.info("Available Cookies:", cookies);
+
+        let cookieName: string | undefined;
+        let cookieValue: string | undefined;
+
+        // Try parsing JSON cookie object
+        try {
+            const parsed = args.value.split(',')
+            cookieName = parsed[0].trim();
+            cookieValue = parsed[1].trim();
+        } catch {
+            // If not JSON, treat input as cookie name
+            cookieName = args.value.trim();
+        }
+
+        // Check cookie existence
+        const matchedCookie = cookies.find(cookie => {
+            if (cookieValue !== undefined) {
+                return cookie.name === cookieName && cookie.value === cookieValue;
+            }
+            return cookie.name === cookieName;
+        });
+
+        if (!matchedCookie) {
+            throw new Error(`Cookie '${cookieName}' is not present.`);
+        }
+
+        logger.info("Matched Cookie:", matchedCookie);
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyIfCookieObjectIsPresent',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfCookieObjectIsPresent");
+        throw new Error("VerifyIfCookieObjectIsPresent action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,60 @@
+import { VerifyIfGivenOptionIsDuplicateInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyIfGivenOptionIsDuplicate(
+    args: VerifyIfGivenOptionIsDuplicateInterface
+): Promise<void> {
+    try {
+
+
+
+        const expectedText = args.value.trim();
+
+        const element = await args.driver.$(args.selector);
+
+
+        const options = await element.$$("option");
+
+        let count = 0;
+
+        for (const option of options) {
+            const text = await option.getText();
+            if (text.trim() === expectedText) {
+                count++;
+            }
+        }
+
+        logger.info("Duplicate count:", { expectedText, count });
+        if (count > 1) {
+            throw new Error(`Option "${expectedText}" is duplicated ${count} times in the dropdown.`);
+        }
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyIfGivenOptionIsDuplicate',
+                stepInputs: [expectedText],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP(
+            "VerifyIfGivenOptionIsDuplicate"
+        );
+        throw new Error(
+            "VerifyIfGivenOptionIsDuplicate failed",
+            { cause: error }
+        );
+    }
+}

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

@@ -0,0 +1,40 @@
+import { VerifyIfImageIsBrokenInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyIfImageIsBroken(
+    args: VerifyIfImageIsBrokenInterface
+): Promise<void> {
+    try {
+
+        const imageUrl = args.value.trim();
+
+        let response;
+
+        try {
+            response = await fetch(imageUrl, {
+                method: "HEAD",
+                redirect: "follow"
+            });
+        } catch {
+            logger.info("ImageUrl request failed (considered broken):", imageUrl);
+        }
+
+        if (response) {
+            logger.info("Checking imageUrl:", imageUrl, "Status:", response.status);
+
+            if (response.status < 400) {
+                throw new Error(`Working image found: ${imageUrl}`);
+            }
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyIfImageIsBroken',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfImageIsBroken");
+        throw new Error("VerifyIfImageIsBroken action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,38 @@
+import { VerifyIfLinkIsBrokenInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyIfLinkIsBroken(
+    args: VerifyIfLinkIsBrokenInterface
+): Promise<void> {
+    try {
+        const link = args.value.trim();
+
+        let response;
+
+        try {
+            response = await fetch(link, {
+                method: "HEAD",
+                redirect: "follow"
+            });
+        } catch {
+            logger.info("link request failed (considered broken):", link);
+        }
+
+        if (response) {
+            logger.info("Checking link:", link, "Status:", response.status);
+
+            if (response.status < 400) {
+                throw new Error(`Working link found: ${link}`);
+            }
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyIfLinkIsBroken',
+            stepInputs: [args.value.trim()],
+            elementsData: []
+        }));
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfLinkIsBroken")
+        throw new Error(`VerifyIfLinkIsBroken action failed`, { cause: error });
+    }
+}

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

@@ -0,0 +1,37 @@
+import { VerifyIfLinkIsWorkingInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyIfLinkIsWorking(
+    args: VerifyIfLinkIsWorkingInterface
+): Promise<void> {
+    try {
+        const url = args.value.trim();
+
+        try {
+
+            const response = await fetch(url, {
+                method: "HEAD",
+                redirect: "follow"
+            });
+
+            logger.info("Checking link:", url, "Status:", response.status);
+
+            if (response.status >= 400) {
+                throw new Error(`Broken link found: ${url}`);
+            }
+
+        } catch {
+            throw new Error(`Link request failed: ${url}`);
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyIfLinkIsWorking',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfLinkIsWorking");
+        throw new Error("VerifyIfLinkIsWorking action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,46 @@
+import { VerifyIfLinksAreBrokenInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyIfLinksAreBroken(
+    args: VerifyIfLinksAreBrokenInterface
+): Promise<void> {
+    try {
+        const links = args.value.split(",").map((link: string) => link.trim()).filter((link: string) => link.length > 0);
+
+        if (links.length === 0) {
+            throw new Error("No valid links provided.");
+        }
+
+        for (const link of links) {
+
+            let response;
+
+            try {
+                response = await fetch(link, {
+                    method: "HEAD",
+                    redirect: "follow"
+                });
+
+            } catch {
+                logger.info("Link request failed (considered broken):", link);
+                continue; // treat as broken
+            }
+
+            logger.info("Checking imageUrl:", link, "Status:", response.status);
+
+            if (response.status < 400) {
+                throw new Error(`Working link found: ${link}`);
+            }
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "VerifyIfLinksAreBroken",
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfLinksAreBroken");
+        throw new Error("VerifyIfLinksAreBroken action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,45 @@
+import { VerifyIfLinksAreWorkingInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+
+export async function verifyIfLinksAreWorking(
+    args: VerifyIfLinksAreWorkingInterface
+): Promise<void> {
+    try {
+        const links = args.value.split(",").map((link: string) => link.trim()).filter((link: string) => link.length > 0);
+
+        if (links.length === 0) {
+            throw new Error("No valid links provided.");
+        }
+
+        for (const link of links) {
+
+            try {
+
+                const response = await fetch(link, {
+                    method: "HEAD",
+                    redirect: "follow"
+                });
+
+                logger.info("Checking link:", link, "Status:", response.status);
+
+                if (response.status >= 400) {
+                    throw new Error(`Broken link found: ${link}`);
+                }
+
+            } catch {
+                throw new Error(`Link request failed: ${link}`);
+            }
+
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: "VerifyIfLinksAreWorking",
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfLinksAreWorking");
+        throw new Error("VerifyIfLinksAreWorking action failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,75 @@
+
+import { logger } from "../../../../utils/logger/logData.js";
+import { VerifyIfOptionWithIndexIsDeselectedInElementInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyIfOptionWithIndexIsDeselectedInElement(
+    args: VerifyIfOptionWithIndexIsDeselectedInElementInterface
+): Promise<void> {
+    try {
+        let result = true
+
+        const expectedIndex = parseInt(args.value, 10);
+
+        const element = await args.driver.$(args.selector);
+
+
+        // Get all <option> elements
+        const options = await element.$$("option");
+
+        if (!options || options.length === 0) {
+            logger.info("No options found in dropdown.");
+            result = false
+        }
+
+        // If index is within range
+        if (expectedIndex < options.length && expectedIndex >= 0) {
+
+            const targetOption = options[expectedIndex];
+            const isSelected = await targetOption.isSelected();
+
+            const isDeselected = !isSelected;
+
+            logger.info("Option index deselection verification result:", {
+                expectedIndex,
+                isDeselected
+            });
+            result = isDeselected
+
+        }
+
+        logger.info("Index out of range. Returning true as per logic.", {
+            expectedIndex,
+            totalOptions: options.length
+        });
+        if (result === false) {
+            throw new Error(`Option with index ${expectedIndex} is not deselected in the dropdown.`);
+        }
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyIfOptionWithIndexIsDeselectedInElement',
+                stepInputs: [expectedIndex],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+    } catch (error: any) {
+        args.scriptDataAppender?.setErrorNLP(
+            "VerifyIfOptionWithIndexIsDeselectedInElement"
+        );
+        throw new Error(
+            "VerifyIfOptionWithIndexIsDeselectedInElement action failed",
+            { cause: error }
+        );
+    }
+}