froth-webdriverio-framework 4.0.6 → 4.0.8

package/froth_common_actions/Utils.js

@@ -20,6 +20,8 @@ let clickIfVisible = null;
 let doubleClick = null;
 
 let assertText = null;
+
+let random = null;
 let randomtext = null;
 let randomnumber = null;
 let randomfloat = null;
@@ -27,6 +29,8 @@ let randomint = null;
 let randomalphanum = null;
 let randomdecimal = null;
 let randomregex = null;
+let randomdate = null;
+
 let storetext = null;
 let storevalue = null;
 let storeattributevalue = null;
@@ -80,6 +84,8 @@ randomint = require(basepath + '/random').RNDINT;
 randomalphanum = require(basepath + '/random').RNDALPHANUM;
 randomdecimal = require(basepath + '/random').RNDDECIMAL;
 randomregex = require(basepath + '/random').RNDREGEX;
+random= require(basepath + '/random').RANDOM;
+randomdate= require(basepath + '/random').RNDDATE;
 
 storetext = require(basepath + '/storeToBuffer').STORETEXT;
 storevalue = require(basepath + '/storeToBuffer').STOREVALUE;
@@ -108,6 +114,7 @@ module.exports = {
     doubleClick,
     assertText,
     assertAttributeValue,
+    random,
     randomtext,
     randomnumber,
     randomfloat,
@@ -115,6 +122,7 @@ module.exports = {
     randomalphanum,
     randomdecimal,
     randomregex,
+    randomdate,
     storetext,
     storevalue,
     storeattributevalue,

package/froth_common_actions/apicall.js

@@ -135,11 +135,9 @@ async function validateAttributeData(attribute_name, attribute, buffer, bufferna
             valueToVerify = Number(valueToVerify);
         } else if (datatype.toLowerCase() == "boolean") {
             valueToVerify = Boolean(valueToVerify);
-        } else if (datatype.toLowerCase() == "float") {
+        } else if (datatype.toLowerCase() == "decimal") {
             valueToVerify = parseFloat(valueToVerify);
-        } else if (datatype.toLowerCase() == "double") {
-            valueToVerify = parseFloat(valueToVerify);
-        } else if (datatype.toLowerCase() == "string") {
+        }else if (datatype.toLowerCase() == "string") {
             valueToVerify = valueToVerify.toString();
         }
 

package/froth_common_actions/random copy.js

@@ -0,0 +1,72 @@
+const RandExp = require('randexp');
+
+async function RNDNUMBER(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+async function RNDFLOAT() {
+    return Math.random();
+}
+
+async function RNDINT() {
+    return Math.floor(Math.random() * 100000);  // You can choose any large multiplier for bigger ranges
+}
+
+async function RNDNUMBER(length) {
+    if (length <= 0) return null; // Handle invalid length
+
+    const min = Math.pow(10, length - 1); // Minimum value for the given length
+    const max = Math.pow(10, length) - 1; // Maximum value for the given length
+
+    return Math.floor(Math.random() * (max - min + 1)) + min; // Generate the random number
+}
+async function RANDOMTEXT(length) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+
+async function RNDALPHANUM(length) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
+
+async function RNDDECIMAL(min, max, decimalPlaces) {
+    let randomNum = Math.random() * (max - min) + min;  // Generates a number between min and max
+    return parseFloat(randomNum.toFixed(decimalPlaces));
+}
+
+async function RNDDECIMAL(decimalPlaces) {
+    let randomNum = Math.random();  // Generates a number between 0 and 1
+    return parseFloat(randomNum.toFixed(decimalPlaces));
+}
+
+async function RNDREGEX(regex) {
+    return new RandExp(regex).gen();
+}
+
+module.exports = {
+    RNDNUMBER,
+    RNDFLOAT,
+    RNDINT,
+    RANDOMTEXT,
+    RNDALPHANUM,
+    RNDDECIMAL,
+    RNDREGEX
+};  
+
+// console.log(RNDNUMBER(1, 100));
+// console.log(RNDFLOAT());
+// console.log(RNDINT());
+// console.log(RANDOMTEXT(10));
+// console.log(RNDALPHANUM(10));
+// console.log(RNDDECIMAL(100, 10000, 4));
+// console.log(RNDDECIMAL(2));
+// console.log(RNDREGEX(/[a-z]{4}\d{4}/));

package/froth_common_actions/random.js

@@ -1,25 +1,33 @@
 const RandExp = require('randexp');
 
-async function RNDNUMBER(min, max) {
-    return Math.floor(Math.random() * (max - min + 1)) + min;
+// Random number generator that can handle both range and length
+async function RNDNUMBER(minOrLength, max) {
+    if (max !== undefined) {
+        // If max is provided, generate a number within the specified range
+        return Math.floor(Math.random() * (max - minOrLength + 1)) + minOrLength;
+    } else {
+        // Otherwise, generate a random number of the specified length
+        const length = minOrLength || 18; // Default to 18 digits if no length is provided
+        //  if (length <= 0) length = 18; // Default to 18 digits if length is invalid
+
+        const min = Math.pow(10, length - 1); // Minimum value for the given length
+        const max = Math.pow(10, length) - 1; // Maximum value for the given length
+
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
 }
 
+// Random floating-point number between 0 and 1
 async function RNDFLOAT() {
     return Math.random();
 }
 
+// Random integer between 0 and 100000 (large multiplier range)
 async function RNDINT() {
-    return Math.floor(Math.random() * 100000);  // You can choose any large multiplier for bigger ranges
+    return Math.floor(Math.random() * 100000);
 }
 
-async function RNDNUMBER(length) {
-    if (length <= 0) return null; // Handle invalid length
-
-    const min = Math.pow(10, length - 1); // Minimum value for the given length
-    const max = Math.pow(10, length) - 1; // Maximum value for the given length
-
-    return Math.floor(Math.random() * (max - min + 1)) + min; // Generate the random number
-}
+// Random text string of specified length
 async function RANDOMTEXT(length) {
     const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
     let result = '';
@@ -29,6 +37,7 @@ async function RANDOMTEXT(length) {
     return result;
 }
 
+// Random alphanumeric string of specified length
 async function RNDALPHANUM(length) {
     const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
     let result = '';
@@ -38,20 +47,153 @@ async function RNDALPHANUM(length) {
     return result;
 }
 
-async function RNDDECIMAL(min, max, decimalPlaces) {
-    let randomNum = Math.random() * (max - min) + min;  // Generates a number between min and max
-    return parseFloat(randomNum.toFixed(decimalPlaces));
-}
+async function RNDDECIMAL(minOrLength, max, decimalPlaces) {
+    if (max !== undefined) {
+        // If max is provided, generate a decimal number within the specified range
+        let randomNum = Math.random() * (max - minOrLength) + minOrLength;
+        console.log(randomNum);
+        return parseFloat(randomNum.toFixed(decimalPlaces));
+    } else {
+        // Otherwise, generate a random decimal number between 0 and 1, rounded to the specified decimal places
+        let length = minOrLength;
+        const integerLength = length - decimalPlaces - 1; // Subtract 1 for the decimal point
+        let integerPart = 0;
 
-async function RNDDECIMAL(decimalPlaces) {
-    let randomNum = Math.random();  // Generates a number between 0 and 1
-    return parseFloat(randomNum.toFixed(decimalPlaces));
+        if (integerLength > 0) {
+            const minInt = Math.pow(10, integerLength - 1);
+            const maxInt = Math.pow(10, integerLength) - 1;
+
+            // Generate the integer part
+            integerPart = Math.floor(Math.random() * (maxInt - minInt + 1)) + minInt;
+        }
+        // Generate the decimal part
+        const decimalFactor = Math.pow(10, decimalPlaces);
+        const decimalPart = Math.floor(Math.random() * decimalFactor);
+        // Combine integer and decimal parts
+        const result = `${integerPart}.${decimalPart.toString().padStart(decimalPlaces, '0')}`;
+        return result;
+    }
 }
 
+
+// Random string based on regex pattern
 async function RNDREGEX(regex) {
     return new RandExp(regex).gen();
 }
 
+async function RNDDATE(startYear = 1950, endYear = 2005, format = 'YYMMDD') {
+    // Generate a random year between startYear and endYear
+    const start = new Date(`${startYear}-01-01`).getTime();
+    const end = new Date(`${endYear}-12-31`).getTime();
+
+    const randomTimestamp = start + Math.random() * (end - start);
+    const randomDate = new Date(randomTimestamp);
+
+    return FORMATDATE(randomDate, format);
+}
+
+async function FORMATDATE(date, format) {
+    const yy = String(date.getFullYear()).slice(2);
+    const yyyy = String(date.getFullYear());
+    const mm = String(date.getMonth() + 1).padStart(2, '0');
+    const dd = String(date.getDate()).padStart(2, '0');
+
+    switch (format.toUpperCase()) {
+        case 'YYMMDD': return `${yy}${mm}${dd}`;
+        case 'DDMMYY': return `${dd}${mm}${yy}`;
+        case 'YYYYMMDD': return `${yyyy}${mm}${dd}`;
+        case 'DDMMYYYY': return `${dd}${mm}${yyyy}`;
+        case 'MMDDYY': return `${mm}${dd}${yy}`;
+        case 'MMDDYYYY': return `${mm}${dd}${yyyy}`;
+        case 'YYDDMM': return `${yy}${dd}${mm}`;
+        case 'YYYYDDMM': return `${yyyy}${dd}${mm}`;
+        default: return `${yy}${mm}${dd}`; // Fallback to YYMMDD
+    }
+}
+// Main function to process templates and replace placeholders with random values
+async function RANDOM(template, datatype) {
+    const regex = /\{(.*?)\}/g;
+    let matches = [...template.matchAll(regex)];
+
+    // Iterate over all matches and replace them with the resolved values
+    let replacements = await Promise.all(matches.map(async (match) => {
+        const content = match[1]; // Get the content inside { ... }
+
+        const parts = content.split(/[\[\]]/).filter(Boolean); // Split by square brackets
+        const type = parts[0];
+
+        switch (type) {
+            case 'RND':
+                if (parts.length === 1) {
+                    return await RNDNUMBER(); // {RND} - Default to 5-digit number
+                }
+                else if (parts.length === 2) {
+                    return await RNDNUMBER(parseInt(parts[1])); // {RND[length]}
+                } else if (parts.length === 3) {
+                    return await RNDNUMBER(parseInt(parts[1]), parseInt(parts[2])); // {RND[min][max]}
+                } else {
+                    return await RNDNUMBER(); // {RND} - Default to 5-digit number
+                }
+                break;
+
+            case 'RNDDECIMAL':
+                console.log(parts);
+                if (parts.length === 3) {
+                    return await RNDDECIMAL(parseInt(parts[1]), undefined, parseInt(parts[2])); // {RNDDECIMAL[length][decimalPlaces]}
+                } else if (parts.length === 4) {
+                    return await RNDDECIMAL(parseInt(parts[1]), parseInt(parts[2]), parseInt(parts[3])); // {RNDDECIMAL[length][decimalPlaces]}
+                } else {
+                    return await RNDDECIMAL(6, undefined, 2); // {RNDDECIMAL[length][decimalPlaces]}
+                }
+                break;
+
+            case 'RANDOMTEXT':
+                return await RANDOMTEXT(parseInt(parts[1])); // {RANDOMTEXT[length]}
+
+            case 'CTMSTMP':
+                return Date.now(); // Current timestamp
+
+            case 'RANDOMREGEX':
+                const regexString = content.match(/"(.+?)"/)?.[1];
+                return await RNDREGEX(regexString); // Generate random string based on regex
+            case 'RNDDATE':
+                return await RNDDATE(parseInt(parts[1]), parseInt(parts[2])); // Generate random date of birth
+            default:
+                return match[0]; // If no match found, return original template string
+        }
+    }));
+
+    // Replace all matches with their resolved values
+    let result = template;
+    matches.forEach((match, index) => {
+        result = result.replace(match[0], replacements[index]);
+    });
+    datatype = datatype.toLowerCase();
+
+    if (datatype == 'integer') {
+        result = parseInt(result);
+    }
+    else if (datatype == 'decimal') {
+        console.log("insude decimal");
+        result = parseFloat(result);
+    }
+    else if (datatype == 'string') {
+        result = result.toString();
+    }
+
+    return result;
+}
+
+// Example function to test the template replacement
+async function main() {
+
+    let template = "SUBHRASUBUDHI {RNDDATE[1968][1970][yymmdd]} @GMAQIL.COM";
+    let result = await RANDOM(template, 'STRING');
+    console.log(result);
+    console.log(typeof result);
+}
+
+main();
 module.exports = {
     RNDNUMBER,
     RNDFLOAT,
@@ -59,14 +201,7 @@ module.exports = {
     RANDOMTEXT,
     RNDALPHANUM,
     RNDDECIMAL,
-    RNDREGEX
-};  
-
-// console.log(RNDNUMBER(1, 100));
-// console.log(RNDFLOAT());
-// console.log(RNDINT());
-// console.log(RANDOMTEXT(10));
-// console.log(RNDALPHANUM(10));
-// console.log(RNDDECIMAL(100, 10000, 4));
-// console.log(RNDDECIMAL(2));
-// console.log(RNDREGEX(/[a-z]{4}\d{4}/));
+    RNDREGEX,
+    RANDOM,
+    RNDDATE
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "froth-webdriverio-framework",
-  "version": "4.0.6",
+  "version": "4.0.8",
 
   "readme": "WebdriverIO Integration",
   "description": "WebdriverIO and BrowserStack App Automate",