Top Selenium Commands for WebDriver with Examples
Tags: testing, selenium, webdriver, testautomation
Published: 2023-05-03 10:28:24

This blog will discuss the most critical Selenium WebDriver commands and how to use them with examples. We'll look at how to find elements on a website, advanced techniques for interacting with dynamic elements, and tips for working with multiple windows. Everything you need to know to get started with Selenium WebDriver is here! Let's get into it and take a look at the best Selenium WebDriver commands!

## Selenium Webdriver Commands

There are lots of different ways you can use Webdriver commands. To understand how to use each method, look at its name, what parameters it needs, and what type of information it returns.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/yqvci8qyg7hv4g3xzzse.png)

**Method Name:** To use a class, we first need to create an object of that class. This will give us access to all the public methods associated with that class.

**Parameter:** An argument that is given to a function so it can perform a particular operation.

**Return type:** Methods can give you something back or not give you anything. It returns no value if it says 'void' after the method.

## Navigational Selenium Commands

Selenium is a popular open-source automation tool that helps developers test web applications. It's got lots of features, like navigating through web pages - ensuring that the website works correctly and does what it should. In this blog, we'll talk about different Selenium commands you can use to navigate around a website.

## Navigate To Commands

The navigate to command is one of the most important commands in Selenium. It lets you go to a specific website or page. There are two ways to get to a page in Selenium -the get method and the navigate method.

### Using the get method

The get method is an easy way to navigate a website. For example, if you want to go to Testsigma's homepage, you would use this code:

```
driver.get("https://testsigma.com/");
```

If you want to go to a specific page on a website, like the product page, you can use the "get method." which looks like this:

```
driver.get("https://testsigma.com/products");
```

### Using the navigate method

The navigate method provides a more flexible approach to navigating a page than the get method. It allows for navigation to a page using a relative URL making it more versatile.

```
driver.navigate().to("/contact-us");
```

The navigate method enables further navigation activities, including navigating back and forth, which we will discuss later in this blog.

### Forward Command

If you've gone to a page on your browser and clicked the back button, you can use the forward command to go back to that page. Take yourself back to where you were before by pressing the forward button on your browser.

```
driver.navigate().forward();
```

### Back Command

To move backward in the browser's history, use the back command. For example, if you navigated to a website and then clicked a link to another page, you could use the back command to go back to the first page. The back command can be used in the following ways:

```
driver.navigate().back();
```

### The Refresh Command

To refresh the current page, use the refresh command. For example, if you navigated to a page and did certain activities, you might use the refresh command to reload the page and check to see if the actions were successful. The refresh command can be used in the following ways:

```
driver.navigate().refresh();
```

These are some of the main commands you need to know to use Selenium. They help you move around different web pages, go back and forth between pages, and refresh the page you're on. Knowing these commands is vital for testing websites.

## Selenium Commands to search for specific Web Elements

[Selenium](https://www.selenium.dev/) offers many commands to locate specific parts of a web page. We will look at some of the most popular Selenium commands for finding stuff on websites.

### Clear Command

The clear()  Selenium command can be used to clear the content that's already in a text box. It's helpful when you want to replace/overwrite the old value with something new. Here's an example of how you can use the clear() command:

```
WebElement element = driver.findElement(By.id("textbox1")).clear();
```

The findElement() method is used to locate a text box with the id "textbox1". Then, the clear() method is called on it to erase whatever was in there before.

### Click Command

 The click() command lets you "click" on something on a website. For example, if you want to press a button or activate a link, you can use the click() command. Here's an example of how it works:

```
WebElement element = driver.findElement(By.linkText("Click me!")).click();
```

The example above uses the findElement() method to locate a link with the words "Click me!". Then, the click() method is used to click on it.

### GetText Command

The getText() command can retrieve the text content of a web element. Here's an example of how you can use the getText() command: 

```
String buttonText = driver.findElement(By.id("submitButton")).getText();
```

We use the findElement() method to locate a button with the id "submitButton". Then, we get its text content and store it in the "buttonText" variable by calling the getText() method.

### IsSelected Command

The isSelected() command checks if a checkbox or radio button has been ticked. It's used to see if an element on a web page has been selected. Here's an example of how you can use the isSelected() command:

```
boolean isChecked = driver.findElement(By.id("checkbox1")).isSelected();
```

We use the findElement() method to locate a checkbox with the id "checkbox1". Then, we call the isSelected() method to see if it's been checked. Whatever the result, we save it in a variable called "isChecked".

### IsEnabled Command

The isEnabled() command checks if a web element (like a form field or button) is ready to be used. For example, you can use it to ensure a button is available for someone to click. 

Here's an example of how you can use the isEnabled() command:

```
boolean isEnabled = driver.findElement(By.id("submitButton")).isEnabled();
```

We use the findElement() method to locate a button with the id "submitButton". Then we use the isEnabled() method on that button to check if it's enabled and can be clicked. The result of this check gets stored in a variable called "isEnabled".

### IsDisplayed Command

The isDisplayed() command checks if a web element (like a button or text) is visible on the page. It's beneficial when you want to ensure the element is visually there and can be seen by the user. Here's an example of how it works:

```
boolean isVisible = driver.findElement(By.id("element1")).isDisplayed();
```

We use the findElement() method to locate an element with the id "element1". Then we call the isDisplayed() method to check if it's visible on the page. We store the result of this in a variable called "isVisible".

### GetSize Command

The getSize() command helps you determine how big something is on a website. For example, it can be used to check the height and width of an image. Here's an example of how it works:

```
Dimension elementSize = driver.findElement(By.id("element1")).getSize();
```

We use the findElement() method to locate an element with the id "element1". Then, we call getSize() on that element to get its size. The size is stored in the "elementSize" variable.

### GetCssValue Command

 The getCssValue() command can be used to determine the value of a CSS property for a web element. This is helpful if you want to check an element's appearance, like its color or font size. Here's an example of how it works:

```
String fontSize = driver.findElement(By.id("element1")).getCssValue("font-size");
```

We use the findElement() method to locate an element with the id "element1". Then, we call the getCssValue() method on it to get the value of its "font-size" CSS property. Whatever that value is gets stored in a variable called "fontSize".

### GetLocation Command

The getLocation() Selenium command lets you find where an element is on a page. For example, if you want to ensure a button or image is in the right spot, this command will help. Here's how it works:

```
elementLocation = driver.findElement(By.id("element1")).getLocation();
```

We use the findElement() method to locate an element with the id "element1". Then, we call that element the getLocation() method to get its position on the page. The result is saved in a variable called "elementLocation".

### Submit Command

The submit() command sends the information you type into a form. It's like pressing the 'submit' button on a website or app. Here's an example of how it works:

```
driver.findElement(By.id("form1")).submit();
```

In the example, we use the findElement() method to locate a form with an id of "form1". Then, we call the submit() method on that form to submit it.

### GetAttribute Command

The getAttribute() Selenium command is a way to get info from an element on a website. It's useful when you want to find out what the value of something is, like an image's "src" attribute. Here's an example of how it works:

```
String imageSrc = driver.findElement(By.id("element1")).getAttribute("src");
```

We use the findElement() method to locate an element with the id "element1". Then, we call getAttribute() on that element to get the value of its "src" attribute. That result is stored in a variable called "imageSrc".

### GetTagName Command

The getTagName() command can determine what type of element you're dealing with on a website. For example, if you want to check if a button is present or an image, you can use this command to find out. Here's an example of how it works:

```
String tagName = driver.findElement(By.id("element1")).getTagName();
```

We use the findElement() method to find an element with the id "element1". Then, we call getTagName() on that element to get its tag name and store it in a variable called "tagName".

### SendKeys Command

If you want to enter text into a web element, like a text field or text area, you can use the sendKeys() command. It's like typing something on your keyboard - it simulates what a user would do when entering data. Here's an example of how to use it:

```
driver.findElement(By.id("element1")).sendKeys("Hello World!");
```

We use the findElement() method to find an element with the id "element1". Then, we call the sendKeys() method on that element and pass it "Hello World!" as an argument. That's how we can type text into the element.

These are some of the most popular Selenium commands you can use to find and interact with elements on a website. It doesn't matter if you're starting out or already have some experience with Selenium - knowing how to use these commands is key for automating your web testing.

## Commands to handle frames in Selenium Webdriver

Using HTML frames, you can divide a web page into sections. This helps display external content on the page, like an advertisement for an online course. To interact with elements in the frame, you need to switch to that frame. That way, you can quickly identify elements and write tests accordingly. In Selenium WebDriver, you can use the switchTo().frame() function to switch between frames. 

There are three ways of doing this: **By.index**, **By.id**, and **By.WebElement** - here's how each works:

**By Index:**

```
 driver.switchTo().frame(1); 
```

 This changes to the page with the number 1.

**By Id:** 

```
driver.switchTo().frame(“resultframe”); 
```

This changes to the page where the "id" is labeled as "resultframe".

**By Web Element:**

```
WebElement iframeElement = driver.findElement(By.id("resultframe")); driver.switchTo().frame(iframeElement); 
```

The WebElement command identifies the part of a website you're looking for, then passes that information to the iframeElement object.

Selenium WebDriver has commands that make it easier to switch between frames and interact with elements on the page. The switchTo().frame() function is helpful for testing automation because it helps you identify elements on the page so you can write tests accordingly.

[Testsigma](https://testsigma.com/) offers a unique community-driven approach, providing an open-source solution that prioritizes sustainability over a limited free model. This means you can get a reliable, constantly improving platform supported by a dedicated community of users and developers.

## Basic Get commands used in the Browser

These commands or methods are essential for helping QAs (Quality Assurance), and developers get specific details from the website they're testing. This helps them make sure it's working correctly.

i. getCurrentUrl() - This command gets the address of the webpage you're currently looking at in your browser. 

ii. getPageSource() - With this command, you can see all the HTML code behind the webpage you're looking at. 

iii. getTitle() - Use this command to show the title of the page you're on.

These Get commands in Selenium are super crucial for grabbing information from a web page. They make it easier for testers to make sure the page is working as it should. These commands can save time and help you get more accurate testing results.

## Wait commands in Selenium

The wait commands in Selenium are super powerful. They allow testers to pause their tests for a certain amount of time, so they can have more control over what's happening. This is especially helpful when pages take longer to load or there are other delays.

Selenium has two kinds of wait commands: **Implicit** and **Explicit**. 

### Implicit wait 

This command tells the WebDriver to wait a certain amount before it gives up and throws an error. You can use this command like this:

```
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
```

### Explicit wait 

This code tells the WebDriver to wait until a specific condition is met before it runs any more of your instructions. It looks like this:

```
WebDriverWait wait = new WebDriverWait(driver,30);
```

Using wait commands in Selenium, QAs can make their test cases more robust and efficient. That way, the web page has enough time to load, and any problems can be fixed quickly.

## Drawbacks and Alternatives to Selenium

[Automated testing](https://testsigma.com/automated-testing) is an important part of creating software, and it's used to ensure the apps work properly and quickly. Selenium is one of the most popular free tools for testing web apps. But like any tool, it has some disadvantages. We'll look at those drawbacks and show you another option to help you get around them.

### Drawbacks of Selenium

i. **Complicated Framework:**  Selenium is a tool that can help you do automated testing, but it requires knowledge of different programming languages like Java, Python, and Ruby. 
This can make it hard for newbies to use Selenium for testing.

ii. **Setup and Configuration:**  Getting started with Selenium for automation testing can be tricky, especially if you're new to the framework. You'll need to download some software, set up your environment, and ensure all the dependencies are in place.

iii. **Maintenance and Upkeep:**  Selenium must be taken care of regularly to work correctly. That means updating the system, fixing any mistakes, and ensuring it works with new programs.

iv. **Lack of Built-in Features:**  Selenium has no special tools to help you organize and manage your tests or create reports. You'll need to use other programs, which can be a pain and take up a lot of time.

v. **Upgrade Your Automated Web Testing -** A Faster and Easier Way than Selenium

If you're looking for a more user-friendly and efficient alternative to Selenium, Testsigma is the perfect solution! Testsigma is a cloud-based, AI-driven platform that makes automated testing easier, faster, and more accessible. Here's why it's the best choice:

i. **No Programming Required:**  Testsigma is a low-code unified platform, so it's super easy for anyone to get started with automated testing. Authoring test cases in Testsigma is as easy as writing simple sentences in English.

ii. **Easy Setup and Configuration:**  Testsigma is a cloud platform that makes it easy to start testing your [web apps.](https://testsigma.com/automated-web-application-testing) You don't have to worry about complicated setup or config - you can be up and running minutes after signing up!

iii. **Integrated Test Management and Reporting:**  Testsigma makes it simple to keep track of all your tests and create reports quickly. This means you don't have to waste time managing them and can quickly see how far along you are in the testing process.

Selenium is a tool that can help you automate your testing, but it's not always easy to use. Testsigma offers an easier and faster way to do automated testing - give it a try and see the results for yourself!

## Conclusion:

To wrap it up, Selenium  is an excellent tool for automated testing of web apps. The commands we discussed here are fundamental to helping you do your tests quickly and accurately with Selenium. We gave examples of how these commands work so you can understand what they can do. Knowing and using these commands can save you time and make your testing process more efficient, leading to better results.

## Frequently Asked Questions:

### How to use Selenium commands?

Selenium is an excellent tool that can help you test web apps. It has a lot of commands that let you automate different tasks. Here are some of the most popular Selenium commands to try out:

1. Open: This command launches a new web browser window and takes you to the website you want.

2. Click: This command clicks on something on the webpage, like a button or link.

3. Type: This command types text into a form field, like a text box or drop-down menu. 

4. Select: This command chooses an option from a list or radio button group. 

5. Verify Element Present: This command checks if something is on the webpage, like a text box or image. 

6. Wait For Element Present: This command waits for something to show up on the webpage before it does anything else. 

7. Drag and Drop: This command moves elements within the page, such as images or text boxes. 

8. Execute Script: This command runs JavaScript code within the page

### What are action commands in Selenium?

In Selenium, you can click, double-click, right-click, hover over, and drag and drop things. Some of the most popular action commands are:

i. click() - This command is used to do a single click on something on the web.

ii. doubleClick() - This command lets you double-click an element on the web.

iii. contextClick() - This command is for right-clicking something on the web.

iv. moveToElement() - This command helps you move your mouse over a certain element on the web. 

v. dragAndDrop() - This command lets you drag and drop an element from one place to another. 

vi. build().perform() - This command helps you put a list of actions into one step and execute it.

### Where can you create your Selenium commands?

Selenium commands can be written in different programming languages like Java, Python, C#, etc., so you can use them in your test code.