JMS Configuration and JSON Path reference in ReadyAPI

JSON Path reference in ReadyAPI

JSONPath is a JSON query language that allows you to refer to the structure of a JSON object in the same way that XPath expressions can do for XML documents. JSONPath expressions can be used in ReadyAPI to refer to specific objects or elements in requests and responses, which is useful for assertions or property expansions that operate with JSON objects.

JSON supported versions

ReadyAPI 1.4.1 – 2.2 – JayWay JSONPath 2.0.0

ReadyAPI 1.1 – 1.4.0 – JayWay JSONPath 0.9.1

ReadyAPI 2.3 - 3.40.2 – JayWay JSONPath 2.4.0

ReadyAPI 3.41.0 and later – JayWay JSONPath 2.7.0
 

Ways to use JSONPath in ReadyAPI

Testing options	Description
Functional Tests	Use JSON objects as data sources. Transfer properties.
Security tests	Get the properties to use these in security scans.
Virtual services	Get request properties to easily compare them with a baseline by the selected dispatch strategy.
Overall ReadyAPI	Retrieve the data to use in the property expansion. Create various assertions.

JSON path Notation

Two types of JSONpath Notation describe the path to the single element or set of elements in a JSON structure. 

1. Dot Notation: $.store.book[0].title
2. Bracket Notation: $['store']['book'][0]['title']

The prefix $ character represents the array or the root object which is optional and can be removed easily. $.object.element and object.element both are the same expressions.

Expression Syntax

Expression	Description
$	It is the array or the root object.
Object.property['object'].['property']	It selects the property in the object.
[n]	It selects the nth element from an array with the starting index 0.
[n1,n2]	It selects the n1 and n2 array items and returns a list.
..property	It Performs the deep scan for the specified property in all available objects and always returns a list, even if the single property matches.
*	All the elements in an object or array are selected independently of their names or indexes.
[n1:n2] [n1:]	Selects the array items from n1 to n2. The n2 element will not be included in the selection. Remove the n2 from the expression to select the array items from n1 to n2 and then return the list.
[:n]	It selects the first n items from the array and then returns the list.
[-n:]	It selects the last item of the array and then returns the list.
[?(expression)]	It selects all the elements in the object that matches the specified filter and then returns the list.
@	It is used for filtering the expressions.

Filters

We apply the filters to JSON objects and arrays to get the subset of items that match the filter conditions.

To create the filter expression, we need to place the filter after the path and then enclose it in the square brackets. 

For example:

$.ninjasstore.book[?@.price>15)]

@ character is used to represent a current array object and array item to process.

Now to refer to the property located outside of a current object, we will add a $ character to filter:

$.ninjasstore.book[?(@.price>$.expensive)]

We can also create the expression that can match all the items that possess a specific property:

[?(@.isbn)] //it matches all the jsbn property.

Filter syntax 

Operator	Description
==	Equal to operator is used to use the string values in the expression. Expression is enclosed in the single quotes. For example, [?(@.color==’red’)].   Remember that   In ReadyAPI 2.3.0 and later: 1 is not equal to ’1’. But in ReadyAPI previous versions than 2.3.0 1 is counted as ‘1’.
!=	Not equal operator is used to use the string values in expression. Expression is enclosed in single quotes. For example,[?(@.color!=’red’)].
>	Greater than
<	Less than
>=	It denotes greater than or equal to.
<=	It denotes less than or equal to.
=~	We will use [?(@.color=~/dog.*/i)] to find all the items that have the names starting with dog (including dog, and so on). But this is not available in ReadyAPI versions before 1.4.1.
!	It denotes the negative filter. For example, let’s use [?(!@.color)] to match all the items that does not contain the color property. But this is not available in ReadyAPI versions before 1.4.1.
&&	It denotes the logical AND operator.It  allows you to combine the multiple filter expressions, for example: [?(@.type==’ninja-shirt’&& @.amount>5)]
||	It denotes the logical OR operator.It allows you to combine the multiple expressions, for example: [?(@.type==’ninja-shirt’|| @.amount>5)]   But this is not available in ReadyAPI versions before 1.4.1.
in	It matches the items whose property has one of the specified values, for example: [?(@.size in[‘S’,’L’])] But this is not available in ReadyAPI versions before 2.3.0.
nin	It matches the items whose property does not have one of the specified values. But this is not available in ReadyAPI versions before 2.3.0.
subsetof	It matches the items whose property has the value which is the subset of the specified array. For example: [?(@.sizes subsetof [‘S’,’M’,’L’])]
size	It matches the items whose property ( array or string) has the specified size. But this is not available in ReadyAPI versions before 2.3.0.
empty	It matches the items whose property (array or string) is empty. For example: [?(@.sizes empty true)] But this is not available in ReadyAPI versions before 2.3.0.

WildCards

Wildcards are used to pick all elements available in an object or array. JSONpath indicates the wildcards with the * symbol. It can be used in both basic expressions and those with filters. For example:

$.store.*

 

The above expression returns all the properties of the object object.

The above option is disabled by default for ReadyAPI dialog boxes that allow you to use JSONPath expressions, so you should activate it before using wildcard expressions. for example:

Assumptions

🔺JSONPath expressions does not returns a single element, but also contains the list of matching elements. For example,

Example

{
  "company_name": "JMS configuration in readyapi",
  "shops": [
    {
      "address": "delhi",
      "phone": "555-120-1234"
    },
    {
      "address": "Mumbai",
      "phone": "555-130-1234",
    }
  ]
}

 

You can call the JSONPath expression to fetch all the phone numbers, which look like this:

shops[*].phone

 

Note: Make sure wildcards enables to use the expression in ReadyAPI.

You will receive the list that consists of two numbers:

[555-120-1234, 555-130-1234]

The above data is not in the JSON array, but the list of items where the [] characters indicate a list's start and end.

🔺When we use  assertions that compare the property value to the list of values, and specifies the list of expected values that are enclosed in [] and separated by the comma and a single space:

[beverages, 20, true, ["bottles", "can"], {"taste": "banana"}]

 

Do not enclose the separate strings (like beverages) in the quotes, unless the quotes are the part of  value – for example, use "Ninjas" to match "\"Ninjas\"".

🔺Do not use the double quotes for every element names and values. Use only single quotes.

🔺JSONPath expressions may return either an array or a single value, depending on expression syntax:

🔻Expression which contain filters ([?(filter)] and array ([start:end] always returns an array, even if the resultant array contains the single item. For example: $.section.fields.item[?(@.name=='Coding Ninjas')].fldValue
 

The above code will return an array if the fldValue element contains only one value. To get the above value, add the index to expression:

$.section.fields.item[?(@.name==JMS configuration in readyapi)].fldValue[0]

 

🔺If the object has two or more properties, object wildcards will return an array. Otherwise, it will return the single property's value (this value will keep the initial type). Suppose you need to obtain the characteristics of the following object:

Example

{
  "section": {
    "first_subsection": {
      "name": "JMS configuration in readyapi"
    },

    "second_subsection": {
      "name": "JMS configuration in readyapi1",
      "contains_images": true
    }
  }
}

 

The below expression will return a titular string:

$.section.first_subsection.*
// The first_subsection element has the single property

The below expression will return the array:
$.section.second_subsection.*
// Returns ["name": "JMS configuration in readyapi", "contains_images": true"]

 

🔺The array wildcards (arr[*]) executes differently depending on the ReadyAPI version:

🔻In ReadyAPI 2.3.0 and later: Array wildcards always return the array. For the above example, the following expression:

$.section.first_subsection[*]

 

– will return an array:

["name": "JMS configuration in readyapi"]

 

🔻ReadyAPI 1.4.1 - 2.2.0- Array wildcards return an array only if the original array contains more than two entries in ReadyAPI 1.4.1 - 2.2.0. The results for arrays with a single item may vary depending on the type of the item.

For example, for the following objects:

{
  "section": ["content"],
  "second_section": [ {"number": 5} ]
}
the JSONPath expressions will be as follows:
$.section[*] = content // A string
$.second_section[*] = [ {"number": 5} ] // The array

Examples

We will see some of the examples in which we will use the modified version of JSON:

{
  "store": {
    "book": [
      {
        "category": "books",
        "author": "Joseph Toynbee",
        "title": "Data Structures",
        "price": 110
      },
      {
        "category": "languages",
        "author": "Aneirin",
        "title": "C++",
        "price": 170
      },
      {
        "category": "food",
        "author": " Joyce",
        "title": "foody doody",
        "isbn": "9788804677628",
        "price": 159
      },
      }
    ],
    "bicycle": {
      "color": "black",
      "price": 255
    }
  },
  "expensive": 110
}

 

▶️To retrieve all the properties of store object.

$.store.*

 

▶️find the bicycle color.

$.store.bicycle.color

 

▶️find the price of all items.

$.store.. Price
$..price

 

Result: [110,170,159]
 

▶️ find the information of all the books.

$.store.book[*]
$..book[*]

 

▶️ find the title of the books.

$..book[*].title

 

Result: [data structure,C++]

Frequently Asked Questions

Differentiate between SoapUI and ReadyAPI?

SmartBear's SoapUI is an open-source solution for automated web service testing. It can be used to automate functional and security API tests while ReadyAPI is an API ready platform that contains a test module for the next generation of SoapUI.

Explain "JMS as a protocol"?

AMQP is a protocol while JMS is an API. JMS does not require a protocol between the JMS client and the JMS message server. The JMS client implements the JMS API and can communicate with the JMS server through any protocol.

Is ReadyAPI a tool for automation?

ReadyAPI is an API automation testing solution for REST and SOAP APIs. ReadyAPI is used to evaluate web services, and focuses on the efficiency and usability. ReadyAPI also provides extensive web services testing.

Conclusion

In this blog, you learned JMS Configuration and JSON Path reference in ReadyAPI. All the important topics related to JMS Configuration in readyapi and JSON Path reference in ReadyAPI were covered in detail.

Also, do refer to other API testing-related articles:

• What are Test Steps in ReadyAPI?
• Security Tests in ReadyAPI
• Running Tests in ReadyAPI
   

Check out this problem - Root To Leaf Path

Please refer to our guided paths on Coding Ninjas Studio to learn more about DSA, Competitive Programming, JavaScript, System Design, etc. And also, enrol in our courses and refer to the mock test and problems available. Have a look at the interview experiences and interview bundle for placement preparations.

Please upvote our Managing Test Items in ReadyAPI blog if you found it helpful and informative!

Happy learning!