ff-automationv2 2.2.0 → 2.2.5

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

@@ -1,48 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,75 +0,0 @@
-
-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 }
-        );
-    }
-}