Forum Discussion

User999's avatar
User999
Contributor
3 years ago

Random String Generator for REST Request

Hi All,

 

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.  So it would just REPLACE "string" any time it is mentioned/displayed with random data...

 

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"

  • nmrao's avatar
    nmrao
    Champion Level 3

    It isn't so simple to achieve that.

     

    Here is one library that can help to achieve the same.

    https://github.com/HannnnXiao/javafaker

     

    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.

     

    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's avatar
    richie
    Community Hero
    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 teststep

    Cheers,

    Rich
    • User999's avatar
      User999
      Contributor

      Thanks.

       

      The fields posted successfully with "string" so could you please provide an example of replacing "string" for all with random data containing 6 letters.  I know how to replace a Name/Address etc but that would be DataGen...  I don't want to have to reference the properties from DataGen.

       

      For my example I would just need this..

      "newBusinessRatingReferenceId": "arfyui",
      "offerOriginChannelEntCd": "wordte",
      "offerOriginSubChannelEntCd": "tyuugi",
      "originalOfferOriginChannelEntCd": "jjiiop",
      "originalOfferOriginSubChannelEntCd": "lopuil",
      "ratingReferenceId": "string",

      • richie's avatar
        richie
        Community Hero

        Hey @Rememo 

         

        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 ChrisAdams or nmrao dont see it!  🙂

         

        I was hoping I could bodge an inline scripting property expansion, but alas - my groovy is rubbish hence my solution.

         

        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:

         

        TestSuite

        ---TestCase

        -----GroovyScript

        -----Properties

        -----REST (sources the 6 digit values)

         

         

        Your Properties step will need a 6 properties created called 'randomString1', 'randomString2','randomString3', 'randomString4', 'randomString5', & 'randomString6',

         

        Your Groovy step will need the following code:

         

         

         

        //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!

         

         

         

        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

         

         

        "Attribute1": "${Properties#randomString1}",

        "Attribute2": "${Properties#randomString2}",

        "Attribute3": "${Properties#randomString3}",

        "Attribute4": "${Properties#randomString4}",

        "Attribute5": "${Properties#randomString5}",

        "Attribute6": "${Properties#randomString6}",

         

        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. 

         

        So - as you can see - there's nothing elegant in the code, not iterating the same code or anything.   The groovy bods will probably be able to do the above in 4 lines of code - but that's them!

         

        if you dont like the above solution (and I can understand if you dont! :)) - perhaps ChrisAdams will sort you out!

         

        Cheers,

         

        Rich