ff-automationv2 2.1.3 → 2.2.0

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

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

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

@@ -0,0 +1,40 @@
+import { VerifyOptionSelectionInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyIfOptionWithTextIsDeselected(
+    args: VerifyOptionSelectionInterface
+): Promise<void> {
+    try {
+        const optionText = args.value;
+        const selectElement = await args.driver.$(args.selector);
+        const option = await selectElement.$(`//option[text()="${optionText}"]`);
+
+        const isSelected = await option.isSelected();
+
+
+        if (!isSelected) {
+            throw new Error(`Option with text ${optionText} is selected`);
+        }
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyIfOptionWithTextIsDeselected',
+                stepInputs: [optionText],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfOptionWithTextIsDeselected")
+        throw new Error(`VerifyIfOptionWithTextIsDeselected action failed `, { cause: error });
+    }
+}

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

@@ -0,0 +1,61 @@
+import { VerifyIfOptionWithValueIsDeSelectedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyIfOptionWithValueIsDeselected(
+    args: VerifyIfOptionWithValueIsDeSelectedInterface
+): Promise<void> {
+    try {
+        let result = false;
+
+
+
+        const expectedValue = args.value.trim();
+
+        const element = await args.driver.$(args.selector);
+
+
+        const options = await element.$$("option");
+
+        for (const option of options) {
+
+            const optionValue = await option.getAttribute("value");
+            const isSelected = await option.isSelected();
+
+            if (optionValue === expectedValue && isSelected) {
+
+                result = true;
+                logger.info("Option with value is selected:", {
+                    expectedValue, result
+                });
+                break;
+            }
+
+        }
+        if (result === true) {
+            throw new Error(`Option with value "${expectedValue}" 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: 'VerifyIfOptionWithValueIsDeselected',
+                stepInputs: [expectedValue],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+    } catch (error: any) {
+        args.scriptDataAppender?.setErrorNLP("VerifyIfOptionWithValueIsDeselected");
+        throw new Error("VerifyIfOptionWithValueIsDeselected failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,58 @@
+import { VerifyIfOptionWithValueIsSelectedInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyIfOptionWithValueIsSelected(
+    args: VerifyIfOptionWithValueIsSelectedInterface
+): Promise<void> {
+    try {
+        let result = false;
+
+
+
+        const expectedValue = args.value.trim();
+
+        const element = await args.driver.$(args.selector);
+
+
+        const options = await element.$$("option");
+
+        for (const option of options) {
+
+            const optionValue = await option.getAttribute("value");
+            const isSelected = await option.isSelected();
+
+            if (optionValue === expectedValue && isSelected) {
+
+                result = true;
+                logger.info("Option with value is selected:", {
+                    expectedValue, result
+                });
+                break;
+            }
+        }
+        if (result === false) {
+            throw new Error(`Option with value "${expectedValue}" is not selected in the dropdown.`);
+        }
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyIfOptionWithValueIsSelected',
+                stepInputs: [expectedValue],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+    } catch (error: any) {
+        args.scriptDataAppender?.setErrorNLP("VerifyIfOptionWithValueIsSelected");
+        throw new Error("VerifyIfOptionWithValueIsSelected failed", { cause: error });
+    }
+}

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

@@ -0,0 +1,40 @@
+import { VerifyOptionSelectionInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyIfOptionWithVisibleTextIsSelected(
+    args: VerifyOptionSelectionInterface
+): Promise<void> {
+    try {
+        const optionText = args.value;
+        const selectElement = await args.driver.$(args.selector);
+        const option = await selectElement.$(`//option[text()="${optionText}"]`);
+
+        const isSelected = await option.isSelected();
+        if (!isSelected) {
+            throw new Error(`Option with visible text ${optionText} is not selected`);
+        }
+
+
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyIfOptionWithVisibleTextIsSelected',
+                stepInputs: [optionText],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfOptionWithVisibleTextIsSelected")
+        throw new Error(`VerifyIfOptionWithVisibleTextIsSelected action failed `, { cause: error });
+    }
+}

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

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

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

@@ -0,0 +1,37 @@
+import { VerifyUrlStatusCodeInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyIfStatusCodeOfALinkIsStatusCode(
+    args: VerifyUrlStatusCodeInterface
+): Promise<void> {
+    try {
+        const inputs = args.value.split(',');
+        const expectedStatusCode = parseInt(inputs[0]);
+        const url = inputs[1];
+
+        const actualStatus = await args.driver.execute(async (url) => {
+            try {
+                const response = await fetch(url, { method: 'HEAD' });
+                return response.status;
+            } catch {
+                return null;
+            }
+        }, url);
+
+        if (actualStatus !== expectedStatusCode) {
+            throw new Error(
+                `Expected status ${expectedStatusCode} but received ${actualStatus} for ${url}`
+            );
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyIfStatusCodeOfALinkIsStatusCode',
+            stepInputs: [expectedStatusCode.toString(), url],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfStatusCodeOfALinkIsStatusCode")
+        throw new Error(`VerifyIfStatusCodeOfALinkIsStatusCode action failed `, { cause: error });
+    }
+
+}

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

@@ -0,0 +1,46 @@
+import { VerifyAllLinksStatusCodeInterface } from "../../interface/verifyActionInterface.js";
+
+export async function verifyIfStatusCodesOfLinks(
+    args: VerifyAllLinksStatusCodeInterface
+): Promise<void> {
+    try {
+        const expectedStatusCode = parseInt(args.value);
+
+        const result = await args.driver.execute(async (expected) => {
+            const links = Array.from(document.querySelectorAll('a[href]'))
+                .map((a: any) => a.href)
+                .filter((url: string) => url && url.startsWith('http'));
+
+            const uniqueLinks = [...new Set(links)];
+
+            for (const url of uniqueLinks) {
+                try {
+                    const response = await fetch(url, { method: 'HEAD' });
+                    if (response.status !== expected) {
+                        return false;
+                    }
+                } catch {
+                    return false;
+                }
+            }
+
+            return true;
+        }, expectedStatusCode);
+
+        if (!result) {
+            throw new Error(`Not all links returned status code ${expectedStatusCode}`);
+        }
+
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyIfStatusCodesOfLinks',
+            stepInputs: [expectedStatusCode.toString()],
+            elementsData: []
+        }));
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfStatusCodesOfLinks")
+        throw new Error(`VerifyIfStatusCodesOfLinks action failed `, { cause: error });
+    }
+
+
+}

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

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

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

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

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

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

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

@@ -0,0 +1,50 @@
+import { VerifyIfVideoIsPlayingInterface } from "../../interface/verifyActionInterface.js";
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyIfVideoIsPlaying(
+    args: VerifyIfVideoIsPlayingInterface
+): Promise<void> {
+    try {
+
+        const element = await args.driver.$(args.selector);
+
+
+        const isPlaying = await args.driver.execute(
+            (el: any) => {
+
+                return (
+                    !el.paused &&
+                    !el.ended &&
+                    el.currentTime > 0 &&
+                    el.readyState > 2
+                );
+            },
+            element
+        );
+        logger.info("Video playing verification result:", { isPlaying });
+        if (isPlaying === false) {
+            throw new Error(`Video is not playing for the selector: ${args.selector}`);
+        }
+
+        args.scriptDataAppender.add(async () => {
+            const ffElement: any = await args.elementGetter.getFireFlinkElement(
+                args.pageDOM,
+                `[ff-inspect="${args.fireflinkIndex}"]`
+            );
+            return {
+                nlpName: 'VerifyIfVideoIsPlaying',
+                stepInputs: [],
+                elementsData: [{
+                    name: args.elementName,
+                    type: args.elementType,
+                    locators: ffElement.locators,
+                    platform: args.platform
+                }]
+            };
+        });
+
+
+    } catch (error: any) {
+        args.scriptDataAppender.setErrorNLP("VerifyIfVideoIsPlaying");
+        throw new Error(`VerifyIfVideoIsPlaying action failed`, { cause: error });
+    }
+}