Getting Began with Selenium 2.0 Cheatsheet – Java Code Geeks

1. Introduction

Selenium 2.0 revolutionized net utility testing by offering a extra sturdy, environment friendly, and user-friendly framework. Its adoption by the testing neighborhood grew quickly, and it turned the de facto commonplace for net UI automation. Selenium 2.0 laid the muse for future variations of Selenium, together with Selenium 3.0 and past, which proceed to evolve and enhance the testing panorama.

2. WHAT IS SELENIUM 2.0?

Selenium 2.0 is a serious launch of the Selenium framework that launched important enhancements and enhancements over its predecessor, Selenium 1.0 (often known as Selenium RC or Distant Management). It was designed to beat the restrictions and challenges confronted by Selenium 1.0 and to supply a extra sturdy and environment friendly device for net utility testing.

One of many key options of Selenium 2.0 is the introduction of WebDriver, a strong API that enables direct interplay with net browsers. WebDriver offers a extra trendy and intuitive strategy to browser automation in comparison with the earlier Selenium RC API. It provides a extra pure and seamless method to management the browser, mimicking person actions comparable to clicking buttons, filling varieties, navigating pages, and verifying web page content material.

With WebDriver, builders can write assessments in a number of programming languages, together with Java, C#, Python, Ruby, and extra. This language binding flexibility makes Selenium 2.0 accessible to a broader vary of builders and allows groups to make use of their most well-liked programming language for check automation.

Along with WebDriver, Selenium 2.0 launched a extra modular structure. The framework was cut up into separate parts, every accountable for a selected facet of net testing. This modular construction permits for higher maintainability, extensibility, and scalability of the Selenium framework.

One other notable enchancment in Selenium 2.0 is the help for a number of browsers via browser-specific driver implementations. Selenium 2.0 offers devoted drivers for common net browsers comparable to Firefox, Chrome, Web Explorer, Safari, and Opera. These drivers facilitate seamless communication between Selenium and the respective browsers, enabling correct and dependable browser automation.

Selenium 2.0 additionally launched varied options and capabilities to reinforce the testing expertise. It improved the dealing with of AJAX-based functions, added help for HTML5 components and occasions, and enhanced the dealing with of pop-up dialogs and alerts. It additionally launched superior options like screenshots, timeouts, browser profiles, and extra, empowering testers to sort out complicated testing situations.

Moreover, Selenium 2.0 helps integration with varied testing frameworks and instruments, permitting testers to leverage their present check infrastructure. It could seamlessly combine with instruments like TestNG, JUnit, and Maven, enabling the execution of Selenium assessments as a part of a complete check suite or steady integration (CI) pipeline.

3. ARCHITECTURE

Selenium 2.0 follows a client-server structure, the place the shopper interacts with the Selenium server to manage the net browser. The Selenium WebDriver API is used to speak with totally different browser drivers, which in flip management the net browsers. This structure permits Selenium to help a number of browsers and working techniques.

4. INSTALLATION

To get began with Selenium 2.0, you must arrange the required dependencies and drivers based mostly in your programming language and browser choice. Listed below are the set up steps for varied languages:

4.1 Java (Maven)

If you happen to’re utilizing Maven as your construct device, you’ll be able to merely add the Selenium Java bindings as a dependency in your venture’s pom.xml file. Right here’s an instance:

<dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <model>2.0.0</model>
</dependency>

4.2 Ruby

To make use of Selenium 2.0 with Ruby, you must set up the Selenium Ruby gem. Open your command immediate or terminal and run the next command:

gem set up selenium-webdriver

4.3 Python

For Python, you’ll be able to set up Selenium 2.0 utilizing pip, the Python bundle supervisor. Run the next command in your command immediate or terminal:

pip set up selenium

4.4 C#

To make use of Selenium 2.0 with C#, you must add the Selenium C# bindings to your venture. You may obtain the Selenium C# bindings from the official Selenium web site or embrace them as a NuGet bundle in your Visible Studio venture.

5. DRIVER IMPLEMENTATIONS

Selenium 2.0 helps varied browser drivers that allow communication between Selenium and net browsers. Every driver implementation offers a method to launch and management a selected net browser utilizing the WebDriver API. Let’s discover some generally used driver implementations:

5.1 Firefox

To make use of Firefox with Selenium 2.0, you

have to obtain the Firefox driver executable and set the trail to the driving force in your code. Right here’s an instance in Java:

System.setProperty("webdriver.gecko.driver", "path/to/geckodriver.exe");
WebDriver driver = new FirefoxDriver();

5.2 Web Explorer

To make use of Web Explorer with Selenium 2.0, you must obtain the Web Explorer driver executable and set the trail to the driving force in your code. Right here’s an instance in Java:

System.setProperty("webdriver.ie.driver", "path/to/IEDriverServer.exe");
WebDriver driver = new InternetExplorerDriver();

5.3 Chrome

To make use of Chrome with Selenium 2.0, you must obtain the Chrome driver executable and set the trail to the driving force in your code. Right here’s an instance in Java:

System.setProperty("webdriver.chrome.driver", "path/to/chromedriver.exe");
WebDriver driver = new ChromeDriver();

5.4 HtmlUnit

HtmlUnit is a headless browser implementation that doesn’t require any further drivers. It’s helpful for testing net functions with out the necessity for a visual browser window. Right here’s an instance in Java:

WebDriver driver = new HtmlUnitDriver();

6. SELENIUM RC EMULATION

Selenium 2.0 launched Selenium RC emulation to supply backward compatibility with Selenium RC. Selenium RC was the predecessor of Selenium WebDriver and had its personal set of APIs for automating net browsers. Nevertheless, Selenium RC had sure limitations and was not as environment friendly and dependable as WebDriver.

To bridge the hole between Selenium RC and WebDriver, Selenium 2.0 launched the idea of RC emulation. With RC emulation, you’ll be able to migrate your present Selenium RC assessments to Selenium 2.0 with out making important modifications to your code. This ensures that your legacy assessments proceed to work whereas profiting from the improved capabilities and efficiency of WebDriver.

Selenium RC emulation works by emulating the Selenium RC API utilizing WebDriver. It interprets the Selenium RC instructions into their corresponding WebDriver instructions, permitting you to execute your Selenium RC assessments utilizing WebDriver-based browsers.

To make use of Selenium RC emulation, you must create a RemoteWebDriver occasion and specify the URL of the Selenium server and the specified browser capabilities. Right here’s an instance:

WebDriver driver = new RemoteWebDriver(new URL("http://localhost:4444/wd/hub"), DesiredCapabilities.firefox());

Within the instance above, we create a RemoteWebDriver occasion by offering the URL of the Selenium server (usually working on localhost at port 4444) and specifying the specified browser capabilities (on this case, we’re utilizing Firefox).

As soon as the RemoteWebDriver occasion is created, you should use it to execute your Selenium RC assessments utilizing the acquainted Selenium RC instructions. The WebDriver instructions will probably be translated into their equal WebDriver instructions behind the scenes.

For instance, in Selenium RC, you may need used the open command to navigate to a URL:

selenium.open("https://www.instance.com");

In Selenium 2.0 with RC emulation, you’ll be able to obtain the identical consequence utilizing WebDriver’s get methodology:

driver.get("https://www.instance.com");

Equally, different Selenium RC instructions like kind, click on, choose, and so forth., may be changed with their WebDriver equivalents.

The RC emulation function in Selenium 2.0 means that you can seamlessly transition from Selenium RC to WebDriver, making certain your present assessments proceed to operate whereas leveraging the improved efficiency and stability of WebDriver. Nevertheless, it’s really helpful to step by step replace your assessments to make use of WebDriver’s native API for higher maintainability and readability.

Word: Selenium RC emulation is offered for backward compatibility and isn’t actively developed or supported. It’s really helpful emigrate your assessments to make use of WebDriver’s native API to take full benefit of the newest options and enhancements.

7. PAGE INTERACTION MODEL

The Web page Interplay Mannequin in Selenium 2.0 refers back to the strategy used to work together with net pages and carry out actions on components inside these pages. The first interface for interacting with net components is the WebDriver API, which offers a wealthy set of strategies for locating, manipulating, and verifying components on an online web page.

To work together with components on an online web page utilizing the Web page Interplay Mannequin, you usually observe these steps:

Finding Parts

You utilize varied locator methods offered by WebDriver, comparable to By.id(), By.title(), By.xpath(), and so forth., to find components on the internet web page. These locators assist you determine particular components based mostly on their attributes, textual content content material, or hierarchical relationships.

Discovering Parts

After you have outlined the locator technique, you should use WebDriver’s findElement() or findElements() strategies to find one or a number of components on the web page, respectively. The findElement() methodology returns the primary matching component, whereas findElements() returns a listing of all matching components.

Performing Actions

After discovering the specified components, you’ll be able to carry out varied actions on them, comparable to clicking on buttons, filling enter fields, deciding on choices from dropdowns, submitting varieties, and so forth. WebDriver offers strategies like click on(), sendKeys(), submit(), selectByVisibleText(), and plenty of extra to carry out these actions.

Right here’s an instance of interacting with components utilizing the Web page Interplay Mannequin:

WebElement searchBox = driver.findElement(By.id("search-box"));
searchBox.sendKeys("Selenium");
searchBox.submit();

Within the above instance, we first find the search field component utilizing its ID attribute. Then, we use the sendKeys() methodology to enter the textual content “Selenium” into the search field. Lastly, we submit the shape utilizing the submit() methodology.

The Web page Interplay Mannequin offers a versatile and intuitive method to simulate person actions and work together with net components throughout automation testing. It means that you can replicate person habits, check person flows, and validate the anticipated habits of net functions.

By combining the Web page Interplay Mannequin with different options of Selenium, comparable to synchronization, waits, and assertions, you’ll be able to construct sturdy and dependable assessments that make sure the performance and value of your net functions.

Bear in mind to all the time contemplate correct error dealing with and synchronization mechanisms, comparable to specific waits, to make sure that your automation scripts work together with the weather on the proper time and within the anticipated state.

Utilizing the Web page Interplay Mannequin successfully will help you create complete check instances and uncover potential points in your net functions, offering you with confidence within the high quality and efficiency of your software program.

8. PAGE OBJECT PATTERN

The Web page Object sample is a extensively adopted design sample in Selenium check automation. It helps in structuring and organizing the check code by separating the check logic from the page-specific particulars. This sample promotes code reusability, maintainability, and readability, making check scripts extra sturdy and simpler to take care of.

Within the Web page Object sample, every net web page or element of an online utility is represented by a separate class known as a “Web page Object.” This class encapsulates the weather on the web page and the actions that may be carried out on these components. The principle aim is to create a transparent separation between the check code and the underlying implementation particulars of the net utility.

Modularity

With the Web page Object sample, every web page or element of the net utility has its personal devoted class. This modularity permits for higher group and administration of the check code. It additionally allows straightforward identification and modification of components and actions particular to a specific web page, with out impacting different elements of the check code.

Reusability

Web page Objects promote code reusability. Since every web page or element has its personal class, the identical Web page Object may be reused throughout a number of check instances. This eliminates code duplication and improves maintainability. Adjustments to the web page’s construction or performance may be made in a single place, and the modifications will routinely propagate to all of the assessments utilizing that Web page Object.

Readability

By encapsulating the weather and actions inside a Web page Object, the check code turns into extra readable and comprehensible. Check instances written utilizing Web page Objects learn like pure language and function documentation of the applying’s habits. This makes it simpler for crew members, together with builders and testers, to collaborate and perceive the aim and movement of the assessments.

Synchronization

Web page Objects present a centralized location to deal with synchronization points. Implicit waits or specific waits may be encapsulated inside the Web page Object strategies, making certain that the check instances anticipate the anticipated state of the web page earlier than continuing. This helps in coping with dynamic components, AJAX requests, and different timing-related points.

Upkeep

As net functions evolve, their UI components could change. With the Web page Object sample, when the construction or performance of a web page modifications, the required updates may be made in a single place – the corresponding Web page Object class. This reduces the upkeep effort, as modifications are localized to the affected Web page Object, relatively than scattered throughout a number of check instances.

public class LoginPage {
    non-public WebDriver driver;
    non-public By usernameInput = By.id("username");
    non-public By passwordInput = By.id("password");
    non-public By loginButton = By.id("login-button");

    public LoginPage(WebDriver driver) {
        this.driver = driver;
    }

    public void login(String username, String password) {
        driver.findElement(usernameInput).sendKeys(username);
        driver.findElement(passwordInput).sendKeys(password);
        driver.findElement(loginButton).click on();
    }
}

// Utilization:
LoginPage loginPage = new LoginPage(driver);
loginPage.login("myusername", "mypassword");

9. XPATH SUPPORT

XPath is a strong question language that means that you can navigate and choose components in an XML or HTML doc. Within the context of Selenium 2.0, XPath is often used to find components on an online web page based mostly on their attributes, textual content content material, or hierarchical relationships.

XPath expressions are written utilizing a mix of component names, attributes, and operators to create a path to the specified component. Selenium offers the By.xpath() methodology to find components utilizing XPath expressions.

Right here’s a more in-depth have a look at some generally used XPath expressions with Selenium 2.0:

9.1 Absolute XPath

Absolute XPath expressions specify the entire path to a component from the basis of the doc. They begin with a ahead slash (“/”) and traverse via the doc’s components. Right here’s an instance:

/html/physique/div[1]/kind/enter[2]

9.2 Relative XPath

Relative XPath expressions are extra versatile and environment friendly. They specify the trail to a component relative to a different component, making them much less depending on the doc’s construction. Right here’s an instance:

//kind/enter[@name="username"]

Within the above instance, the XPath expression selects the enter component inside a kind component that has the attribute title with the worth ‘username’.

9.3 XPath Axes

XPath axes help you navigate via totally different elements of the doc, comparable to mum or dad, youngster, sibling, and ancestor components. Listed below are some frequent XPath axes:

XPath axes are helpful whenever you need to choose components based mostly on their relationship with different components within the doc.

9.4 XPath Capabilities and Predicates

XPath features and predicates present further capabilities to refine component choice. They help you apply circumstances, comparisons, and calculations inside XPath expressions. Listed below are some examples:

XPath features and predicates allow you to create extra particular and dynamic component picks based mostly on varied standards.

9.5 Utilizing XPath in Selenium 2.0

To find components utilizing XPath in Selenium 2.0, you’ll be able to make the most of the By.xpath() methodology. Right here’s an instance of utilizing XPath to find an enter area with a selected attribute:

WebElement component = driver.findElement(By.xpath("//enter[@id='username']"));

Within the above instance, the XPath expression selects an enter component with the attribute id equal to ‘username’.

XPath help in Selenium 2.0 is highly effective and versatile, permitting you to find components precisely based mostly on totally different standards. It’s particularly helpful when working with complicated net web page buildings or when different finding methods, comparable to ID or class, usually are not obtainable or dependable.

Bear in mind to fastidiously assemble XPath expressions to focus on particular components with out relying too closely on the doc’s construction, as it could change over time. Recurrently check and replace your XPath expressions as wanted to make sure their accuracy and maintainability in your automated assessments.

10. REMOTE WEBDRIVER

RemoteWebDriver is a category offered by Selenium 2.0 that means that you can execute your assessments on distant machines. That is significantly helpful whenever you need to run your assessments on totally different working techniques, browsers, or units with out the necessity to arrange the drivers regionally.

By utilizing RemoteWebDriver, you’ll be able to set up a connection to a distant WebDriver server and delegate the check execution to that server. The server may be working on a distinct machine and even in a cloud-based infrastructure.

To make use of RemoteWebDriver, you must specify the URL of the distant WebDriver server and the specified capabilities, which outline the browser and platform configurations on your check. The server can deal with requests from a number of purchasers concurrently, making it appropriate for parallel check execution.

Right here’s an instance of utilizing RemoteWebDriver to hook up with a distant WebDriver server:

WebDriver driver = new RemoteWebDriver(new URL("http://remote-machine:4444/wd/hub"), DesiredCapabilities.chrome());

Within the instance above, we create a brand new occasion of RemoteWebDriver by offering the URL of the distant WebDriver server and the specified capabilities for the Chrome browser. The URL factors to the server’s endpoint (e.g., http://remote-machine:4444/wd/hub), the place the server is listening for incoming WebDriver requests.

The specified capabilities specify the browser, platform, and different configurations for the distant session. On this case, we set the specified capabilities to make use of Chrome.

By leveraging RemoteWebDriver, you’ll be able to carry out cross-browser testing by executing the identical check suite on totally different browsers working on distant machines. This lets you make sure the compatibility and performance of your net utility throughout varied environments.

It’s price noting that the distant WebDriver server must be arrange and working earlier than you’ll be able to set up a connection utilizing RemoteWebDriver. The Selenium documentation offers detailed directions on find out how to arrange and configure the distant server for various browsers and platforms.

RemoteWebDriver offers a versatile and scalable resolution for distributed check execution, making it a beneficial device for groups engaged on large-scale automation tasks or working assessments in parallel throughout a number of environments.

With RemoteWebDriver, you’ll be able to simply develop your check protection by working assessments on totally different browsers, platforms, and units with out the necessity to preserve an area infrastructure for every configuration. This allows environment friendly and complete check execution whereas saving time and sources.

10.1 Selenium Grid

RemoteWebDriver is constructed on high of the WebDriver protocol, which defines a standardized manner for various WebDriver implementations to speak with browsers. It acts as a bridge between your check code and the WebDriver server working on a distant machine.

The distant WebDriver server may be arrange in varied methods, relying in your necessities. One common selection is to make use of Selenium Grid, which lets you arrange a hub that manages a number of WebDriver nodes working on totally different machines. This setup allows parallel check execution throughout a number of browsers and platforms.

Listed below are the important thing steps concerned in utilizing RemoteWebDriver with Selenium Grid:

Begin the Selenium Grid Hub: The hub acts as a central level for distributing check requests to the suitable WebDriver nodes. You can begin the hub by working the next command:

java -jar selenium-server-standalone.jar -role hub

Register WebDriver Nodes: Every WebDriver node represents a selected browser and platform mixture. You can begin a number of WebDriver nodes by working the next command:

java -jar selenium-server-standalone.jar -role node -hub http://hub-url:4444/grid/register

Set up a Reference to RemoteWebDriver: In your check code, you must create an occasion of RemoteWebDriver and supply the URL of the Selenium Grid hub. Right here’s an instance:

DesiredCapabilities capabilities = DesiredCapabilities.chrome();
WebDriver driver = new RemoteWebDriver(new URL("http://hub-url:4444/wd/hub"), capabilities);

Within the instance above, we create a brand new occasion of RemoteWebDriver by specifying the URL of the Selenium Grid hub and the specified capabilities for the Chrome browser.

Execute Exams: As soon as the RemoteWebDriver is instantiated, you’ll be able to write your check code as regular. The WebDriver instructions you employ will probably be despatched to the suitable WebDriver node based mostly on the specified capabilities you offered.

Selenium Grid handles the distribution of check execution throughout obtainable nodes, permitting you to run assessments in parallel and maximize useful resource utilization. It routinely routes check requests to nodes that match the specified capabilities specified within the RemoteWebDriver setup.

Utilizing RemoteWebDriver with Selenium Grid offers a number of advantages:

• Scalability: Selenium Grid means that you can scale your check execution by including extra WebDriver nodes. This ensures environment friendly utilization of sources and quicker check execution.
• Cross-Browser Testing: With RemoteWebDriver and Selenium Grid, you’ll be able to simply run your assessments on totally different browsers and platforms concurrently, enabling complete cross-browser testing.
• Parallel Execution: Selenium Grid allows parallel check execution throughout a number of nodes, permitting you to execute a number of assessments concurrently and scale back general check execution time.
• Centralized Administration: Selenium Grid offers a centralized hub to handle and distribute check execution. This simplifies the setup and upkeep of your check infrastructure.

It’s necessary to notice that when utilizing RemoteWebDriver with Selenium Grid, you must be sure that the suitable WebDriver binaries and drivers are put in and configured on the distant machines. The WebDriver binaries should match the specified browser and model specified within the desired capabilities.

By leveraging RemoteWebDriver and Selenium Grid, you’ll be able to create a sturdy and scalable check infrastructure that helps distributed check execution throughout varied browsers, platforms, and units. This allows you to obtain complete check protection and environment friendly check execution in a parallel and distributed testing atmosphere.

11. MOBILE DEVICE SUPPORT

Selenium 2.0 offers a method to automate cell net functions by integrating with the Appium framework. Appium is an open-source device that extends the capabilities of Selenium WebDriver to help cell utility testing. With Appium, you’ll be able to write assessments in your most well-liked programming language and use the WebDriver API to work together with cell apps.

11.1 Setting Up Appium

To get began with cell machine help in Selenium 2.0, you must arrange the Appium server and configure the specified capabilities for the goal machine or emulator. Listed below are the final steps to arrange Appium:

1. Set up Node.js: Appium requires Node.js to run. You may obtain and set up Node.js from the official Node.js web site (https://nodejs.org).
2. Set up Appium: Open your command immediate or terminal and run the next command to put in Appium globally:

   npm set up -g appium

3. Set up Appium Dependencies: Appium depends on varied dependencies, such because the Android SDK for Android units and Xcode for iOS units. Be sure that to put in these dependencies based mostly on the platform you need to check.
4. Begin Appium Server: As soon as the dependencies are put in, begin the Appium server by working the next command in your command immediate or terminal:

   appium

It will begin the Appium server and permit it to hear for incoming WebDriver requests.

11.2 Configuring Desired Capabilities

Earlier than working your cell assessments with Selenium 2.0, you must configure the specified capabilities to specify the goal machine or emulator, platform, and different related settings. Right here’s an instance of configuring desired capabilities for Android:

DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability("deviceName", "Android Machine");
capabilities.setCapability("platformName", "Android");
capabilities.setCapability("browserName", "Chrome");

On this instance, we set the deviceName functionality to specify the goal Android machine or emulator. The platformName functionality signifies the goal cell platform (Android or iOS), and the browserName functionality specifies the browser to make use of for testing (on this case, Chrome).

11.3 Operating Cell Exams

As soon as the Appium server is up and working, and you’ve got configured the specified capabilities, you’ll be able to run your cell assessments utilizing Selenium 2.0. Right here’s an instance of initializing the WebDriver with Appium:

WebDriver driver = new RemoteWebDriver(new URL("http://localhost:4723/wd/hub"), capabilities);

On this instance, we create an occasion of the RemoteWebDriver class and supply the URL of the Appium server together with the specified capabilities.

From right here, you should use the WebDriver API to work together with the cell net utility, similar to you’d with desktop net testing. You’ll find components, carry out actions, and confirm the anticipated habits of your cell app.

11.4 Appium Options

Appium offers further options and capabilities to reinforce your cell testing expertise. Some notable options embrace:

• Cross-platform help: Appium means that you can write assessments in a single language (comparable to Java, Python, or JavaScript) and run them on each Android and iOS units, making it handy for cross-platform testing.
• Help for native apps: Along with cell net functions, Appium additionally helps automating native cell apps. You should utilize the identical WebDriver API to work together with native app components and carry out actions.
• Constructed-in gestures and interactions: Appium offers built-in help for frequent cell gestures, comparable to swiping, tapping, and scrolling. These gestures may be simply included into your check scripts to simulate person interactions.
• Integration with cloud-based testing providers: Appium may be built-in with cloud-based testing providers, permitting you to run your cell assessments on a variety of actual units hosted within the cloud. This allows you to cowl a broader spectrum of units and configurations with out the necessity for bodily units.

11.5 Limitations and Issues

Whereas cell machine help in Selenium 2.0 and Appium is highly effective, there are just a few limitations and issues to bear in mind:

• Machine-specific habits: Cell units can exhibit totally different behaviors, display sizes, and capabilities. It’s essential to think about device-specific variations and check on a various vary of units to make sure optimum app efficiency.
• Efficiency and stability: Emulators and simulators could not absolutely replicate the habits and efficiency of actual units. It’s really helpful to carry out testing on actual units at any time when attainable to acquire extra correct outcomes.
• Appium server and dependencies: Appium depends on the Appium server and varied dependencies, such because the Android SDK or Xcode. Preserving these parts updated and making certain compatibility along with your testing atmosphere is necessary.
• Appium model compatibility: Appium is underneath lively improvement, and new variations could introduce modifications or deprecate sure options. Guarantee compatibility between your Appium model, Selenium model, and different associated libraries.

By contemplating these components and leveraging the capabilities of Appium, you’ll be able to successfully automate the testing of cell net functions and guarantee their performance throughout totally different cell platforms.