ff-automationv2 2.2.27 → 2.2.29

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

@@ -2,14 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyCssAttributeValue = verifyCssAttributeValue;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyCssAttributeValue(args) {
     try {
         const element = await args.driver.$(args.selector);
         const parts = args.value.split(",");
         const cssProperty = parts[0].trim();
-        const expectedValue = parts[1].trim();
+        const expectedValueInput = parts[1].trim();
+        let expectedValue = expectedValueInput;
         const caseSensitive = false;
-        const actualValue = (await element.getCSSProperty(cssProperty)).value || "";
+        let actualValue = (await element.getCSSProperty(cssProperty)).value || "";
+        const unitRegex = /(px|rem|em)$/i;
+        if (unitRegex.test(actualValue) || unitRegex.test(expectedValue)) {
+            actualValue = actualValue.replace(unitRegex, "").trim();
+            expectedValue = expectedValue.replace(unitRegex, "").trim();
+        }
         const isMatched = caseSensitive
             ? actualValue === expectedValue
             : actualValue.toLowerCase() === expectedValue.toLowerCase();
@@ -23,18 +30,17 @@ async function verifyCssAttributeValue(args) {
         if (isMatched === false) {
             throw new Error(`CSS 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: 'VerifyCssAttributeValue',
-                stepInputs: [cssProperty, expectedValue, caseSensitive],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
+        (0, appendScriptData_js_1.appendScriptData)({
+            scriptDataAppender: args.scriptDataAppender,
+            nlpName: "VerifyCssAttributeValue",
+            stepInputs: [cssProperty, expectedValueInput, caseSensitive],
+            pageDOM: args.pageDOM,
+            elementGetter: args.elementGetter,
+            ffNumber: args.fireflinkIndex,
+            elementName: args.elementName,
+            elementType: args.elementType,
+            selector: args.selector,
+            platform: args.platform
         });
     }
     catch (error) {

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

@@ -1,35 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyElementIsClickable = verifyElementIsClickable;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 const logData_js_1 = require("../../../../utils/logger/logData.js");
 async function verifyElementIsClickable(args) {
+    const nlpName = args.platform === "ios" ? "IOS_VerifyElementIsClickable" : "MOB_VerifyElementIsClickable";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
                 if (!element) {
                     throw new Error("Element not found");
                 }
-                const isClickable = await element.getAttribute("clickable");
+                const attributeName = args.platform === "ios" ? "accessible" : "clickable";
+                const isClickable = await element.getAttribute(attributeName);
                 logData_js_1.logger.info("Element enabled status:", { isClickable });
                 if (isClickable !== "true") {
                     throw new Error(`Element is not enabled. Expected: true, Actual: ${isClickable}`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_VerifyElementIsClickable',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: [{ "name": "xpath", "value": args.selector }],
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: args.platform === "ios" ? ["5"] : [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {
-                args.scriptDataAppender.setErrorNLP("MOB_VerifyElementIsClickable");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`VerifyElementIsClickable action failed `, { cause: error });
             }
             break;
@@ -41,18 +45,17 @@ async function verifyElementIsClickable(args) {
                 if (isClickable === false) {
                     throw new Error(`Element is not clickable. Expected: clickable, Actual: not clickable`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'VerifyElementIsClickable',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyElementIsClickable",
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {

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

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyElementIsDisabled = verifyElementIsDisabled;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyElementIsDisabled(args) {
+    const nlpName = args.platform === "ios" ? "IOS_VerifyElementIsDisabled" : "MOB_VerifyElementIsDisabled";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
                 if (!element) {
@@ -12,24 +15,24 @@ async function verifyElementIsDisabled(args) {
                 }
                 const enabled = await element.getAttribute("enabled");
                 logData_js_1.logger.info("Element enabled status:", { enabled });
-                if (enabled !== "false") {
-                    throw new Error(`Element is not enabled. Expected: true, Actual: ${enabled}`);
+                if (enabled === "true") {
+                    throw new Error(`Element is not disabled. Expected: false, Actual: ${enabled}`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_VerifyElementIsDisabled',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: [{ "name": "xpath", "value": args.selector }],
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {
-                args.scriptDataAppender.setErrorNLP("MOB_VerifyElementIsDisabled");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`VerifyElementIsDisabled action failed `, { cause: error });
             }
             break;
@@ -43,20 +46,19 @@ async function verifyElementIsDisabled(args) {
                 const isEnabled = await element.isEnabled();
                 logData_js_1.logger.info("Element enabled status in verifyElementIsDisabled:", !isEnabled);
                 if (isEnabled === true) {
-                    throw new Error(`Element is not disabled. Expected: disabled, Actual: enabled`);
+                    throw new Error(`Element is not disabled. Expected: false, Actual: enabled`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'VerifyElementIsDisabled',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyElementIsDisabled",
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {

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

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyElementIsDisplayed = verifyElementIsDisplayed;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyElementIsDisplayed(args) {
+    const nlpName = args.platform === "ios" ? "IOS_IsDisplayed" : "MOB_IsDisplayed";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
                 if (!element) {
@@ -15,21 +18,21 @@ async function verifyElementIsDisplayed(args) {
                 if (enabled !== "true") {
                     throw new Error(`Element is not enabled. Expected: true, Actual: ${enabled}`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_IsDisplayed',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: [{ "name": "xpath", "value": args.selector }],
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {
-                args.scriptDataAppender.setErrorNLP("MOB_IsDisplayed");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`VerifyElementIsDisplayed action failed `, { cause: error });
             }
             break;
@@ -45,18 +48,17 @@ async function verifyElementIsDisplayed(args) {
                 if (isDisplayed === false) {
                     throw new Error(`Element is not displayed. Expected: displayed, Actual: not displayed`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'IsDisplayed',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "IsDisplayed",
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {

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

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyElementIsEnabled = verifyElementIsEnabled;
 const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
 async function verifyElementIsEnabled(args) {
+    const nlpName = args.platform === "ios" ? "IOS_IsEnabled" : "MOB_IsEnabled";
     switch (args.platform) {
         case "android":
+        case "ios":
             try {
                 const element = await args.driver.$(args.selector);
                 if (!element) {
@@ -15,21 +18,21 @@ async function verifyElementIsEnabled(args) {
                 if (enabled !== "true") {
                     throw new Error(`Element is not enabled. Expected: true, Actual: ${enabled}`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    return {
-                        nlpName: 'MOB_IsEnabled',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: [{ "name": "xpath", "value": args.selector }],
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {
-                args.scriptDataAppender.setErrorNLP("MOB_IsEnabled");
+                args.scriptDataAppender.setErrorNLP(nlpName);
                 throw new Error(`VerifyElementIsEnabled action failed `, { cause: error });
             }
             break;
@@ -45,18 +48,17 @@ async function verifyElementIsEnabled(args) {
                 if (isEnabled === false) {
                     throw new Error(`Element is not enabled. Expected: enabled, Actual: disabled`);
                 }
-                args.scriptDataAppender.add(async () => {
-                    const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-                    return {
-                        nlpName: 'IsEnabled',
-                        stepInputs: [],
-                        elementsData: [{
-                                name: args.elementName,
-                                type: args.elementType,
-                                locators: ffElement.locators,
-                                platform: args.platform
-                            }]
-                    };
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "IsEnabled",
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
                 });
             }
             catch (error) {

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

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

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyElementIsEnabledInSpecifiedTime = verifyElementIsEnabledInSpecifiedTime;
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+const logData_js_1 = require("../../../../utils/logger/logData.js");
+async function verifyElementIsEnabledInSpecifiedTime(args) {
+    const nlpName = args.platform === "ios" ? "IOS_VerifyElementIsEnabled" : "MOB_VerifyElementIsEnabled";
+    switch (args.platform) {
+        case "android":
+        case "ios":
+            try {
+                let isEnabled = false;
+                await args.driver.waitUntil(async () => {
+                    const element = await args.driver.$(args.selector);
+                    if (!element) {
+                        return false;
+                    }
+                    isEnabled = await element.isEnabled();
+                    return isEnabled;
+                }, {
+                    timeout: Number(args.value.split(",")[1]),
+                    timeoutMsg: "Element is not displayed within the specified time"
+                });
+                logData_js_1.logger.info("Android Element display status:", { isEnabled });
+                if (!isEnabled) {
+                    throw new Error(`Element is not displayed. Expected: displayed, Actual: not displayed`);
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [args.value.split(",")[1]],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP(nlpName);
+                throw new Error(`VerifyElementIsEnabled action failed`, { cause: error });
+            }
+            break;
+        case "web":
+        default:
+            try {
+                let isEnabled = false;
+                await args.driver.waitUntil(async () => {
+                    const element = await args.driver.$(args.selector);
+                    if (!element) {
+                        return false;
+                    }
+                    isEnabled = await element.isEnabled();
+                    return isEnabled;
+                }, {
+                    timeout: Number(args.value),
+                    timeoutMsg: "Element is not displayed within the specified time"
+                });
+                logData_js_1.logger.info("Web Element display status:", { isEnabled });
+                if (!isEnabled) {
+                    throw new Error(`Element is not displayed. Expected: displayed, Actual: not displayed`);
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyElementIsEnabled",
+                    stepInputs: [args.value],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("VerifyElementIsEnabled");
+                throw new Error(`VerifyElementIsEnabled action failed`, { cause: error });
+            }
+            break;
+    }
+}

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

@@ -1,34 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.verifyElementIsNotDisplayed = verifyElementIsNotDisplayed;
-const logData_js_1 = require("../../../../utils/logger/logData.js");
+const appendScriptData_js_1 = require("../../../../fireflinkData/fireflinkScript/appendScriptData.js");
+// import { logger } from "../../../../utils/logger/logData.js";
 async function verifyElementIsNotDisplayed(args) {
-    try {
-        const element = await args.driver.$(args.selector);
-        if (!element) {
-            logData_js_1.logger.info("Element not found in verifyElementIsNotDisplayed");
-        }
-        const isDisplayed = await element.isDisplayed();
-        logData_js_1.logger.info("Element display status in verifyElementIsNotDisplayed:", { isDisplayed });
-        if (isDisplayed === true) {
-            throw new Error(`Element is displayed. Expected: not displayed, Actual: displayed`);
-        }
-        args.scriptDataAppender.add(async () => {
-            const ffElement = await args.elementGetter.getFireFlinkElement(args.pageDOM, `[ff-inspect="${args.fireflinkIndex}"]`);
-            return {
-                nlpName: 'VerifyElementIsNotDisplayed',
-                stepInputs: [],
-                elementsData: [{
-                        name: args.elementName,
-                        type: args.elementType,
-                        locators: ffElement.locators,
-                        platform: args.platform
-                    }]
-            };
-        });
-    }
-    catch (error) {
-        args.scriptDataAppender.setErrorNLP("VerifyElementIsNotDisplayed");
-        throw new Error(`VerifyElementIsNotDisplayed action failed `, { cause: error });
+    const nlpName = args.platform === "ios" ? "IOS_VerifyElementIsNotDisplayed" : "MOB_VerifyElementIsNotDisplayed";
+    switch (args.platform) {
+        case "android":
+        case "ios":
+            try {
+                if (args.selector.toLowerCase() !== "fire-flink-0") {
+                    throw new Error("Element is displayed. Expected: not displayed, Actual: displayed");
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: nlpName,
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP(nlpName);
+                throw new Error(`VerifyElementIsNotDisplayed action failed `, { cause: error });
+            }
+            break;
+        case "web":
+            try {
+                if (args.selector.toLowerCase() !== "fire-flink-0") {
+                    throw new Error("Element is displayed. Expected: not displayed, Actual: displayed");
+                }
+                (0, appendScriptData_js_1.appendScriptData)({
+                    scriptDataAppender: args.scriptDataAppender,
+                    nlpName: "VerifyElementIsNotDisplayed",
+                    stepInputs: [],
+                    pageDOM: args.pageDOM,
+                    elementGetter: args.elementGetter,
+                    ffNumber: args.fireflinkIndex,
+                    elementName: args.elementName,
+                    elementType: args.elementType,
+                    selector: args.selector,
+                    platform: args.platform
+                });
+            }
+            catch (error) {
+                args.scriptDataAppender.setErrorNLP("VerifyElementIsNotDisplayed");
+                throw new Error(`VerifyElementIsNotDisplayed action failed `, { cause: error });
+            }
+            break;
     }
 }