You will be required to have Java 8, Maven, Selenium WebDriver 3.13, Eclipse Kepler or higher.

The code files of this chapter can be found on GitHub:
https://github.com/PacktPublishing/Selenium-WebDriver-Quick-Start-Guide/tree/master/Chapter01

Check out the following video to see the code in action:
http://bit.ly/2PqyMEt

Let's get started by understanding why test automation is needed. Today's agile world needs quick feedback on the code's quality. The developers check-in application code in a source code repository like GitHub. It is imperative that these changes be tested, and the best way to do so is through automation. A test-automation suite can eliminate the mundane work of manual regression testing and can be helpful in finding bugs earlier, thus reducing manual testing time. It can be configured to run at a particular time in the day.

A cut-off time should be provided to the developers, such as 6 P.M. in the evening, by which time they should check in code, get the application build done, and the application deployed to a server like Apache Tomcat. The automation suite may be scheduled to run at 7 P.M. daily. Jenkins is a tool that's used for continuous integration, and so can be used for this purpose.

Advantages of test automation include reducing the burden on the testers doing the manual execution so that they can focus on the functional aspects of the application. Generally, a smoke, sanity, regression test suite is created for this purpose. The advantage of having automatic triggering through Jenkins is that it facilitates test execution in an unattended mode.

We will be using version 3.13, which is the latest version of Selenium at the time of writing this book. It has developed a lot from its early ancestor, Selenium 1. Selenium RC was another tool that would let you write automated web application UI tests in programming languages such as Java, C#, Python, Ruby, and so on, against a HTTP website using any JavaScript enabled browser. For the coding part, we will be working with Java 8. Learning with Java can be fun and at the same time, fast.

Up until Java 7, we only had object-oriented features in Java. Java 8 has added many new features. Some of these features are as follows:

• Lambda expressions and functional interfaces
• Default and static methods in interfaces
• The forEach() method in iterable interfaces
• The Java Stream API for bulk data operations on collections

Don't worry if you find this intimidating. We will slowly uncover Java 8 as we progress throughout this book.

Lambda expressions are essential in functional programming. Lambda expressions are constructs that exist in a standalone fashion and not as a part of any class. One particular scenario where Lambda expressions can be used is while creating classes which consist of just a single method. Lambda expressions, in this case, help to be an alternative to anonymous classes (classes without names), which might not be feasible in certain situations. We will briefly look at two examples, side by side, of how we can convert a conventional Java snippet into a Lambda expression.

In the following code, we will assign a method to a variable called blockofCodeA. This is just what we are intending to solve with the means of Lambda expressions:

blockofCodeA = public void demo(){ System.out.println("Hello World");
}

The same piece of code can be written using Lambda expressions, as shown here:

blockofCodeA = () -> {                                 
    System.out.println("Hello World");
}

Remove the name, return type, and the modifier, and simply add the arrow after the brackets. This becomes your Lambda expression.

Functional interfaces contain one—and only one—abstract method. An abstract method is one which should have a body in the implementation class if the implementation class is not abstract. It can have any number of regular methods (methods which have a body in the implementation classes), but the prerequisite of a functional interface is that the number of abstract methods must be only one. These interfaces are used hand-in-hand with Lambda expressions.

In the following code block, the demo method is inside an interface Greeting. Therefore, this interface should only have one abstract method, which is the demo method. In order to instruct other users that this is a functional interface, we annotate this interface with the @FunctionalInterface annotation.

The type of blockofCodeA will be of this functional interface type. This annotation is optional:

@FunctionalInterface
public interface Greeting {
        public void demo();
}

Up until Java 1.7, it was not possible to define a method inside an interface. Now, 1.8 introduces the default methods through which we can provide implementation for a method inside the interface. Let's see an example of this here:

interface Phone{
 void dial();
 default void text() { 
 System.out.println("Texting a message");
 }
}

Static methods in Java are those methods that can be invoked without creating an object of a particular class, provided that the static method is in that particular class. In Java 8, static methods can be defined inside an interface, as shown here:

interface Phone {
    inx x;
    void changeRingtone();
    static void text() {
        System.out.println("Texting");
    }
}
public class PhoneDemo {
    public static void main(String[] args) {
        Phone.text();
    }
}

You can invoke the text() method directly using the name of the interface.

Starting with Java 8, we can invoke the forEach method on a collection and iterate through the contents of the collection. Let's compare the 7 and 8 versions of iterating over an array list of strings.

The following code, which is from Jave 7, fetches individual fruit names from the fruits list and prints it to the console:

    List<String> fruits = Arrays.asList("Apples", "Oranges", "Bananas",
        "Pears");
    for (int i = 0; i < fruits.size(); i++) {
      System.out.println(fruits.get(i));
    }

A second alternative that you can use is as follows:

for (String fruit : fruits ){
    System.out.println(fruit);
}

The example shown here does the same thing in Java 8 using lambda expressions:

fruits.forEach(i -> System.out.println(i));

As per the Java documentation's definition:

Imagine a factory in which workers are standing with tools in their hands, and machine parts keep moving around so that the individual worker can do their part. Streams can be compared somewhat to such a scenario:

List<String> fruits = Arrays.asList("Apples","Oranges","Bananas","Pears");
fruits.stream().forEach(fruit -> System.out.println(fruit));

Selenium RC is a popular UI automation library for automating browsers. Selenium RC uses a generic form of JavaScript called Selenium Core to perform automation. However, this should comply with a security policy called the same-origin policy. The same-origin policy is a security measure that prevents website scripts from accessing the scripts of other websites. For example, JavaScript present on Google cannot access or communicate with JavaScript present on Yahoo. Three things are checked for the same-origin policy: the protocol, domain, and port. If these three things match, then only the request can be said as being one from the same domain.

Another concept related to same-origin policy is cross-site scripting. Cross-site scripting refers to the situation where a website can be prone to attacks from hackers. A typical hacker injects one or more JavaScript codes into web pages that are being browsed. These JavaScript codes can be malicious, and can pull cookie information from websites, pertaining to be banks, for example. This way, the malicious script bypasses the same-origin policy control.

Selenium RC consists of two parts:

• Selenium server
• Client libraries

The following diagram shows the functioning of Selenium RC, where the RC Server sits in-between the libraries like Java and Python and sends instructions to Selenium Core, thereafter operating on the individual browser:

The role of the Remote Control Server is to inject the Selenium Core in the respective browser. The client libraries send instructions in the form of requests to the RC Server, and the RC Server communicates this to the browser. After receiving a response, this is communicated back to the user by the RC Server.

Selenium WebDriver is used for automating web browsers by using the browser's internal plugins or dll with the individual browser drivers, which are available for each individual browser.

The following diagram shows the high-level functionality of Selenium WebDriver. The JSON API parses the instructions from languages like Java, Python, and so on, and invokes and operates on the concerned browser:

The following diagram is a snapshot of the class structure of Selenium WebDriver. The WebDriver interface is the parent of Remote WebDriver, which is a public class. Drivers for Internet Explorer, Firefox, Chrome, and so on inherit from the Remote WebDriver. In future chapters, we will be digging deep into these drivers:

We will now take a look at the various drivers that are available in Selenium and their usage.

Remote WebDriver is the implementation class of the WebDriver interface. Apart from WebDriver, it also implements the interfaces of TakesScreenShot, findBy, JavaScriptExecutor, and so on.

All modern web apps have implementations for mobile devices. The two most popular operating systems in mobile devices are Android and iOS. Selenium has implementations for Android and iPhone, that is, AndroidDriver and IODDriver. Both of these are direct implementations of WebDriver.

Headless browsers are those that do not have a graphical user interface (GUI). Everything runs in the background. When a test is executed with a headless browser, no screen is displayed to the user. Two popular headless browsers are HTMLUnit and Phantom JS. Chrome now supports the HTMLUnit browser.

Suppose that Selenium tests have to be executed on an OS which does not have a GUI like Linux or when multiple browser behaviors have to be simulated on just one machine. The advantage of a headless browser is that the resources utilized by the test are minimal. A scenario where you can use these browsers is for test data creation. In these situations, there is no special need to display the screen to the user.

Follow the steps shown here to get started with Selenium WebDriver.

Follow the instructions below to install Java 8:

1. Go to http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html and click on the appropriate version. I have selected the 64-bit Windows version since mine is a Windows machine.
2. Once the file has downloaded, run the .exe file. Java will start installing it onto your machine. Next, we have to set two environment variables in order to use Java.
3. Go to Control Panel and click Advanced System Settings.
4. Click on Environment variables and add two system variables:
   • One is JAVA_HOME. Provide the path of the root folder where Java is installed. In this case, this will be C:\Program Files\Java\jdk1.8.0_152.
   • The second is the Path variable. Remember that this variable has to be appended after adding a ;. Here, the path of the bin folder has to be specified. In this case, this will be C:\Program Files\Java\jdk1.8.0_152\bin.
5. The next step is to check our configuration. Open the Command Prompt and type java –version:

If you get an output similar to the one shown in the preceding screenshot, you are all set to start coding.

Now, let's get our hands dirty!

We will be using Eclipse as an IDE for developing Selenium Scripts in this book, but you are free to use whichever IDE suits you best.

Navigate to the Eclipse website (www.eclipse.org/ide) and click on the Download link. Here, you can find very specific instructions regarding how to install you favourite IDE version (Kepler, Neon, and so on).

Once the IDE is installed, perform the following steps:

1. Double click on the .exe file for Eclipse and go to File | New | Other.
2. Select Maven Project. Click Next.
3. Click Next on the screen that appears.
4. Select Create a simple project (skip archetype selection). Then, click Next.
5. Input the Group ID. Ideally, this is the package name of the project. The Artifact ID corresponds to the name of the JAR file in case you want to create one. Keep the packaging as JAR. Notice that the version is 0.0.1-SNAPSHOT. The SNAPSHOT part indicates that the project is still under development and has not been released.

6. Click Finish. The following is a snapshot of the Project Explorer:

When you create a Maven Project, the src/main/java, src/main/resources, src/test/java, and src/test/resources folders, are created for you. Apart from these, you will see a Maven Dependencies folder that is currently empty. Marked with a black box, there is a .xml file called pom.xml. This is the place where you will place all of the dependencies for your project. By dependencies, I mean dependent JARs. JAR stands for Java archive.

It's time to explore pom.xml. This is what pom.xml looks like:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>org.packt.selenium</groupId>
 <artifactId>FirstSelenium</artifactId>
 <version>0.0.1-SNAPSHOT</version>
</project>

Group ID and Artifact ID that you added in the previous screens have appeared in the preceding file, inside the Project tag. In order to work with Selenium, we will need to add Selenium dependencies within the Project tag. Let's go ahead and add those from the Maven repository:

1. Go to the Maven repository (https://mvnrepository.com) and grab the dependency shown here:

      <!-- 
      https://mvnrepository.com/artifact/org.seleniumhq.selenium/
      selenium-java -->
      <dependency>
          <groupId>org.seleniumhq.selenium</groupId>
          <artifactId>selenium-java</artifactId>
          <version>3.13.0</version>
      </dependency>

2. Place this dependency inside a dependencies tag, as shown in the pom.xml file here:

      <project xmlns="http://maven.apache.org/POM/4.0.0"    
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
      http://maven.apache.org/xsd/maven-4.0.0.xsd">
          <modelVersion>4.0.0</modelVersion>
          <groupId>org.packt.selenium</groupId>
          <artifactId>FirstSelenium</artifactId>
          <version>0.0.1-SNAPSHOT</version>
          <dependencies> 
              <!-- 
      https://mvnrepository.com/artifact/org.seleniumhq.selenium/
      selenium-java -->
               <dependency>
                  <groupId>org.seleniumhq.selenium</groupId>
                  <artifactId>selenium-java</artifactId>
                  <version>3.13.0</version>
              </dependency>
           </dependencies>
      </project>

3. Save the pom.xml. You will see a small activity in the bottom-right corner of Eclipse, stating that the project is being built.

The Maven Dependencies folder now gets populated with all of the downloaded JARs, as shown previously.

With this, we are ready, and have the basic Eclipse setup for Selenium WebDriver. But we are not done yet. It might occur that, under a corporate firewall, you are unable to download the required JARS. In this situation, perform the following steps:

1. Simply create a plain Java project.
2. Right -click on the project in Project Explorer.
3. Select Build Path | Configure Build Path.
4. Click on Add External JARs and add the required JARs manually.
5. Next, we will write a very simple script which just opens www.google.com (this is shown in the following section). Right-click the Project and select new class.

Type the following code. What the following script does is simply opens a new Chrome browser and navigates to the URL http://www.google.com:

public class FirstTest {
    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver",
                       "C:\\SeleniumWD\\src\\main\\resources\\chromedriver.exe");
        WebDriver driver = new ChromeDriver();
        driver.get("http://www.google.com");
    }
}

Right-click the file and click Run as Java Application and hurrah! A chrome browser opens and http://www.google.com gets loaded.

You have successfully created your first Selenium Script.

This chapter gave you an idea of what Selenium RC and WebDriver are and also touched upon concepts like same-origin policy and cross-site scripting. We also did a basic Eclipse setup using Maven as well as without Maven, and finally we created a very simple program to open a URL in the browser.

In Chapter 2, Understanding the Document Object Model and Creating Customized XPaths, we will learn about the Document Object Model and its various traversal techniques.