Selenium Webdriver Practical Guide

selenium%20webdriver%20practical%20guide

User Manual:

Open the PDF directly: View PDF .
Page Count: 264 [warning: Documents this large are best viewed by clicking the View PDF Link!]

Community

Experience

Distilled

Selenium

WebDriver

Practical

Guide

Interactively

automate

web

applications

using

Selenium

WebDriver

sourceÿ

open

community

experience

cTistHied

Satya

Avasarala

PACKT

PUBLISHING

Selenium WebDriver

Practical Guide

Interactively automate web applications using

Selenium WebDriver

Satya Avasarala

BIRMINGHAM - MUMBAI

source

open

community

experience

distilled

PUBLISHING

Selenium WebDriver Practical Guide

system, or transmitted in any form or by any means, without the prior written

permission of the publisher, except in the case of brief quotations embedded in

critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy

of the information presented. However, the information contained in this book is

sold without warranty, either express or implied. Neither the author, nor Packt

Publishing, and its dealers and distributors will be held liable for any damages

caused or alleged to be caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the

companies and products mentioned in this book by the appropriate use of capitals.

However, Packt Publishing cannot guarantee the accuracy of this information.

First published: January 2014

Production Reference: 1170114

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham B3 2PB, UK.

ISBN 978-1-78216-885-0

www.packtpub.com

Cover Image by Prashant Timappa Shetty (sparkling.spectrum.123@gmail.com)

Credits

Author

Satya Avasarala

Reviewers

Anuj Chaudhary

David Askirk Fotel

Daniel Lam

Ripon Al Wasim

Acquisition Editors

Anthony Albuquerque

Richard Harvey

Lead Technical Editor

Priya Singh

Technical Editors

Dennis John

Venu Manthena

Gaurav Thingalaya

Copy Editors

Tanvi Gaitonde

Kirti Pai

Adithi Shetty

Project Coordinator

Amey Sawant

Proofreader

Clyde Jenkins

Indexers

Hemangini Bari

Monica Ajmera Mehta

Rekha Nair

Priya Subramani

Graphics

Yuvraj Mannari

Abhinash Sahu

Production Coordinator

Aparna Bhagat

Cover Work

Aparna Bhagat

About the Author

Satya Avasarala has rich experience in Java development and automation testing.

He is an engineer in computer science. He has used WebDriver for many years

now and has created several good automation frameworks. He has worked at

various large software enterprises such as Oracle Corp, Yahoo! Inc., VMware Inc.,

and the REA Group.

In addition, he is also interested in Service Oriented Architectural design and

%XVLQHVV,QWHOOLJHQFH+HLVDQ2UDFOHFHUWLÀHG6HUYLFH2ULHQWHG$UFKLWHFWXUH

Infrastructure Implementation Expert and a Business Intelligence Foundation

Suite Implementation Specialist.

I would like to thank all my acquisition editors, technical editors,

and project coordinators for constantly supporting me in completing

this book. I should also thank my colleagues, Pratik Patil and Kerri

Rusnak, for their constant encouragement and support in writing

this book. Last but not least, I would like to thank my wife, Swathi

9HQQHODJDQWLIRUVDFULÀFLQJPDQ\ZHHNHQGVZKLOH,ZDVEXV\

writing this book. Without all these people, this book wouldn't have

been a reality.

About the Reviewers

Anuj Chaudhary is a software engineer who enjoys working on software testing

and automation. He has a vast experience with various testing methodologies such

as manual testing, automated testing, performance testing, and security testing. He

has worked as an individual contributor and technical lead on various software

projects dealing with all of the stages in the application development life cycle.

He has been awarded the title of Microsoft MVP twice in a row. He writes a blog that

you can visit at www.anujchaudhary.com.

I would like to thank and congratulate the Packt Publishing team for

publishing this awesome book.

David Askirk Fotel has worked with computers since his parents brought

home an old, used IBM PS/2. He started his development career writing simple

programs in QBasic and later in Pascal. From there, he moved on to writing

programs in C. Later on, he moved on to Java and other languages. His greatest

experience so far was with Lisp, which had a great impact on his programming

style and approach to code.

David has worked on test-driven development and as a test manager, implementing

Selenium tests on an e-learning system.

7KLVERRNLVWKHÀUVWRQZKLFK'DYLGKDVZRUNHGEXWZLOOQRWEHWKHODVW

Daniel Lam is an Agile Test Developer with experience in open and closed source

test tools. He specializes in Java, Selenium WebDriver, Continuous Integration, and

BDD test frameworks.

Ripon Al Wasim is a software engineer living in Dhaka, Bangladesh. He has 12

years' experience in the software industry, three years in software development,

and nine years in software testing (both manual and automated). He has also been

involved in conducting software testing courses in various companies. He has

worked for clients in various countries such as Japan, USA, Finland, Norway, and

Bangladesh.

Ripon started participating in posting professional questions and answers on Stack

2YHUÁRZLQWKH\HDUDWhttp://stackoverflow.com/users/617450/ripon-

al-wasim.

5LSRQLVD6XQ&HUWLÀHG-DYD3URJUDPPHU6&-3+HLV-DSDQHVH/DQJXDJH

3URÀFLHQF\7HVW-/37/HYHOFHUWLÀHGDQGLVDOLWWOHIDPLOLDUZLWK-DSDQHVHFXOWXUH

DVKHVWD\HGLQ-DSDQIRURQH\HDUDVDQ,7SURIHVVLRQDO7KLVERRNLV5LSRQVÀUVW

RIÀFLDOHIIRUW

I would like to thank my mother and wife for fostering a helping

and inspiring environment at home so I could study and review.

I am also deeply thankful and grateful to Cefalo Amravi Ltd.

(http://cefalo.com/en), my current company, for providing me

a good opportunity to work with automated testing using Selenium

WebDriver. I would like to thank Yves Hwang, Product Manager

at Varnish Software (https://www.varnish-software.com/) and

Partha Guha Roy, CTO of Cefalo Amravi Ltd. for providing technical

assistance during my project work.

www.PacktPub.com

6XSSRUW¿OHVH%RRNVGLVFRXQWRIIHUVDQGPRUH

You might want to visit www.PacktPub.comIRUVXSSRUWÀOHVDQGGRZQORDGVUHODWHG

to your book.

Did you know that Packt offers eBook versions of every book published, with PDF

DQGH3XEÀOHVDYDLODEOH"<RXFDQXSJUDGHWRWKHH%RRNYHUVLRQDWwww.PacktPub.

com and as a print book customer, you are entitled to a discount on the eBook copy.

Get in touch with us at service@packtpub.com for more details.

At www.PacktPub.com, you can also read a collection of free technical articles, sign

up for a range of free newsletters and receive exclusive discounts and offers on Packt

books and eBooks.

http://PacktLib.PacktPub.com

'R\RXQHHGLQVWDQWVROXWLRQVWR\RXU,7TXHVWLRQV"3DFNW/LELV3DFNWVRQOLQHGLJLWDO

book library. Here, you can access, read and search across Packt's entire library

of books.

Why Subscribe?

 Fully searchable across every book published by Packt

 Copy and paste, print and bookmark content

 On demand and accessible via web browser

Free Access for Packt account holders

If you have an account with Packt at www.PacktPub.com, you can use this to access

PacktLib today and view nine entirely free books. Simply use your login credentials

for immediate access.

[TIPACKT

Table of Contents

Preface 1

Chapter 1: ,QWURGXFLQJ:HE'ULYHUDQG:HE(OHPHQWV 

8QGHUVWDQGLQJWKHKLVWRU\RI6HOHQLXP 

Selenium 1 or Selenium Remote Control or Selenium RC 9

Selenium 2 or Selenium WebDriver or WebDriver 12

Differences between Selenium 1 and Selenium 2 13

Handling the browser 14

Having better APIs 14

Testing mobile apps 14

Having developer support and advanced functionalities 14

Setting up a project in Eclipse 15

:HE(OHPHQWV 

Locating WebElements using WebDriver 21

7KH¿QG(OHPHQWPHWKRG 

7KH¿QG(OHPHQWVPHWKRG 

Firebug 22

Using the By locating mechanism 23

Actions on WebElements 32

7KHJHW$WWULEXWHPHWKRG 

7KHVHQG.H\VPHWKRG 

7KHFOHDUPHWKRG 

7KHVXEPLWPHWKRG 

7KHJHW&VV9DOXHPHWKRG 

7KHJHW/RFDWLRQPHWKRG 

7KHJHW6L]HPHWKRG 

7KHJHW7H[WPHWKRG 

7KHJHW7DJ1DPHPHWKRG 

7KHLV'LVSOD\HGPHWKRG 

7KHLV(QDEOHGPHWKRG 

7KHLV6HOHFWHGPHWKRG 

6XPPDU\ 

Table of Contents

[ ii ]

&KDSWHU([SORULQJ$GYDQFHG,QWHUDFWLRQVRI:HE'ULYHU 

8QGHUVWDQGLQJDFWLRQVEXLOGDQGSHUIRUP 

/HDUQLQJPRXVHEDVHGLQWHUDFWLRQV 

7KHPRYH%\2IIVHWDFWLRQ 

7KHFOLFNDWFXUUHQWORFDWLRQDFWLRQ 

The click on a WebElement action 49

7KHFOLFN$QG+ROGDWFXUUHQWORFDWLRQDFWLRQ 

7KHFOLFN$QG+ROGD:HE(OHPHQWDFWLRQ 

7KHUHOHDVHDWFXUUHQWORFDWLRQDFWLRQ 

7KHUHOHDVHRQDQRWKHU:HE(OHPHQWDFWLRQ 

7KHPRYH7R(OHPHQWDFWLRQ 

7KHGUDJ$QG'URS%\DFWLRQ 

7KHGUDJ$QG'URSDFWLRQ 

7KHGRXEOH&OLFNDWFXUUHQWORFDWLRQDFWLRQ 

7KHGRXEOH&OLFNRQ:HE(OHPHQWDFWLRQ 

7KHFRQWH[W&OLFNRQ:HE(OHPHQWDFWLRQ 

7KHFRQWH[W&OLFNDWFXUUHQWORFDWLRQDFWLRQ 

/HDUQLQJNH\ERDUGEDVHGLQWHUDFWLRQV 

7KHNH\'RZQDQGNH\8SDFWLRQV 

7KHVHQG.H\VPHWKRG 

6XPPDU\ 

&KDSWHU([SORULQJWKH)HDWXUHVRI:HE'ULYHU 

6HWWLQJWKHGHVLUHGFDSDELOLWLHVIRUDEURZVHU 

7DNLQJVFUHHQVKRWV 

/RFDWLQJWDUJHWZLQGRZVDQGL)UDPHV 

6ZLWFKLQJDPRQJZLQGRZV 

6ZLWFKLQJDPRQJIUDPHV 

+DQGOLQJDOHUWV 

([SORULQJ1DYLJDWH 

:DLWLQJIRU:HE(OHPHQWVWRORDG 

,PSOLFLWZDLWWLPH 

([SOLFLWZDLWWLPH 

+DQGOLQJFRRNLHV 

6XPPDU\ 

&KDSWHU'LIIHUHQW$YDLODEOH:HE'ULYHUV 

)LUHIR['ULYHU 

8QGHUVWDQGLQJWKH)LUHIR[SUR¿OH 

$GGLQJWKHH[WHQVLRQWR)LUHIR[ 

6WRULQJDQGUHWULHYLQJDSUR¿OH 

'HDOLQJZLWK)LUHIR[SUHIHUHQFHV 

6HWWLQJSUHIHUHQFHV 

Understanding frozen preferences 91

Table of Contents

[ iii ]

Firefox binary 93

Installing multiple versions of Firefox 93

,QWHUQHW([SORUHU'ULYHU 

,QVWDOOLQJ,QWHUQHW([SORUHU'ULYHU 

:ULWLQJ\RXU¿UVWWHVWVFULSWIRUWKH,(EURZVHU 

%XLOGLQJWKH,QWHUQHW([SORUHUGULYHUVHUYLFH 

8QGHUVWDQGLQJ,('ULYHUFDSDELOLWLHV 

&KURPH'ULYHU 

,QVWDOOLQJ&KURPH'ULYHU 

:ULWLQJ\RXU¿UVWWHVWVFULSWIRUWKH&KURPHEURZVHU 

8VLQJ&KURPH2SWLRQV 

6DIDUL'ULYHU 

:ULWLQJ\RXU¿UVWWHVWVFULSWIRUWKH6DIDULEURZVHU 

2SHUD'ULYHU 

,QVWDOOLQJ2SHUD'ULYHU 

:ULWLQJ\RXU¿UVWWHVWVFULSWIRUWKH2SHUDEURZVHU 

6XPPDU\ 

Chapter 5: 8QGHUVWDQGLQJ:HE'ULYHU(YHQWV 

,QWURGXFLQJ(YHQW)LULQJ:HE'ULYHUDQG(YHQW/LVWHQHUFODVVHV 

&UHDWLQJDQLQVWDQFHRI(YHQW/LVWHQHU 

,PSOHPHQWLQJ:HE'ULYHU(YHQW/LVWHQHU 

([WHQGLQJ$EVWUDFW:HE'ULYHU(YHQW/LVWHQHU 

&UHDWLQJD:HE'ULYHULQVWDQFH 

&UHDWLQJ(YHQW)LULQJ:HE'ULYHUDQG(YHQW/LVWHQHULQVWDQFHV 

5HJLVWHULQJ(YHQW/LVWHQHUZLWK(YHQW)LULQJ:HE'ULYHU 

Executing and verifying the events 119

5HJLVWHULQJPXOWLSOH(YHQW/LVWHQHUV 

([SORULQJGLIIHUHQW:HE'ULYHUHYHQWOLVWHQHUV 

Listening for WebElement value change 121

Listening for WebElement clicked 122

Listening for a WebElement search event 122

Listening for browser back navigation 122

Listening for browser forward navigation 123

Listening for browser navigateTo events 123

Listening for script execution 123

Listening for any exception 124

Unregistering EventListener with EventFiringWebDriver 124

6XPPDU\ 

Table of Contents

[ iv ]

&KDSWHU'HDOLQJZLWK,2 

/HDUQLQJDERXWWKH)LOH+DQGOHUFODVV 

&RS\LQJ¿OHVIURPWKHVRXUFHWRWKHGHVWLQDWLRQGLUHFWRU\ 

&RS\LQJ¿OHVIURPWKHVRXUFHWRWKHGHVWLQDWLRQGLUHFWRU\EDVHG

RQ¿OHQDPHVXI¿[ 

&UHDWLQJDGLUHFWRU\ 

'HOHWLQJD¿OHRUGLUHFWRU\ 

8QGHUVWDQGLQJWKH,V=LSSHGPHWKRG 

8QGHUVWDQGLQJWKHPDNH([HFXWDEOHPHWKRG 

8QGHUVWDQGLQJWKHPDNH:ULWDEOHPHWKRG 

5HDGLQJD¿OH 

8QGHUVWDQGLQJWKHFDQ([HFXWHPHWKRG 

/HDUQLQJDERXWWKH7HPSRUDU\)LOHV\VWHPFODVV 

8QGHUVWDQGLQJWKHGHIDXOWWHPSRUDU\¿OHV\VWHP 

Creating a directory in DefaultTmpFS 133

Deleting a temporary directory 134

'HOHWLQJPXOWLSOH¿OHV 

&KDQJLQJWKHWHPSRUDU\¿OHV\VWHP 

/HDUQLQJDERXWWKH=LSFODVV 

&RPSUHVVLQJDGLUHFWRU\ 

'HFRPSUHVVLQJDGLUHFWRU\ 

6XPPDU\ 

&KDSWHU([SORULQJ5HPRWH:HE'ULYHUDQG

:HE'ULYHU%DFNHG6HOHQLXP 

,QWURGXFLQJ5HPRWH:HE'ULYHU 

Understanding the RemoteWebDriver server 141

Downloading the server 141

Running the server 141

Understanding the RemoteWebDriver client 143

Converting an existing test script to use RemoteWebDriver server 143

8VLQJ5HPRWH:HE'ULYHUIRUWKH)LUHIR[EURZVHU 

Using RemoteWebDriver and the IE browser 149

8VLQJ5HPRWH:HE'ULYHUDQGWKH&KURPHEURZVHU 

([WHQGLQJWKH5HPRWH:HE'ULYHUFOLHQWWRWDNHVFUHHQVKRWV 

8QGHUVWDQGLQJWKH-621ZLUHSURWRFRO 

5HSODFLQJWKHFOLHQWOLEUDU\ZLWK\RXURZQFRGH 

([SORULQJ:HE'ULYHU%DFNHG6HOHQLXP 

6XPPDU\ 

Table of Contents

[ v ]

&KDSWHU8QGHUVWDQGLQJ6HOHQLXP*ULG 

([SORULQJ6HOHQLXP*ULG 

8QGHUVWDQGLQJWKHKXE 

8QGHUVWDQGLQJWKHQRGH 

0RGLI\LQJWKHH[LVWLQJWHVWVFULSWWRXVH6HOHQLXP*ULG 

5HTXHVWLQJIRUQRQUHJLVWHUHGFDSDELOLWLHV 

4XHXLQJXSWKHUHTXHVWLIWKHQRGHLVEXV\ 

'HDOLQJZLWKWZRQRGHVZLWKPDWFKLQJFDSDELOLWLHV 

&RQ¿JXULQJ6HOHQLXP*ULG 

6SHFLI\LQJQRGHFRQ¿JXUDWLRQSDUDPHWHUV 

6HWWLQJVXSSRUWHGEURZVHUVE\DQRGH 

6HWWLQJQRGHWLPHRXWV 

6HWWLQJWKHOLPLWRQEURZVHULQVWDQFHV 

5HUHJLVWHULQJWKHQRGHDXWRPDWLFDOO\ 

6HWWLQJQRGHKHDOWKFKHFNWLPH 

8QUHJLVWHULQJDQXQDYDLODEOHQRGH 

6HWWLQJWKHEURZVHUWLPHRXW 

+XEFRQ¿JXUDWLRQSDUDPHWHUV 

:DLWLQJIRUDPDWFKRIGHVLUHGFDSDELOLW\ 

&XVWRPL]HG&DSDELOLW\0DWFKHU 

:DLW7LPHRXWIRUDQHZVHVVLRQ 

'LIIHUHQWZD\VWRVSHFLI\WKHFRQ¿JXUDWLRQ 

6XPPDU\ 

&KDSWHU8QGHUVWDQGLQJ3DJH2EMHFW3DWWHUQ 

&UHDWLQJWHVWFDVHVIRURXU:RUG3UHVVEORJ 

Test case 1 – Adding a new post to our WordPress blog 192

Test case 2 – Deleting a post from our WordPress blog 193

Test case 3 – Counting the number of posts on our WordPress blog 194

:KDWLVWKH3DJH2EMHFWSDWWHUQ" 

8VLQJWKH#)LQG%\DQQRWDWLRQ 

8QGHUVWDQGLQJ3DJH)DFWRU\ 

*RRGSUDFWLFHVIRUWKH3DJH2EMHFWVGHVLJQ 

Consider a web page as a services provider 199

$OZD\VORRNIRULPSOLHGVHUYLFHV 

8VLQJ3DJH2EMHFWVZLWKLQD3DJH2EMHFW 

7KH$GG1HZ3RVW3DJH2EMHFW 

7KH$OO3RVWV3DJH3DJH2EMHFW 

&RQVLGHUPHWKRGVLQ3DJH2EMHFWVDVVHUYLFHVDQGQRWDV8VHU$FWLRQV 

,GHQWLI\LQJVRPH:HE(OHPHQWVRQWKHÀ\ 

.HHSLQJWKHSDJHVSHFL¿FGHWDLOVRIIWKHWHVWVFULSW 

8QGHUVWDQGLQJORDGDEOHFRPSRQHQWV 

Table of Contents

[ vi ]

:RUNLQJRQDQHQGWRHQGH[DPSOHRI:RUG3UHVV 

/RRNLQJDWDOOWKH3DJH2EMHFWV 

7KH$GPLQ/RJLQ3DJH3DJH2EMHFW 

7KH$OO3RVWV3DJH3DJH2EMHFW 

The AddNewPostPage PageObject 213

The EditPostPage PageObject 213

The DeletePostPage PageObject 214

/RRNLQJDWWKHWHVWFDVHV 

$GGLQJDQHZSRVW 

(GLWLQJDSRVW 

'HOHWLQJDSRVW 

&RXQWLQJSRVWV 

6XPPDU\ 

&KDSWHU7HVWLQJL26DQG$QGURLG$SSV 

'LIIHUHQWIRUPVRIPRELOHDSSOLFDWLRQV 

$YDLODEOHVRIWZDUHWRROV 

$XWRPDWLQJL26DQG$QGURLGWHVWVXVLQJ$SSLXP 

Automating iOS application tests 224

$XWRPDWLQJ$QGURLGDSSOLFDWLRQWHVWV 

3UHUHTXLVLWHVIRU$SSLXP 

6HWWLQJXS;FRGH 

6HWWLQJXS$QGURLG6'. 

Installing Appium 231

Automating for iOS 232

$XWRPDWLQJIRU$QGURLG 

6XPPDU\ 

,QGH[ 

Preface

This book is about Selenium WebDriver, also known as Selenium 2, which is a UI

automation tool used by software developers and QA engineers to test their web

application on different web browsers. The reader is expected to have a basic idea

of programming, preferably using Java, because we take the reader through several

features of WebDriver using code examples. This book can be used as a reference for

your day-to-day usage of WebDriver.

What this book covers

Chapter 1, Introducing WebDriver and WebElementsZLOOVWDUWRIIE\EULHÁ\GLVFXVVLQJ

the history of Selenium and the differences between Selenium 1 and Selenium 2.

Then, we quickly jump into WebDriver by describing how it perceives a web page.

We will also look at what a WebDriver's WebElement is. Then, we talk about locating

WebElements on a web page and performing some basic actions on them.

Chapter 2, Exploring Advanced Interactions of WebDriver, will dive deeply into more

advanced actions that WebDriver can perform on the WebElements of a web page,

such as the dragging-and-dropping of elements from one frame of a page to another

DQGULJKWFRQWH[WFOLFNLQJRQ:HE(OHPHQWV:HUHVXUH\RXZLOOÀQGWKLVFKDSWHU

interesting to read.

Chapter 3, Exploring the Features of WebDriver, will talk about some advanced features

of WebDriver, such as taking screenshots of web pages, executing JavaScript, and

handling cookies and proxies.

Preface

[]

Chapter 4, Different Available WebDrivers, will talk about various implementations of

WebDriver, such as FirefoxDriver, IEDriver, and ChromeDriver. When we discuss

WebDriver in Chapter 1, Introducing WebDriver and WebElements, we will see that

:HE'ULYHUKDVVSHFLÀFLPSOHPHQWDWLRQVIRUPRVWRIWKHSRSXODUEURZVHUVDYDLODEOH

on the market.

Chapter 5, Understanding WebDriver Events, will deal with the event-handling aspect

of WebDriver. To state a few, events can be a value change on a WebElement,

a browser back-navigation invocation, script execution completion, and so on.

Chapter 6, Dealing with I/OZLOOLQWURGXFH\RXWRWKHÀOHKDQGOLQJIHDWXUHVRI

:HE'ULYHU&RQFHSWVVXFKDVFRS\LQJÀOHVXSORDGLQJÀOHVDQGGHOHWLQJÀOHVZLOO

be discussed in this chapter.

Chapter 7, Exploring RemoteWebDriver and WebDriverBackedSelenium, will

deal with two very important topics of WebDriver: RemoteWebDriver and

WebDriverBackedSelenium. If you want to execute a WebDriver installed on a

different machine from your machine, you can use the RemoteWebDriver class

to handle all your commands for that remote machine. One of its popular use cases

is browser compatibility testing. The other class we talk about in this chapter is

WebDriverBackedSelenium. This is useful for people who want to use WebDriver,

but still have many of their existing tests using Selenium 1. Finally, we will migrate

some code using Selenium1 APIs to use WebDriver APIs.

Chapter 8, Understanding Selenium Grid, will talk about one important and interesting

feature of Selenium named Selenium Grid. Using this, you can submit your

developed automation scenarios to a server and specify there the target platform,

that is, the OS, browser type, and version, upon which you want these scenarios

WREHH[HFXWHG,IDQRGHZLWKVXFKDFRQÀJXUDWLRQLVUHJLVWHUHGDQGDYDLODEOHWKH

server will dispatch your job to that node, and it will take care of executing your

automation scenarios in its environment and publish the results back to the server.

Chapter 9, Understanding PageObject Pattern, will talk about a well-known design

pattern named the PageObject pattern. This is a proven pattern that will give you

a better handle on your automation framework and scenarios.

Chapter 10, Testing iOS and Android Apps, we will take you through how WebDriver

can be used to automate your test scripts for iOS and Android applications. We will

also discuss a recently developed software tool called Appium.

By the end of this book, we are sure you will be one of the world's advanced

WebDriver users.

Preface

[]

What you need for this book

The following sections describe the installation of components required to work with

the code in this book.

Installing Java

In this book, all the code examples that we show covering various features of

WebDriver will be in Java. To follow these examples and write your own code, you

need Java Development Kit installed on your computer. The latest version of JDK

can be downloaded from the following link:

http://docs.oracle.com/javase/7/docs/webnotes/install/windows/jdk-

installation-windows.html

A step-by-step installation guide is available at the following link:

http://docs.oracle.com/javase/7/docs/webnotes/install/windows/jdk-

installation-windows.html

Installing Eclipse

This book is a practical guide that expects the user to write and execute WebDriver

examples. For this, it would be handy to install a Java IDE. You can install your

favorite IDE. Here, I am installing Eclipse. It can be downloaded from the

following link:

http://www.eclipse.org/downloads/packages/eclipse-ide-java-

developers/junosr2

Installing Firefox

Most of the work in this book will be done using Firefox. However, we do talk

about other browsers and their respective drivers in Chapter 4, Different Available

WebDrivers. We will work with Firefox 17.0.1, which has been tested and tried

against WebDriver 2.33.0. It can be downloaded from the following link:

https://ftp.mozilla.org/pub/mozilla.org/firefox/releases/17.0.1/

Installing Firebug

Firebug is one of the add-ons of Firefox. It is widely used to inspect HTML elements

on a web page. You can get Firebug from the following link:

https://getfirebug.com/

Preface

[]

$IWHULQVWDOODWLRQZKHQ\RXRSHQWKH)LUHIR[EURZVHU\RXVKRXOGVHHWKHÀUHEXJ

icon on the top-right corner of the browser, as shown highlighted in red in the

following screenshot:

Now, click on the Firebug icon to load the Firebug UI, as shown in the following

screenshot:

Firefox

Mozilla

Firefox

Start

Page

too

Website

firebug

mozilla

Google

Fast.

Smart.

Safe.

It's

never

been

easier

put

Firefox

your

Android

phone.

ft-

Downloads

Bookmarks

History

Add-ons

Sync

Settings

Mozilla

Firefox

Start

Page

<f*

Website

firebug

mozilla

Goggle

Fast.

Smart.

Safe.

It's

never

been

easier

put

Firefox

your

Android

phone.

* *

Oft

QnumlAailf-

fiAnkmaikt.

Cm,

Wirtnni

JWMÿnr.

•

Console

HTML

"•

CSS

Script

DOM

Net

Edit

body

html

Style

Computed

Layout

DOM

body

{

aboutHome.css

(line

10)

-muz

-box-

orient:

vertical;

background-

image:

url

(

"chrome

://brc

/content/abouthome

/noise

.png”)

linear-

gradient

(rgba

<255,

255,

0.7),

rgba

(255,

255, 255,

0.4));

display:

-moz-box;

height:

100%;

margin:

width:

100%;

<!DOCTYPS

haal>

<html

xmlns=”http://www-w3.org/1999/xhtml">

<head>

<body

dir=”ltr

<div

cla33=”spacer

"></div>

<div

id=”topSection”>

<div

class="spacer"></div>

<div

id=”launcher">

id="aboutMozilla"

href="http

//www.

mozilla

org/about/"x/a>

</bcdy>

</html>

Preface

[ 5 ]

Installing FirePath

After you have installed the Firebug add-on to Firefox, it's time to extend Firebug

to have something named FirePath. FirePath is used to get XPath and CSS values

of an HTML element on a web page. You can download FirePath from the

following location:

https://addons.mozilla.org/en-US/firefox/addon/FirePath/

After installation, you should see a new tab in the Firebug UI for FirePath, as shown

in the following screenshot:

Downloading WebDriver client library

(language bindings)

As discussed earlier, test scripts need a client library with which to interact, or

FRPPDQG:HE'ULYHUWRH[HFXWHVSHFLÀFXVHUHYHQWVDJDLQVWDZHEDSSOLFDWLRQ

being tested on a browser. For this, you need to download the WebDriver client

library. In this book, we use Java language bindings to create and execute our

automation scripts.

google.com.au

Google

if*

Google

Get

Google

faster.

Add

Google

your

start

screen.

Images

Maps

Play

YouTube

News

Gmail

Drive

Calendar

Sure

thanks

Goode

Australia

s>|

Console

HTML

CSS

Script

DOM

Net

FirePath

Top

Window

•

Highlight

XPath:

•

.//*[@id='gs_ttiO']

<div

id=”gbfwa"

class="gbqfwa

'*>

<div

id="gbqfqw"

class=''gbqfqw

gsfe_a">

<div

id="gbqfqwb"

clas3="gbqfqwc">

<table

id=”gs_idO''

class='’gstl_0

lst-t"

cellspacing=''0''

cellpadding="0"

style="height

27px;

padding:

Opx;

<tbody>

<tr>

<td

id="g3

ttcQ

3tyle="white-3pace

nowrap;"

dir="lbr"/>

<td

id=''g3_ttiO"

cla33="g3ib_an>

<td

cXas3=''gsib_b">

</tr>

</cbody>

</table>

</div>

matching

node

[5s

Preface

[]

At the time of writing this book, all the code examples are written based on Selenium

Java Version 2.33.0. It is recommended that you download that version from the

following location:

https://code.google.com/p/selenium/downloads/detail?name=selenium-

java-2.33.0.zip&can=2&q=

Downloading the Firefox Driver

The good news is that you have already downloaded the Firefox Driver. Yes, the

Firefox Driver comes along with client libraries. But, for other drivers, such as the

IE Driver, Safari Driver, Chrome Driver, and so on, you have to download them

explicitly from the following link:

http://docs.seleniumhq.org/download/

We will download them when we need to in Chapter 4, Different Available WebDrivers.

Who this book is for

If you are a quality assurance/testing professional, software developer, or web

application developer looking to create automation test scripts for your web

applications, this is the perfect guide for you! As a prerequisite, this book expects

you to have a basic understanding of Java programming, although any previous

knowledge of WebDriver or Selenium 1 is not needed. By the end of this book, you

will have acquired a comprehensive knowledge of WebDriver, which will help you

in writing your automation tests.

Conventions

,QWKLVERRN\RXZLOOÀQGDQXPEHURIVW\OHVRIWH[WWKDWGLVWLQJXLVKDPRQJGLIIHUHQW

kinds of information. Here are some examples of these styles, and an explanation of

their meaning.

&RGHZRUGVLQWH[WGDWDEDVHWDEOHQDPHVIROGHUQDPHVÀOHQDPHVÀOHH[WHQVLRQV

pathnames, dummy URLs, user input, and Twitter handles are shown as follows:

"The moveByOffset() method is used to move the mouse from its current position

to another point on the web page."

A block of code is set as follows:

public class NavigateToAUrl {

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

Preface

[]

driver.get("http://www.google.com");

}

When we wish to draw your attention to a particular part of a code block, the

relevant lines or items are set in bold:

public class GoogleSearchButtonByName {

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchBox = driver.findElement(By.name("btnK"));

searchBox.submit();

}

Any command-line input or output is written as follows:

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

http://172.16.87.131:1111/grid/register -registerCycle 10000

New terms and important words are shown in bold. Words that you see on the

screen, in menus or dialog boxes for example, appear in the text like this: "Open

Eclipse from the directory you have installed it in earlier. Navigate to File | New |

Java Project".

Warnings or important notes appear in a box like this.

Tips and tricks appear like this.

Reader feedback

Feedback from our readers is always welcome. Let us know what you think about

this book—what you liked or may have disliked. Reader feedback is important for us

to develop titles that you really get the most out of.

To send us general feedback, simply send an e-mail to feedback@packtpub.com,

and mention the book title via the subject of your message.

If there is a topic that you have expertise in and you are interested in either writing

or contributing to a book, see our author guide on www.packtpub.com/authors.

Preface

[]

&XVWRPHUVXSSRUW

Now that you are the proud owner of a Packt book, we have a number of things

to help you to get the most from your purchase.

'RZQORDGLQJWKHH[DPSOHFRGH

<RXFDQGRZQORDGWKHH[DPSOHFRGHÀOHVIRUDOO3DFNWERRNV\RXKDYHSXUFKDVHG

from your account at http://www.packtpub.com. If you purchased this book

elsewhere, you can visit http://www.packtpub.com/support and register to have

WKHÀOHVHPDLOHGGLUHFWO\WR\RX

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes

GRKDSSHQ,I\RXÀQGDPLVWDNHLQRQHRIRXUERRNV³PD\EHDPLVWDNHLQWKHWH[WRU

the code—we would be grateful if you would report this to us. By doing so, you can

save other readers from frustration and help us improve subsequent versions of this

ERRN,I\RXÀQGDQ\HUUDWDSOHDVHUHSRUWWKHPE\YLVLWLQJhttp://www.packtpub.

com/submit-errata, selecting your book, clicking on the errata submission form link,

DQGHQWHULQJWKHGHWDLOVRI\RXUHUUDWD2QFH\RXUHUUDWDDUHYHULÀHG\RXUVXEPLVVLRQ

will be accepted and the errata will be uploaded on our website, or added to any list of

existing errata, under the Errata section of that title. Any existing errata can be viewed

by selecting your title from http://www.packtpub.com/support.

Piracy

Piracy of copyright material on the Internet is an ongoing problem across all media.

At Packt, we take the protection of our copyright and licenses very seriously. If you

come across any illegal copies of our works, in any form, on the Internet, please

provide us with the location address or website name immediately so that we can

pursue a remedy.

Please contact us at copyright@packtpub.com with a link to the suspected

pirated material.

We appreciate your help in protecting our authors, and our ability to bring you

valuable content.

Questions

You can contact us at questions@packtpub.com if you are having a problem with

any aspect of the book, and we will do our best to address it.

Introducing WebDriver and

WebElements

,QWKLVFKDSWHUZHZLOOORRNEULHÁ\LQWRWKH6HOHQLXPKLVWRU\DQGSURFHHGWRWKH

basic components of a web page, WebElements. We will learn different ways to

locate WebElements on a web page and execute various user actions on them. We

will cover the following topics in this chapter:

 History of Selenium

 Difference between Selenium 1 and Selenium 2

 Setting up an Eclipse project to execute the example code

 Locating WebElements on a web page

 Actions that can be taken on the WebElements

8QGHUVWDQGLQJWKHKLVWRU\RI6HOHQLXP

Though this book is not intended to deal with Selenium 1, it is a good idea to know

EULHÁ\DERXWLWEHIRUHZHVWDUWRIIZLWK:HE'ULYHU,QWKLVZD\ZHFDQXQGHUVWDQG

how and why WebDriver has evolved.

6HOHQLXPRU6HOHQLXP5HPRWH&RQWURORU

6HOHQLXP5&

Selenium RC is a popular UI automation library, allowing developers and testers

to automate their interactions with a Web Application Under Test (WAUT) by

providing them with the necessary libraries, supported in multiple languages,

to program.

Introducing WebDriver and WebElements

[]

In terms of design, Selenium RC chose to use generic JavaScript named Selenium

Core to drive the WAUT on a browser. However, the decision of using generic

JavaScript that can drive the WAUT on any browser should comply with a security

policy named Same-Origin Policy. Every available browser in the market imposes

this policy on the websites that are loaded on it.

To know about this policy, we should take a closer look at how a browser executes

JavaScript loaded from a website. For every website that is loaded on it, the browser

creates a separate sandbox for the website's JavaScript, which restricts the JavaScript

to be executed only on it's respective website domain. This way, a JavaScript that

belongs to one website doesn't execute on another website that is currently loaded on

that browser. This security vulnerability, named Cross-site scripting, is the browser's

responsibility to restrict. So, coming back to Selenium RC, its generic JavaScript is

not allowed, by the browser, to execute on a website (WAUT) that is coming from

a different domain.

6RKRZGLG6HOHQLXP5&KDQGOHWKLV"7RRYHUFRPHWKLVVHFXULW\UHVWULFWLRQ

Selenium RC acts as an HTTP Proxy Server. When the test script asks to launch

a browser, Selenium RC server launches the browser and injects its JavaScript

(Selenium Core) into the browser. All the subsequent requests for the WAUT go

through Selenium RC (acting as an HTTP Proxy Server) to the actual web server

hosting WAUT. Thus making the browser think that the web application is being

served from the Selenium RC's server domain than the actual web server's domain

and allowing Selenium Core to execute and drive the web application.

Typically, it works in the following way:

1. A tester or a developer, through his/her test script, can command Selenium

RC server to perform certain actions on the WAUT on a certain browser. The

way the user can command Selenium RC to perform something is by using

the client libraries provided by Selenium RC. These libraries are provided

in different languages, such as Java, Ruby, Python, Perl, PHP, and .NET.

These commands, which are passed from the test scripts to Selenium RC,

are named Selenese commands. In a test script, you will have a set of

Selenese commands to test a scenario on the WAUT.

Chapter 1

[ 11 ]

2. Once the Selenium RC server receives the command from the test script, it

will launch the test script preferred browser, and while launching, it injects

the Selenium Core into the browser.

Test Script

using Client libraries

in Java, Python,

Ruby and so on., Selenium Remote Control Server

Browsers loaded with Selenium Core

JavaScript on them

Selenese Command

to launch browser

Launch

3. Upon loading on the browser, Selenium Core executes all the Selenese

commands from the test script, coming through Selenium RC, against the

WAUT. The browser doesn't restrict it, because it treats Selenium Core and

WAUT as a part of the same domain.

Test Script

using Client libraries

in Java, Python,

Ruby and so on., Selenium Remote Control Server

Selenese Command

to be executed on WAUT

Selenese Command

to be executed on WAUT

Selenium Core

Treated as same Domain

js WAUT

Introducing WebDriver and WebElements

[]

4. Now comes the HTTP Proxy part of the Selenium RC server. All the

requests and responses of the browser for WAUT go to the actual web

server via Selenium RC server, because the browser thinks Selenium RC

is serving WAUT.

Selenium Remote Control Server

(acting as HTTP Proxy)

Actual Web server hosting WAUT

Browser making request to Selenium RC

Request

Selenium Core

js WAUT

Response

Request Response

5. After execution, Selenium RC will send out the test result back to the test

script for developer's analysis.

6HOHQLXPRU6HOHQLXP:HE'ULYHURU

WebDriver

To overcome some of the limitations of Selenium 1, which we are going to discuss

shortly, WebDriver has come into existence for the following reasons:

 7RJLYHDEHWWHUFRQWURORQWKHEURZVHUE\LPSOHPHQWLQJEURZVHUVSHFLÀF

implementations.

 To give a better programming experience to the developer by adhering more

closely to the object-oriented programming fundamentals.

It works in the following way:

1. A tester or developer, through his/her test script, can command WebDriver to

perform certain actions on the WAUT on a certain browser. The way the user

can command WebDriver to perform something is by using the client libraries

or language bindings provided by WebDriver. These libraries are provided in

different languages, such as Java, Ruby, Python, Perl, PHP, and .NET.

wmm\

Chapter 1

[]

2. By using the language-binding client libraries, developers can invoke the

EURZVHUVSHFLÀFLPSOHPHQWDWLRQVRI:HE'ULYHUVXFKDV)LUHIR['ULYHU,(

Driver, Opera Driver, and so on, to interact with the WAUT on the respective

EURZVHU7KHVHEURZVHUVSHFLÀFLPSOHPHQWDWLRQVRI:HE'ULYHUZLOOZRUN

with the browser natively and execute commands from outside the browser

to simulate exactly how the application user does.

3. After execution, WebDriver will send out the test result back to the test script

for developer's analysis.

Test Script using WebDriver

Client libraries supported in

Java, Ruby, Python, and so on.

Request-Response

Browsers

Web Server hosting WAUT

Web river’sD

Browser specific-

Implementations

IE Driver

Firefox Driver

Chrome Driver

'LIIHUHQFHVEHWZHHQ6HOHQLXPDQG

6HOHQLXP

Now that we know how Selenium 1 and Selenium 2 are designed, let's quickly see

the differences between them.

Introducing WebDriver and WebElements

[]

Handling the browser

As we saw earlier, Selenium RC drives the browser from within the browser by

sitting in it as JavaScript (Selenium Core). All the events that are to be executed on

the WAUT go through Core. This kind of approach will come with some limitations,

such as:

 Core being limited within the JavaScript sandbox of the browser, as it needs

to comply with the Same-Origin policy.

 %HFDXVHWKLV-DYD6FULSWOLEUDU\LVJHQHULFDQGQRWVSHFLÀFWRDQ\SDUWLFXODU

browser, the developers of test scripts sometimes end up with a situation

where their test scripts execute very well on some browsers but not on

some other.

To overcome this limitation, WebDriver, on the other hand, handles the browser

from outside the browser. It has an implementation for each browser, and the

developer who wants to execute his/her tests on a particular browser should use

that particular implementation of WebDriver. This gives the test scripts a better

handle on the browser because these WebDriver implementations speak to the

browsers natively, thus increasing the robustness of the test scripts.

Having better APIs

WebDriver comes with a better set of APIs meeting the expectations of most

developers by being closer to the object-oriented programming in terms of

its implementation.

7HVWLQJPRELOHDSSV

8VLQJ:HE'ULYHUVPRELOHVSHFLÀFLPSOHPHQWDWLRQVVXFKDV,3KRQH'ULYHUDQG

AndroidDriver, developers can actually generate test scripts that can execute their

mobile applications on simulators/emulators and actual devices. Selenium RC

doesn't support mobile application testing.

Having developer support and advanced

functionalities

WebDriver is being actively developed over a period of time, and you can see many

advanced interactions with the web as well as mobile applications, such as File

Handling, Touch APIs, and so on. The API set of it is getting bigger and bigger

ZLWKORWVRIIHDWXUHVZKLFKZHUHQHYHUWKRXJKWDERXWLQ6HOHQLXP5&'HÀQLWHO\

it is the future!

Chapter 1

[ 15 ]

Setting up a project in Eclipse

Now, let's VHWXSRXUSURMHFWLQ(FOLSVHDQGZULWHRXUÀUVW piece of code to use

WebDriver and navigate to a web page. Please follow the sequence of the

following steps to create an Eclipse WebDriver project:

1. Open Eclipse from the directory you have installed it in earlier. Navigate

to File | New | Java Project.

2. A New Java Project dialog appears, as shown in the following screenshot.

Enter the project name of your choice, leave the rest to default, and

click Next.

New

Java

Project

Jte

Create

Java

Project

Create

Java

project

the

workspace

external

location.

Project

name:

Learning-WebDriver

Use

default

location

Location:

C:\workspace\Learning-WebDriver

Browse...

JRE

(•)

Use

execution

environment

JRE:

JavaSE-1

Use

project

specific

JRE:

Use

default

JRE

(currently

'jre7')

jre7

Configure

JREs...

Project

layout

Use

project

folder

root

for

sources

and

class

files

(•)

Create

separate

folders

for

sources

and

class

files

Configure

default...

Working

sets

l~1

Add

project

working

sets

Working

sets:

Select...

Back

Finish

Cancel

Introducing WebDriver and WebElements

[]

3. In the next screen, go to the Libraries tab, click on the Add External JARs…

button, and select selenium-java-2.33.0.jar and selenium-java-2.33.0-

srcs.jarÀOHVIURPWKHGRZQORDGHGORFDWLRQRI6HOHQLXP:HE'ULYHU

New

Java

Project

Java

Settings

Define

the

Java

build

settings.

Source

Projects

Libraries

Order

and

Export

JARs

and

class

folders

the

build

path:

oio

selenium-java-2.33.0-srcs.jar

C:\Selenium2.33.0\seh

oio

selenium-java-2.33.0.jar

C:\Selenium2.33.0\seleniur

Add

JARs...

Add

External

JARs...

JRE

System

Library

[JavaSE-1.7]

Add

Variable...

Add

Library...

Add

Class

Folder...

Add

External

Class

Folder...

Edit...

Remove

Migrate

JAR

File...

< >

Back

Finish

Cancel

Chapter 1

[]

4. Click on the Add External JARs… button and add all the jars available under

the libs folder of the Selenium WebDriver directory(). Now the Libraries

section should look like this:

5. Click on Finish.

New

Java

Project

Java

Settings

Define

the

Java

build

settings.

Source

Projects

—

Libraries

•%.

Order

and

Export

JARs

and

class

folders

the

build

path:

IOIO

apache-mime4j-0.6.jar

C:\Selenium2.33.0\seleni

ioi<j

bsh-1.3.0.jar

C:\Selenium2.33.0\selenium-2.33.0'

IOIO

cglib-nodep-2.1_3.jar

C:\Selenium2.33.0\seleniu

oio

commons-codec-1.

6.jar

C:\Selenium2.33.0\seler

oio

commons-collections-3.2.1.

jar

C:\Selenium2.33.

oio

commons-exec-1.

jar

C:\Selenium2.33.0\selenii

IOIO

commons-io-2.2.jar

C:\Selenium2.33.0\seleniurr

commons-jxpath-1.3.jar

C:\Selenium2.33.0\seler

commons-lang3-3.

jar

C:\Selenium2.33.0\selen

commons-logging-1.1

.jar

C:\Selenium2.33.0\s

cssparser-0.9.9.jar

C:\Selenium2.33.0\selenium-i

guava-14.0.jar

C:\Selenium2.33.0\selenium-2.33.

IOIO

hamcrest-core-1.3.jar

C:\Selenium2.33.0\seleniu

hamcrest-library-1.3.jar

C:\Selenium2.33.0\selen

htmlunit-2.12.jar

C:\Selenium2.33.0\selenium-2.

IOTO

htmlunit-core-js-2.12.jar

C:\Selenium2.33.0\sele

httpclient-4.2.1.

jar

C:\Selenium2.33.0\selenium-

httpcore-4.2.1.

jar

C:\Selenium2.33.0\selenium-2

httpmime-4.2.1.

jar

C:\Selenium2.33.0\selenium-

ioTo

ini4j-0.5.2.jar

C:\Selenium2.33.0\selenium-2.33.0

ioTo

jcommander-1.29.jar

C:\Selenium2.33.0\seleniut

ioTo

jetty-websocket-8.1.8.jar

C:\Selenium2.33.0\sele

IoTo

ina-3.4.0.iar

C:\Selenium2.33.0\selenium-2.33.0\

Add

JARs...

Add

External

JARs...

Add

Variable...

Add

Library...

Add

Class

Folder...

Add

External

Class

Folder...

Edit-

Remove

Migrate

JAR

File...

Back

Finish

Cancel

Introducing WebDriver and WebElements

[]

6. Now,OHWVFUHDWHRXUÀUVWFODVVWKDWXVHV:HE'ULYHUWRQDYLJDWHWRDZHE

page. In the project explorer window of Eclipse, right-click and navigate to

src | New | Class, enter the details of the class name and package name, as

shown in the following screenshot, and then click on Finish:

7. TheÀUVWSLHFHRIFRGHWRLQYRNH:HE'ULYHUand navigate to a URL is

as follows:

package com.packt.webdriver.chapter1;

import org.openqa.selenium.WebDriver;

import org.openqa.selenium.firefox.FirefoxDriver;

public class NavigateToAUrl {

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

}

New

Java

Class

Java

Class

Create

new

Java

class.

Learning-WebDriver/src

Source

folder

Browse...

com.packt.webdriver.chapterl

Package:

I I

Enclosing

type:

Browse...

NavigateToAUrl|

Name:

(•)

public

default

private

protected

I I

abstract

final

static

Modifiers:

java.

lang.

Object

Browse...

Superclass:

interfaces:

Add...

Remove

Which

method

stubs

would

you

create?

I I

public

static

void

main(String[]

args)

Constructors

from

superclass

[ÿ1

Inherited

abstract

methods

you

want

add

comments?

(Configure

templates

and

default

value

here)

Generate

comments

Finish

Cancel

Chapter 1

[]

Downloading the example code

You can download the example code files for all Packt books

you have purchased from your account at http://www.

packtpub.com. If you purchased this book elsewhere, you can

visit http://www.packtpub.com/support and register to

have the files e-mailed directly to you.

Lets look at each line of code. Line 1 is the name of the package in which

\RXUFODVVÀOHLVJRLQJWRUHVLGHOLQHVDQGLPSRUWQHFHVVDU\:HE'ULYHU

classes that we are going to explore, line 4 is the class declaration, and line 5

is the start of the main method.

Now, coming to the important part of the code:

WebDriver driver = new FirefoxDriver();

Line 6 is where we instantiate the Firefox implementation of the WebDriver

interface. WebDriver is an interface whose concrete implementation is done

in two classes: RemoteWebDriver and HtmlUnitDriver.

We will talk about the RemoteWebDriver and HtmlUnitDriver classes more

in depth later in this book, but right now knowing them as implementations

of the WebDriver LQWHUIDFHLVVXIÀFLHQWFirefoxDriver is a subclass

of the RemoteWebDriver class, which extends the RemoteWebDriver

FODVVPRUHVSHFLÀFDOO\IRUWKH)LUHIR[EURZVHU6LPLODUO\ZHKDYHWKH

InternetExplorerDriver, ChromeDriver, SafariDriver, AndroidDriver,

and IPhoneDriverFODVVHVZKLFKDUHVSHFLÀFLPSOHPHQWDWLRQVIRUWKH

UHVSHFWLYHEURZVHUVDQGGHYLFHV7KHIROORZLQJÀJXUHVKRZVWKHKLHUDUFK\

of the classes:

WebDriver

RemoteWebDriver HtmlUnitDriver

FirefoxDriver InternetExplorerDriver SafariDriver ChromeDriver AndroidDriver IPhoneDriver

Let's now look at the last line of the code:

driver.get("http://www.google.com");

Introducing WebDriver and WebElements

[]

In the preceding code, we use one of the methods of the WebDriver interface

called the get() method to make the browser load the requested web page

on it. If the browser, in this case Firefox, is not already opened, it will launch

a new browser window.

8. Now, execute your code by navigating to Run | Run or using the Ctrl + F11

shortcut. A Firefox browser should open and load the Google Search page in

your browser.

:HE(OHPHQWV

A web page is comprised of many different HTML elements, such as buttons,

links, a body, labels, forms, and so on, that are named WebElements in the context

of WebDriver. Together, these elements on a web page will achieve the business

functionality. For example, let's look at the HTML code of the login page of a website.

<html>

<body>

<label>Enter Username: </label>

<label>Enter Password: </label>

</form>

<a href="forgotPassword.html">Forgot Password ?</a>

</body>

</html>

In the preceding HTML code, there are different types of WebElements such as

<html>, <body>, <form>, <label>, <input>, and <a>, which together make a

web page. Let's analyze the following WebElement:

<label>Enter Username: </label>

Here, <label> is the start tag of the WebElement label. Enter Username: is the text

present on the label element. Finally, </label> is the end tag, which indicates the

end of WebElement.

Similarly, take another WebElement:

In the preceding code, type and name are the attributes of the WebElement input

with values text and Username, respectively.

Chapter 1

[]

UI Automation is mostly about locating these WebElements on a web page and

executing user actions on them. In the rest of the chapter, we will use various ways

to locate WebElements and execute relevant user actions on them.

/RFDWLQJ:HE(OHPHQWVXVLQJ:HE'ULYHU

Let's start this section by automating the Google Search page, which involves

opening the Google Search page, typing the search text in the textbox, and

executing the search. The code for that is as follows:

public class GoogleSearch {

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchBox = driver.findElement(By.name("q"));

searchBox.sendKeys("Packt Publishing");

searchBox.submit();

}

In the preceding code, lines 1 to 4 are same as the example discussed earlier. When

you look at line 5, there are three new things that are highlighted as follows:

WebElement searchBox = driver.findElement(By.name("q"));

They are the findElement() method, By.name() method, and the WebElement

interface. The findElement() and By() methods instruct WebDriver to locate a

WebElement on a web page, and once found, the findElement() method returns

the WebElement instance of that element. Actions such as click, type, and so on,

are performed on a returned WebElement using the methods declared in the

WebElement interface, which will be discussed in detail in the next section.

7KH¿QG(OHPHQWPHWKRG

In UI DXWRPDWLRQORFDWLQJDQHOHPHQWLVWKHÀUVWVWHS before executing any user

actions on it. WebDriver's findElement() method is a convenient way to locate an

element on the web page. According to WebDriver's Javadoc (http://selenium.

googlecode.com/git/docs/api/java/index.html), the method declaration is

as follows:

WebElement findElement(By by)

So, the input parameter for the findElement() method is the By instance. The By

instance is a WebElement-locating mechanism. There are eight different ways to locate

a WebElement on a web page. We will see that when we discuss By, shortly.

Introducing WebDriver and WebElements

[]

The return type of the findElement() method is the WebElement instance that

represents the actual HTML element or component of the web page. The method

UHWXUQVWKHÀUVW:HE(OHPHQWWKDWWKHGULYHUFRPHVDFURVVZKLFKVDWLVÀHVWKH

locating-mechanism condition. This WebElement instance will act as a handle to

that component from then on. Appropriate actions can be taken on that component

by the test script developer using this returned WebElement instance.

If:HE'ULYHUGRHVQWÀQGWKHHOHPHQWLWWKURZVDruntime exception named

NoSuchElementException, which the invoking class or method should handle.

The test script developer is advised to avoid using this method if he/she thinks the

WebElement will not be present on the web page. For those purposes, we can use

another method of WebDriver named findElements.

7KH¿QG(OHPHQWVPHWKRG

If developers think that they may encounter zero or more number of WebElements

for a given locating mechanism on a web page, they should rather use the

findElements() method than the findElement() method. Because the

findElement() method throws NoSuchElementException in case of zero occurrences

RI:HE(OHPHQWDQGRQWKHRWKHUKDQGRQO\WKHÀUVWRFFXUUHG:HE(OHPHQWWKDW

VDWLVÀHVWKHORFDWLQJPHFKDQLVPFRQGLWLRQWKRXJKWKHZHESDJHFRQWDLQVPXOWLSOH

WebElements. The method declaration of the findElements() method is as follows:

java.util.List<WebElement> findElements(By by)

The input parameter is same as the findElement() method, which is an instance of

the By class. The difference lies in the return type. Here, if no element is found, an

empty list is returned and if there are multiple WebElements present satisfying the

locating mechanism, all of them are returned to the caller in a list.

Firebug

Before we discuss about locating mechanism using the By class, we have to see how

Firebug works. Firebug is an add-on/plugin for Firefox, which we have installed

earlier. This is used to inspect the HTML elements on a web page loaded in Firefox.

Let's load www.google.com on Firefox. To inspect the search button element, launch

WKHÀUHEXJSOXJLQE\FOLFNLQJRQWKHÀUHEXJLFRQFORVHWRWKHWRSULJKWFRUQHUDV

shown in the following screenshot:

Mozilla

Firefox

Start

Page

(<J*

2jl±JlJi

is|'r

Coogle

Website

Chapter 1

[]

Once launched, click on the Inspect Element icon, which looks like the following

screenshot:

Now move the cursor to the search button element and click on it. Firebug will

highlight the HTML code that represents the element on the web page. In this case,

it will be:

<button class="gbqfba" name="btnK" aria-label="Google Search"

id="gbqfba"><span id="gbqfsa">Google Search</span></button>

As Firebug shows the respective HTML code for the WebElement, now it's the

developer's choice to select the attribute of the element used to locate the element

and pass it to the findElement() method. For example, in this case, the element has

name, class, and id attributes declared. So it is up to the developer to choose one

attribute of the WebElement to identify the element uniquely.

WebElements on a web page may not have all the attributes

declared. It is up to the developer of the test script to select the

DWWULEXWHWKDWXQLTXHO\LGHQWLÀHVWKH:HE(OHPHQWRQWKHZHESDJH

for the automation.

8VLQJWKH%\ORFDWLQJPHFKDQLVP

By is the locating mechanism passed to the findElement() method or the

findElements() method to fetch the respective WebElement(s) on a web page.

There are eight different locating mechanisms; that is, eight different ways to identify

an HTML element on a web page. They are located by Name, ID, TagName, Class,

LinkText, PartialLinkText, XPath, and CSS.

7KH%\QDPHPHWKRG

As seen earlier, every element on a web page has many attributes. Name is one

among them. For instance, the HTML code for the Google Search button will be:

<button id="gbqfba" aria-label="Google Search" name="btnK"

class="gbqfba"><span id="gbqfsa">Google Search</span></button>

Convol*

HTML

CSS

Script

DOM

Net

Pape

Speed

FirePalh

Style

Layout

DOM

K*pirhp

[ ]

Introducing WebDriver and WebElements

[]

Here name is one of the many attributes of the button, and its value is btnK. If we

want to identify this button and click on it in your test script, the code will look

as follows:

public class GoogleSearchButtonByName {

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchBox = driver.findElement(By.name("btnK"));

searchBox.submit();

}

If you observe line 5, the locating mechanism used here is By.name and the name is

btnK6RIURPZKHUHGLGZHJHWWKLVQDPH"$VGLVFXVVHGLQWKHSUHYLRXVVHFWLRQLW

LVWKHÀUHEXJWKDWKHOSHGXVJHWWKHQDPHRIWKHEXWWRQ/DXQFKWKH)LUHEXJDQGXVH

the inspect elements widget to get the attributes of an element.

7KH%\LGPHWKRG

On a web page, each element is uniquelyLGHQWLÀHGE\DQ,'LISURYLGHG$Q,'FDQ

be assigned manually by the developer of the web application or, most of the times,

left to be dynamically generated by the server where the web application is hosted,

and this ID can change over a period of time.

Now, if we consider the same HTML code of the Google Search button:

<button id="gbqfba" aria-label="Google Search" name="btnK"

class="gbqfba"><span id="gbqfsa">Google Search</span></button>

In the preceding code, the id value of this button is gbqfba. This might change by

the time you read this book, because this could be a server-generated ID.

Let us see what changes need to be made to our test script to use id instead of name:

public class GoogleSearchButtonById {

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchBox = driver.findElement(By.id("gbqfba"));

searchBox.submit();

}

Chapter 1

[]

We have changed the locating mechanism from the By.name() method to the

By.id() method, and used the search button's id value instead of name. Here, try to

use the By.idLGHQWLÀHUDQGXVHWKHname value (that is. btnK) instead of the id value

(that is. gbqfba). Modify line 5 as follows:

WebElement searchBox = driver.findElement(By.id("btnK"));

The test script will fail to throw an exception as follows:

Exception in thread "main" org.openqa.selenium.NoSuchElementException:

Unable to locate element: {"method":"id","selector":"btnK"}

WebDriverFRXOGQWÀQGDQHOHPHQWE\id whose value is btnK. Thus, it throws an

H[FHSWLRQVD\LQJLWFRXOGQWÀQGDQ\VXFKHOHPHQWZLWKid as btnK.

7KH%\WDJ1DPHPHWKRG

Locating an element by tag name is slightly different from name and id locating

mechanisms. The reason being it can return zero or more results. For example, on a

Google Search page, if you search for an element with the tag name button, it will

result in three WebElements because there are three buttons present on the search

page. So it is always advisable to use the findElements() method rather than the

findElement() method when trying to locate elements using tag names.

Let's see how the code looks like when a search for the number of buttons present

on a Google Search page is made.

public class GoogleSearchPageByTagName{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

List<WebElement> buttons = driver.findElements(By.

tagName("button"));

System.out.println(buttons.size());

}

In the preceding code, we have used the By.tagName locating mechanism and

findElements() method, which returns a list of all the buttons available on the

page. On line 6, when we printed the size of the list, it returns 3.

If you are wondering how there are three buttons on the Google Search page while

only two are visible, the following are all the buttons available on the search page:

<button id=gbqfb aria-label="Google Search" class=gbqfb

name=btnG><span class=gbqfi></span></button>

<button id=gbqfba aria-label="Google Search" name=btnK

class=gbqfba><span id=gbqfsa>Google Search</span></button>

Introducing WebDriver and WebElements

[]

<button id=gbqfbb aria-label="I'm Feeling Lucky" name=btnI

class=gbqfba onclick="if(this.form.q.value)this.checked=1;else window.

top.location='/doodles/'"><span id=gbqfsb>I'm Feeling Lucky</span></

button>

7KLVLVZK\:HE'ULYHULVVRKHOSIXOWRUHYHDOWKLQJVWKDWDUHGLIÀFXOWWRÀJXUH

out manually.

Some commonly used HTML elements are mentioned as follows, and they can be

used by tag names (also mentioned).

7KHUHDUHPDQ\WDJVZKRVHQDPHVDUHLQSXW)RUWKRVH\RXKDYHWRIXUWKHUÀOWHU

them by using the type attribute. We will learn that in the next section.

Tag

Name

Type

Component

Select

RADIO

Input

CHECKBOX

Input

ABI

TEXTBOX

Input

PASSWORD

Input

List

Chapter 1

[]

7KH%\FODVV1DPHPHWKRG

Before we discuss about the className() method, we have to talk a little about style

and CSS. Every HTML element on a web page, generally, is styled by the web page

developer or designer. It is not mandatory that each element should be styled, but it

is generally followed to make it appealing to the end user.

So, in order to apply styles to an element, they can be declared directly in the

HOHPHQWWDJRUSODFHGLQDVHSDUDWHÀOHFDOOHGWKH&66ÀOHDQGFDQEHUHIHUHQFHG

in the element using the className() method. For instance, a style attribute for a

EXWWRQFDQEHGHFODUHGLQD&66ÀOHDVIROORZV

.buttonStyle{

width: 50px;

height: 50px;

border-radius: 50%;

margin: 0% 2%;

}

Now, this style can be applied on the button element in a web page as follows:

<button name="sampleBtnName" id="sampleBtnId" class="buttonStyle">I'm

Button</button>

So, buttonStyle is used as value for the class attribute of the button element, and it

inherits all the styles declared inWKH&66ÀOH1RZOHWVWU\WKLVRQRXU*RRJOHVHDUFK

page. We will try to make WebDriver identify the search box using its class name

and type some text into it. First, in order to get the class name of the search box,

as we know, we will use Firebug and fetch it. After getting it, change the location

mechanism to By.className and specify the class attribute value in it. The code

for that is as follows:

public class GoogleSearchByClassName{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchBox = driver.findElement(By.className("gbqfif"));

searchBox.sendKeys("Packt Publishing");

}

In the preceding code, we have used the By.className locating mechanism by

passing the class attribute value to it.

Introducing WebDriver and WebElements

[]

7KH%\OLQN7H[WPHWKRG

As the name suggests, the By.linkText locating mechanism can only be used to

identify the HTML links. Before we start discussing about how WebDriver can be

commanded to identify a link element using link text, let's see what an HTML link

element looks like. The HTML link elements are represented on a web page using

the <a> tag, abbreviation for the anchor tag. A typical anchor tag looks like this:

<a href="/intl/en/about.html">About Google</a>

Here, href is the link to a different page where your web browser will take you

when clicked on the link. So, the preceding HTML code when rendered by the

browser looks like this:

This About Google is the link text. So the locating mechanism By.linkText uses

this text on an anchor tag to identify the WebElement. The code for this would look

like this:

public class GoogleSearchByLinkText{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement aboutLink = driver.findElement(By.linkText("About

Google"));

aboutLink.click();

}

Here, the By.linkText locating mechanism is used to identify the About

Google link.

7KH%\SDUWLDO/LQN7H[WPHWKRG

The By.partialLinkText locating mechanism is an extension to the previous one.

If you are not sure of the entire link text or want to use only part of the link text,

you can use this locating mechanism to identify the link element. So let's modify

the previous example to use only partial text on the link, that is, About.

public class GoogleSearchByPartialLinkText{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

About

Google

Chapter 1

[]

WebElement aboutLink = driver.findElement(By.

partialLinkText("About"));

aboutLink.click();

}

What happens if there are multiple links whose text has AboutLQLW"7KDWLVD

question to the findElement() method rather than to the locating mechanism.

Remember when we discussed the findElement() method earlier, it will return only

WKHÀUVW:HE(OHPHQWWKDWLWFRPHVDFURVV,Iyou want all the WebElements which

contain About in its link text, use the findElements() method, which will return a

list of all those elements.

Use WebDriver's findElements() method if you think you need

all the WebElements that satisfy a locating mechanism condition.

7KH%\[SDWKPHWKRG

WebDriver uses XPath to identify a WebElement on the web page. Before we see

how it does that, we will quickly look at the syntax for XPath. XPath is a short

name for the XML path. The HTML for our web page is also one form of the XML

document. So in order to identify an element on an HTML page, we need to use a

VSHFLÀF;3DWKV\QWD[DVIROORZV

 7KHURRWHOHPHQWLVLGHQWLÀHGDV//

 To identify all the div elements, the syntax will be //div

 To identify the link tags that are within the div element, the syntax will be

//div/a

 To identify all the elements with a tag, we use *. The syntax will be //div/*

 To identify all the div elements that are at three levels down from the root,

we can use //*/*/div

 7RLGHQWLI\VSHFLÀFHOHPHQWVZHXVHDWWULEXWHYDOXHVRIWKRVHHOHPHQWVVXFK

as //*/div/a[@id='attrValue'], which will return the anchor element.

This element is at third level from root within a div element, and has an id

value attrValue

Introducing WebDriver and WebElements

[]

So, we need to pass these kinds of XPath syntaxes to our WebDriver to make it

LGHQWLI\RXUWDUJHWHOHPHQW%XWJRLQJWKURXJKWKH+70/SDJHÀJXULQJRXWWKH

;3DWKIRUHDFKHOHPHQWZLOOEHH[WUHPHO\GLIÀFXOW)RUWKLVLI\RXUHPHPEHUZH

have installed a Firebug extension named FirePath. This will quickly give you the

XPath of the target element that you can use in the WebDriver code. Following is

the screenshot of the XPath of the Google Search button:

If you see the preceding image, the Google Search Button is selected and in the

FirePath tab below the XPath, the value is displayed as //*[@id='gbqfba'].

Now, let us see the code example and how WebDriver uses this XPath to identify

the element.

public class GoogleSearchByXPath{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.xpath("//*[@

id='gbqfba']"));

System.out.println(searchButton.getText());

}

In the preceding code, we are using the By.xpath locating mechanism and passing

the XPath of the WebElement to it.

Google

I'm

Feeling

Lucky

Advertising

Programmes

Business

Solutions

Privacy

Terms

+Google

’

Console

HTML

CSS

Script

DOM

Net

FirePath

Highlight

XPath:

’

.//*[@id='gbqfba']

<div

id=”gbqfw">

<form

id="gbqf”

onsubmit=”gbar

logger

.il

(31)

;

action="/search”

method=”get”

name="gbqf

”>

(±1

ieldaet

cla33=”gbxx”>

ieldset

id=”gbqff”

cla33="gbqf

l±)

<div

id=”gbqfbw”>

<div

id="gbqfbwa''

cla33=''

sb">

<button

id=,,gbqfba”

claaa="gbqfba

gbqfba-hvr"

name="btnK”

aria-label=”Google

Searcb”>

l±)

<button

id="gbqfbb"

cla33=''gbqfba”

onclick="if

(this

form.

value

)

this

checked=l;

else

window.

top

location='

/doodles/

”

najne="btnl”

aria-label="I

Feeling

Lucky”>

div>

Chapter 1

[]

One disadvantage of using XPath is it is costly in terms of time. For every element

WREHLGHQWLÀHG:HE'ULYHUDFWXDOO\VFDQVWKURXJKWKHHQWLUHSDJHWKDWLVYHU\WLPH

consuming, and too much usage of XPath in your test script will actually make them

too slow to be executed.

7KH%\FVV6HOHFWRUPHWKRG

The By.cssSelector() method is similar to the By.xpath() method in its usage

but the difference is that it is slightly faster than the By.xpath locating mechanism.

Following are the commonly used syntaxes to identify elements:

 To identify an element using the div element with id #flrs, we use the

#flrs syntax

 To identify the child anchor element, we use the #flrs > a syntax, which

will return the link element

 To identify the anchor element with its attribute, we use the #flrs >

a[a[href="/intl/en/about.html"]] syntax

Let's try to modify the previous code, which uses the XPath-locating mechanism

to use the cssSelector mechanism.

public class GoogleSearchByCSSSelector{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.

cssSelector("#gbqfba"));

System.out.println(searchButton.getText());

}

The preceding code uses the By.cssSelector locating mechanism that uses the css

selector ID of the Google Search button.

Let's look at a slightly complex example. We will try to identify the About Google

link on the Google Search page:

public class GoogleSearchByCSSSelector{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.

cssSelector("#flrs>a[href='/intl/en/about.html']"));

System.out.println(searchButton.getText());

}

Introducing WebDriver and WebElements

[]

The preceding code uses the cssSelector()PHWKRGWRÀQGWKHanchor element

LGHQWLÀHGE\LWVhref attribute[ ].

$FWLRQVRQ:HE(OHPHQWV

In the previous section, we have seen how to locate WebElements on a web page by

using different locating mechanisms. Here, we will see all the different user actions

that can be taken on a WebElement. Different WebElements will have different

actions that can be taken on them. For example, in a textbox element, we can type

in some text or clear the text that is already typed in it. Similarly for a button, we

can click on it, get the dimensions of it, and so on, but we cannot type into a button,

and for a link, we cannot type into it. So, though all the actions are listed in one

WebElement interface, it is the test script developer's responsibility to use the actions

that are supported by the target element. In case we try to execute a wrong action on

a WebElement, we don't see any exception or error thrown and also we don't see any

action that really gets executed; WebDriver ignores such actions silently.

Now, let's get into each of the actions individually by looking into their Javadocs and

a code example.

7KHJHW$WWULEXWHPHWKRG

The getAttribute action can be executed on all the WebElements. Remember

we have seen attributes of WebElement in the WebElements section. The HTML

DWWULEXWHVDUHPRGLÀHUVRI+70/HOHPHQWV7KH\DUHJHQHUDOO\NH\YDOXHSDLUV

appearing in the start tag of an element. For example, in the following WebElement:

<label name="Username" id="uname">Enter Username: </label>

In the preceding code, name and id are the attributes or attribute keys and Username

and uname are the attribute values.

The API syntax of the getAttributes() method is as follows:

java.lang.String getAttribute(java.lang.String name)

In the preceding code, the input parameter is String, which is the name of the

attribute. The return type is again String, which is the value of the attribute.

Now let's see how we can get all the attributes of a WebElement using WebDriver.

Here, we will make use of the Google Search button again. This is what the element

looks like:

<button id="gbqfba" class="gbqfba" name="btnK" aria-label="Google

Search">

Chapter 1

[]

We will list all the attributes of this WebElement using WebDriver. The code for that

is as follows:

public class GetAttributes{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.name("btnK"));

System.out.println("Name of the button is: "

+searchButton.getAttribute("name"));

System.out.println("Id of the button is: "

+searchButton.getAttribute("id"));

System.out.println("Class of the button is: "

+searchButton.getAttribute("class"));

System.out.println("Label of the button is: "

+searchButton.getAttribute("aria- label"));

}

In the preceding code, the last four lines of code use the getAttribute() method

to fetch the attribute values of the attribute name, id, class, and aria-label of the

Google Search button WebElement. The output of the preceding code is shown in

the following screenshot:

Going back to the By.tagName() method of the previous section, if the search by

locating mechanism, By.tagName, results in more than one result, you can use

the getAttribute()PHWKRGWRIXUWKHUÀOWHUWKHUHVXOWVDQGJHWWR\RXUH[DFW

intended element.

7KHVHQG.H\VPHWKRG

The sendKeys action is applicable for textbox or textarea HTML elements. This is

used to type text into the textbox. This will simulate the user keyboard and types

text into WebElements exactly as would a user.

The API syntax for the sendKeys() method is as follows:

void sendKeys(java.lang.CharSequence...keysToSend)

Name

the

button

btnK

the

button

is:

gbqfba

Class

the

button

is:

gbqfba

Label

the

button

null

Introducing WebDriver and WebElements

[]

The input parameter for the preceding method is CharSequence of text that has to be

entered into the element. This method doesn't return anything.

Now, let's see a code example of how to type a search text into the Google Search

box using the sendKeys() method.

public class sendKeys{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchBox = driver.findElement(By.name("q"));

searchButton.sendKeys("Packt Publishing");

}

In the preceding code, the sendKeys() method is used to type the required text in

the textbox element of the web page. This is how we deal with normal keys, but if

you want to type in some special keys, such as Backspace, Enter, Tab, Shift, and so

on, we need to use a special enum class of WebDriver named Keys. Using the Keys

enumeration, you can simulate many special keys while typing into a WebElement.

Now let's see some code example, which uses the Shift key to type the text in

uppercase in the Google Search Box:

public class SendKeys{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchBox = driver.findElement(By.name("q"));

searchBox.sendKeys(Keys.chord(Keys.SHIFT,"packt publishing"));

}

In the preceding code, the chord() method from the Keys enum is used to type the

NH\ZKLOHWKHWH[WVSHFLÀHGLVEHLQJJLYHQDVDQLQSXWWREHWKHWH[WER[7U\WKLVLQ

your environment to see all the text being typed in uppercase.

7KHFOHDUPHWKRG

The clear action is similar to the sendKeys() method, which is applicable for textbox

and textarea elements. This is used to erase the text that is entered in a WebElement

using the sendKeys() method. This can be achieved using the Keys.BACK_SPACE

enum, but WebDriver has given us an explicit method to clear the text easily.

Chapter 1

[]

The API syntax for the clear() method is as follows:

void clear()

This method doesn't take any input and doesn't return any output. It is simply

executed on the target text entry element.

Now, let us see how we can clear text that is entered in the Google Search box. The

code example for it is as follows:

public class Clear{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchBox = driver.findElement(By.name("q"));

searchBox.sendKeys(Keys.chord(Keys.SHIFT,"packt publishing"));

searchBox.clear();

}

We have used the WebElement's clear() method to clear the text after typing packt

publishing into the Google Search box.

7KHVXEPLWPHWKRG

The submit action can be taken on a form or on an element, which is inside a form.

This is used to submit a form of a web page to the server hosting the web application.

The API syntax for the submit() method is as follows:

void submit()

The preceding method doesn't take any input parameter and doesn't return

anything. But a NoSuchElementException is thrown when this method is

executed on a WebElement that is not present within a form.

Now, let's see a code example to submit the form on a Google Search page:

public class Submit{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchBox = driver.findElement(By.name("q"));

searchBox.sendKeys(Keys.chord(Keys.SHIFT,"packt publishing"));

searchBox.submit();

}

Introducing WebDriver and WebElements

[]

In the preceding code, towards the end is where the Search form is submitted to

the Google servers using the submit() method. Now, try to execute the submit()

method on an element, let's say the About Google link, which is not a part of any

form. We should see a NoSuchElementException being thrown.

So when you use the submit() method on a WebElement, make sure it is part of the

form element.

7KHJHW&VV9DOXHPHWKRG

The getCssValue action can be taken on all the WebElements. This is used to fetch

the CSS properties' values of the given element. CSS properties can be font-family,

background-color, color, and so on. This is useful when you want to validate the

CSS styles that are applied to your WebElements through your test scripts.

The API syntax for the getCssValue() method is as follows:

java.lang.String getCssValue(java.lang.String propertyName)

In the preceding code, the input parameter is the String value of the CSS property

name, and return type is the value assigned for that property name.

The following is the code example to retrieve the font-family of the text on the

Google Search button:

public class GetCSSValue{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.name("btnK"));

System.out.println(searchButton.getCssValue("font-family"));

}

The preceding code uses the getCssValue()PHWKRGWRÀQGWKHIRQWIDPLO\RIWKH

text visible on the Google Search button. The output of this is shown in the

following screenshot:

Shell

Dig

Chapter 1

[]

Similarly, we can retrieve the background color of an element using this method. Let

us see a code for this:

public class GetCSSValue2{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.name("btnK"));

System.out.println(searchButton.getCssValue("background-color"));

}

The output for the preceding code is shown in the following screenshot:

7KHJHW/RFDWLRQPHWKRG

The getLocation action can be executed on all the WebElements. This is used to

get the relative position of an element where it is rendered on the web page. This

position is calculated relative to the top-left corner of the web page of which the (x, y)

coordinates are assumed as (0, 0). This method will be of use if your test script tries

to validate the layout of your web page.

The API syntax of the getLocation() method is as follows:

Point getLocation()

The preceding method obviously doesn't take any input parameter, but the return

type is a Point class, which contains the (x, y) coordinates of the element.

The following is the code to retrieve the location of the Google Search button:

public class GetLocation{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.name("btnK"));

System.out.println(searchButton.getLocation());

}

transparent

Introducing WebDriver and WebElements

[]

The output for the preceding code is the (x, y) location of the Google Search button,

as shown in the following screenshot:

7KHJHW6L]HPHWKRG

The getSize action can also be applied on all the visible components of HTML. It

will return the width and height of the rendered WebElement.

The API syntax of the getSize() method is as follows:

Dimension getSize()

The preceding method doesn't take any input parameters, and the return type is a

class instance named Dimension. This class contains the width and height of the

target WebElement.

The following is the code to get the width and height of our favorite Google

Search button:

public class GetSize{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.name("btnK"));

System.out.println(searchButton.getSize());

}

The output for the preceding code is the width and height of the Google Search

button, as shown in the following screenshot:

7KHJHW7H[WPHWKRG

The getText action can be taken on all the WebElements. It will give the visible text

if the element contains any text on it or else will return nothing.

(372,

356)

(102,

29)

Chapter 1

[]

The API syntax for the getText() method is as follows:

java.lang.String getText()

There is no input parameter for the preceding method, but it returns the visible

innerText string of the WebElement if anything is available, else will return an

empty string.

The following is the code to get the text present on the Google Search button:

public class GetText{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.name("btnK"));

System.out.println(searchButton.getText());

}

The preceding code uses the getText() method to fetch the text present on the

Google Search button, which returns the following:

7KHJHW7DJ1DPHPHWKRG

The getTagName action can be taken on all the WebElements. This will return the tag

name of the WebElement. For example, in the following HTML code, button is the

tag name of the HTML element:

<button id="gbqfba" class="gbqfba" name="btnK" aria-label="Google

Search">

In the preceding code, button is the tag name of the HTML element.

The API syntax for the getTagName() method is as follows:

java.lang.String getTagName()

The return type of the preceding method is String, and it returns the tag name of

the target element.

Google

Introducing WebDriver and WebElements

[]

The following is the code that returns the tag name of the Google Search button:

public class GetTagName{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.name("btnK"));

System.out.println(searchButton.getTagName());

}

The preceding code uses the getTagName() method to get the tag name of the

Google Search button element. The output of the code is as expected:

7KHLV'LVSOD\HGPHWKRG

The isDisplayedDFWLRQYHULÀHVLIDQHOHPHQWLVGLVSOD\HGRQWKHZHESDJHDQGFDQ

be executed on all the WebElements.

The API syntax for the isDisplayed() method is as follows:

boolean isDisplayed()

The preceding method returns a Boolean value specifying whether the target element

is displayed or not displayed on the web page.

The following is the code to verify if the Google Search button is displayed or not,

which obviously should return true in this case:

public class isDisplayed{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.name("btnK"));

System.out.println(searchButton.isDisplayed());

}

The preceding code uses the isDisplayed() method to determine if the element

is displayed on a web page. The preceding code returns true for the Google

Search button.

button

Chapter 1

[]

7KHLV(QDEOHGPHWKRG

The isEnabledDFWLRQYHULÀHVLIDQHOHPHQWLV enabled on the web page and can be

executed on all the WebElements.

The API syntax for the isEnabled() method is as follows:

boolean isEnabled()

The preceding method returns a Boolean value specifying whether the target element

is enabled or not enabled on the web page.

The following is the code to verify if the Google Search button is enabled or not,

which obviously should return true in this case:

public class isEnabled{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchButton = driver.findElement(By.name("btnK"));

System.out.println(searchButton.isEnabled());

}

The preceding code uses the isEnabled() method to determine if the element is

displayed on a web page. The preceding code returns true for the Google Search

button.

7KHLV6HOHFWHGPHWKRG

The isSelectedDFWLRQYHULÀHVLIDQHOHPHQW is selected right now on the web

page and can be executed only on a radio button, options in select, and checkbox

WebElements. When executed on other elements, it will return false.

The API syntax for the isSelected() method is as follows:

boolean isSelected()

The preceding method returns a Boolean value specifying whether the target element

is selected or not selected on the web page.

Introducing WebDriver and WebElements

[]

The following is the code to verify if the Google Search box is selected or not on a

search page:

public class IsSelected{

public static void main(String[] args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement searchBox = driver.findElement(By.name("q"));

System.out.println(searchBox.isSelected());

}

The preceding code uses the isSelected() method. It returns false for the Google

Search box, because this is not a radio button, options in select, or a checkbox.

6XPPDU\

In this chapter, we have seen a brief history of Selenium, the architecture of

WebDriver, WebElements, how to locate them, and actions that can be taken on

them. We have also covered some of the fundamentals of WebDriver, which are

useful in your day-to-day dealing with WebDriver.

In the next chapter, we will see more advanced actions that can be performed on

WebElements.

Exploring Advanced

Interactions of WebDriver

In the previous chapter, we have discussed WebElements, how to locate them on a

web page, and some basic actions that can be performed on them. In this chapter, we

will go through some advanced ways of performing actions on WebElements.

8QGHUVWDQGLQJDFWLRQVEXLOGDQGSHUIRUP

We know how to take some basic actions, such as clicking on a button and typing

text into a textbox; however, there are many scenarios where we have to perform

multiple actions at the same time. For example, keeping the Shift button pressed and

typing text for uppercase letters, and the dragging and dropping mouse actions.

Let's see a simple scenario here. Open the selectable.htmlÀOHWKDWLVDWWDFKHGZLWK

this book. You will see tiles of numbers from 1 to 12. If you inspect the elements with

Firebug, you will see an ordered list tag (<ol>) and 12 list items (<li>) under it, as

shown in the following code:

Exploring Advanced Interactions of WebDriver

[]

</ol>

If you click a number, it's background color changes to orange. Try selecting

the 1, 3, and 5 numbered tiles. You do that by holding the Ctrl key + 1 numbered

tile + 3 numbered tile + 5 numbered tile. So, this involves performing multiple

actions, that is, holding the Ctrl key continuously and clicking on 1, 3, and 5 tiles.

+RZGRZHSHUIRUPWKHVHPXOWLSOHDFWLRQVXVLQJ:HE'ULYHU"The following code

demonstrates that:

public class ActionBuildPerform {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/selectable.html");

WebElement one = driver.findElement(By.name("one"));

WebElement three = driver.findElement(By.name("three"));

WebElement five = driver.findElement(By.name("five"));

// Add all the actions into the Actions builder.

Actions builder = new Actions(driver);

builder.keyDown(Keys.CONTROL)

.click(one)

.click(three)

.click(five)

.keyUp(Keys.CONTROL);

// Generate the composite action.

Action compositeAction = builder.build();

// Perform the composite action.

compositeAction.perform();

}

Now, if you see the code, line number 9 is where we are getting introduced to a new

class named Actions. This Actions class is the one that is used to emulate all the

complex user events. Using this, the developer of the test script could combine all

the necessary user gestures into one composite action. From line 9 to line 14, we have

declared all the actions that are to be executed to achieve the functionality of clicking

on the numbers 1, 3, and 5. Once all the actions are grouped together, we build that

into a composite action. This is contained on line 16. Action is an interface that has

only the perform() method, which executes the composite action. Line 18 is where

we are actually executing the action using the perform() method.

Chapter 2

[]

So, to make WebDriver perform multiple actions at the same time, you need to

follow a three-step process of using the user-facing API of the Actions class to

group all the actions, then build the composite action, and then the perform the

action. This process can be made into a two-step process as the perform() method

internally calls the build() method. So the previous code will look as follows:

public class ActionBuildPerform {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/selectable.html");

WebElement one = driver.findElement(By.name("one"));

WebElement three = driver.findElement(By.name("three"));

WebElement five = driver.findElement(By.name("five"));

// Add all the actions into the Actions builder.

Actions builder = new Actions(driver);

builder.keyDown(Keys.CONTROL)

.click(one)

.click(three)

.click(five)

.keyUp(Keys.CONTROL);

// Perform the action.

builder.perform();

}

In the preceding code, we have directly invoked the perform() method on the

Actions instance, which internally calls the build() method to create a composite

action before executing it.

In the subsequent sections of this chapter, we will take a closer look at the Actions

class. All the actions are basically divided into two categories: mouse-based actions

and keyboard-based actions. In the following sections, we will discuss all the actions

WKDWDUHVSHFLÀFWRWKHPRXVHDQGNH\ERDUGDYDLODEOHLQWKHActions class.

/HDUQLQJPRXVHEDVHGLQWHUDFWLRQV

There are around eight different mouse actions that can be performed using the

Actions class. We will see each of their syntax and a working example.

7KHPRYH%\2IIVHWDFWLRQ

The moveByOffset() method is used to move the mouse from its current position to

another point on the web page. Developers can specify the X distance and Y distance

the mouse has to be moved. When the page is loaded, generally the initial position of

a mouse would be (0, 0), unless there is an explicit focus declared by the page.

Exploring Advanced Interactions of WebDriver

[]

The API syntax for the moveByOffset() method is as follows:

public Actions moveByOffset(int xOffSet, int yOffSet)

In the preceding code, xOffSet is the input parameter providing the WebDriver

the amount of offset to be moved along the x axis. A positive value is used to move

the cursor to the right, and a negative value is used to move the cursor to the left.

yOffSet is the input parameter providing the WebDriver the amount of offset to be

moved along the y axis. A positive value is used to move the cursor down along the

y axis and a negative value is used to move the cursor toward the top.

When the xOffSet and yOffSet values result in moving the cursor out of the

document, a MoveTargetOutOfBoundsException is raised.

Let's see a working example of it. The objective of the following code is to move

the cursor on to the number 3 tile on the web page:

public class MoveByOffSet{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Selectable.html");

WebElement three = driver.findElement(By.name("three"));

System.out.println("X coordinate: "+three.getLocation().getX()+"

Y coordinate: "+three.getLocation().getY());

Actions builder = new Actions(driver);

builder.moveByOffset(three.getLocation().getX()+1, three.

getLocation().getY()+1);

builder.perform();

}

We have added +1 to the coordinates, because if you observe the element in Firebug,

we have a style border of 1 px. Border is a CSS-style attribute, which when applied

WRDQHOHPHQWZLOODGGDERUGHURIWKHVSHFLÀHGFRORUDURXQGWKHHOHPHQWZLWKWKH

VSHFLÀHGDPRXQWRIWKLFNQHVV7KRXJKWKHSUHYLRXVFRGHGRHVPRYH\RXUPRXVH

over tile 3, we don't realize it because we are not doing any action there. We will

see that when we use this moveByOffset() method in combination with the click()

method shortly.

The moveByOffset() method may not work in Mac OSX and may raise

a JavaScript error when used independently like the previous code.

Chapter 2

[]

The click at current location action

The click() method is used to simulate the left-click of your mouse at its current

point of location. This method doesn't really realize where or on which element it is

clicking. It just blindly clicks wherever it is at that point of time. Hence, this method

is used in combination with some other action rather than independently, to create a

composite action.

The API syntax for the click() method is as follows:

public Actions click()

The click() method doesn't really have any context about where it is performing its

action; hence, it doesn't take any input parameter.

Let's see a code example of the click() method:

public class MoveByOffsetAndClick{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Selectable.html");

WebElement seven = driver.findElement(By.name("seven"));

System.out.println("X coordinate: "+seven.getLocation().getX()+" Y

coordinate: "+seven.getLocation().getY());

Actions builder = new Actions(driver);

builder.moveByOffset(seven.getLocation().getX()+1, seven.

getLocation().getY()+1).click();

builder.perform();

}

Line 8 is where we have used a combination of the moveByOffset() and click()

methods to move the cursor from point (0, 0) to the point of tile 7. Because the initial

position of the mouse is (0, 0), the X, Y offset provided for the moveByOffset()

method is nothing but the location of the tile 7 element. Now, lets try to move the

cursor from tile 1 to tile 11 and from there to tile 5 and see how the code looks. Before

we get into the code, let's inspect the selectable.html page using Firebug. The

following is the style of each tile:

#selectable li {

float: left;

font-size:4em;

height: 80px;

text-align:center;

width: 100px;

}

Exploring Advanced Interactions of WebDriver

[]

.ui-state-default, .ui-widget-content .ui-state-default, .ui-widget-

header .ui-state-default {

background:url("images/ui-bg_glass_75_e6e6e6_1x400.png") repeat-x

scroll 50% 50% #E6E6E6;

border: 1px solid #D3D3D3;

color: #555555;

font-weight: normal;

}

The three elements with which we are concerned for our offset movement in the

preceding style code are: height, width, and the border thickness. Here, the height

value is 80px, width value is 100px, and border value is 1px. Use these three factors

to calculate the offset to navigate from one tile to the other. Note that the border

thickness between any two tiles will result in 2 px; that is, 1 px from each tile. The

following is the code that uses the moveByOffset and click() methods to navigate

from tile 1 to tile 11, and from there to tile 5:

public class MoveByOffsetAndClick{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Selectable.html");

WebElement one = driver.findElement(By.name("one"));

WebElement eleven = driver.findElement(By.name("eleven"));

WebElement five = driver.findElement(By.name("five"));

int border = 1;

int tileWidth = 100;

int tileHeight = 80;

Actions builder = new Actions(driver);

//Click on One

builder.moveByOffset(one.getLocation().getX()+border, one.

getLocation().getY()+border).click();

builder.build().perform();

// Click on Eleven

builder.moveByOffset(2*tileWidth+4*border, 2*tileHeight+4*border).

click();

builder.build().perform();

//Click on Five

builder.moveByOffset(-2*tileWidth-4*border,-tileHeight-2*border).

click();

builder.build().perform();

}

Chapter 2

[]

7KHFOLFNRQD:HE(OHPHQWDFWLRQ

We have seen how to click a WebElement by calculating the offset to it. This process

may not be needed every time, especially when the WebElement has its own

LGHQWLÀHUVVXFKDVDQDPHRU,':HFDQXVHDQRWKHURYHUORDGHGYHUVLRQRIWKH

click() method to click directly on the WebElement.

The API syntax for clicking on a WebElement is as follows:

public Actions click(WebElement onElement)

The input parameter for this method is an instance of the WebElement on which the

click action should be performed. This method, like all the other methods in the

Actions class, will return an Actions instance.

Now, let's try to modify the previous code example to use the click(WebElement)

method instead of using the moveByOffset() method to move to the location of the

WebElement and clicking on it using the click() method:

public class ClickOnWebElement{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Selectable.html");

WebElement one = driver.findElement(By.name("one"));

WebElement eleven = driver.findElement(By.name("eleven"));

WebElement five = driver.findElement(By.name("five"));

Actions builder = new Actions(driver);

//Click on One

builder.click(one);

builder.build().perform();

// Click on Eleven

builder.click(eleven);

builder.build().perform();

//Click on Five

builder.click(five)

builder.build().perform();

}

Now the moveByOffset() method has been replaced by the click(WebElement)

method, and all of a sudden the complex coordinate geometry has been removed

from the code. If you're a tester, this is one more good reason to push your

GHYHORSHUVWRSURYLGHLGHQWLÀHUVIRUWKH:HE(OHPHQWV

Exploring Advanced Interactions of WebDriver

[]

If you observe the previous code or the moveByOffset and click class code, all the

operations of moving the mouse and clicking on one, eleven, and five tiles are built

separately and performed separately. This is not how we use our Actions class.

You can actually build all these actions together and then perform them. So, the

preceding code will turn out to be as follows:

public class ClickOnWebElement{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Selectable.html");

WebElement one = driver.findElement(By.name("one"));

WebElement eleven = driver.findElement(By.name("eleven"));

WebElement five = driver.findElement(By.name("five"));

Actions builder = new Actions(driver);

//Click on One, Eleven and Five

builder.click(one).click(eleven).click(five);

builder.build().perform();

}

The clickAndHold at current location action

The clickAndHold() method is another method of the Actions class that

left-clicks on an element and holds it without releasing the left button of the mouse.

This method will be useful when executing operations such as drag-and-drop. This

method is one of the variants of the clickAndHold() method that the Actions class

provides. We will discuss the other variant in the next section.

Now, open the Sortable.htmlÀOHWKDWcame with the book. You can see that the

tiles can be moved from one position to the other. Now let's try to move tile 3 to

the position of tile 2. The sequence of steps that are involved to do this are:

1. Move the cursor to the position of tile 3.

2. Click and hold tile 3.

3. Move the cursor in this position to the tile 2 location.

Now, let's see how this can be accomplished using the WebDriver's clickAndHold()

method:

public class ClickAndHold{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Sortable.html");

Actions builder = new Actions(driver);

Chapter 2

[ 51 ]

//Move tile3 to the position of tile2

builder.moveByOffset(200, 20)

.clickAndHold()

.moveByOffset(120, 0)

.perform();

}

Let's analyze the following line of code:

builder.moveByOffset(200, 20)

.clickAndHold()

.moveByOffset(120, 0)

.perform();

First we move the cursor to the location of tile 3. Then we click and hold tile 3. Then,

we move the cursor by 120px horizontally to the position of tile 2. The last line

performs all the preceding actions. Now, execute this in your eclipse and see what

happens. If you observe closely, our tile 3 doesn't properly go into the position of

tile 2. This is because we are yet to release the left button. We just commanded the

WebDriver to click and hold, but not to release. Yes, in a short while, we will discuss

the release() method of WebDriver.

7KHFOLFN$QG+ROGD:HE(OHPHQWDFWLRQ

In the previous section, we have seen the clickAndHold() method, which will click

and hold a WebElement at the current position of the cursor. It doesn't care with which

element it is dealing with. So, if we want to deal with a particular WebElement on

WKHZHESDJHZHKDYHWRÀUVWPRYHWKHFXUVRUWRWKHDSSURSULDWHSRVLWLRQDQGWKHQ

perform the clickAndHold() action. In order to avoid the hassle of moving the cursor

geometrically, WebDriver provides the developers with another variant or overloaded

method of the clickAndHold() method that takes the WebElement as input.

The API syntax is as follows:

public Actions clickAndHold(WebElement onElement)

The input parameter for this method is the WebElement that has to be clicked

and held. The return type, as in all the other methods of the Actions class, is the

Actions instance.

Now, let's refactor the example in the previous section to use this method, as follows:

public class ClickAndHold{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

Exploring Advanced Interactions of WebDriver

[]

driver.get("file://C:/Sortable.html");

WebElement three = driver.findElement(By.name("three"));

Actions builder = new Actions(driver);

//Move tile3 to the position of tile2

builder.clickAndHold(three)

.moveByOffset(120, 0)

.perform();

}

The only change is that we have removed the action of moving the cursor to the

(200, 20) position and provided the WebElement to the clickAndHold() method

that will take care of identifying the WebElement.

The release at current location action

Now in the previous example, we have seen how to click and hold an element. The

ultimate action that has to be taken on a held WebElement is to release it so that the

element can be dropped or released from the mouse. The release() method is

the one that can release the left mouse button on a WebElement.

The API syntax for the release() method is as follows:

public Actions release()

The preceding method doesn't take any input parameter and returns the Actions

class instance.

Now, let's modify the previous code to include release action in it:

public class ClickAndHoldAndRelease{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Sortable.html");

WebElement three = driver.findElement(By.name("three"));

Actions builder = new Actions(driver);

//Move tile3 to the position of tile2

builder.clickAndHold(three)

.moveByOffset(120, 0)

.release()

.perform();

}

The preceding code will make VXUHWKDWWKHPRXVHLVUHOHDVHGDWWKHVSHFLÀHGORFDWLRQ

Chapter 2

[]

7KHUHOHDVHRQDQRWKHU:HE(OHPHQWDFWLRQ

This is an overloaded version of the release() method. Using this, you can actually

release the currently held WebElement in the middle of another WebElement. In

this way, we don't have to calculate the offset of the target WebElement from the

held WebElement.

The API syntax is as follows:

public Actions release(WebElement onElement)

The input parameter for the preceding method is obviously the target WebElement

where the held WebElement should be dropped. The return type is the instance of

the Actions class.

Let's modify the preceding code example to use this method:

public class ClickAndHoldAndReleaseOnWebElement{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Sortable.html");

WebElement three = driver.findElement(By.name("three"));

WebElement two = driver.findElement(By.name("two"));

Actions builder = new Actions(driver);

//Move tile3 to the position of tile2

builder.clickAndHold(three)

.release(two)

.perform();

}

Check how simple the preceding code looks. We have removed all the moveByOffset

code and added the release() method that takes the WebElement with the name

two as the input parameter.

Invoking the release() or release(WebElement) methods

without calling the clickAndHold() method will result in an

XQGHÀQHGEHKDYLRU

7KHPRYH7R(OHPHQWDFWLRQ

The moveToElement() method is another method of WebDriver that helps us to

move the mouse cursor to a WebElement on the web page.

The API syntax for the moveToElement() method is as follows:

public Actions moveToElement(WebElement toElement)

Exploring Advanced Interactions of WebDriver

[]

The input parameter for the preceding method is the target WebElement where the

mouse should be moved.

Now, go back to The clickAndHold at current location action section of this chapter and

try to modify the code to use this method. The following is the code we have written

in the The clickAndHold at current location action section:

public class ClickAndHold{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Sortable.html");

Actions builder = new Actions(driver);

//Move tile3 to the position of tile2

builder.moveByOffset(200, 20)

.clickAndHold()

.moveByOffset(120, 0)

.perform();

}

In the preceding code, we will replace the moveByOffset(x, y) method with the

moveToElement(WebElement) method:

public class ClickAndHold{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Sortable.html");

WebElement three = driver.findElement(By.name("three"));

Actions builder = new Actions(driver);

//Move tile3 to the position of tile2

builder.moveToElement(three)

.clickAndHold()

.moveByOffset(120, 0)

.perform();

}

In the preceding code, we have moved to tile 3, clicked and held it, and then

moved to the location of tile 2 by specifying its offset. If you want, you can add

the release() method before the perform() method.

There might be a number of ways to achieve the same task. It is

up to the user to choose the appropriate ones that best suit the

given circumstances.

Chapter 2

[ 55 ]

7KHGUDJ$QG'URS%\DFWLRQ

There might be many instances where we may have to drag-and-drop components

or WebElements of a web page. We can accomplish that by using many of the actions

seen until now. But WebDriver has given us a convenient out of the box method to

use. Let's see its API syntax.

The API syntax for the dragAndDropBy() method is as follows:

public Actions dragAndDropBy(WebElement source,

int xOffset,int yOffset)

The WebElement input parameter is the target WebElement to be dragged, the

xOffset parameter is the horizontal offset to be moved, and the yOffset parameter

is the vertical offset to be moved.

/HWVVHHDFRGHH[DPSOHIRULW2SHQWKH+70/ÀOHDragMe.html, provided with

this book. You can actually drag that rectangle to any location on the web page. Let's

see how we can do that using WebDriver. The following is the code example for that:

public class DragMe {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/DragMe.html");

WebElement dragMe = driver.findElement(By.id("draggable"));

Actions builder = new Actions(driver);

builder.dragAndDropBy(dragMe, 300, 200).perform();

}

In the preceding code, dragMeLVWKH:HE(OHPHQWWKDWLVLGHQWLÀHGE\LWVId, and that

is dragged 300px horizontally and 200px vertically.

The dragAndDrop action

The dragAndDrop() method is similar to the dragAndDropBy() method. The only

difference being that instead of moving the WebElement by an offset, we move

it on to a target element.

The API syntax for the dragAndDrop() method is as follows:

public Actions dragAndDrop(WebElement source,

WebElement target)

The input parameters for the preceding method are the WebElement source and the

WebElement target, while the return type is the Actions class.

Exploring Advanced Interactions of WebDriver

[]

Let's see a working code example for it. Open the DragAndDrop.htmlÀOHWKDW

is provided with the book. Here we can actually drag the Drag me to my target

rectangle to the Drop here rectangle. Try that. Let's see how that can be achieved

using WebDriver:

public class DragAndDrop {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/DragAndDrop.html");

WebElement src = driver.findElement(By.id("draggable"));

WebElement trgt = driver.findElement(By.id("droppable"));

Actions builder = new Actions(driver);

builder.dragAndDrop(src, trgt).perform();

}

,QWKHSUHFHGLQJFRGHWKHVRXUFHDQGWDUJHW:HE(OHPHQWVDUHLGHQWLÀHGE\WKHLU,'V

and the dragAndDrop() method is used to drag one to the other.

The doubleClick at current location action

Moving on to another action that can be performed using mouse, doubleClick()

is another out of the box method that WebDriver provides to emulate the

double-clicking of the mouse. This method, like the click() method, comes in

WZRÁDYRUV2QHLVGRXEOHFOLFNLQJD:HE(OHPHQWZKLFKZHZLOOGLVFXVVLQQH[W

section; the second is clicking at the current location of the cursor, which will be

discussed here.

The API syntax is as follows:

public Actions doubleClick()

Obviously, the preceding method doesn't take any input parameters, as it just clicks

on the current cursor location and returns an Actions class instance.

Let's see how the previous code can be converted to use this method:

public class DoubleClick {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/DoubleClick.html");

WebElement dblClick= driver.findElement(By.name("dblClick"));

Actions builder = new Actions(driver);

builder.moveToElement(dblClick).doubleClick().perform();

}

Chapter 2

[]

In the preceding code, we have used the moveToElement(WebElement) method to

move the mouse to the location of the button element, and just double-clicked at the

current location.

7KHGRXEOH&OLFNRQ:HE(OHPHQWDFWLRQ

Now that we have seen a method that double-clicks at the current location, we will

discuss another method that WebDriver provides to emulate the double-clicking

of a WebElement.

The API syntax for the doubleClick() method is as follows:

public Actions doubleClick(WebElement onElement)

The input parameter for the preceding method is the target WebElement that has

to be double-clicked and the return type is the Actions class.

Let's see a code example for this. Now, open the DoubleClick.htmlÀOHDQGFOLFN

(single) on the Click Me button. You shouldn't see anything happening. Now

double-click on the button; you should see an alert saying Double Clicked !!. Now,

we try to do the same thing using WebDriver. The following is the code to do that:

public class DoubleClick {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/DoubleClick.html");

WebElement dblClick = driver.findElement(By.name("dblClick"));

Actions builder = new Actions(driver);

builder.doubleClick(dblClick).perform();

}

After executing the preceding code, you should see an alert dialog saying that the

button has been double-clicked.

7KHFRQWH[W&OLFNRQ:HE(OHPHQWDFWLRQ

The contextClick() method, also known as right-click, is quite common on many

web pages these days. The context is nothing but a menu; a list of items is associated

to a WebElement based on the current state of the web page. This context menu can

be accessed by a right-click of the mouse on the WebElement. WebDriver provides

the developer with an option of emulating that action using the contextClick()

method. Like many other methods, this method has two variants as well. One is

clicking on the current location and the other overloaded method is clicking on the

WebElement. Lets discuss the context clicking on WebElement here.

Exploring Advanced Interactions of WebDriver

[]

The API syntax for the contextClick() method is as follows:

public Actions contextClick(WebElement onElement)

The input parameter is obviously the WebElement that has to be right-clicked, and

the return type is the Actions instance.

As we do normally, its time to see a code example. If you open the ContextClick.

htmlÀOH\RXFDQULJKWFOLFNRQWKHWH[WYLVLEOHRQWKHSDJHDQGLWZLOOGLVSOD\

the context menu. Now, clicking any item pops up an alert dialog stating which

item has been clicked. Now, let's see how to implement this in WebDriver in the

following code:

public class ContextClick {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/ContextClick.html");

WebElement contextMenu = driver.findElement(By.id("div-context"));

Actions builder = new Actions(driver);

builder.contextClick(contextMenu)

.click(driver.findElement(By.name("Item 4")))

.perform();

}

,QWKHSUHFHGLQJFRGHÀUVWZHKDYHULJKWFOLFNHGXVLQJWKHcontextClick() method

on the WebElement contextMenu, and then left-clicked on Item 4 from the context

menu. This should pop up an alert dialog saying Item 4 Clicked.

The contextClick at current location action

Now that we have seen context click on a WebElement, its time to explore the

contextClick() method at the current mouse location.

The API syntax for the contextClick() method is as follows:

public Actions contextClick()

As expected, the preceding method doesn't expect any input parameter, and

returns the ActionsLQVWDQFH/HWVVHHWKHQHFHVVDU\PRGLÀFDWLRQVQHHGHGWRWKH

previous example in order to use this method. The following is the code refactored

to achieve this:

public class ContextClick {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

Chapter 2

[]

driver.get("file://C:/ContextClick.html");

WebElement contextMenu = driver.findElement(By.id("div-context"));

Actions builder = new Actions(driver);

builder.moveToElement(contextMenu)

.contextClick()

.click(driver.findElement(By.name("Item 4")))

.perform();

}

7KHSUHFHGLQJFRGHÀUVWPRYHVWKHcursor to the div-context WebElement, and

then context clicks it.

Learning keyboard-based interactions

Until now, we have seen all the actions that can be taken using a mouse. It's time

WRORRNDWVRPHRIWKHDFWLRQVWKDWDUHVSHFLÀFWRWKHNH\ERDUGLQWKHActions class.

Basically, there are three different actions that are available in the Actions class that

DUHVSHFLÀFWRWKHNH\ERDUG7KH\DUHWKHkeyUp, keyDown, and sendKeys actions, each

having two overloaded methods. One method is to execute the action directly on the

WebElement, and the other is to just execute the method irrespective of its context.

The keyDown and keyUp actions

The keyDown() method is used to simulate the action of pressing and holding a

key. The keys that we are referencing here are Shift, Ctrl, and Alt keys. The keyUp()

method is used to release the key that is already pressed using the keyDown()

method. The API syntax for the keyDown() method is as follows

public Actions keyDown(Keys theKey) throws IllegalArgumentException

An IllegalArgumentException is thrown when the passed key is not one of the

Shift, Ctrl, and Alt keys.

The API syntax for the keyUp() method is as follows

public Actions keyUp(Keys theKey)

The keyUp action performed on a key, on which a keyDown action is not already

being performed, will result in some unexpected results. So, we have to make sure

we perform the keyUp action after a keyDown action is performed.

Exploring Advanced Interactions of WebDriver

[]

7KHVHQG.H\VPHWKRG

This is used to type in alphanumeric and special character keys into WebElements

such as textbox, textarea, and so on. This is different from the WebElement.

sendKeys(CharSequence keysToSend) method, as this method expects the

WebElements to have the focus before being called. The API syntax for the

sendkeys() method is as follows:

public Actions sendKeys(CharSequence keysToSend)

We expect you to implement a couple of test scripts around these keyboard events

using the keyUp, keyDown, and sendKeys() methods.

6XPPDU\

In this chapter, we have learned how to use the Actions class to create a set of

actions, and build them into a composite action to execute it in one pass using the

perform() method. In this way, we can aggregate a series of complex user actions

into a single functionality, which can be executed in one pass. In the next chapter, we

will see some of the features of WebDriver such as capabilities, taking screenshots,

and so on.

Exploring the Features

of WebDriver

Until the previous chapter, we have seen various basic and advanced interactions

that a user can perform on a webpage using WebDriver. In this chapter, we will

discuss the different capabilities and features of WebDriver that enable the test

script developer to have better control on WebDriver and consequently on the web

application that is under test. The list of features that we are going to cover in this

chapter is as follows:

 Setting the desired capabilities for a browser

 Taking screenshots

 Locating target windows and iFrames

 Exploring Navigate

 Waiting for WebElements to load

 Handling cookies

Let's get started without any further delay.

Setting the desired capabilities for

a browser

You, as DXVHURI:HE'ULYHUKDYHWKHÁH[LELOLW\WRFUHDWHDVHVVLRQIRUDEURZVHU

with your own set of desired capabilities that a browser should or shouldn't have.

Using the capabilities feature in WebDriver, you are given a way to specify your

choice of how your browser should behave.

Exploring the Features of WebDriver

[]

Some of the examples of browser capabilities include enabling a browser session

to support taking screenshots of the webpage, executing custom JavaScript on the

webpage, enabling the browser session to interact with window alerts, and so on.

7KHUHDUHPDQ\FDSDELOLWLHVWKDWDUHVSHFLÀFWRLQGLYLGXDOEURZVHUVEXWWKHUHDUH

VRPHVSHFLÀFFDSDELOLWLHVWKDWDUHJHQHULFWRDOOWKHEURZVHUV:HZLOOGLVFXVVVRPH

of them here, and the remaining, as and when we come across those features in

WKLVERRN7KHEURZVHUVSHFLÀFFDSDELOLWLHVZLOOEHGLVFXVVHGLQJUHDWHUGHWDLOLQ

the next chapter.

Capabilities is an interface in the WebDriver library whose direct implementation is

the DesiredCapabilities class. The series of steps involved in creating a browser

VHVVLRQZLWKVSHFLÀFFDSDELOLWLHVLVDVIROORZV

1. Identify all of the capabilities that you want to arm your browser with.

2. Create a DesiredCapabilities class instance and set all of the capabilities

to it.

3. Now, create an instance of WebDriver with all of the above capabilities

passed to it.

This will create an instance of Firefox/IE/Chrome or whichever browser you have

instantiated with all of your desired capabilities.

Let's create an instance of FirefoxDriver while enabling the takesScreenShot

capability:

public class BrowserCapabilities {

public static void main(String... args) {

Map capabilitiesMap = new HashMap();

capabilitiesMap.put("takesScreenShot", true);

DesiredCapabilities capabilities

= new DesiredCapabilities(capabilitiesMap);

WebDriver driver = new FirefoxDriver(capabilities);

driver.get("http://www.google.com");

}

In the preceding code, we set all of the capabilities that we desire in a map and

created an instance of DesiredCapabilities using that map. Now, we have created

an instance of FirefoxDriver with these capabilities. This will now launch a Firefox

browser that will have support for taking screenshots of the webpage. If you see

WKHGHÀQLWLRQRIWKHDesiredCapabilities class, the constructor of the class is

overloaded in many different ways. Passing a map is one of them. You can use the

default constructor and create an instance of the DesiredCapabilities class, and

then set the capabilities using the setCapability() method.

Chapter 3

[]

Some of the default capabilities that are common across browsers are shown in the

following table:

Capability What it is used for

takesScreenShot Tells whether the browser session can take a screenshot

of the webpage

handlesAlert Tells whether the browser session can handle modal

dialogs

cssSelectorsEnabled Tells whether the browser session can use CSS selectors

while searching for elements

javascriptEnabled Enables/disables user-supplied JavaScript execution in

the context of the webpage

acceptSSLCerts Enables/disables the browser to accept all of the SSL

certificates by default

webStorageEnabled This is an HTML5 feature, and it is possible to enable

or disable the browser session to interact with storage

objects

There are many other capabilities of WebDriver, and we will talk about them

when we cover individual features; some in this chapter, and the remaining

in the upcoming chapters.

Taking screenshots

Taking a screenshot of a webpage is a very useful capability of WebDriver. This is

very handy when your test case fails, and you want to see the state of the application

when the test case failed. The TakesScreenShot interface in the WebDriver library

is implemented by all of the different variants of WebDriver, such as Firefox Driver,

Internet Explorer Driver, Chrome Driver, and so on.

The TakesScreenShot capability is enabled in all of the browsers by default. Because

this is a read-only capability, a user doesn't have much say on toggling it. Before we

see a code example that uses this capability, we should look at an important method

of the TakesScreenShot interface—getScreenshotAs().

The API syntax for getScreenshotAs() is as follows:

public <X> X getScreenshotAs(OutputType<X> target)

Exploring the Features of WebDriver

[]

Here, OutputType is another interface of the WebDriver lib. We can ask WebDriver

to give your screenshot in three different formats; they are: BASE64, BYTES (raw

data), and FILE. If you choose the FILE format, it writes the data into a .pngÀOH

ZKLFKZLOOEHGHOHWHGRQFHWKH-90LVNLOOHG6R\RXVKRXOGDOZD\VFRS\WKDWÀOH

into a safe location so that it can be used for later reference.

7KHUHWXUQW\SHLVDVSHFLÀFRXWSXWWKDWGHSHQGVRQWKHVHOHFWHGOutputType.

For example, selecting OutputType.BYTES will return a byte array, and selecting

OutputType.FILEZLOOUHWXUQDÀOHREMHFW

Depending on the browser used, the output screenshot will be one of the following

in the order of preference:

 The entire page

 The current window

 A visible portion of the current frame

 The screenshot of the entire display containing the browser

 For example, if you are using Firefox Driver, getScreenshotAs() takes the

screenshot of the entire page, but Chrome Driver returns only the visible

portion of the current frame.

 It's time to take a look at the following code example:

public class TakesScreenShotExample{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("http://www.packtpub.com/");

File scrFile = ((TakesScreenShot)driver).

getScreenshotAs(OutputType.FILE);

System.out.println(scrFile.getAbsolutePath());

}

 In the preceding code, we have used the getScreenshotAs() method

WRWDNHWKHVFUHHQVKRWRIWKHZHESDJHDQGVDYHLWWRDÀOHIRUPDW7KH

getAbsolutePath() method returns the path of the saved image, which

you can open and examine.

7KHÀOHWRZKLFKWKHVFUHHQVKRWGDWDLVZULWWHQLVDWHPSRUDU\ÀOH

and will be deleted as soon as the JVM exits. So it is a good idea to

FRS\WKHÀOHEHIRUHWKHWHVWFRPSOHWHV

Chapter 3

[]

/RFDWLQJWDUJHWZLQGRZVDQGL)UDPHV

WebDriver enables the developers to switch easily between the multiple windows or

frames an application loads in. For instance, when you click on the Internet banking

link on a bank web application, it will open the Internet banking application in a

separate window. At this point, you may want to switch back to the original window

to handle some events. Similarly, you may have to deal with a web application

that is divided into two frames on the web page. The frame on the left may contain

navigation items, and the frame on the right displays the appropriate web page

based on what is selected in the frame on the left. Using WebDriver, you can develop

test cases that can easily handle such complex situations.

The WebDriver.TargetLocator interface is used to locate a given frame or window.

In this section, we will see how WebDriver handles switching between browser

windows and between two frames in the same window.

6ZLWFKLQJDPRQJZLQGRZV

First, we will see a code example for handling multiple windows. For this chapter,

WKHUHLVDQ+70/ÀOHSURYLGHGZLWKWKLVERRNQDPHGWindow.html. It is a very

basic web page that links to the Google Search page. When you click on the link, the

Google Search page is opened in a different window. Every time you open a web

page using WebDriver in a browser window, WebDriver assigns a window handle

WRWKDW:HE'ULYHUXVHVWKLVLGHQWLÀHUWRLGHQWLI\WKHZLQGRZ$WWKLVSRLQWLQ\RXU

WebDriver, there are two window handles registered. Now, on the screen, you can

see that the Google Search page is in the front and has the focus. At this point, if you

ZDQWWRVZLWFKWRWKHÀUVWEURZVHUZLQGRZ\RXFDQXVH:HE'ULYHUVswitchTo()

method to do that.

The API syntax for TargetLocator is as follows:

WebDriver.TargetLocator switchTo()

This method returns the WebDriver.TargetLocator instance, where you can tell the

WebDriver whether to switch between browser windows or frames. Let's see how

WebDriver deals with this:

public class WindowHandling {

public static void main(String... args){

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Window.html");

String window1 = driver.getWindowHandle();

System.out.println("First Window Handle is: "+window1);

Exploring the Features of WebDriver

[]

WebElement link = driver.findElement(By.linkText("Google

Search"));

link.click();

String window2 = driver.getWindowHandle();

System.out.println("Second Window Handle is: "+window2);

System.out.println("Number of Window Handles so for: "

+driver.getWindowHandles().size());

driver.switchTo().window(window1);

}

Observe the following line in the preceding code:

String window1 = driver.getWindowHandle();

+HUHWKHGULYHUUHWXUQVWKHDVVLJQHGLGHQWLÀHUIRUWKHZLQGRZ1RZEHIRUHZH

move on to a different window, it is better to store this value so that if we want to

VZLWFKEDFNWRWKLVZLQGRZZHFDQXVHWKLVKDQGOHRULGHQWLÀHU,QRUGHUWRUHWULHYH

all of the window handles that are registered with your driver so far, you can use

the following method:

driver.getWindowHandles()

7KLVZLOOUHWXUQWKHVHWRILGHQWLÀHUVRIDOORIWKHEURZVHUZLQGRZKDQGOHVRSHQHG

in the driver session so far. Now, in our example, after we open the Google Search

page, the window corresponding to it is shown in front with the focus. If you want

WRJREDFNWRWKHÀUVWZLQGRZZHKDYHWRXVHWKHIROORZLQJFRGH

driver.switchTo().window(window1);

7KLVZLOOEULQJWKHÀUVWZLQGRZLQWRIRFXV

6ZLWFKLQJDPRQJIUDPHV

Let us now see how we can handle switching among the frames of a web page. In

WKH+70/ÀOHVVXSSOLHGZLWKWKLVERRN\RXZLOOVHHDÀOHQDPHGFrames.html. If

\RXRSHQWKDW\RXZLOOVHHWZR+70/ÀOHVORDGHGLQWZRGLIIHUHQWIUDPHV/HW

Let's see how we can switch between them and type into the text boxes available in

each frame.

public class SwitchBetweenFrames {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("file://C:/Frames.html");

Chapter 3

[]

Actions action = new Actions(driver);

driver.switchTo().frame(0);

WebElement txt = driver.findElement(By.name("1"));

txt.sendKeys("I'm Frame One");

driver.switchTo().defaultContent();

driver.switchTo().frame(1);

txt = driver.findElement(By.name("2"));

txt.sendKeys("I'm Frame Two");

}

In the preceding code, we have used switchTo().frame instead of switchTo().

window because we are moving across frames.

The API syntax for frame is as follows:

WebDriver frame(int index)

This method takes the index of the frame that you want to switch to. If your web

page has three frames, WebDriver indexes them as 0, 1, and 2 where the zero index

LVDVVLJQHGWRWKHÀUVWIUDPHHQFRXQWHUHGLQWKH'206LPLODUO\\RXFDQVZLWFK

among frames using their names by using the overloaded method of the above.

The API syntax is as follows:.

WebDriverframe(String frameNameOrframeID)

You can pass the name of the frame or its ID. Using this, you can switch to the frame

if you are not sure about the index of the target frame. The other overloaded method

is as follows:

WebDriver frame(WebElement frameElement)

The input parameter is the WebElement of the frame.

ComingEDFNWRRXUFRGHH[DPSOHÀUVWZHKDYHVZLWFKHGWRRXUÀUVWIUDPHDQG

W\SHGLQWRWKHWH[WÀHOG7KHQLQVWHDGRIGLUHFWO\VZLWFKLQJWRWKHVHFRQGIUDPHZH

have come to the main or default content, and then switched to the second frame.

The code for that is as follows:

driver.switchTo().defaultContent();

Exploring the Features of WebDriver

[]

This is very important. If you don't do this, and try to switch to the second frame

ZKLOH\RXDUHVWLOOLQWKHÀUVWIUDPH\RXU:HE'ULYHUZLOOFRPSODLQVD\LQJWKDWLW

FRXOGQWÀQGDIUDPHZLWKLQGH[1. This is because the WebDriver searches for the

VHFRQGIUDPHLQWKHFRQWH[WRIWKHÀUVWIUDPHZKLFKLVREYLRXVO\QRWDYDLODEOH6R

\RXKDYHWRÀUVWFRPHWRWKHWRSOHYHOFRQWDLQHUDQGVZLWFKWRWKHIUDPH\RXDUH

interested in.

After switching to the default content, you can now switch to the second frame using

the following code:

driver.switchTo().frame(1);

Thus, you can switch between the frames and execute the corresponding

WebDriver actions.

Handling alerts

Apart from switching between windows and frames, you may have to handle

various modal dialogs in a web application. For this, WebDriver provides an

API to handle alert dialogs. The API for that is as follows:

Alert alert()

The preceding method will switch to the currently active modal dialog on the web

page. This returns an Alert instance where appropriate actions can be taken on that

dialog. If there is no dialog currently present, and you invoke this API, it throws

back a NoAlertPresentException.

The Alert interface contains a number of APIs to execute different actions. The

following list discusses them one after the other:

 void accept(): This is equivalent to the OK button action on the dialog.

The corresponding OK button actions are invoked when the accept()

action is taken on a dialog.

 void dismiss():This is equivalent to clicking on the CANCEL action button.

 java.lang.String getText(): This will return the text that appears on the

dialog. This can be used if you want to evaluate the text on the modal dialog.

 void sendKeys(java.lang.String keysToSend): This will allow the

developer to type in some text into the alert if the alert has some provision

for it.

Chapter 3

[]

Exploring Navigate

As we know, WebDriver talks to individual browsers natively. This way it has better

control, not just on the web page, but on the browser itself. Navigate is one such

feature of WebDriver that allows the test script developer to work with the browser's

Back, Forward, and Refresh controls. As users of a web page, quite often, we use

the browser's Back and Forward controls to navigate between the pages of a single

application, or sometimes, multiple applications. As a test script developer, you may

want to develop tests that observe the behavior of the application when browser

navigation buttons are clicked, especially the Back button. For example, if you use

your navigation button in a banking application, the session should expire and the

user should be logged out. So, using the WebDriver's navigation feature, you can

emulate those actions.

The method that is used for this purpose is navigate(). The following is its

API syntax:

WebDriver.Navigation navigate()

Obviously, there is no input parameter for this method, but the return type is the

WebDriver.Navigation interface, which contains all of the browser navigation

options that help you navigate through your browser's history.

Now let's see a code example and then analyze the code:

public class WebDriverNavigate{

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.navigate().to("http://www.google.com");

WebElement searchBox = driver.findElement(By.name("q"));

searchBox.sendKeys("Selenium WebDriver");

WebElement searchButton = driver.findElement(By.name("btnG"));

searchButton.click();

searchBox.clear();

searchBox.sendKeys("Packt Publishing");

searchButton.click();

driver.navigate().back();

driver.navigate().forward();

driver.navigate().refresh();

}

Exploring the Features of WebDriver

[]

The SUHFHGLQJFRGHRSHQVWKH*RRJOH6HDUFKSDJHDQGDWÀUVWVHDUFKHVIRUWKHWH[W

Selenium WebDriver; then, after the search results are loaded, it does a second

search for Packt Publishing and waits for the results. Now that we have a

navigation history created in the browser, it uses WebDriver navigation to go

back in the browser history, then go forward and refresh the page.

Let's analyze the navigation methods used in the preceding code. The line of code

that initially loads the Google web page uses the to() method of the Navigation

class as follows:

driver.navigate().to("http://www.google.com");

+HUHÀUVWdriver.navigate() returns the WebDriver.Navigation interface on

which the to() method is used to navigate to a web URL. The API syntax is as follows:

void to(java.lang.String url)

The input parameter for this method is the url string that has to be loaded in the

browser. This method will load the page in the browser by using the HTTP GET

operation, and it will block everything else until the page is completely loaded.

This method is the same as the driver.get(String url) method.

The WebDriver.Navigation interface also provides an overloaded method of this

to() method to make it easy to pass the URL. The API syntax for it is as follows:

void to(java.net.URL url)

Next, in the code example, we did a couple of searches for Selenium WebDriver and

Packt Publishing. Then, we tried to use Navigation's back() method to emulate

our browser's Back button using the following line of code:

driver.navigate().back();

This will take the browser to the Selenium WebDriver search results page. The API

syntax for this method is pretty straightforward, as follows:

void back()

This method doesn't take any input and doesn't return anything as well, but takes

the browser one level back in its history.

Then, the next method in the navigation is the forward() method, which is pretty

much similar to the back() method, but takes the browser one level in the opposite

direction. In the preceding code example, invoking the following should take the

browser to the Packt Publishing search results:

driver.navigate().forward();

Chapter 3

[]

The API syntax for the method is as follows:

void forward()

This method doesn't take any input and doesn't return anything as well, but takes

the browser one level forward in its history.

The last line of code in the code example uses the refresh() method of WebDriver's

navigation:

driver.navigate().refresh();

This method will reload the current URL to emulate the browser's refresh (F5 key)

action. The API syntax is as follows:

void refresh()

As you can see, the syntax is very similar to the back() and forward() methods,

and this method will reload the current URL. Hence, these are the various methods

WebDriver provides the developers to emulate some browser actions.

:DLWLQJIRU:HE(OHPHQWVWRORDG

If you have a previous WebUI automation experience, I'm sure you would have

FRPHDFURVVDVLWXDWLRQZKHUH\RXUWHVWVFULSWFRXOGQWÀQGDQHOHPHQWRQWKH

webpage as the webpage is still loading. This could happen due to various reasons.

One classic example is when the application server or webserver is serving the page

too slowly due to resource constraints; the other could be when you are accessing the

page on a very slow network. The reason could be that the element on the webpage

LVQRWORDGHGE\WKHWLPH\RXUWHVWVFULSWWULHVWRÀQGLW7KLVLVZKHUH\RXKDYH

WRFDOFXODWHDQGFRQÀJXUHWKHDYHUDJHZDLWWLPH\RXUWHVWVFULSWVVKRXOGZDLWIRU

WebElements to load on the webpage.

WebDriver provides the test script developers a very handy feature to manage wait

time. Wait time is the time your driver will wait for the WebElement to load before it

gives up and throws NoSuchElementException. Remember, in Chapter 1, Introducing

WebDriver and WebElements, we have discussed the findElement(By by) method

that throws NoSuchElementExceptionZKHQLWFDQQRWÀQGWKHWDUJHW:HE(OHPHQW

There are two ways by which you can make WebDriver wait for WebElement. They

are implicit wait time and Explicit wait time. Implicit timeouts are common to all the

WebElements and has a global timeout period associated to it, but the explicit timeouts

FDQEHFRQÀJXUHG to individual WebElements. Let's discuss each of them here.

Exploring the Features of WebDriver

[]

,PSOLFLWZDLWWLPH

Implicit wait timeLVXVHGZKHQ\RXZDQWWRFRQÀJXUH the WebDriver's wait time as

a whole for the application under test. Imagine you have hosted a web application

on a local server and on a remote server. Obviously, the time to load for a webpage

hosted on a local server would be less than the time for the same page hosted on a

remote server, due to network latency. Now, if you want to execute your test cases

DJDLQVWHDFKRIWKHP\RXPD\KDYHWRFRQÀJXUHWKHZDLWWLPHDFFRUGLQJO\VXFKWKDW

your test case doesn't end up spending more time waiting for the page or spend far

too less time and timeout. To handle these kind of wait time issues, WebDriver gives

an option to set the implicit wait time for all of the operations that the driver does

using the manage() method.

Let's see a code example of implicit wait time:

public class ImplicitWaitTime {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.manage().timeouts().implicitlyWait(10, TimeUnit.

SECONDS);

driver.get("www.google.com");

}

Let us analyze the following highlighted line of code:

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

Here, driver.manage().timeouts() returns WebDriver.Timeouts interface, which

declares a method named implicitlyWait, which is where you specify the amount

of time the driver should wait when searching for a WebElement on a webpage if it is

not immediately present. Periodically, the WebDriver will poll for the WebElement on

WKHZHESDJHXQWLOWKHPD[LPXPZDLWWLPHVSHFLÀHGWRWKHSUHYLRXVPHWKRGLVRYHU,Q

the preceding code, 10 seconds is the maximum wait time your driver will wait for any

WebElement to load on your browser. If it loads within this time period, WebDriver

proceeds with the rest of the code; else, it will throw a NoSuchElementException.

Use this method when you want to specify a maximum wait time, which is

generally common for most of the WebElements on your web application. The

YDULRXVIDFWRUVWKDWLQÁXHQFHWKHSHUIRUPDQFHRI\RXUSDJHDUHQHWZRUNEDQGZLGWK

VHUYHUFRQÀJXUDWLRQDQGVRRQ%DVHGRQWKRVHFRQGLWLRQVDVDGHYHORSHURI\RXU

WebDriver test cases, you have to arrive at a value for the maximum implicit wait

time, such that your test cases don't take too long to execute and at the same time

don't timeout very frequently.

Chapter 3

[]

([SOLFLWZDLWWLPH

Implicit timeout is generic to all the WebElements of a web page. But, if you have

RQHVSHFLÀF:HE(OHPHQWLQ\RXUDSSOLFDWLRQZKHUH\RXZDQWWRZDLWIRUDYHU\ORQJ

time, this approach may not work. Setting the implicit wait time to the value of this

very long time period will delay your entire test suite execution. So you have to

make an exception for only a particular case, like this WebElement. To handle such

scenarios, WebDriver has explicit wait time for a WebElement.

So let's see how you can wait for a particular WebElement using WebDriver with the

following code:

public class ExplicitWaitTime {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

WebElement element = (new WebDriverWait(driver, 20)).until(new

ExpectedCondition<WebElement>() {

@Override

public WebElement apply(WebDriver d) {

return d.findElement(By.name("q"));

}

});

}

The highlighted code is where we have created a conditional wait for a particular

WebElement. The ExpectedCondition interface can be used to apply the conditional

wait on a WebElement. Here, WebDriver will wait for a maximum of 20 seconds

for this particular WebElement. The implicit timeout doesn't get applied for this

WebElement. If the WebElement doesn't load within the 20 seconds maximum wait

time, as we know, the driver throws a NoSuchElementException. Thus, you can

override the implicit wait time exclusively for the WebElements you think will take

more time by using this handy explicit wait time.

Handling cookies

Let's say you are automating the Facebook webpage. There could be many scenarios

you want to automate, such as writing on your wall, writing on your friend's

wall, reading other walls, adding friends, deleting friends, and so on. For all these

actions, one common thing is to have to log in to Facebook in each of the test cases.

So, logging in to Facebook in every test case of yours will increase the overall test

H[HFXWLRQWLPHVLJQLÀFDQWO\7RUHGXFHWKHH[HFXWLRQWLPHRI\RXUWHVWFDVHV\RX

can actually skip signing in for every test case. This can be done by signing in for

RQHWLPHDQGZULWLQJDOOWKHFRRNLHVRIWKDWGRPDLQLQWRDÀOH)URPWKHQH[WORJLQ

RQZDUGV\RXFDQDFWXDOO\ORDGWKHFRRNLHVIURPWKHÀOHDQGDGGWRWKHGULYHU

Exploring the Features of WebDriver

[]

To fetch all of the cookies that are loaded for a webpage, WebDriver provides the

following method:

driver.manage().getCookies()

This will return all of the cookies that the web page stores in the current session.

Each cookie is associated with a name, value, domain, path, expiry, and the status of

whether it is secure or not. The server to validate a client cookie parses all of these

YDOXHV1RZZHZLOOVWRUHDOORIWKLVLQIRUPDWLRQIRUHDFKFRRNLHLQDÀOHVRWKDWRXU

LQGLYLGXDOWHVWFDVHVUHDGIURPWKLVÀOHDQGORDGWKDWLQIRUPDWLRQLQWRWKHGULYHU

Hence, you can skip the login, because once your driver session has this information

in it, the Facebook server treats your browser session as authenticated and directly

takes you to your requested URL.

The following is a quick code to store the cookie information:

package com.packt.webdriver.chapter3;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import org.openqa.selenium.By;

import org.openqa.selenium.Cookie;

import org.openqa.selenium.WebDriver;

import org.openqa.selenium.firefox.FirefoxDriver;

public class StoreCookieInfo {

public static void main(String... args) {

WebDriver driver = new FirefoxDriver();

driver.get("http://www.facebook.com");

driver.findElement(By.name("email")).sendKeys("<<ur mailID>>");

driver.findElement(By.name("pass")).sendKeys("<<ur password>>");

driver.findElement(By.name("persistent")).click();

driver.findElement(By.name("pass")).submit();

File f = new File("browser.data");

try{

f.delete();

f.createNewFile();

FileWriter fos = new FileWriter(f);

BufferedWriter bos = new BufferedWriter(fos);

Chapter 3

[]

for(Cookie ck : driver.manage().getCookies()) {

bos.write((ck.getName()+";"+ck.getValue()+";"+ck.

getDomain()

+";"+ck.getPath()+";"+ck.getExpiry()+";"+ck.

isSecure()));

bos.newLine();

}

bos.flush();

bos.close();

fos.close();

}catch(Exception ex){

ex.printStackTrace();

}

From now on, for every test case or a set of test cases, load the cookie information

from the browser.dataÀOHDQGDGGLWWRWKHGULYHUXVLQJWKHIROORZLQJPHWKRG

driver.manage().addCookie(ck);

After you add this information to your browser session and go to the Facebook page,

it will automatically redirect you to the home page without asking for a login, thus

avoiding a login every time for every test case. The code that adds all of the previous

cookies to the driver is as follows:

package com.packt.webdriver.chapter3;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.util.Date;

import java.util.StringTokenizer;

import org.openqa.selenium.Cookie;

import org.openqa.selenium.WebDriver;

import org.openqa.selenium.firefox.FirefoxDriver;

public class LoadCookieInfo {

public static void main(String... args){

WebDriver driver = new FirefoxDriver();

driver.get("http://www.facebook.com");

try{

Exploring the Features of WebDriver

[]

File f = new File("browser.data");

FileReader fr = new FileReader(f2);

BufferedReader br = new BufferedReader(fr);

String line;

while((line=br.readLine())!=null){

StringTokenizer str = new StringTokenizer(line,";");

while(str.hasMoreTokens()){

String name = str.nextToken();

String value = str.nextToken();

String domain = str.nextToken();

String path = str.nextToken();

Date expiry = null;

String dt;

if(!(dt=str.nextToken()).equals("null")){

expiry = new Date(dt);

}

boolean isSecure = new Boolean(str.nextToken()).

booleanValue();

Cookie ck = new Cookie(name,value,domain,path,expi

ry,isSecure);

driver.manage().addCookie(ck);

}

}catch(Exception ex){

ex.printStackTrace();

}

driver.get("http://www.facebook.com");

}

Thus, we can be directly taken to the home page without logging in again and again.

If you observe, after creating the driver instance, we have the following line:

driver.get("http://www.facebook.com");

Ideally, this line should be visible after we have set the cookies to the driver. But the

reason it is at the top is because the WebDriver doesn't allow you to set the cookies

directly into this session, because it treats those cookies as if they are from a different

domain. Try removing the previous line of code and execute it, and you will see the

error. So, initially you will try to visit the Facebook page to set the domain value

of the driver to Facebook and load all of the cookies. When you execute this code,

initially you will see the login page of Facebook, and you will be automatically taken

to the home page when the same code at the end is invoked again after the cookies

are loaded.

Chapter 3

[]

Thus, you can avoid entering the username and password on the server validating

them again and again for each test, and thereby save a lot of time by using the

WebDriver's cookies feature.

6XPPDU\

In this chapter, we have discussed the various features of WebDriver. Using these

features will help you test your target web application more effectively by designing

more innovating test frameworks and test cases.

In the next chapter, we will look at the different available WebDriver implementations.

Different Available

WebDrivers

All this while in the previous chapters, we have discussed many features

of WebDriver using FirefoxDriver. Similar to FirefoxDriver, which is an

LPSOHPHQWDWLRQRI:HE'ULYHUVSHFLÀFWRWKH)LUHIR[EURZVHUZHKDYHPDQ\

RWKHULPSOHPHQWDWLRQVRI:HE'ULYHUVSHFLÀFWRYDULRXVRWKHUEURZVHUVVXFKDV

Internet Explorer, Chrome, Safari, and Opera. In this chapter, we will go through

details of each of these implementations starting with Firefox Driver. Though all

these implementations have all the features of WebDriver that we have discussed

VRIDUWKHUHDUHDIHZWKLQJVWKDWDUHVSHFLÀFWRDSDUWLFXODUEURZVHULPSOHPHQWDWLRQ

,QWKHFKDSWHUZHZLOOFRQFHQWUDWHPRUHRQWKHVHVSHFLÀFV

FirefoxDriver

The FirefoxDriver works as an extension to the Firefox browser. It uses the

XPCOM (Cross Platform Component Object Model) framework of Mozilla

to execute the commands sent by the language bindings. Language bindings

communicate with the extension, that is, FirefoxDriver, by connecting over a socket

and sending commands. This socket is bound to a port, which is called the locking

port; typically, it would be 7055. The reason it is called the locking port is because it

is used as a mutex so that it allows only one instance of Firefox to listen to a Firefox

Driver on that port.

After this socket is established, the client language binding (in our case, the Java

binding) sends the commands to the Firefox extension in a serialized JSON format.

The JSON format contains the following components:

 Context: This is the current window or frame

 CommandName: For example, DragAndDrop, SendKeys

Different Available WebDrivers

[]

 Parameters: This can be empty, or sometimes the text will need to be typed

 ElementId: This is the ID of the element on which the action has to be

performed

This serialized JSON is sent over the socket or wire established earlier to the Firefox

Extension or FirefoxDriver. This is the reason Selenium-2 or WebDriver is said to be

working on JSON-Wire protocol.

Once the commands reach from the client language bindings to the FirefoxDriver,

it deserializes the JSON, and the commands are interpreted and looked up in the

Firefox Driver prototype, which are the JavaScript functions for each command.

After execution, the response is sent back via the socket to the client. This response

is again a JSON that contains methodName (this is same as the commandName in the

request), Context, isError (indicating if an error has occurred, so that the client can

thrown an exception), and ResponseText (the output of the command executed).

1RZWKDWZHKDYHVHHQWKHEDVLFÁRZRIKRZWKH)LUHIR['ULYHUZRUNVLQWKH

following section, we will learn about the Firefox browser, how it maintains user

SURÀOHVLWVSUHIHUHQFHVDQGKRZ\RXFDQGHDOZLWKWKHPXVLQJ)LUHIR[:HE'ULYHU

As you know, different browsers have different ways and mechanisms to deal with

its user's choices and preferences. Similarly, Firefox has its own way. To start with,

OHWXVWDNHDORRNDWZKDWD)LUHIR[SURÀOHLV

8QGHUVWDQGLQJWKH)LUHIR[SUR¿OH

$)LUHIR[SURÀOHLVDIROGHUWKDWWKHFirefox browser uses to store all your passwords,

bookmarks, settings, and all other user data. A Firefox user can create any number of

SURÀOHVZLWKGLIIHUHQWFXVWRPVHWWLQJVDQGXVHLWDFFRUGLQJO\$FFRUGLQJWR0R]LOOD

WKHIROORZLQJDUHWKHGLIIHUHQWDWWULEXWHVWKDWFDQEHVWRUHGLQWKHSURÀOHV

 Bookmarks and browsing history

 Passwords

 6LWHVSHFLÀFSUHIHUHQFHV

 Search engines

 A personal dictionary

 Autocomplete history

 Download history

 Cookies

 DOM Storage

 6HFXULW\FHUWLÀFDWHVHWWLQJV

Chapter 4

[]

 Security device settings

 Download actions

 Plugin MIME types

 Stored sessions

 Toolbar customizations

 User styles

To create, rename, or delete a SURÀOH\RXKDYHto perform the following steps:

1. 2SHQWKH)LUHIR[SURÀOHPDQDJHU7RGRWKDWLQWKHFRPPDQGSURPSW

terminal, you have to navigate to the install directory of Firefox; typically, it

would in Program Files if you are on Windows. Navigate to the location where

\RXFDQÀQGWKHfirefox.exeÀOHDQGH[HFXWHWKHIROORZLQJFRPPDQG

firefox.exe -p

,WZLOORSHQWKHSURÀOHPDQDJHUWKDWZLOOORRNOLNHWKHIROORZLQJVFUHHQVKRW

Note that before executing the above command, you need to make sure you

close all your currently running Firefox instances.

2. Use the &UHDWH3URÀOHEXWWRQWRFUHDWHDQRWKHUSURÀOH5HQDPH3URÀOH

EXWWRQWRUHQDPHDQH[LVWLQJSURÀOHDQG'HOHWH3URÀOH button to delete one.

So, coming back to our WebDriver, whenever we create an instance of FirefoxDriver,

DWHPSRUDU\SURÀOHLVFUHDWHGDQGXVHGE\WKH:HE'ULYHU7RVHHWKHSURÀOHWKDW

is currently being used by a Firefox instance, you have to navigate to Help |

Troubleshooting Information.

Firefox

Choose

User

Profile

Firefox

stores

information

about

your

settings,

preferences,

and

other

user

items

your

user

profile.

default

Create

Profile...

Rename

Profile...

Delete

Profile...

Work

offline

I I

Don't

ask

startup

Start

Firefox

Exit

Different Available WebDrivers

[]

7KLVZLOOODXQFKDOOWKHGHWDLOVRIWKDWSDUWLFXODU)LUHIR[LQVWDQFHRIZKLFKWKHSURÀOH

is a part. It will look similar to the following screenshot:

7KHKLJKOLJKWHGRYDOLQWKHSUHFHGLQJVFUHHQVKRWVKRZVWKHSURÀOHIROGHU&OLFNRQ

the Show Folder button; it should RSHQWKHORFDWLRQRIWKHSURÀOHFRUUHVSRQGLQJWR

that of your current Firefox instance. Now, let's launch a Firefox browser instance

XVLQJRXU)LUHIR['ULYHUDQGYHULI\LWVSURÀOHORFDWLRQ

Let's launch a Firefox browser using the following code:

public class FirefoxProfile {

public static void main(String... args) {

FirefoxDriver driver = new FirefoxDriver();

driver.get("http://www.google.com");

}

Troubleshooting

Information

This

page

contains

technical

information

that

might

useful

when

you're

trying

solve

problem.

you

are

looking

for

answers

common

questions

about

Firefox,

check

out

our

support

website.

Copy

raw

data

clipboard

Copy

text

clipboard

Application

Basics

Name

Firefox

23.0

Version

User

Agent

Mozilla/5.0

(Windows

6.2;

rv:23.0)

Gecko/20100101

Firefox/23.0

Show

Folder

Profile

Folder

about:pluains

Enabled

Plugins

Build

Configuration

Crash

Reports

Memory

Use

about:buildconfia

aboutcrashes

about:memorv

Name

Enablei

Firefox

WebDrivei

:driver©googlecode.coi

Chapter 4

[]

This will launch a browser instance. Now navigate to Help | Troubleshooting

Information, and once the info is launched, click the Show Folder button. This will

RSHQWKHFXUUHQW:HE'ULYHUVSURÀOHGLUHFWRU\(YHU\WLPH\RXODXQFKD)LUHIR[

LQVWDQFHXVLQJ)LUHIR['ULYHULWZLOOFUHDWHDQHZSURÀOHIRU\RX,I\RXJRRQHOHYHO

DERYHWKLVGLUHFWRU\\RXZLOOVHHWKHSURÀOHVFUHDWHGE\\RXU)LUHIR['ULYHUDV

shown in the following screenshot:

All the above folders correspond to each of the Firefox instances launched by the

FirefoxDriver.

8QWLOQRZZHKDYHVHHQZKDW)LUHIR[SURÀOHVDUHDQGKRZ:HE'ULYHUFUHDWHVRQH

every time it launches the browser. Now, let's see how we can create our own custom

SURÀOHVXVLQJ:HE'ULYHU$3,V7KHIROORZLQJLVWKHFRGHH[DPSOHWRFUHDWH\RXU

RZQ)LUHIR[SURÀOHXVLQJWKH:HE'ULYHUOLEUDU\DQGset in it the options you want

your browser to have, overriding what FirefoxDriver gives you:

public class FirefoxCustomProfile {

public static void main(String... args){

FirefoxProfile profile = new FirefoxProfile();

FirefoxDriver driver = new FirefoxDriver(profile);

driver.get("http://www.google.com");

}

grr

P-

Temp

File

Home

View

(?)

Users

Satya

Avasarala

AppData

Local

Temp

I~1

Name

08051

650-00001

0f8-9mggqn504g

08051

650-00001

0f8-569m6rxe6o

08051

651

-000007e4-wt1

a6ppqqa

anonymoi

Date

modified

Type

"if

Favourites

Desktop

Downloads

Recent

places

05/08/2013

16:50

05/08/2013

16:50

05/08/2013

16:51

44ÿ06/2013

19:24

10/06??&K42:13

11/06/2013

2ftfe

11/06/2013