Author: vibssingh

vibssingh

How to Switch Between Frames in Selenium WebDriver

Last Updated On

HOME

Switching between frames in Selenium can be necessary when dealing with web pages that use iframes. The methods to switch between frames allow you to interact with elements within those frames

In this tutorial, we will learn handling iFrames using Selenium Webdriver. iFrame is a HTML document embedded inside an HTML document. iFrame is defined by an <iframe></iframe> tag in HTML. With this tag, you can identify an iFrame while inspecting the HTML tree as shown below:

Below is the page that contains Frames.

1) Switching by Name or ID

If the frame or iframe has an id or name attribute, we can switch the frames using name or ID. If the name or ID is not unique on the page, then the first one found will be switched to.

//switch To IFrame using name or id
driver.findElement(By.name("iframe1-name"));

//Switch to the frame
driver.switchTo().frame(iframe);

2) Switching by WebElement

We can find the frame using any selector and switch to it.

WebElement frameElement = driver.findElement(By.id("frameId"));
driver.switchTo().frame(frameElement);

3) Switching by Index

Switching between the frames can be done by Index also.

//switch To IFrame using index
driver.switchTo().frame(0);

4) Switching back to the default content:

To leave an iframe or frameset, switch back to the default content like:

//leave frame
driver.switchTo().defaultContent();

Let us explain frame switchching with an example:-

1) Launch new Browser and open https://demoqa.com/frames
2) Switch iFrame using any of locator strategy
3) Switch back to main content
4) Switch iFrame using index
5) Close the window

The program for the above scenario is shown below:

package com.example;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;


public class iFrame_Demo {

    public static void main(String[] args) {

        ChromeOptions options = new ChromeOptions();
        WebDriver driver = new ChromeDriver(options);
        driver.manage().window().maximize();
        driver.get("https://demoqa.com/frames");

        //Switch iFrame using any of locator strategy
        WebElement iframeElement = driver.findElement(By.id("frame1"));
        driver.switchTo().frame(iframeElement);
        String Frame_1 = driver.findElement(By.id("sampleHeading")).getText();
        System.out.println("Switch by locator:" + Frame_1);

        //Switch back to the main window
        driver.switchTo().defaultContent();
        String mainPage = driver.findElement(By.xpath("//*[@id='framesWrapper']/h1")).getText();
        System.out.println("Back to Main page :" + mainPage);

        //Switch iFrame using index
         driver.switchTo().frame(1);
        String Frame_2 = driver.findElement(By.id("sampleHeading")).getText();
        System.out.println("Switch by Index :" + Frame_2);

        //quit the browser
        driver.quit();
    }
}

The output of the above program is

Note:-

1. Make sure to always switch back to the default content after performing actions within a frame. This is particularly important before interacting with elements that are outside of the frame.

    2. If you want to switch between multiple frames, then switch to a frame and them switch back to main window and then switch to another frame.

    Congratulations. We have learnt about window switching in Selenium. I hope you find this tutorial helpful. Happy Learning!!

    vibssingh

    Serenity Testing on Different Browsers

    HOME

    Many organizations aim to execute automation tests across various browsers, such as Chrome, Firefox, Edge, and others, to ensure a consistent user experience. Serenity offers the capability to run tests on different browsers, supporting this need.

    We can set up multiple driver configurations using the environments section, as demonstrated below.

    mvn clean verify -Denvironment=chrome

    The complete framework using Serenity with JUnit5 can be found here – Testing of Web Application using Serenity with JUnit5.

    We need to add serenity.conf in src/test/resources.

    To apply the driver settings, simply set the environment system property to the desired environment, for example:

    environments {
  chrome {
    webdriver {
      driver = chrome
      autodownload = true
      capabilities {
        browserName = "chrome"
        acceptInsecureCerts = true
        "goog:chromeOptions" {
          args = ["test-type", "ignore-certificate-errors", "headless", "--window-size=1000,800"
            "incognito", "disable-infobars", "disable-gpu", "disable-default-apps", "disable-popup-blocking"]
        }
      }
    }
  }
  edge {
    webdriver {
      capabilities {
        browserName = "MicrosoftEdge"
        "ms:edgeOptions" {
          args = ["test-type", "ignore-certificate-errors", "headless",
            "incognito", "disable-infobars", "disable-gpu", "disable-default-apps", "disable-popup-blocking"]
        }
      }
    }
  }
  firefox {
    webdriver {
      capabilities {
        browserName = "firefox"
        pageLoadStrategy = "normal"
        acceptInsecureCerts = true
        unhandledPromptBehavior = "dismiss"
        strictFileInteractability = true

        "moz:firefoxOptions" {
          args = ["-headless"],
          prefs {
            "javascript.options.showInConsole": false
          },
          log {"level": "info"},
        }
      }
    }
  }
}

    Chrome Browser

    To run the tests using the chrome browser, use the below command:

    mvn clean verify -Denvironment="chrome"

    Serenity Report shows that the tests are executed in the Chrome Browser.

    Firefox Browser

    To run the tests using the chrome browser, use the below command:

    mvn clean verify -Denvironment="firefox"

    Serenity Report shows that the tests are executed in the Firefox Browser.

    Edge Browser

    To run the tests using the chrome browser, use the below command:

    mvn clean verify -Denvironment="edge"

    Serenity Report shows that the tests are executed in the Edge Browser.

    We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

    vibssingh

    How to handle token expiration and automatic refreshing of tokens in REST Assured?

    Last Updated On

    HOME

    Handling token expiration and automatically refreshing tokens in REST Assured involves a few steps to ensure your tests can obtain a fresh token when the current one expires. 

    Add the below-mentioned dependencies to the Maven project.

    <dependencies>
 
       <!-- Rest Assured Dependency -->
      <dependency>
         <groupId>io.rest-assured</groupId>
        <artifactId>rest-assured</artifactId>
        <version>5.4.0</version>
        <scope>test</scope>
      </dependency>

      <!-- JSON path Dependency -->
      <dependency>
         <groupId>io.rest-assured</groupId>
         <artifactId>json-path</artifactId>
         <version>5.4.0</version>
         <scope>test</scope>
      </dependency>
 
        <!-- TestNG Dependency-->
      <dependency>
          <groupId>org.testng</groupId>
         <artifactId>testng</artifactId>
         <version>7.8.0</version>
         <scope>test</scope>
       </dependency>
 
</dependencies>

    Implementation Steps

    1. Obtain Initial Access Token:– Implement a method to obtain the initial access token from the authentication server.
    2. Store Token and Expiration Time:- Use a structure to store the access token and its expiration time.
    3. Check Token Validity:– Before making an API request, check if the token is still valid. If it’s expired or about to expire, refresh it.
    4. Refresh the Token:- Implement a method to refresh the token.
    5. Update Token Storage:– Store the new token and update the expiration time after refreshing.

    import io.restassured.RestAssured;
import io.restassured.response.Response;

import java.time.Instant;

public class TokenGeneration {

    private static String accessToken;
    private static Instant tokenExpiryTime;
    Response response;
    int expiresIn;

    // Method to obtain initial token
    public static String getAccessToken() {
        if (accessToken == null || isTokenExpired()) {
            refreshAccessToken();
        }
        return accessToken;
    }

    // Method to check if the token is expired
    private static boolean isTokenExpired() {
        return tokenExpiryTime == null || Instant.now().isAfter(tokenExpiryTime);
    }

    // Method to refresh token
    private static void refreshAccessToken() {
            response = RestAssured.given()
            .contentType("application/x-www-form-urlencoded")
            .formParam("grant_type", "client_credentials")
            .formParam("client_id", "your-client-id")
            .formParam("client_secret", "your-client-secret")
            .post("https://your-auth-server.com/oauth/token");

        accessToken = response.jsonPath().getString("access_token");
        expiresIn = response.jsonPath().getInt("expires_in");
        tokenExpiryTime = Instant.now().plusSeconds(expiresIn);

        System.out.println("Access Token: " + accessToken);
        System.out.println("Token Expiry Time: " + tokenExpiryTime);
    }
}

    Instant.now – The now() method of Instant returns the current time from the system clock. If the current time is “2023-10-01T12:00:00Z”, “Instant.now()“ would represent this moment in time.

    isAfter(tokenExpiryTime) – checks if the current time is after the token’s expiration time.

    tokenExpiryTime == null || Instant.now().isAfter(tokenExpiryTime);

    plusSeconds(expiresIn) –  This method adds a specified number of seconds to the Instant object. If expiresIn is “3600“ seconds (which is equivalent to 1 hour), it adds an hour to the current Instant.

    tokenExpiryTime = Instant.now().plusSeconds(expiresIn);

    Use the Token in REST Assured Requests.

    import static io.restassured.RestAssured.given;
import org.testng.annotations.Test;

public class ApiTest {

        String token = TokenGeneration.getAccessToken();
        Response response;

       @Test
       public getResponse() {
         response = given()
                .auth().oauth2(token)
                .when()
                .get("https://example.com/protected/resource")
                .then()
                .statusCode(200)
                .extract().response();

        System.out.println("Response: " + response.asString());
    }
}

    Best Practices:

    Token Expiry Buffer:– Consider implementing a buffer time before the actual expiry to refresh the token. This prevents the edge cases where the token might expire during an API call.

    private static final long TOKEN_EXPIRY_BUFFER_SECONDS = 60;  // 1 minute buffer
    
private static boolean isTokenExpired() {
        return tokenExpiryTime == null || Instant.now().isAfter(tokenExpiryTime.minusSeconds(TOKEN_EXPIRY_BUFFER_SECONDS));
 }

    Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!! Cheers!!

    vibssingh

    TestNG Multiple Choice Answers

    Last Updated On

    HOME

    Are you familiar with Rest API and want to test your understanding? This post contains 25 useful TestNG multiple-choice questions (quiz) to self-test your knowledge of TestNG .

    You can find the questions for the below-mentioned answers in this post – 25 Useful TestNG Multiple-Choice Questions | Self-Test Your Knowledge

    Answers

    1)  1) A testing framework for java inspired by JUnit

    2) 2) Cédric Beust

    3) 2) After

    4)  2) Next Generation

    5) 4) All of the above

    TestNG offers extensive control over the execution of test cases, including setting dependencies, priorities, and parallel execution.

    Prior to running test case X, run multiple test cases as a pre-request – TestNG allows us to set dependencies between test methods using dependsOnMethods or dependsOnGroups, so you can ensure that certain test cases run before others.

    TestNG provides powerful features such as annotations, test grouping, sequencing, and parameterization, which resolve the limitations found in earlier frameworks like JUnit.

    6) 4) None of the above

    7) 4) All of the above

    8) 2) Independently of

    This means that each test case can be executed on its own without depending on the execution or results of other test cases. However, TestNG also allows us to create dependencies between test cases using the dependsOnMethods or dependsOnGroups attributes if needed.

    9) 1) Java

    10) 4) All of the above

    11) 3) XML

    In TestNG, an XML file (commonly named as testng.xml) is used to define and configure test suites, test groups, and the sequence of test execution.

    12) 2) Testng.xml

    Sample testng.xml

    <!DOCTYPE suite SYSTEM "https://testng.org/testng-1.0.dtd" >
<suite name="SampleSuite">
    <test name="SampleTest">
        <classes>
            <class name="com.example.MyTestClass" />
        </classes>
    </test>
</suite>

    13) 4) All of the above

    14) 3) Both A and B

    15) 4) All of the above

    16) 1) BeforeSuite

    17) 3) Before each and every test method in the class i.e., the method with @BeforeMethod annotation will execute for every test method in the class

    18) 2) Once before the execution of test methods in the class begins

    19) 1) AfterSuite

    @AfterSuite: This method is executed after all the test methods in an entire suite have been completed.

    20)  2) Annotation

    21) 3) BeforeTest

    @BeforeTest: This method is executed before any test methods in the <test> tag in the testng.xml file, which can include multiple classes and folders.

    22) 2) AfterTest

    @AfterTest: This method is executed after all the test methods in the <test> tag in the testng.xml file have been run, which can include multiple classes.

    23) 2) BeforeClass

    @BeforeClass: This method is invoked before the first test method in the current class is executed.

    24) 3) AfterClass

    The annotations have different scopes:

    • @AfterClass: This method is invoked after all the test methods in the current class have been executed.
    • @AfterMethod: Runs after each individual test method.
    • @AfterSuite: Runs once after all the tests in the entire suite have finished.
    • @AfterTest: Runs after all test methods in the <test> tag of the testng.xml file.

    25) 1) BeforeMethod

    Each of these annotations is executed before a test method, but at different levels:

    1. @BeforeMethod: Runs before each individual test method in the current class.
    2. @BeforeTest: Runs before any test methods in the <test> tag in the testng.xml file.
    3. @BeforeClass: Runs before the first test method in the current class.
    4. @BeforeSuite: Runs once before all tests in the entire suite defined in the testng.xml file.
    vibssingh

    25 Useful TestNG Multiple-Choice Questions | Self-Test Your Knowledge

    Last Updated On

    HOME

    Are you familiar with TestNG and want to test your understanding? This post contains 25 useful TestNG multiple-choice questions (quiz) to self-test your knowledge.

    1. What is TestNG?

    Select the best answer

    1. A testing framework for java inspired by JUnit
    2. Programming Language
    3. Database
    4. All of the above

    Answer

    2. Who created TestNG?

    Choose one option

    1. Sun microsystems
    2. Cédric Beust
    3. Bell labs
    4. None

    Answer

    3. A more powerful and easier-to-use framework, TestNG framework came ____ JUnit.

    Choose one option

    1. Before
    2. After
    3. Alongwith
    4. None

    Answer

    4. What is meant by NG in TestNG?

    Choose one option

    1. New Generation
    2. Next Generation
    3. Name Generation
    4. No Generation

    Answer

    5.  What is TRUE about TestNG?

    Choose one option

    1. With TestNG, you are in complete control of what is happening in the test cases and how they are executed.
    2. Prior to running test case X, run multiple test cases as a pre-request.
    3. By utilizing easy annotations, grouping, sequencing, and parametrizing, the TestNG framework eliminates the limitations of the older framework.
    4. All of the above

    Answer

    6.  Unlike Junit, TestNG does not have constraints like ____.

    1. @beforeclass
    2. @afterclass
    3. Both A and B
    4. None of the above

    Answer

    7. ____ are all supported by TestNG.

    1. A suite before/after
    2. A test before/after
    3. A group of tests before/after
    4. All of the above

    Answer

    8. In the TestNG framework, test cases can be defined ____ one another.

    1. Dependently on
    2. Independently of
    3. Interdependently on
    4. Intradependently on

    Answer

    9. TestNG is written in

    Choose one option

    1. Java
    2. Kotlin
    3. Python
    4. None

    Answer

    10. What is/are the feature(s) of TestNG?

    Choose one option

    1. Before and After annotations
    2. Dependent methods
    3. Better reporting
    4. All of the above

    Answer

    11. ____ based files are used to configure TestNG test suites

    Choose one option

    1. HTML
    2. CSS
    3. XML
    4. PHP

    Answer

    12.  The test suites are organized and run using the ____ file.

    Choose one option

    1. Testng.html
    2. Testng.xml
    3. Testng.php
    4. Testng.pl

    Answer

    13. A testng.xml file defines ____, and test groups that are used to create test suites.

    Choose one option

    1. Classes
    2. Methods
    3. Packages
    4. All of the above

    Answer

    14.  ____ files can be used to pass parameters to test methods.

    Choose one option

    1. DataProviders
    2. Testng.xml
    3. Both A and B
    4. None of the above

    Answer

    15. Which of the following is/are the TestNG Annotation(s)?

    Choose one option

    1. @BeforeSuite
    2. @AfterSuite
    3. @BeforeTest
    4. All of the above

    Answer

    16. All test methods in the suite will be executed before the @____ method runs.

    Choose one option

    1. BeforeSuite
    2. BeforeClass
    3. BeforeTest
    4. BeforeMethod

    Answer

    17. A method with ‘@BeforeMethod’ annotation in a class will execute _____

    Choose one option

    1. Before the first test method in the class executes
    2. Only once before the execution of the @Test, annotated methods begins
    3. Before each and every test method in the class i.e., the method with @BeforeMethod annotation will execute for every test method in the class

    Answer

    18. A method with ‘@BeforeTest’ annotation in a class will execute _______

    Choose one option

    1. Before every test method in the class
    2. Once before the execution of test methods in the class begins
    3. After every test method in the class

    Answer

     19. After all test methods in a suite have been executed, the @____ annotation will run.

    1. AfterSuite
    2. AfterTest
    3. AfterClass
    4. AfterMethod

    Answer

    20. A TestNG ____ is a piece of code that comes into play during test execution and controls the flow of the test.

    Choose one option

    1. Groups
    2. Annotation
    3. Code
    4. Tags

    Answer

    21. All test methods in that folder will be executed before the @____ annotated method is executed.

    Choose one option

    1. BeforeClass
    2. BeforeSuite
    3. BeforeTest
    4. BeforeMethod

    Answer

    22. Upon completion of all the test methods of the classes in the folder, the @____ method will be executed.

    Choose one option

    1. AfterSuite
    2. AfterTest
    3. AfterClass
    4. AfterMethod

    Answer

    23.  This method is called before the class’s first method is invoked using the @____ annotation.

    Choose one option

    1. BeforeSuite
    2. BeforeClass
    3. BeforeTest
    4. BeforeMethod

    Answer

    24. After all test methods of the current class have been executed, the @____ method will be invoked.

    Choose one option

    1. AfterMethod
    2. AfterSuite
    3. AfterClass
    4. AfterTest

    Answer

    25. Every test method will be run prior to the @____ annotation.

    Choose all options

    1. BeforeMethod
    2. BeforeTest
    3. BeforeClass
    4. BeforeSuite

    Answer

    vibssingh

    How to test ToolTip in Selenium

    HOME

    In this tutorial, we will discuss the ToolTip and how to automate the ToolTip in Selenium.

    What is ToolTip?

    A ToolTip is a small, informational popup that appears when a user hovers over an element such as a button, image, or link. It provides additional context or information about the element. Tooltips are often implemented using the title attribute in HTML or through JavaScript and CSS for custom tooltips.

    Tool Tips are implemented in different ways–

    • The basic implementation is based on HTML’s “title” attribute. getAttribute(title) gets the value of the tooltip.
    • Another tool tip implementation is using Action Class.

    This tutorial explains the steps to automate the Custome ToolTip where no title attribute is present.

    Let’s understand how one can automate the process of verifying tooltip in Selenium.

    To test tooltips in Selenium, you generally follow these steps:

    1. Locate the Element with Tooltip: Identify the element that contains the tooltip.
    2. Hover Over the Element: Use Actions class to simulate mouse hover event.
    3. Capture the Tooltip Text: Retrieve the text from the tooltip element.
    4. Validate the Text: Assert that the tooltip text matches the expected value.

    Implementation Steps

    Locate the Tooltip Element

    Identify the element that contains the tooltip. Here, the element has been found using By.id().

     WebElement elementWithTooltip = driver.findElement(By.id("toolTipButton"));

    Hover Over the Element

    Identify the element that contains the tooltip using Actions class to hover over the element.

    Actions actions = new Actions(driver);
actions.moveToElement(elementWithTooltip).perform();

    Retrieve Tooltip Text

    Capturing the tooltip text typically found in the title attribute. But in this case, there is no title in page source, so I have created an xpath using contains(text()) to find the tooltip text.

    WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
WebElement tooltip = wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//*[contains(text(),'You hovered over the Button')]")));

    Validate the Text

    Comparing the captured text with the expected tooltip text.

      if (expectedTooltipText.equals(actualTooltipText)) {
            System.out.println("Tooltip text is correct!");
        } else {
            System.out.println("Tooltip text is incorrect!");
 }

    The complete program is shown below:

    package com.example;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import org.openqa.selenium.interactions.Actions;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;

public class TooltipTest_Demo {

    static WebDriver driver;
    static String expectedTooltipText = "You hovered over the Button";
    static String actualTooltipText;

    public static void main(String[] args) {

        ChromeOptions options = new ChromeOptions();
        driver = new ChromeDriver(options);
        driver.manage().window().maximize();

        driver.get("https://demoqa.com/tool-tips");

        // Locate the element with the tooltip
        WebElement elementWithTooltip = driver.findElement(By.id("toolTipButton"));

        // Perform hover action using Actions class
        Actions actions = new Actions(driver);
        actions.moveToElement(elementWithTooltip).perform();

        // Wait for the tooltip to be visible
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
        WebElement tooltip = wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//*[contains(text(),'You hovered over the Button')]")));

        // Check the tooltip text
        actualTooltipText = tooltip.getText();
        System.out.println("Actual Tooltip Text: " + actualTooltipText);

        if (expectedTooltipText.equals(actualTooltipText)) {
            System.out.println("Tooltip text is correct!");
        } else {
            System.out.println("Tooltip text is incorrect!");
        }

        driver.quit();
    }

}

    The output of the above program is

    We are using WebDriverWait to wait for the hover text to appear.

    Summary

    1. Custom ToolTip can be automated using Action class.
    2. moveToElement(element) of Actions class is used to mouse hover an element.
    3. Build() method of Actions class builds the sequence of user actions into an Action object.
    4. Perform() of Action class executes all the sequence of user actions at once.
    vibssingh

    How to compare JSON File with JSON Response

    HOME

    In the below tutorial, we will compare the JSON File structure and data with the JSON Response.

    To compare a JSON file with a JSON response using Rest Assured in Java, follow these steps:

    1. Read JSON from a file
    2. Make a REST API call

    3. Read JSON Content
    4. Compare the JSON content

    Add the below dependencies:-

    <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.13.2</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>io.rest-assured</groupId>
      <artifactId>rest-assured</artifactId>
      <version>5.4.0</version>
      <scope>test</scope>
    </dependency>

    <dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.11.3</version>
    </dependency>
</dependencies>

    JSON File

    The file is placed in “src/test/resources/expectedUser.json”.

    Sample JSON File is shown below:

    Let us create a program to compare the JSON File with JSON response.

    package com.example;

import io.restassured.RestAssured;
import io.restassured.response.Response;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Assert;
import org.junit.Test;

import java.io.File;
import java.io.IOException;

public class JsonFileComparison {

    @Test
    public void compareResponse() throws IOException {

        // Path to the JSON file
        File jsonFile = new File("src/test/resources/expectedUser.json");

        // Read JSON content from file
        ObjectMapper objectMapper = new ObjectMapper();
        JsonNode jsonFromFile = objectMapper.readTree(jsonFile);

        // Make an API call
        Response response = RestAssured.given().when().get("https://reqres.in/api/users/3").then().extract().response();
        String expectedResponse = response.getBody().asString();
        System.out.println("Response is : " + expectedResponse);

        // Verify the status code
        response.then().statusCode(200);

        // Read JSON content from response
        JsonNode jsonFromResponse = objectMapper.readTree(expectedResponse);

        Assert.assertEquals(jsonFromFile, jsonFromResponse);

        // Compare JSON content
        if (jsonFromFile.equals(jsonFromResponse)) {
            System.out.println("JSON from file matches JSON from response");
        } else {
            System.out.println("JSON content does not match");
        }
    }
}

    The output of the above program is

    The ObjectMapper class from the Jackson library is used to parse the JSON content, and the `equals` method is used to compare the two JsonNode objects.


    Read JSON from a file:

    Using the Jackson library’s ObjectMapper, read the JSON file’s content into a JsonNode object. This object represents the JSON structure.

    ObjectMapper objectMapper = new ObjectMapper();
JsonNode jsonFromFile = objectMapper.readTree(jsonFile);

     Making a REST API Call

    Use Rest Assured to make a GET request to the specified API endpoint. Capture the response in a Response object.

    Response response = RestAssured.given().when().get("https://reqres.in/api/users/3").then().extract().response();
String expectedResponse = response.getBody().asString();
System.out.println("Response is : " + expectedResponse);

// Verify the status code
response.then().statusCode(200);

    Reading JSON Content 

    Convert the JSON content from the response into another JsonNode object using the ObjectMapper.

    JsonNode jsonFromResponse = objectMapper.readTree(expectedResponse);

    Compare the JSON content

    Convert the JSON content from the response into another JsonNode object using the ObjectMapper.

     Assert.assertEquals(jsonFromFile, jsonFromResponse);

    JSON Response data mismatches

    In the below example, the data of the response does not matches.

    The output of the above program is

    JSON Response structure mismatches

    The response returns email whereas JSON File has email_address as shown in the below image:

    The output of the above program is

    We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

    vibssingh

    Fluent Wait in Serenity

    HOME

    In the previous tutorials, I explained the Implicit Wait in Serenity and Explicit Wait in Serenity. This tutorial will explain the Fluent Wait in Serenity.

    What is Fluent Wait?

    Fluent waits provide more flexibility, allowing us to specify polling intervals and ignore specific exceptions during the wait time.  Fluent Wait not only lets you specify the maximum amount of time to wait for a condition but also allows you to define the frequency with which the condition is checked and to ignore specific exceptions during the wait time.

    Key Features of Fluent Wait:

    1. Timeout: The maximum amount of time to wait for the condition.
    2. Polling Frequency: How often the condition should be checked.
    3. Ignoring Exceptions: The ability to ignore specific types of exceptions while waiting.

    Below is an example that shows that loading of element take sometime. So to wait for the element, we can use the Fluent Wait.

    Step 1

    Step 2

    Step 3

    Below is the example of Fluent wait.

    import net.serenitybdd.annotations.DefaultUrl;
import net.serenitybdd.annotations.Managed;
import net.serenitybdd.core.annotations.findby.FindBy;
import net.serenitybdd.core.pages.PageObject;
import net.serenitybdd.core.pages.WebElementFacade;
import net.serenitybdd.junit.runners.SerenityRunner;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.openqa.selenium.ElementNotInteractableException;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.ui.FluentWait;

import java.time.Duration;
import java.util.function.Function;

@RunWith(SerenityRunner.class)
@DefaultUrl("http://the-internet.herokuapp.com/dynamic_loading/1")
public class FluentWait_Demo extends PageObject {

    @Managed
    WebDriver driver;

    @FindBy(xpath = "//*[@id='start']/button")
    WebElementFacade startButton;


    @FindBy(xpath = "//*[@id='finish']/h4")
    WebElementFacade pageText;

    @Test
    public void fluentWaitDemo() throws InterruptedException {

        open();
        startButton.click();
        waitForElementWithFluentWait(pageText);

    }

    public void waitForElementWithFluentWait(WebElement pageText) {
        FluentWait wait = new FluentWait<>(getDriver())
                .withTimeout(Duration.ofSeconds(10))
                .pollingEvery(Duration.ofSeconds(2))
                .ignoring(ElementNotInteractableException.class);

        wait.until((Function<WebDriver, Boolean>)
                driver -> pageText.isDisplayed());

        System.out.println("Text :" + pageText.getText());
        System.out.println("Fluent Time defined for the test (in seconds) :" + getWaitForTimeout().toSeconds());
    }
}

    Explanation:

    1. withTimeout(Duration.ofSeconds(10)): Specifies the maximum time to wait for the condition to be met, which is 30 seconds in this case.
    2. pollingEvery(Duration.ofSeconds(2)): Specifies the interval at which the check should be performed, here it is every 5 seconds.
    3. ignoring(ElementNotInteractableException.class): Instructs the wait to ignore ElementNotInteractableException that might occur during the polling period.

    The output of the above program is

    Fluent Wait supports various conditions similar to explicit waits, such as:

    1. visibilityOfElementLocated
    2. presenceOfElementLocated
    3. elementToBeClickable
    4. textToBePresentInElementLocated
    5. alertIsPresent
    6. elementToBeSelected
    7. frameToBeAvailableAndSwitchToIt
    8. Custom conditions

    We can use Lambda expression to simplify the condition:

    public void waitForElementWithFluentWait(WebElement pageText) {
        FluentWait wait = new FluentWait<>(getDriver())
                .withTimeout(Duration.ofSeconds(10))
                .pollingEvery(Duration.ofSeconds(2))
                .ignoring(ElementNotInteractableException.class);

       wait.until(driver -> pageText.isDisplayed());

        System.out.println("Text :" + pageText.getText());
        System.out.println("Fluent Time defined for the test (in seconds) :" + getWaitForTimeout().toSeconds());
    }

    We are done! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

    vibssingh

    Appending Data to Excel with Python using openpyxl

    HOME

    We are given an Excel file and our task is to append the data into this excel file using Python. In this article, we’ll explore openpyxl library to append data to an Excel file using Python.

    Prerequisite:

    Python is installed
    PIP is installed
    PyCharms is installed

    Sample Excel

    Step 1 – Install openpyxl

    Openpyxl can be installed using pip

    pip install openpyxl

    Step 2 – Load the workbook

    workbook = load_workbook("C:\\Users\\Vibha\\Automation\\SearchInBing.xlsx")

    Step 3 – Select the active worksheet

    sheet = workbook.active

    Step 4 – Create new data to be appended to the Excel in the list of lists.

    new_data =[
    ["Scrum Master", "5-10 Years", "35K"],
    ["Consultatnt", "8-12 Years", "37K"]
]

    Step 5 – Find the next available row in the sheet.

    last_row = sheet.max_row + 1

    Step 6 – Append the data to the excel by using the nested loops.

    for i, row in enumerate(new_data, start=last_row):
    for j, value in enumerate(row, start=1):
        sheet.cell(row=i, column=j, value=value)

    Step 7 – Save the changes made to the workbook

    workbook.save("C:\\Users\\Vibha\\Automation\\SearchInBing.xlsx")

    The complete program is

    from openpyxl.reader.excel import load_workbook
from openpyxl.styles import Font


#Load the workbook
workbook = load_workbook("C:\\Users\\ykv12\\Documents\\Vibha\\Automation\\SearchInBing.xlsx")

sheet = workbook.active

#Sample data
new_data =[
    ["Scrum Master", "5-10 Years", "35K"],
    ["Consultatnt", "8-12 Years", "37K"]
]

#Append the new data to the sheet
last_row = sheet.max_row + 1
for i, row in enumerate(new_data, start=last_row):
    for j, value in enumerate(row, start=1):
        sheet.cell(row=i, column=j, value=value)

#Save the workbook
workbook.save("C:\\Users\\ykv12\\Documents\\Vibha\\Automation\\SearchInBing.xlsx")

print("Data is appended in the Excel file successfully")

    The output of the above program is

    Updated Excel

    That’s it! Congratulations on making it through this tutorial and hope you found it useful! Happy Learning!!

    vibssingh

    What is CucumberOptions in Cucumber?

    HOME

    In Cucumber, “@CucumberOptions“ is an annotation used to specify various options for running Cucumber tests. It allows you to configure different aspects of how your Cucumber tests are executed. This annotation is typically placed above the test runner class, which is responsible for triggering the execution of Cucumber tests.

    1.Command-line arguments have the highest precedence. If you specify options through the CLI, they will override any settings provided by “@CucumberOptions“ or properties files. For example, running the tests with specific options from the terminal.

    mvn clean test -Dcucumber.options="--tags @smoke --plugin pretty"

    2. The “@CucumberOptions” annotation comes next in the precedence order. Settings configured here will override those provided in properties files but will be overridden by CLI arguments. For example, specifying configurations directly in the test runner class.

    import org.junit.runner.RunWith;
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;

@RunWith(Cucumber.class)
@CucumberOptions(
         features = "src/test/resources/features",
         glue = "com.mycompany.stepdefinitions",
         plugin = {"pretty", "html:target/cucumber-reports.html", "json:target/cucumber.json"},
         tags = "@smoke",
         monochrome = true,
         dryRun = false
     )

public class RunCucumberTests {
}

    3. Configuration settings in properties files have the lowest precedence. These settings will be used if neither CLI arguments nor “@CucumberOptions“ provide a value for a particular option. For example, Creating a “cucumber.properties“ file to specify default configurations.

    cucumber.features=src/test/resources/features
cucumber.glue=com.mycompany.stepdefinitions
cucumber.plugin=pretty, html:target/cucumber-reports.html, json:target/cucumber.json
cucumber.tags=@smoke

    Configuration Options in CucumberOptions

    Below is an example of CucumberOptions

    import org.junit.runner.RunWith;
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;

@RunWith(Cucumber.class)
@CucumberOptions( features = "src/test/resources/features",
    glue = "com.mycompany.stepdefinitions",
    plugin = {"pretty", "html:target/cucumber-reports.html", "json:target/cucumber.json"},
    tags = "@smoke",
    monochrome = true,
    dryRun = false,
    strict = true,
    name = "Login functionality"  )

public class RunCucumberTest {
}

    In this example:

    1. The “features” attribute points to the location of the feature files.
    2. The “glue” attribute points to the package where the step definitions are located.
    3. The “plugin” attribute specifies three plugins: one for pretty output in the console, one for an HTML report, and one for a JSON report.
    4. The “tags” attribute specifies that only scenarios tagged with @smoke will be run.
    5. The “monochrome” attribute is set to true to make the console output more readable.
    6. The “dryRun” attribute is set to false to indicate that the tests should actually be executed.
    7. The “strict” attribute treats undefined and pending steps as errors, ensuring all steps are fully implemented.
    8. The “name” attribute allows running scenarios that match a specific name or pattern using regular expressions.