Category: Automation Testing

Most of the testing in API requires authentication and we need to pass it in every request we make.
Similarly there can be any other dynamic authorization/authentication mechanism which needs to be passed along with header or as parameter.
What becomes problem is every time we generate access token from one endpoint (EX: token endpoint) and copy the token and paste in another request as header or body parameter.
There is a simpler way to handle this by transferring the token from one request to another request via a variable.

POSTMAN supports javascript based Test scripts where we can write code snippet to do the above.

Use case:
1- Call token endpoint using some valid credentials
2- Get the token from response and store in a variable
3- Use the token variable in another request

pm.test("Fetch Token and Set", function () {
    var jsonData = pm.response.json();
    pm.globals.set("token_global", jsonData.access_token);
   });

The above code can be added in Test tab of POSTMAN.
It will store the response in a variable.
Then it will extract the value from the key access_token from response and set in the variable token_global
* Please note that you need to create a global variable named token_global.

Notice that the token generated in step 1 is used in step 2.
Highlighted the token to show the token value are same.

Many at times we need to use different content types , headers , parameters while working with different API testing.
Today i have figured out a way how to send a different content type as x-www-form-urlencoded for a POST request.

For one my project we have to generate access token using content type as x-www-form-urlencoded and I found it difficult to send it from rest assured or Karate code. However it was easy to send the same request using POSTMAN.

Finally after a lot of trial and error and search over google I found a solution.

USE CASE:
1- Make a POST request
2- Set contet-type as x-www-form-urlencoded in Body (Hence there will be no body content for this content type, only it will have related form parameters)
3- Set 3 parameters for the above content-type
– grant_type : password
– username: abcd
– password: abcd

Now I have done the above request using KARATE API as below.

Feature: To test Authentication API using x-www-form-urlencoded
Scenario: Generate access token 
	Given url 'https://login-qa.mywebsite.com/api/v1/token'
	And header Content-Type = 'application/x-www-form-urlencoded'
	And form field username = 'user_ppr_test01@yopmail.com'
	And form field password = 'Test@12345'
	And form field grant_type = 'password'
	And request {}
 	When method post
 	Then status 200 

Output:
1 < 200
{"access_token":"5bb73fc5-6e69-43b6-931d-eb80c87a2cc9","token_type":"bearer","expires_in":1799}

While working with extracting data from JSON , we feel the need of expression which helps us to fetch the data from a complex JSON with conditions.

Based on the conditions and logic we provide, it will return the data if the condition matches.

It is indeed very helpful and must have feature in our API testing.
Jayway jsonpath is the best solution this.

Head on to this beautiful website which helps you filter JSON using JsonPath expression:
https://jsonpath.com/?

For more information about the library that we will use here is below:
https://github.com/json-path/JsonPath
Check the instructions on how to implement in your java project.

About the expression:
JSONPath expressions always refer to a JSON structure in the same way as XPath expression are used in combination with an XML document. Since a JSON structure is usually anonymous and doesn’t necessarily have a “root member object” JSONPath assumes the abstract name $ assigned to the outer level object.

JSONPath expressions can use the dot–notation
$.store.book[0].title

or the bracket–notation
$[‘store’][‘book’][0][‘title’]

Sample JSON:
use the website with below JSON
https://jsonpath.com

{ "store": {
    "book": [ 
      { "category": "reference",
        "author": "Nigel Rees",
        "title": "Sayings of the Century",
        "price": 8.95
      },
      { "category": "fiction",
        "author": "Evelyn Waugh",
        "title": "Sword of Honour",
        "price": 12.99
      },
      { "category": "fiction",
        "author": "Herman Melville",
        "title": "Moby Dick",
        "isbn": "0-553-21311-3",
        "price": 8.99
      },
      { "category": "fiction",
        "author": "J. R. R. Tolkien",
        "title": "The Lord of the Rings",
        "isbn": "0-395-19395-8",
        "price": 22.99
      }
    ],
    "bicycle": {
      "color": "red",
      "price": 19.95
    }
  }
}

Below table explains how expression works for above JSON.

For more expressions refer below links.

Credits:
https://goessner.net/articles/JsonPath/index.html#e2

There many locators in selenium.
Based on scenarios we use one of those.

Here are the list of locators:
id, name , css selector, linkText, partialLinkText, Xpath

Sequence as per the choice of faster execution:
1- id
2- name
3- css
4- xpath
5- linkText
6- partialLinkText

Most widely used locators are xpath and css (If id and name is not present)
Between xpath and CSS, css is more faster and more reliable due to below reasons:

1- xpath has different engines for different browsers, where as CSS is same for all browsers
2- CSS is best suited for IE browser than xpath
3- Xpath can traverse backward/froward direction in DOM elements but css can only find forward direction(disadvantage)

• // : Select current node.
• Tagname: Tagname of the particular node.
• @: Select attribute.
• Attribute: Attribute name of the node.
• Value: Value of the attribute.

XPATH examples:
1- //div[@class=’somename’]/table/td
2- //a[text()=’sometext’]
3- //table/tr/td/label[contains(.,’sometext’)]
4- //table/tr/td/label[contains(text,’sometext’)]
5- //*[@type=’submit’ or @name=’btnReset’]
6- //input[@type=’submit’ and @name=’btnLogin’]

<bookshelf>
        <book>
                <title>The Great Adventure</title>
                <author>J.K.Miller</author>
                <pages countingCover="true">360</pages>
                <publisher>B and B</publisher>
        </book>
        <book>
                <title>On the Way</title>
                <author>J.Johnson</author>
                <pages countingCover="true">2135</pages>
        </book>
        <book>
                <title>The Silent Rage</title>
                <author>Thomas B.</author>
                <pages countingCover="false">530</pages>
        </book>
</bookshelf>

• //title/ancestor::book – returns all books within its ancestors
• //book/ancestor-or-self::book
• //book/following::book – following nodes after the context node only
• //title/following-sibling::author – following sibling
• //book/child::title
• //title/preceding::book – before book node
• //title/parent::book – all parent nodes
• //book/descendant::title – all parent,child, grandchild below the node

CSS locators:

^ - Starts with
input[id^='cb-select']

$ -  Ends with
input[id$='319']

# id
input#cb-select-319
or 
input[id='cb-select-319']

.  class
input.class_name

* contains
input[id*='login']