Java

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

    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

    How to Write Data to Excel File in Java using Apache POI

    HOME

    This tutorial describes the steps to write data in Excel file in Java.

    I’m using Apache POI to write data to the excel file. To download and install Apache POI, refer here.

    In the previous tutorial, I have explained How to read data from Excel in Java.

    Dependency:

    If you are using maven, then you need to add below dependency in pom.xml.

    <dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>5.3.0</version>
</dependency>
 
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>5.3.0</version>
</dependency>

    Here are few classes which you need to aware of.

    • Workbook : This is high level class for representing excel workbook.
    • Sheet : This is high level class for representing excel sheet.
    • Row : This is high level class for representing excel row. It has methods which are related to row.
    • Cell: This is high level class for representing individual excel cell. It has methods which are related to cell for example : getDataType().

    The basic steps for writing data into an excel file using Apache POI API are given below:

    Implementation Steps

    Step 1 – Create a blank workbook.

    XSSFWorkbook wb = new XSSFWorkbook();

    Step 2 – Import XSSFWorkbook from package.

    import org.apache.poi.xssf.usermodel.XSSFWorkbook;

    Step 3 – Create a sheet and pass name of the sheet.

    XSSFSheet sheet = workbook.createSheet("Write_TestData");

    Step 4 – Import XSSFSheet from package.

    import org.apache.poi.xssf.usermodel.XSSFSheet;

    Step 5 – Prepare Data to Write

    An ArrayList of Object[] arrays is created to hold the data. Each array represents a row in the sheet.

    ArrayList<Object[]> data = new ArrayList<Object[]>();
		data.add(new String[] { "Name", "Id", "Salary" });
		data.add(new Object[] { "Jim", "001A", 10000 });
		data.add(new Object[] { "Jack", "1001B", 40000 });
		data.add(new Object[] { "Tim", "2001C", 20000 });
		data.add(new Object[] { "Gina", "1004S", 30000 });

    Step 6 – Create a Row. A spreadsheet consists of rows and cells. It has a grid layout.

     XSSFRow row = sheet.createRow(rownum++);

    Step 7 – Import XSSFRow from package

    import org.apache.poi.xssf.usermodel.XSSFRow;

    Step 8 – Create cells in a row. A row is a collection of cells. When you enter data in the sheet, it is always stored in the cell.

     XSSFCell cell = row.createCell(cellnum++);

    Step 9 – Import XSSFCell from package.

     XSSFCell cell = row.createCell(cellnum++);

    Step 10 – Iterate over Data and Write to the sheet

    	int rownum = 0;
		for (Object[] employeeDetails : data) {

			// Create Row
			XSSFRow row = sheet.createRow(rownum++);

			int cellnum = 0;
			for (Object obj : employeeDetails) {

				// Create cell
				XSSFCell cell = row.createCell(cellnum++);

				// Set value to cell
				if (obj instanceof String)
					cell.setCellValue((String) obj);
				else if (obj instanceof Double)
					cell.setCellValue((Double) obj);
				else if (obj instanceof Integer)
					cell.setCellValue((Integer) obj);
			}
		}

    Step 11 – Open a FileOutputStream to a new file named “EmployeeDetails.xlsx”. Write data to an OutputStream. Use the below code to write output stream.

    FileOutputStream out = new FileOutputStream(new File("EmployeeDetails.xlsx"));
workbook.write(out);

    Step 12 – Close the output stream.

    out.close();

    Below is the sample code for writing the data in an excel in Java.

    import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;

import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

public class ReadWriteExcelFile {

	public static void main(String[] args) throws IOException {

		// create blank workbook
		XSSFWorkbook workbook = new XSSFWorkbook();

		// Create a blank sheet
		XSSFSheet sheet = workbook.createSheet("Write_TestData");

		ArrayList<Object[]> data = new ArrayList<Object[]>();
		data.add(new String[] { "Name", "Id", "Salary" });
		data.add(new Object[] { "Jim", "001A", 10000 });
		data.add(new Object[] { "Jack", "1001B", 40000 });
		data.add(new Object[] { "Tim", "2001C", 20000 });
		data.add(new Object[] { "Gina", "1004S", 30000 });

		// Iterate over data and write to sheet
		int rownum = 0;
		for (Object[] employeeDetails : data) {

			// Create Row
			XSSFRow row = sheet.createRow(rownum++);

			int cellnum = 0;
			for (Object obj : employeeDetails) {

				// Create cell
				XSSFCell cell = row.createCell(cellnum++);

				// Set value to cell
				if (obj instanceof String)
					cell.setCellValue((String) obj);
				else if (obj instanceof Double)
					cell.setCellValue((Double) obj);
				else if (obj instanceof Integer)
					cell.setCellValue((Integer) obj);
			}
		}
		try {

			// Write the workbook in file system
			FileOutputStream out = new FileOutputStream(new File("EmployeeDetails.xlsx"));
			workbook.write(out);
			out.close();
			System.out.println("EmployeeDetails.xlsx has been created successfully");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			workbook.close();
		}
	}

}

    The output of the above program is

    Summary:

    1. Create a WorkBook and Sheet
    2. Prepare the data. Use ArrayList to store the rows of data.
    3. Write Data to the Excel by iterating over each row and cell
    4. Save the Workbook
    5. Handle the exceptions appropriately

    That’s it! We have written data in Excel.

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

    vibssingh

    Java Excel Tutorial: Creating Excel with Formulas Using Apache POI

    Last Updated On

    HOME

    In the previous tutorial, I have explained How to update data in existing excel in Java. In this Java Excel tutorial, I will explain how to create an Excel with formula in a Java program. Excel is very excellent in calculating formulas. The Apache POI library provides excellent support for working with formulas in Excel.

    I’m using Apache POI to write data to the excel file. To download and install Apache POI, refer here.

    If you are using maven, then you need to add below dependency in pom.xml.

    <!-- https://mvnrepository.com/artifact/org.apache.poi/poi -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi</artifactId>
    <version>5.3.0</version>
</dependency>
  
<!-- https://mvnrepository.com/artifact/org.apache.poi/poi-ooxml -->
<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>5.3.0</version>
</dependency>

    To know about various Interfaces and Classes in Excel, please refer this link.

    Implementation Steps

    Step 1 – Create a blank workbook.

    XSSFWorkbook workbook = new XSSFWorkbook();

    Step 2 – Import XSSFWorkbook from package.

    import org.apache.poi.xssf.usermodel.XSSFWorkbook;

    Step 3 – Create a sheet and pass name of the sheet.

    XSSFSheet sheet = workbook.createSheet("Calculate Salary");

    Step 4 – Import XSSFSheet from package.

    import org.apache.poi.xssf.usermodel.XSSFSheet;

    Step 5 – Create a Row. A spreadsheet consists of rows and cells. It has a grid layout. I have created object called Header of XSSFRow.

    XSSFRow header = sheet.createRow(0);

    Step 6 – Below syntax create new cells within the row at index 0 and set a string value for the cell.

    header.createCell(0).setCellValue("Employee_Name");

    Step 7 – Below syntax creates a cell at index 4 and sets formula for cell.

    dataRow.createCell(4).setCellFormula("B2+C2+D2");

    Step 8 – The following line of code sets formula for the cell at the row #1 and column #5 (remember index is 0-based):

    In case the column (Cell) does not exist (but the row does), use the following code.

    XSSFRow dataRow = sheet.createRow(1);
dataRow.createCell(5).setCellFormula("SUM(B2:C2)");

    Step 9 – Write the workbook to a File and close the workbook

    try {

			// Write the workbook in file system
			FileOutputStream out = new FileOutputStream(new File("Salary_Slip.xlsx"));
			workbook.write(out);
			out.close();
			System.out.println("Excel written successfully.");

		} catch (IOException e) {
			e.printStackTrace();

		}

    In the above line, note that you should make sure that the cell at position (1, 5) does exist, otherwise you get a NullPointerException.

    Let us see a program where I have created a cell which contains the formula.

    import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

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

public class FormulaExcelDemo {
    
    public static void main(String[] args) {

        // Create object of XSSFWorkbook class
        XSSFWorkbook workbook = new XSSFWorkbook();

        // Create object of XSSFSheet class
        XSSFSheet sheet = workbook.createSheet("Calculate Salary");

        // Create Header row using XSSFRow class
        XSSFRow header = sheet.createRow(0);
        header.createCell(0).setCellValue("Employee_Name");
        header.createCell(1).setCellValue("Base_Salary");
        header.createCell(2).setCellValue("Variable_Pay");
        header.createCell(3).setCellValue("Other_Benefits");
        header.createCell(4).setCellValue("Total Salary");
        header.createCell(5).setCellValue("Base_Variable Salary");

        XSSFRow dataRow = sheet.createRow(1);
        dataRow.createCell(0).setCellValue("George");
        dataRow.createCell(1).setCellValue(5000);
        dataRow.createCell(2).setCellValue(650);
        dataRow.createCell(3).setCellValue(1200);

        // Set formula
        dataRow.createCell(4).setCellFormula("B2+C2+D2");
        dataRow.createCell(5).setCellFormula("SUM(B2:C2)");

        try {

            // Write the workbook in file system
            FileOutputStream out = new FileOutputStream(new File("Salary_Slip.xlsx"));
            workbook.write(out);
            out.close();
            System.out.println("Excel written successfully.");

        } catch (IOException e) {
            e.printStackTrace();

        }
    }
}

    The output of the above program is

    Updated Excel

    That’s it! Well Done! Cheers!!

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

    vibssingh

    Deleting Directories in Java: Complete Tutorial

    HOME

    In this tutorial I will explain the steps to delete a directory in Java.

    The delete() method of the File class deletes the files and empty directory represented by the current File object. If a directory is not empty or has files, then it can’t be deleted directly. First, empty the directory, then delete the folder.

    Suppose there exists a directory with path Desktop\Test. The next image displays the files and directories present inside Test folder. The Test directory has folders Demo_1, Demo_2, and Demo_3.

    The next java programs illustrate how to delete a directory. This example uses a recursive method to delete the directory and all its contents, including subdirectories.

    package org.example;

import java.io.File;

public class DeleteDirectoryDemo {

    public static void main(String[] args) {

        String directoryPath = "C:\\Users\\Vibha\\Desktop\\Test";

        //Create a file object for the directory
        File directory = new File(directoryPath);

        if(directory.exists()&& directory.isDirectory()) {
            boolean successful = deleteDirectory(directory);
            if (successful) {
                System.out.println("Directory deleted :" + directoryPath);
            } else {
                System.out.println("Failed to delete Directory :" + directoryPath);
            }
        } else {
            System.out.println("Directory does not exists :" + directoryPath);

            }
        }

        private static boolean deleteDirectory(File directory) {
            File[] allContents = directory.listFiles();

            if (allContents != null) {
                for (File file : allContents) {
                    deleteDirectory(file);
                    System.out.println("File deleted :" + file);
                }
            }
            return directory.delete();
        }
    }

    Explanation

    Step 1 – Check if the directory exists.

      if(directory.exists()&& directory.isDirectory())

    Step 2 – List files in the directory.

    File[] allContents = directory.listFiles();

    Step 3 – Delete files and subdirectories recursively

     for (File file : allContents) {
                    deleteDirectory(file);
                    System.out.println("File deleted :" + file);
                }
            }

    Step 4 – Delete the empty directory.

    directory.delete();

    The output of the above program is

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