ff-automationv2 2.2.0 → 2.2.5

package/dist/automation/actions/interaction/switch/switchToParentWindow.js

@@ -0,0 +1,15 @@
+export async function switchToParentWindow(args) {
+    try {
+        const windowHandles = await args.driver.getWindowHandles();
+        await args.driver.switchToWindow(windowHandles[0]);
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'SwitchToParentWindow',
+            stepInputs: [],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("switchToParentWindow");
+        throw new Error(`Switch to parent window failed`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/switch/switchToTabBasedOnUrl.d.ts

@@ -0,0 +1,2 @@
+import { ISwitchToTabBasedOnUrl } from "../../interface/switchingActionInterface.js";
+export declare function switchToNewTabBasedOnUrl(args: ISwitchToTabBasedOnUrl): Promise<void>;

package/dist/automation/actions/interaction/switch/switchToTabBasedOnUrl.js

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

package/dist/automation/actions/interaction/switch/switchToWindowBasedOnURL.d.ts

@@ -0,0 +1,2 @@
+import { ISwitchToWindowBasedOnURL } from "../../interface/switchingActionInterface.js";
+export declare function switchWindowBasedOnUrl(args: ISwitchToWindowBasedOnURL): Promise<void>;

package/dist/automation/actions/interaction/switch/switchToWindowBasedOnURL.js

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

package/dist/automation/actions/interaction/switch/switchToWindowIfTitleContainsString.d.ts

@@ -0,0 +1,2 @@
+import { ISwitchToWindowIfTitleContainsString } from "../../interface/switchingActionInterface.js";
+export declare function switchToWindowIfTitleContainsString(args: ISwitchToWindowIfTitleContainsString): Promise<void>;

package/dist/automation/actions/interaction/switch/switchToWindowIfTitleContainsString.js

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

package/dist/automation/actions/interaction/switch/switchToWindowIfUrlContainsString.d.ts

@@ -0,0 +1,2 @@
+import { ISwitchToWindowIfUrlContainsString } from "../../interface/switchingActionInterface.js";
+export declare function switchToWindowIfUrlContainsString(args: ISwitchToWindowIfUrlContainsString): Promise<void>;

package/dist/automation/actions/interaction/switch/switchToWindowIfUrlContainsString.js

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

package/dist/automation/actions/interaction/upload/uploadfile.d.ts

@@ -0,0 +1,2 @@
+import { uploadFilePathUsingRobotInterface } from "../../interface/uploadFile.js";
+export declare function uploadFilePathUsingRobot(args: uploadFilePathUsingRobotInterface): Promise<void>;

package/dist/automation/actions/interaction/upload/uploadfile.js

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

package/dist/automation/actions/interaction/verify/VerifyAccessibilityScore.d.ts

@@ -0,0 +1,2 @@
+import { VerifyLighthouseScoreInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyAccessibilityScore(args: VerifyLighthouseScoreInterface): Promise<void>;

package/dist/automation/actions/interaction/verify/VerifyAccessibilityScore.js

@@ -0,0 +1,55 @@
+export async function verifyAccessibilityScore(args) {
+    try {
+        const inputs = args.value.split(',');
+        const url = inputs[0];
+        const device = inputs[1];
+        const minScore = parseFloat(inputs[2]);
+        if (!args.value) {
+            throw new Error("Input value is missing");
+        }
+        // Navigate only if URL is provided
+        if (url && url.startsWith("http")) {
+            await args.driver.url(url);
+        }
+        const checks = await args.driver.execute(() => {
+            const html_lang = document.documentElement.hasAttribute('lang');
+            const title_present = document.title && document.title.trim().length > 0;
+            const img_alt = Array.from(document.images)
+                .every(img => img.hasAttribute('alt'));
+            const inputs_labeled = Array.from(document.querySelectorAll('input,textarea,select'))
+                .every(el => el.labels && el.labels.length > 0 || el.hasAttribute('aria-label'));
+            const buttons_accessible = Array.from(document.querySelectorAll('button'))
+                .every(btn => btn.innerText.trim().length > 0 ||
+                btn.hasAttribute('aria-label'));
+            const no_aria_hidden_focusable = Array.from(document.querySelectorAll('[aria-hidden="true"]'))
+                .every(el => el.tabIndex === -1);
+            const text_has_color = Array.from(document.querySelectorAll('body *'))
+                .some(el => window.getComputedStyle(el).color !== 'rgba(0, 0, 0, 0)');
+            return {
+                html_lang,
+                title_present,
+                img_alt,
+                inputs_labeled,
+                buttons_accessible,
+                no_aria_hidden_focusable,
+                text_has_color
+            };
+        });
+        const values = Object.values(checks);
+        const passed = values.filter(v => v).length;
+        const total = values.length;
+        const actualScore = Math.floor((passed / total) * 100);
+        if (actualScore < minScore) {
+            throw new Error(`Accessibility score ${actualScore} is less than expected ${minScore}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyAccessibilityScore',
+            stepInputs: [url, device, minScore.toString()],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("VerifyAccessibilityScore");
+        throw new Error(`VerifyAccessibilityScore action failed `, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/verify/VerifyAllBrokenImages.d.ts

@@ -0,0 +1,2 @@
+import { VerifyAllBrokenImagesInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyAllBrokenImages(args: VerifyAllBrokenImagesInterface): Promise<void>;

package/dist/automation/actions/interaction/verify/VerifyAllBrokenImages.js

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

package/dist/automation/actions/interaction/verify/VerifyAllBrowserWindowsClosed.d.ts

@@ -0,0 +1,2 @@
+import { VerifyAllBrowserWindowsClosedInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyAllBrowserWindowsClosed(args: VerifyAllBrowserWindowsClosedInterface): Promise<void>;

package/dist/automation/actions/interaction/verify/VerifyAllBrowserWindowsClosed.js

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

package/dist/automation/actions/interaction/verify/VerifyAllOptionsAreDeSelected.d.ts

@@ -0,0 +1,2 @@
+import { VerifyAllOptionsAreDeselectedInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyAllOptionsAreDeselected(args: VerifyAllOptionsAreDeselectedInterface): Promise<void>;

package/dist/automation/actions/interaction/verify/VerifyAllOptionsAreDeSelected.js

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

package/dist/automation/actions/interaction/verify/VerifyAllOptionsAreSelected.d.ts

@@ -0,0 +1,2 @@
+import { VerifyAllOptionsAreSelectedInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyAllOptionsAreSelected(args: VerifyAllOptionsAreSelectedInterface): Promise<void>;

package/dist/automation/actions/interaction/verify/VerifyAllOptionsAreSelected.js

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

package/dist/automation/actions/interaction/verify/VerifyAttributeValue.d.ts

@@ -0,0 +1,2 @@
+import { VerifyAttributeValueInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyAttributeValue(args: VerifyAttributeValueInterface): Promise<void>;

package/dist/automation/actions/interaction/verify/VerifyAttributeValue.js

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

package/dist/automation/actions/interaction/verify/VerifyBestPracticesScore.d.ts

@@ -0,0 +1,2 @@
+import { VerifyLighthouseScoreInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyBestPracticesScore(args: VerifyLighthouseScoreInterface): Promise<void>;

package/dist/automation/actions/interaction/verify/VerifyBestPracticesScore.js

@@ -0,0 +1,55 @@
+export async function verifyBestPracticesScore(args) {
+    try {
+        const inputs = args.value.split(',');
+        const url = inputs[0];
+        const device = inputs[1];
+        const minScore = parseFloat(inputs[2]);
+        if (!args.value) {
+            throw new Error("Input value is missing");
+        }
+        if (url && url.startsWith("http")) {
+            await args.driver.url(url);
+        }
+        const checks = await args.driver.execute(() => {
+            const https = window.location.href.startsWith("https");
+            const no_mixed_content = Array.from(document.querySelectorAll('img,script,link'))
+                .every(e => {
+                const src = e.src || e.src || e.href;
+                return !src || src.startsWith("https") || src.startsWith("data:");
+            });
+            const no_deprecated_tags = document.querySelectorAll('font,center,marquee').length === 0;
+            const no_inline_js = Array.from(document.querySelectorAll('*'))
+                .every(el => !Array.from(el.attributes)
+                .some(a => a.name.startsWith('on')));
+            const no_console_errors = window.__jsErrors__ === undefined ||
+                window.__jsErrors__.length === 0;
+            const secure_iframes = Array.from(document.querySelectorAll('iframe'))
+                .every(f => !f.hasAttribute('sandbox') ||
+                f.getAttribute('sandbox')?.includes('allow-same-origin'));
+            return {
+                https,
+                no_mixed_content,
+                no_deprecated_tags,
+                no_inline_js,
+                no_console_errors,
+                secure_iframes
+            };
+        });
+        const values = Object.values(checks);
+        const passed = values.filter(v => v).length;
+        const total = values.length;
+        const actualScore = Math.floor((passed / total) * 100);
+        if (actualScore < minScore) {
+            throw new Error(`Best Practices score ${actualScore} is less than expected ${minScore}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBestPracticesScore',
+            stepInputs: [url, device, minScore.toString()],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("VerifyBestPracticesScore");
+        throw new Error(`VerifyBestPracticesScore action failed `, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/verify/VerifyBrowserHtmlCodeContainsString.d.ts

@@ -0,0 +1,2 @@
+import { VerifyBrowserHtmlCodeContainsStringInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyBrowserHtmlCodeContainsString(args: VerifyBrowserHtmlCodeContainsStringInterface): Promise<void>;

package/dist/automation/actions/interaction/verify/VerifyBrowserHtmlCodeContainsString.js

@@ -0,0 +1,24 @@
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyBrowserHtmlCodeContainsString(args) {
+    try {
+        const expectedText = args.value.trim().toLowerCase();
+        const pageSource = (await args.driver.getPageSource()).toLowerCase();
+        const isMatched = pageSource.includes(expectedText);
+        logger.info("Browser HTML contains string verification result:", {
+            isMatched,
+            expectedText
+        });
+        if (isMatched === false) {
+            throw new Error(`Browser HTML does not contain the expected string: ${args.value}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserHtmlCodeContainsString',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserHtmlCodeContainsString");
+        throw new Error(`VerifyBrowserHtmlCodeContainsString action failed`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/verify/VerifyBrowserWindowHeight.d.ts

@@ -0,0 +1,2 @@
+import { VerifyBrowserWindowHeightInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyBrowserWindowHeight(args: VerifyBrowserWindowHeightInterface): Promise<void>;

package/dist/automation/actions/interaction/verify/VerifyBrowserWindowHeight.js

@@ -0,0 +1,25 @@
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyBrowserWindowHeight(args) {
+    try {
+        const expectedHeight = parseInt(args.value, 10);
+        const windowSize = await args.driver.getWindowSize();
+        const isMatched = windowSize.height === expectedHeight;
+        logger.info("Browser window height verification result:", {
+            isMatched,
+            actualHeight: windowSize.height,
+            expectedHeight
+        });
+        if (isMatched === false) {
+            throw new Error(`Browser window height does not match. Expected: ${expectedHeight}, Actual: ${windowSize.height}`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserWindowHeight',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserWindowHeight");
+        throw new Error(`VerifyBrowserWindowHeight action failed`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/verify/VerifyBrowserWindowTitleContainsString.d.ts

@@ -0,0 +1,2 @@
+import { VerifyBrowserWindowTitleContainsStringInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyBrowserWindowTitleContainsString(args: VerifyBrowserWindowTitleContainsStringInterface): Promise<void>;

package/dist/automation/actions/interaction/verify/VerifyBrowserWindowTitleContainsString.js

@@ -0,0 +1,23 @@
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyBrowserWindowTitleContainsString(args) {
+    try {
+        logger.info(args.value);
+        const expectedText = args.value.trim().toLowerCase();
+        const actualTitle = (await args.driver.getTitle()).toLowerCase();
+        logger.info("Actual title:", actualTitle);
+        logger.info("Expected fragment:", expectedText);
+        if (!actualTitle.includes(expectedText)) {
+            logger.info("Title does not contain expected fragment:", expectedText);
+            throw new Error(`Title does not contain expected value.`);
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserWindowTitleContainsString',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserWindowTitleContainsString");
+        throw new Error(`VerifyBrowserWindowTitleContainsString action failed`, { cause: error });
+    }
+}

package/dist/automation/actions/interaction/verify/VerifyBrowserWindowTitleIsString.d.ts

@@ -0,0 +1,2 @@
+import { VerifyBrowserWindowTitleIsStringInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyBrowserWindowTitleIsString(args: VerifyBrowserWindowTitleIsStringInterface): Promise<void>;

package/dist/automation/actions/interaction/verify/VerifyBrowserWindowTitleIsString.js

@@ -0,0 +1,22 @@
+import { logger } from "../../../../utils/logger/logData.js";
+export async function verifyBrowserWindowTitleIsString(args) {
+    try {
+        const expectedTitle = args.value.trim().toLowerCase();
+        const actualTitle = (await args.driver.getTitle()).toLowerCase();
+        logger.info("Actual title:", actualTitle);
+        logger.info("Expected title:", expectedTitle);
+        if (actualTitle !== expectedTitle) {
+            logger.info("Browser title does not exactly match expected value.");
+            throw new Error("Browser title does not exactly match expected value.");
+        }
+        args.scriptDataAppender.add(async () => ({
+            nlpName: 'VerifyBrowserWindowTitleIsString',
+            stepInputs: [args.value],
+            elementsData: []
+        }));
+    }
+    catch (error) {
+        args.scriptDataAppender.setErrorNLP("VerifyBrowserWindowTitleIsString");
+        throw new Error("VerifyBrowserWindowTitleIsString action failed", { cause: error });
+    }
+}

package/dist/automation/actions/interaction/verify/VerifyBrowserWindowUrlContainsExpectedUrl.d.ts

@@ -0,0 +1,2 @@
+import { VerifyBrowserWindowUrlContainsExpectedUrlInterface } from "../../interface/verifyActionInterface.js";
+export declare function verifyBrowserWindowUrlContainsExpectedUrl(args: VerifyBrowserWindowUrlContainsExpectedUrlInterface): Promise<void>;