froth-webdriverio-framework 4.0.6 → 4.0.7

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;
@@ -80,6 +82,7 @@ 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;
 
 storetext = require(basepath + '/storeToBuffer').STORETEXT;
 storevalue = require(basepath + '/storeToBuffer').STOREVALUE;
@@ -108,6 +111,7 @@ module.exports = {
     doubleClick,
     assertText,
     assertAttributeValue,
+    random,
     randomtext,
     randomnumber,
     randomfloat,

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,128 @@ 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();
 }
 
+// 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
+
+            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 = "DEMO{RND[5][90]}-{CTMSTMP}-{RND[10]}-SUBHRA{RANDOMTEXT[9]}";
+    // let result = await RANDOM(template);
+    // console.log(result); // Example output: "DEMO12345-1617973448012-987654321-SuKbLfGHi"
+    // template = "{RNDDECIMAL[2][10][3]} - {RNDDECIMAL[4][3]}";
+    // result = await RANDOM(template);
+    // console.log(result);
+    template = "{RNDDECIMAL[4][3]}";
+    result = await RANDOM(template,'decimal');
+    console.log(result);
+    console.log(typeof result);
+}
+
+main();
 module.exports = {
     RNDNUMBER,
     RNDFLOAT,
@@ -59,14 +176,6 @@ 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
+};

package/package.json

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