Random String Generator for REST Request

Question

Hi All,&nbsp;I was wondering if anyone could help with being able to create random data for a POST request that contains about 1000 lines of json.&nbsp; So it would just REPLACE "string" any time it is mentioned/displayed with random data...&nbsp;Part of Example below:"newBusinessRatingReferenceId": "string","offerOriginChannelEntCd": "string","offerOriginSubChannelEntCd": "string","originalOfferOriginChannelEntCd": "string","originalOfferOriginSubChannelEntCd": "string","ratingReferenceId": "string","schemaVersionNbr": "string","sourceSystemEntCd": "string","transactionEffDtTimeStr": "string","transactionProcessedDtTimeStr": "string","transactionSubEntCd": "string","transactionTypeEntCd": "string","transactionUserId": "string"

richie · Answer

Hey&nbsp;@Rememo&nbsp;
&nbsp;
Ok - I've worked out a way to do it - but it's not very elegant - I mean like - it's really awful coding - it does the job - but I hope&nbsp;ChrisAdams&nbsp;or&nbsp;nmrao&nbsp;dont see it!&nbsp; 🙂
&nbsp;
I was hoping I could bodge an inline scripting property expansion, but alas - my groovy is rubbish hence my solution.
&nbsp;
Ok - you're test case object hierarchy will need to be as follows (you have name value pairs in your example so I'm taking a guess on this is JSON/REST:
&nbsp;
TestSuite
---TestCase
-----GroovyScript
-----Properties
-----REST (sources the 6 digit values)
&nbsp;
&nbsp;
Your Properties step will need a 6 properties created called 'randomString1',&nbsp;'randomString2','randomString3',&nbsp;'randomString4',&nbsp;'randomString5', &amp;&nbsp;'randomString6',
&nbsp;
Your Groovy step will need the following code:
&nbsp;
&nbsp;
&nbsp;
//THIS IS REALLY HORRIBLE CODE - BUT WHAT DO YOU EXPECT?  MY GROOVY'S RUBBISH!
import org.apache.commons.lang.RandomStringUtils

//generate a 6 digit random string and assign to the randomString1 variable
String randomString1 = RandomStringUtils.random(6, true, true)

//define the properties step and write the randomString1 value to the Properties step
def propertiesStep1 = context.testCase.testSteps["Properties"] 
propertiesStep1.setPropertyValue("randomString1", randomString1)

//generate a 6 digit random string and assign to the randomString2 variable
String randomString2 = RandomStringUtils.random(6, true, true)

//define the properties step and write the randomString2 value to the Properties step
def propertiesStep2 = context.testCase.testSteps["Properties"] 
propertiesStep2.setPropertyValue("randomString2", randomString2)

//generate a 6 digit random string and assign to the randomString3 variable
String randomString3 = RandomStringUtils.random(6, true, true)

//define the properties step and write the randomString3 value to the Properties step
def propertiesStep3 = context.testCase.testSteps["Properties"] 
propertiesStep3.setPropertyValue("randomString3", randomString3)

//generate a 6 digit random string and assign to the randomString4 variable
String randomString4 = RandomStringUtils.random(6, true, true)

//define the properties step and write the randomString4 value to the Properties step
def propertiesStep4 = context.testCase.testSteps["Properties"] 
propertiesStep4.setPropertyValue("randomString4", randomString4)

//generate a 6 digit random string and assign to the randomString5 variable
String randomString5 = RandomStringUtils.random(6, true, true)

//define the properties step and write the randomString5 value to the Properties step
def propertiesStep5 = context.testCase.testSteps["Properties"] 
propertiesStep5.setPropertyValue("randomString5", randomString5)

//generate a 6 digit random string and assign to the randomString6 variable
String randomString6 = RandomStringUtils.random(6, true, true)

//define the properties step and write the randomString6 value to the Properties step
def propertiesStep6 = context.testCase.testSteps["Properties"] 
propertiesStep6.setPropertyValue("randomString6", randomString6)

//normally I give credit in any code I produce to whoever I ripped it off from - however - this is all my own, so I have to take the blame myself this time!
&nbsp;
&nbsp;
&nbsp;
So each one of I think 6 name value pairs in your JSON PAYLOAD should source the values from the Properties step - so in your payload you should look something like this
&nbsp;
&nbsp;
"Attribute1": "${Properties#randomString1}",
"Attribute2": "${Properties#randomString2}",
"Attribute3": "${Properties#randomString3}",
"Attribute4": "${Properties#randomString4}",
"Attribute5": "${Properties#randomString5}",
"Attribute6": "${Properties#randomString6}",
&nbsp;
So when you now execute the test - your 6 attributes in your payload will be populated by those 6 random string values sourced from the Properties step.&nbsp;
&nbsp;
So - as you can see - there's nothing elegant in the code, not iterating the same code or anything.&nbsp; &nbsp;The groovy bods will probably be able to do the above in 4 lines of code - but that's them!
&nbsp;
if you dont like the above solution (and I can understand if you dont! :)) - perhaps&nbsp;ChrisAdams&nbsp;will sort you out!
&nbsp;
Cheers,
&nbsp;
Rich
&nbsp;
&nbsp;

tneuschwanger · Answer

Hello User999&nbsp;
&nbsp;
Here is an attempt at your solution.&nbsp; Drop this into a groovy test step to exercise it and add a "Properties" test step to catch the resultant new json. Hack it up as desired.&nbsp; There might be portions that are helpful to your final resolution...
&nbsp;
import groovy.json.JsonSlurper;
import groovy.json.JsonOutput;

log.info 'Test Step "' + testRunner.runContext.currentStep.name + '" start...';
log.info "";

// embellished some sample json I had laying around...
def String jsonStr = """
[
  {
    "createDate": "2004-01-01T00:00:00",
    "endDate": null,
    "lastUpdateDate": null,
    "lastUpdateUser": null,
    "instanceCode": "CLAIM",
    "roleCode": "ALL",
    "roleName": "All",
    "newBusinessRatingReferenceId": "string",
    "offerOriginChannelEntCd": "string",
    "offerOriginSubChannelEntCd": "string",
    "originalOfferOriginChannelEntCd": "string",
    "originalOfferOriginSubChannelEntCd": "string",
    "ratingReferenceId": "string",
    "schemaVersionNbr": "string",
    "sourceSystemEntCd": "string",
    "transactionEffDtTimeStr": "string",
    "transactionProcessedDtTimeStr": "string",
    "transactionSubEntCd": "string",
    "roleType": "DEVELOPER"
  },
  {
    "createDate": "2004-01-01T00:00:00",
    "endDate": "2021-01-12T00:00:00",
    "lastUpdateDate": null,
    "lastUpdateUser": null,
    "instanceCode": "CLAIM",
    "roleCode": "BACK_OFFICE",
    "roleName": "Back Office",
    "newBusinessRatingReferenceId": "string",
    "offerOriginChannelEntCd": "string",
    "offerOriginSubChannelEntCd": "string",
    "originalOfferOriginChannelEntCd": "string",
    "originalOfferOriginSubChannelEntCd": "string",
    "ratingReferenceId": "string",
    "schemaVersionNbr": "string",
    "sourceSystemEntCd": "string",
    "transactionEffDtTimeStr": "string",
    "transactionProcessedDtTimeStr": "string",
    "transactionSubEntCd": "string",
    "roleType": "WEB"
  }
]
""";

def jsonSlurper = new JsonSlurper();
def jsonObj = jsonSlurper.parseText(jsonStr);  
log.info "jsonObj=$jsonObj";

// I don't know the extent of the depth of your actual JSON, so the sample I used contains two groups... You might have to 
// eliminate a depth on your actual (or add more).
jsonObj.each { depth -&gt;
   depth.each { element -&gt;
      log.info "elementBefore=${element.value}";
      if (element.value == 'string') {
         randomString = org.apache.commons.lang.RandomStringUtils.random(6, true, true);
         element.value = randomString;      	
      };
      log.info "   elementAfter=${element.value}";
   };
};

jsonNewStr = JsonOutput.toJson(jsonObj);
log.info "jsonNewStr=$jsonNewStr";
// make sure to have a "Properties" test step to have a landing area for the resultant new json content.
testRunner.testCase.testSteps['Properties'].setPropertyValue('jsonNewStr', jsonNewStr);

// The resultant json will be something like...
//[
//  {
//    "createDate": "2004-01-01T00:00:00",
//    "endDate": null,
//    "instanceCode": "CLAIM",
//    "lastUpdateDate": null,
//    "lastUpdateUser": null,
//    "newBusinessRatingReferenceId": "M7MzVq",
//    "offerOriginChannelEntCd": "oLU3Qe",
//    "offerOriginSubChannelEntCd": "QWV5O8",
//    "originalOfferOriginChannelEntCd": "7ydvd3",
//    "originalOfferOriginSubChannelEntCd": "OlHycp",
//    "ratingReferenceId": "DgEiM5",
//    "roleCode": "ALL",
//    "roleName": "All",
//    "roleType": "DEVELOPER",
//    "schemaVersionNbr": "R8w1WO",
//    "sourceSystemEntCd": "KuPtvJ",
//    "transactionEffDtTimeStr": "ujlqUr",
//    "transactionProcessedDtTimeStr": "UdD7se",
//    "transactionSubEntCd": "Sn8lRS"
//  },
//  {
//    "createDate": "2004-01-01T00:00:00",
//    "endDate": "2021-01-12T00:00:00",
//    "instanceCode": "CLAIM",
//    "lastUpdateDate": null,
//    "lastUpdateUser": null,
//    "newBusinessRatingReferenceId": "6LUM3g",
//    "offerOriginChannelEntCd": "71CyqS",
//    "offerOriginSubChannelEntCd": "WVDGbU",
//    "originalOfferOriginChannelEntCd": "zqOwZD",
//    "originalOfferOriginSubChannelEntCd": "fiUk22",
//    "ratingReferenceId": "ow6Sjg",
//    "roleCode": "BACK_OFFICE",
//    "roleName": "Back Office",
//    "roleType": "WEB",
//    "schemaVersionNbr": "vGwmld",
//    "sourceSystemEntCd": "nvdMQx",
//    "transactionEffDtTimeStr": "3vQ6L6",
//    "transactionProcessedDtTimeStr": "PrxZsV",
//    "transactionSubEntCd": "84dzvX"
//  }
//]

log.info "";
log.info 'Test Step "' + testRunner.runContext.currentStep.name + '" done...';
&nbsp;
Regards,
Todd

richie · Answer

Oh...so literally the fields have "string" in them and you want to replace them all?You've already identified the groovy method to do this....replaceall() why dont you just use that and drop the random requirement....adding random values arent really gonna add all that much to the level of rigour in your tests anyway...CheersRich

nmrao · Answer

It isn't so simple to achieve that.
&nbsp;
Here is one library that can help to achieve the same.
https://github.com/HannnnXiao/javafaker
&nbsp;
Apart from that, the trick is to create the custom classes based on the REST API specification and collect the each field data type and length restrictions from it instead of hard coded values. This way, even if there are changes in the API specification, one can quickly redo it.
&nbsp;
It may take a while to fully create the library and plug it with Events so that when a new request step is created, data is automatically populated for the request. One need to see if this is really needed compared to time required to the above development.

richie · Answer

Hey User999,Theres a number of ways to do this.However, to answer your question people will need to know the field length of each attribute you want to populate with any old string.  Theres no point generating a random string with 10 digits in it, if the field only supports 8.Once we have field lengths we can then look at how to do it, although probably easiest will be inline scripting....or maybe the datagen option in the DataSource teststepCheers,Rich

Forum Discussion

Random String Generator for REST Request

Recent Discussions

Update API definition : Error with the json format

Test result Pass when data source times out

Run Test Case properties not populating for Data Source based items

Related Content

Generate a random number within a range

How to generate a random Number, String, AlphaNumeric string

[TechCorner Challenge #9] Generate a random number within a range