Selenium 2 Testing Tools Beginner's Guide

(1)

(2)

Selenium 2 Testing Tools Beginner's Guide

Learn to use Selenium testing tools from scratch

David Burns

BIRMINGHAM - MUMBAI

(3)

Selenium 2 Testing Tools Beginner's Guide

All rights reserved. No part of this book may be reproduced, stored in a retrieval 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: November 2010 Second published: October 2012 Production Reference: 1091012

Published by Packt Publishing Ltd.

Livery Place 35 Livery Street

Birmingham B3 2PB, UK.

ISBN 978-1-84951-830-7 www.packtpub.com

(4)

Credits

Author David Burns

Reviewers

Tarun Kumar Bhadauria Dave Hunt

Acquisition Editor Usha Iyer

Lead Technical Editor Pramila Balan

Technical Editors Joyslita D'Souza Rohit Rajgor

Project Coordinator Yashodhan Dere

Proofreader Steve Maguire

Indexers

Monica Ajmera Mehta Rekha Nair

Tejal R. Soni

Graphics Aditi Gajjar

Production Coordinators Melwyn D'sa

Arvindkumar Gupta

Cover Work Melwyn D'sa Arvindkumar Gupta

(5)

About the Author

David Burns is a Senior Developer in Test having worked with Selenium for quite a few years. He is a Selenium Core Committer and so he knows and understands what users and developers want from the framework.

I would like to thank everyone in the Selenium community for making this product the great tool it is, and giving me an opportunity to write the Second Edition of this book!

(6)

About the Reviewers

Tarun Kumar Bhadauria has been associated with software testing industry from more than seven years. His primary interest is towards manual testing and he equally enjoys using Selenium for automated testing of web applications. He has been using Selenium from the days of Selenium Remote Control. He has co-authored the official Selenium doc available at SeleniumHQ. He is working as a Test Engineer at Pontiflex.

Dave Hunt lives in Kent, UK, with his wife and young son. He has always had a passion for turning mundane tasks into one-click solutions, and when he discovered Selenium back in 2005, his career in software testing and automation development was sealed. He works from home for Mozilla, where he assists teams to create automated tests for their projects—ranging from Mozilla's web properties to the Firefox web browser and the Thunderbird e-mail client.

(7)

www.PacktPub.com

Support files, eBooks, discount offers and more

You might want to visit www.PacktPub.com for support files and downloads related to your book.

Did you know that Packt offers eBook versions of every book published, with PDF and ePub files available? You can upgrade to the eBook version at 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 [email protected] 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

Do you need instant solutions to your IT questions? PacktLib is Packt's online digital 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

(8)

(9)

(10)

To my loving wife and my amazing boy for giving me the support and drive to finish this book! I love you both!

(11)

(12)

Preface

Selenium WebDriver is the most used tool for browser automation. This book shows developers and testers how to create automated tests using a browser. You will learn how to be able to use Selenium IDE for quick throwaway tests. Or if you want to create tests to last, learn to use Selenium WebDriver.

You will learn to use Selenium WebDriver with both desktop browsers and mobile browsers, and learn good design patterns to make sure your tests will be extremely maintainable.

What this book covers

Chapter 1, Getting Started with Selenium IDE, explains how to install Selenium IDE and record our first tests. We will see what is needed to work against AJAX applications.

Chapter 2, Locators, shows how we can find elements on the page to be used in our tests.

We will use XPath, CSS, Link Text, and ID to find elements on the page so that we can interact with them.

Chapter 3, Overview of Selenium WebDriver, discusses all the history and architectural designs for Selenium WebDriver. You will also go through the necessary items for setting up a development environment.

Chapter 4, Design Patterns, introduces the different design patterns that can be used with Selenium WebDriver. The design patterns will show you how to make your tests more maintainable and allow more people to work on your code.

Chapter 5, Finding Elements, explains all the different techniques to find elements with Selenium WebDriver. This chapter builds on the locators that we learnt in Chapter 2, Locators.

Chapter 6, Working with WebDriver, introduces all the different aspects of getting different browsers that Selenium WebDriver supports on desktop operating systems.

(21)

Chapter 7, Mobile Devices, explains how Selenium WebDriver works on mobile devices to test mobile websites or sites built with responsive web design.

Chapter 8, Getting Started with Selenium Grid, shows us how we can set up our Selenium Grid. We will also take a look at running tests in parallel to try bringing down the time it takes to run tests.

Chapter 9, Advanced User Interactions, explains how to build chains of actions together to help when you need to drag-and-drop or have key combinations working. We will also look at how we can press a mouse button and hold it down while we move the mouse.

Chapter 10, Working with HTML5, explains working with some of the HTML5 technologies that are becoming available to browsers. The Selenium WebDriver APIs are very similar to the JavaScript APIs in the browser to try make use of them easier.

Chapter 11, Advanced Topics, explains how to capture network traffic between the browser and the web server. We finish off by capturing screenshots.

Appendix A, Migrating from Remote Control to WebDriver, introduces how the interaction with the browser has changed and how we can convert our Selenium 1 tests to Selenium 2 to take advantage of the changes in Selenium WebDriver.

What you need for this book

Mozilla Firefox

Google Chrome

Internet Explorer

Opera

Intellij IDEA

Firebug

Firefinder

Selenium IDE

Selenium Grid

Ubuntu Linux

Who this book is for

(22)

Conventions

In this book, you will find several headings appearing frequently.

To give clear instructions of how to complete a procedure or task, we use:

Time for action – heading 1. ^{Action 1}

2. ^{Action 2} 3. Action 3

Instructions often need some extra explanation so that they make sense, so they are followed with:

What just happened?

This heading explains the working of tasks or instructions that you have just completed.

You will also find some other learning aids in the book, including:

Pop quiz – heading

These are short multiple choice questions intended to help you test your own understanding.

Have a go hero – heading

These set practical challenges and give you ideas for experimenting with what you have learned.

You will also find a number of styles of text that distinguish between different kinds of information. Here are some examples of these styles, and an explanation of their meaning.

Code words in text are shown as follows: "We do this by running java–jar selenium-server.jar from a command prompt or from a terminal depending on your operating system."

A block of code is set as follows:

@Before

public void setUp(){

selenium = new FirefoxDriver();

}

(23)

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

–jar selenium-server-standalone.jar

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: "Select Selenium Grid from the drop-down box."

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 [email protected], and mention the book title through 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.

Customer support

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.

(24)

Errata

Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you find a mistake in one of our books—maybe a mistake in the text or 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 book. If you find any errata, please report them by visiting http://www.packtpub.com/support, selecting your book, clicking on the errata submission form link, and entering the details of your errata. Once your errata are verified, your submission will be accepted and the errata will be uploaded to our website, or added to any list of existing errata, under the Errata section of that title.

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 [email protected] 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 [email protected] if you are having a problem with any aspect of the book, and we will do our best to address it.

(25)

(26)

Getting Started with Selenium IDE 1

Test automation is growing in popularity over the years because teams do not have the time or money to invest in large test teams to make sure that applications work as they are expected. Developers also want to make sure that the code they have created works as they expect it to.

Jason Huggins saw this issue too and wanted to make sure that a system he was working on would work on multiple operating systems and browsers. He created Selenium.

Selenium is one of the most well known testing frameworks in the world that is in use. It is an open source project that allows testers and developers alike to develop functional tests to drive the browser. It can be used to record workflows so that developers can prevent future regressions of code. Selenium can work on any browser that supports JavaScript, since Selenium has been built using JavaScript.

In this chapter we shall cover:

What is Selenium IDE

Recording our first test

Updating tests to work with AJAX sites

Using variables in our tests

Debugging tests

Saving tests to be used later

Creating and saving test suites So let's get on with it...

(27)

Important preliminary points

Before we start working through this chapter we need to make sure that Mozilla Firefox is installed on your machine. If you do not have Mozilla Firefox installed you will need to download it from http://www.getfirefox.com/.

What is Selenium IDE

Selenium IDE is a Firefox Add-on developed originally by Shinya Kasatani as a way to use the original Selenium Core code without having to copy Selenium Core onto the server. Selenium Core is the key JavaScript modules that allow Selenium to drive the browser. It has been developed using JavaScript so that it can interact with DOM (Document Object Model) using native JavaScript calls.

Selenium IDE was developed to allow testers and developers to record their actions as they follow the workflow that they need to test.

Time for action – installing Selenium IDE

Now that we understand what Selenium IDE is, it is a good time to install it. At the end of these steps, you will have successfully installed Selenium IDE on to your computer:

1. Go to http://seleniumhq.org/download/.

2. Click on the download link for Selenium IDE. You may see a message appear saying Firefox prevented this site (seleniumhq.org) from asking you to install software on your computer. If you do, click the Allow button.

3. A Firefox prompt will appear, as shown in the following screenshot:

(28)

4. You will then be asked if you would like to install Selenium IDE and the exporter add-ons. These have been made pluggable to the IDE by the work that Adam Goucher did. You will see a screen like the following appear:

5. Once the countdown has finished on the Install button, it will become active; click it.

This will now install Selenium IDE and formatters as Firefox Add-ons.

6. Once the install process is complete it will ask you to restart Firefox. Click the Restart Now button. Firefox will close and then re-open. If you have anything open in another browser it might be worth saving your work, as Firefox will try to go back to its original state but this cannot be guaranteed.

(29)

7. Once the installation is complete, the Add-ons window will show the Selenium IDE and its current version:

What just happened?

You have successfully installed Selenium IDE and we can start thinking about writing our first test.

Selenium IDE

Selenium IDE has been installed, so let's take some time to familiarize ourselves with Selenium IDE. This will give us the foundation that we can use in later chapters.

Open up Selenium IDE by going through the tools menu in Mozilla Firefox. The steps are Tools | Selenium IDE. A window will appear. If the menu bar is not available, which is now the default in Firefox, you can launch Selenium IDE via Firefox | Web Developer | Selenium IDE.

(30)

Starting from the top, I will explain what each of the items are:

Base URL: This is the URL that the test will start at. All open commands will be relative to the Base URL unless a full path is inserted in the open command.

Speed Slider: This is the slider under the Fast and Slow labels on the screen.

Run all the tests in the IDE.

Run a single test in the IDE.

Pause a test that is currently running.

Step through the test once it has paused.

This is the record button. This will be engaged when the test is recording.

The Command selectbox has a list of all the commands that are needed to create a test. You can type into it to use the auto complete functionality or use it as a dropdown.

The Target textbox allows you to input the location of the element that you want to work against.

The Find button, once the target box is populated, can be clicked to highlight the element on the page.

The Value textbox is where you place the value that needs to change. For example, if you want your test to type in an input box on the web page, you would put what you want it to type in the value box.

The Test table will keep track of all your commands, targets, and values. It has been structured this way because the original version of Selenium was styled on FIT tests.

FIT was created by Ward Cunningham and means Framework for Integrated Testing.

The tests were originally designed to be run from HTML files and the IDE keeps this idea for its tests.

If you click the Source tab you will be able to see the HTML that will store the test.

Each of the rows will look like:

<tr>

<td>/chapter1</td>

</tr>

(31)

The area below the Value textbox will show the Selenium log while the tests are running. If an item fails, then it will have an [error] entry.

This area will also show help on Selenium Commands when you are working in the Command selectbox. This can be extremely useful when typing commands into Selenium IDE instead of using the record feature.

The Log tab will show a log of what is happening during the test. The Reference tab gives you documentation on the command that you have highlighted.

Important note: Rules for automation

Now that we have installed Selenium IDE and understood what it is, we can think about working through our first tests. There are a few things that we need to consider when creating your first test. These rules apply to any form of test automation but need to be adhered to especially when creating tests against a User Interface.

Tests should always have a known starting point. In the context of Selenium, this could mean opening a certain page to start a workflow.

Tests should not have to rely on any other tests to run. If a test is going to add something, do not have a separate test to delete it. This is to ensure that if something goes wrong in one test, it will not mean you have a lot of unnecessary failures to check.

Tests should only test one thing at a time.

Tests should clean up after themselves.

These rules, like most rules, can be broken. However, breaking them can mean that you may run into issues later on, and when you have hundreds, or even thousands of tests, these small issues can mean that large parts of a test suite are failing.

With these rules in mind let us create our first Selenium IDE test.

(32)

Time for action – recording your first test with Selenium IDE

We are going to record our first test using Selenium IDE. To start recording the tests we will need to start Mozilla Firefox. Once it has been loaded, you will need to start Selenium IDE.

You will find it under the Tools dropdown menu in Mozilla Firefox or in the Web Developer dropdown menu. Once loaded it will look like the next screenshot. Note that the record button is engaged when you first load the IDE.

To start recording your tests let us do the following:

1. When in record mode, navigate to http://book.theautomatedtester.co.uk/

chapter1.

2. On the Web Application do the following:

1. Click on the radio button.

2. Select another value from the drop-down box, for example, Selenium RC.

(33)

3. Click on the Home Page link.

3. Your test has now been recorded and should look like the previous screenshot. Click the play button that looks like this:

4. Once your test has completed it will look like this:

(34)

What just happened?

We have successfully recorded our first test and played it back. As we can see Selenium IDE has tried to apply the first rule of test automation by specifying the open command. It has set the starting point of the test, in this case /chapter1, and then it began stepping through the workflow that we want to record.

Once the actions have all been completed you will see that all of the actions have a green background. This shows that they have completed successfully. On the left you will see that it has completed one successful test, or run, within Selenium IDE. If you were to write a test that failed, the Failure label would have a 1 next to it.

Pop quiz – Selenium IDE

1. What is the main language that drives Selenium IDE?

a. Ruby b. Python c. JavaScript

(35)

2. Selenium IDE works on Internet Explorer:

a. True b. False

Updating a test to assert items are on the page

In the last few steps we were able to record a workflow that we would expect the user to perform. It will test that the relevant bit of functionality is there, like buttons and links to work against. Unfortunately we are not checking that the other items on the page are there or if they are visible when they should be hidden. We are going to work against the same page as before but we shall make sure that different items are on the page.

There are two mechanisms for validating elements available on the application under test.

The first is assert; this allows the test to check if the element is on the page. If it is not available then the test will stop on the step that failed. The second is verify; this also allows the test to check the element is on the page, but if it isn't then the test will carry

on executing.

To add the assert or verify commands to the tests we need to use the context menu that Selenium IDE adds to Firefox. All that one needs to do is right-click on the element if on Windows or Linux. If you have a Mac, then you will need to do the two finger click to show the context menu.

When the context menu appears, it will look roughly like the following screenshot with the normal Firefox functions above it:

(36)

Time for action – updating a test to verify items on the page

In this section we are going to be recording a test and then we are going to update it to have some verify commands:

1. Open the IDE so that we can start recording.

2. Navigate to http://book.theautomatedtester.co.uk/chapter1.

3. Select Selenium Grid from the drop-down box.

4. Change the Select to Selenium Grid.

5. Verify that Assert that this text is on the page text is mentioned on the right- hand side of the drop-down box, by right-clicking on the text and selecting Verify TextPresent Assert that this text is on the page. You can see the command in the previous screenshot.

6. Verify that the button is on the page. You will need to add a new command for verifyElementPresent with the target verifybutton in Selenium IDE.

7. Now that you have completed the previous steps, your Selenium IDE should look like the following screenshot:

If you now run the test you will see it has verified that what you are expecting to see on the page has appeared. Notice that the verify commands have a darker green color. This is to show that they are more important to the test than moving through the steps. The test has now checked that the text we required is on the page and that the button was there too.

(37)

What would happen if the verify command did not find what it was expecting? The IDE would have thrown an Error stating what was expected was not there, but it carried on with the rest of the test. We can see an example of this in the following screenshot:

The test would not have carried on if it was using assert as the mechanism for validating that the elements and text were loaded with the page.

What just happened?

We have just seen that we can add Asserts or Verification to the page. Selenium IDE does not do this when recording, so it will always be a manual step. We saw that if we use the assert command it will cause the test to stop if it fails while the verify command allows the test to carry on after a failure. Each of these has their merits.

(38)

Have a go hero – recreating the test by using the assert methods

Some of the verify and assert methods are:

verifyElementPresent

assertElementPresent

verifyElementNotPresent

assertElementNotPresent

verifyText

assertText

verifyAttribute

assertAttribute

verifyChecked

assertChecked

verifyAlert

assertAlert

verifyTitle

assertTitle

Pop quiz – verifying and asserting

1. Selenium verifies items on the page when it is recording steps:

a. True b. False

2. What is the difference between verify and assert?

3. If you wanted to validate that a button has appeared on a page, which two commands would be the best to use?

a. verifyTextPresent/assertTextPresent

b. verifyElementPresent/assertElementPresent c. verifyAlertPresent/assertAlertPresent d. verifyAlert/assertAlert

(39)

Comments

Before we carry on further with Selenium, it would be a good time to mention how to create comments in your tests. As all good software developers know, having readable code and having comments can make maintenance in the future much easier. Unlike in software development it is extremely hard, almost impossible, to write self-documenting code. To combat this, it is good practice to make sure that your tests have comments that future software testers can use.

Time for action – adding Selenium IDE comments

To add comments to your tests do the following steps:

1. In the test that was created earlier, right-click on a step. For example, the verify step.

2. The Selenium IDE context menu will be visible as shown in the following screenshot:

3. Click on Insert New Comment. A space will appear between the Selenium commands.

4. Click on the Command textbox and enter in a comment so that you can use it for future maintenance. It will look like the following screenshot:

(40)

What just happened?

We have just had a look at how to create comments. Comments will always appear as purple text in the IDE. This, like in most IDEs, is to help you spot comments quicker when looking through your test cases. Now that we know how to keep our tests maintainable with comments, let's carry on working with Selenium IDE to record/tweak/replay our scripts.

Multiplying windows

Web applications unfortunately do not live in one window of your browser. An example of this could be a site that shows reports. Most reports would have their own window so that people can easily move between them.

Unfortunately in testing terms this can be quite difficult to do, but in this section we will have a look at creating a test that can move between windows.

(41)

Time for action – working with multiple windows

Working with multiple browser windows can be one of the most difficult things to do within a Selenium Test. This is down to the fact that the browser needs to allow Selenium to programmatically know how many child browser processes have been spawned.

In the following examples we shall see the tests click on an element on the page which will cause a new window to appear. If you have a pop-up blocker running, it may be a good idea to disable it for this site while you work through these examples.

1. Open up Selenium IDE and go to the Chapter 1 page on the site.

2. Click on one of the elements on the page that has the text Click this link to launch another window. This will cause a small window to appear.

3. Verify the text in the popup by right-clicking and selecting VerifyText id=popup text within the popup window.

4. Once the window has loaded, click on the Close the Window text inside it.

5. Add a verify command for an element on the page. Your test should now look like the following screenshot:

(42)

Sometimes Selenium IDE will add a clickAndWait instead of a click command.

This is because it notices that the page has to unload. If this happens just change the clickAndWait to a click so that it does not cause a timeout in the test.

What just happened?

In the test script we can see that it has clicked on the item to load the new window and then has inserted a waitForPopUp. This is so that your test knows that it has to wait for a web server to handle the request and the browser to render the page. Any commands that require a page to load from a web server will have a waitFor command.

The next command is the selectWindow command. This command tells Selenium IDE that it will need to switch context to the window, called popupwindow, and will execute all the commands that follow in that window unless told otherwise by a later command.

Once the test has finished with the popup window, it will need to return to the parent window from where it started. To do this we need to specify null as the window. This will force the selectWindow to move the context of the test back to its parent window.

Time for action – complex working with multiple windows

In the next example we are going to open up two pop-up windows and move between them and the parent window as it completes its steps.

1. Start Selenium IDE and go to Chapter 1 on the website.

2. Click on the Click this link to launch another window link. This will launch a pop-up window.

3. Assert the text on the page. We do this by right-clicking and selecting assertText.

4. Go back to the parent window and click on the link to launch the second pop-up window.

5. Verify the text on the page.

6. Move to the first pop-up window and close it using the close link. As before, be aware of clickAndWait instead of click.

7. Move to the second pop-up window and close it using the close link.

8. Move back to the parent window and verify an element on that page.

(43)

9. Run your test and watch how it moves between the windows. When complete it should look like the following screenshot:

What just happened?

We just had a look at creating a test that can move between multiple windows. We saw how we can move between the child windows and its parent window as though we were a user.

Selenium tests against AJAX applications

Web applications today are being designed in such a way that they appear the same as desktop applications. Web developers are accomplishing this by using AJAX within their web applications. AJAX stands for Asynchronous JavaScript And XML due to the fact that it relies on JavaScript creating asynchronous calls and then returning XML with the data that the user

(44)

Time for action – working on pages with AJAX

In our first example, we are going to click on a link and then assert some text is visible on the screen:

1. Start up Selenium IDE and make sure that the Record button is pressed.

3. Click on the text that says Click this link to load a page with AJAX.

4. Verify the text that appears on your screen. Your test should look like the following screenshot:

(45)

5. Run the test that you have created. When it has finished running it should look like the following screenshot:

Have a look at the page that you are working against. Can you see the text that the test is expecting? You should see it, so why has this test failed? The test has failed because when the test reached that point, the element containing the text was not loaded into the DOM.

This is because it was being requested and rendered from the web server into the browser.

To remedy this issue, we will need to add a new command to our test so that our tests pass in the future:

1. Right-click on the step that failed so the Selenium IDE context menu appears.

(46)

4. In the Target box add the target that is used in the verifyText command.

5. Run the test again and it should pass this time:

What just happened?

Selenium does not implicitly wait for the item that it needs to interact with, so it is seen as good practice to wait for the item you need to work with then interact with it. The waitFor commands will timeout after 30 seconds by default but if you need it to wait longer you can specify the tests by using the setTimeout command. This will set the timeout value that the tests will use in future commands.

If need be you can change the default wait if you go to Options | Options and then on the General tab and under Default timeout value of recorded command in milliseconds (30s = 30000ms) change it to what you want. Remember that there are 1000 milliseconds in a second.

(47)

Time for action – working with AJAX applications

As more and more applications try to act like desktop applications we need to be able to handle synchronization steps between our test and our application. In this section we will see how to handle AJAX and what to synchronize.

1. Click on the load text to the page button.

3. Wait for the text I have been added with a timeout. Your test will look like the following screenshot:

What just happened?

In the previous examples, we waited for an element to appear on the page; there are a number

(48)

waitForAlertNotPresent

waitForAlertPresent

waitForElementPresent

waitForElementNotPresent

waitForTextPresent

waitForTextNotPresent

waitForPageToLoad

waitForFrameToLoad

A number of these commands are run implicitly when other commands are being run. An example of this is the clickAndWait command. This will fire off a click command and then fire off a waitForPageToLoad. Another example is the open command which only completes when the page has fully loaded.

If you are feeling confident then it would be a good time to try different waitFor techniques.

Pop quiz – waiting for elements

1. If an element got added after the page has loaded what command would you use to make sure the test passed in the future?

a. waitForElementPresent b. pause

c. assertElementPresent

Storing information from the page in the test

Sometimes there is a need to store elements that are on the page to be used later in a test.

This could be that your test needs to pick a date that is on the page and use it later so that you do not need to hardcode values into your test.

Once the element has been stored you will be able to use it again by requesting it from a JavaScript dictionary that Selenium keeps track of. To use the variable it will take one of the following two formats: it can look like ${variableName} or storedVars['variableName']. I prefer the storedVars format as it follows the same format as it is within Selenium internals.

(49)

Time for action – storing elements from the page

To see how this works lets work through the follow example:

1. Open up Selenium IDE and switch off the Record button.

3. Right-click on the text Assert that this text is on the page and go to the storeText command in the context menu and click on it.

4. A dialog will appear as shown in the following screenshot. Enter the name of a variable that you want to use. I have used textOnThePage as the name of my variable.

5. Click on the row below the storeText command in Selenium IDE.

6. ^Type^type into the Command textbox.

7. Type storeinput into the Target box.

8. ^Type${textOnThePage} into the Value box.

9. Run the test. It should look like the following screenshot:

(50)

What just happened?

Once your test has completed running you will see that it has placed Assert that this text is on the page into the textbox.

Debugging tests

We have successfully created a number of tests and have seen how we can work against AJAX applications but unfortunately creating tests that run perfectly first time can be difficult. Sometimes, as a test automator, you will need to debug your tests to see what is wrong.

To work through this part of the chapter you will need to have a test open in Selenium IDE.

Time for action – debugging tests

These two steps are quite useful when your tests are not running and your want to execute a specific command.

1. Highlight a command.

2. Press the X key, this will make the command execute in Selenium IDE.

What just happened?

When a test is running you can press the Pause button to pause the test after the step that is currently being run. Once the test has been paused the Step button is no longer disabled and you can press it to step through the test as if you were stepping through an application.

If you are having issues with elements on the page you can type in their location and then click on the Find button. This will surround the element that you are looking for with a green border that flashes for a few seconds. It should look like the following screenshot:

(51)

The echo command is also a good way to write something from your test to the log. This is equivalent to Console.log in JavaScript. For example, echo|${variableName}. Also remember that if you are trying to debug a test script that you have created with Selenium IDE, you can set breakpoints in your test. You simply right-click on the line and select breakpoint from the list. It will be similar to the following screenshot:

You can also use the keyboard shortcut of B to allow you to do it quicker.

Test Suites

We have managed to create a number of tests using Selenium IDE and have managed to run them successfully. The next thing to have a look at is how to create a test suite, so that we can open the test suite and then have it run a number of tests that we have created.

Time for action – creating Test Suites

If you have Selenium IDE open from the last steps, click on the File menu:

1. Click New Test Case.

2. You will see that Selenium IDE has opened a new area on the left of the IDE as shown in the following screenshot:

(52)

You can do this as many times as you want and when the Play entire test suite button is clicked it will run all the tests in the test suite. It will log all the passes and failures at the bottom of the Test Case box.

To Save this, click on the File menu and then click Save Test Suite and save the Test Suite file to somewhere that you can get to again. One thing to note is that saving a test suite does not save the test case. Make sure that you save the test case every time you make a change and not just the test suite.

To change the name of the test case to something a lot more meaningful you can do this by right-clicking on the test and clicking on the Properties item in the context menu:

You can now add meaningful names to your tests and they will appear in Selenium IDE instead of falling back to their filenames.

Selenium 2 Testing Tools Beginner's Guide

Selenium 2 Testing Tools Beginner's Guide

Learn to use Selenium testing tools from scratch

Selenium 2 Testing Tools Beginner's Guide

Credits

About the Author

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers and more

Table of Contents

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Getting Started with Selenium IDE 1

Important preliminary points

What is Selenium IDE

Selenium IDE

Important note: Rules for automation

Updating a test to assert items are on the page

Comments

Multiplying windows

Selenium tests against AJAX applications

Storing information from the page in the test

Debugging tests

Test Suites