Continuous Integration testing based on Selenium and Hudson

ISSN 1866-5705 www.testingexperience.com free digital version print version 8,00 € printed in Germany 12

The Magazine for Professional Testers

Open Source Tools
December 2010

© diego cervo - Fotolia.com

Automated tests in
Continuous Integration
environments.
A case study on open-source tools.
© Horst Brandt - Fotolia.com

by Zbyszek Moćkun

The aim of this article is to share our experience in building and Tutorials for the tools mentioned are out of the scope in this artic-
managing Continuous Integration environments on the basis of le, because this would be too extensive to describe here.
open-source tools like Hudson and Selenium. In this article we
will concentrate on testing purposes, suggest just few improve- Short iterations should finish with demo/release to the client and
ments and describe our experience with using open-source tools. are based on continuous functional testing. Testers spend their
The main idea is to present how to use automated tests reasona- whole time testing new functionality for the iteration, which me-
bly by minimizing the time spent on them while optimizing the ans there is no time for regression testing. If we add regression
benefits that automated tests give us. Of course, most of us in tests at the end of a short iteration, we achieve a mini waterfall
the Agile world concentrate mostly on a methodologies based on process.
short iterations.

Figure 1 – Mini waterfall

In addition, we lose time from the short iteration. For example, if following two schemas illustrate this idea.
we have a 10-day iteration and plan regression testing for 2 days,
we have only 8 days left. If we add half a day for planning at the So how can we have our cake and eat it? Be Agile, use short itera-
beginning of the iteration and half a day for demo, then we have tions, deliver high-quality software and don’t go back to the wa-
only 7 days left. In conclusion, the regression test at the end of terfall?
the process lessens the number of delivered functionalities. The

28 The Magazine for Professional Testers www.testingexperience.com

Figure 2 - Agile vs Waterfall

What is CI (Continuous Integration)? How important is to integrate automated tests with
the continuous integration environment?
The following quotation I like the best:
Agile methodologies are based mostly on short iterations (one or
“Continuous Integration is a software development practice where two weeks). The questions are: How efficient is this? How can we
members of a team integrate their work frequently, usually each be sure that the released software is of high quality? How can we
person integrates at least daily - leading to multiple integrations manage and plan tests that fit our budget and resources?
per day. Each integration is verified by an automated build (inclu-
ding test) to detect integration errors as quickly as possible.” If we think about automated tests – the question is: How often
and when should we run automated tests?
Mark Fowler
Our initial answer is really easy: As often as possible and as
This short quotation says everything; The idea is to integrate new quickly as possible.
pieces of software as fast as possible. Very important here are
time frames. Integration should be divided into three steps: Both answers suggest one solution: Continuous Integration (CI).
CI allows us to run automated tests after each commit and send
1. Commit new functionality and build new application
feedback with results to developers.
2. Run unit tests
3. Run integration and system tests Good automated tests should cover all functionality or at least
most of it. If we plan to run automated tests at the end of an
The first two steps should be run for each commit. They are very iteration, there would probably be no time left for fixing any
specific and shouldn’t take more than several minutes. For smal- found issues. Not all issues are quick to fix; some need changes
ler applications it shouldn’t take even a minute. As we can see, that can influence already implemented features or may require
running these steps for every commit is not an issue if we talk a change to the technical solution. What if a new feature has a
about time or cost. These two steps can be done without a test bigger impact on the application than we thought? There is no
(QA) engineer. time for changing the new feature or asking the client for addi-
tional feedback. All of this suggests that regression tests should
The third step, integration and system test, is more complicated be done during the whole iteration. The question is how to use
and time consume. Usually system tests need more time and re- automated tests as often as possible without causing a big effort
quire a test engineer. for the QA team when they should be concentrating on testing
new features?
There are several open-source tools on the market that allow you
to introduce continuous integration. Hudson is used in this artic-
Automate functional tests – Selenium
le as an example. Selenium is an open-source tool to automate web application
testing across many platforms. We use it for functional/regressi-
on tests. Please read more about Selenium here: http://selenium-
hq.org/ . Below are some tips on how to use Selenium in CI.

Figure 3 - Continuous Integration tools
Figure 4 - Selenium logo

Selenium is divided into two parts:- First, the IDE
– an extension for Firefox which allows quick test case develop-
ment and running of test suites (but only under Firefox) mostly

www.testingexperience.com The Magazine for Professional Testers 29

for debug purpose. Selenium users. For more information about extensions, please
take a look at this example page: http://wiki.openqa.org/display/
Second, the Remote Control (RC) allows us to run test suites on SEL/Contributed+User-Extensions.
different browsers. Selenium RC is just an expanded version of
the IDE. Below is the functionality that is important in the CI pro- Selenium reports are simple and clear, but unfortunately they
cess need some improvements if we want to use them frequently. Re-
ports show which test cases have failed, and clicking on it moves
• can be run from the command line
to the test case, where you can see the status for each step. There
• saves reports from test suite execution are three command execution states: passed, failed and not run.
• supports most popular browsers Exploring the report you can see only the command that failed,
but what really happened on the tested page we do not know. The
If you want to write test scripts, use Selenium IDE, record your use failed command is not enough to raise a bug report, so we have to
case, update the script saved by the Selenium IDE, add to the test re-run the test (mostly using Selenium IDE). But what if the test
suite and run it using Selenium RC. passes when we rerun it? What if the test fails on other browsers
than Firefox? We would need to re-run the whole suite and ob-
Developing test scripts in Selenium IDE is very simple. Selenium serve manually. It’s clear that, finding what caused the issue and
supports most languages, but for beginners or for uncomplicated gathering data/logs takes a lot of time. If we run automated tests
scenarios, I suggest using HTML. HTML scripts can be converted to often, the aggregate time spent on debugging becomes a criti-
any language. cal issue. The solution is to extend Selenium reports. The easier
way is to use built in a captureScreenshots function which take
Unfortunately, you can’t rely on record and playback feature. automatic screens of tested pages. Before each command is run,
Some steps are not saved, or the commands used are wrong. Se- the screen of the page is captured and saved. At the end of each
lenium has a very simple way of adding new commands or exten- command screens are added as a link. When a command fails, it
ding existing ones. New commands should be added to the user- is enough to click on the link to see the page screen and better
extensions.js file (writing commands is really simple – believe identify the cause of the error. It is possible to reproduce the who-
me). The file should be added to Selenium IDE (Option->General le test case path by clicking on previous commands to see if there
Tab-> Selenium core extensions field) and to Selenium RC as wasn’t any unexpected behavior not verified in previous steps.
parameter user-extension <path to user-extension.js file>. Many Selenium reports can be extended not only by automatic screens-
additional commands are written and shared via the Internet by hots. It is also possible to save the html code of the tested pages.

delete_all_emails.html

Delete all emails from gmail account
setTimeout 90000
open https://mail.google.com/mail/h/jo4absofnx9z/?logout&hl=en-GB
waitFotElementPresent Email
type Email test@gmail.com
type Passwd password
clickAndWait signIn
selectAllMailsInGmail
click //input[@value=’Delete’]
waitForTextPresent conversation
clickAndWait link=Sign out
waitFotElementPresent Email
verifyTextPresent Welcome to Gmail

Figure 5 - Selenium reports with links to screenshots/saved html code

This part of a report (see figure above of failed test case) shows ficult for debugging purposes if there are no comments for non-
that Selenium wasn’t able to click on the Delete button. But we authors as it does not identify the element that should be tested.
do not know why. Adding screenshots allows us to check what When testing only a specific element, changes in other parts of
the state of the page was before the click. A screenshot or saved the page shouldn’t cause failure or influence the test case results.
html code shows us if the page loaded, if there wasn’t a Delete
button or if the button name changed or maybe other reasons of If a change occurs on the page, but locators are not written wisely,
the failure. Extended reports save time, because we do not need all tests will fail and finding the cause will not be easy. Additio-
to re-run tests. This is very important if an issue is not 100% re- nally, all test cases need to be improved not only once for this spe-
producible. cific element. It’s better to use locator that says something more
and contains only the necessary elements. Use XPATH like this: //
Another important thing is to use locators wisely. Selenium al- table[@class=’test’]//div[text()=’Some testing text’]. It’s simple to
lows the use of preferred types of locators, but the default is read and if the test case fails, finding the cause shouldn’t be a
XPATH. Recording tests usually return XPATH to identify elements problem.
like this: //span[2]/center/span/center/div/div/div. It is very dif-


Continuous Integration tool - HUDSON on different browsers, we have two choices:

Hudson is an open-source tool which allows Continuous Integ- - use one server, rebuild the application before each run (job for
ration to be introduced in our process. Hudson uses projects and different browser). This idea, however, has one big minus: the
jobs to manage content. Under each project we can define several time needed for executing all jobs can be really long when the
jobs. Jobs will be our test suites for a specific project/application. application and tests are run on the same machine.
Selenium RC allows us to run the same tests suites on different
browsers. So a job will be an individual run for specific browsers. - use individual servers for different jobs. In this case we may need
several servers (or virtual machines). Running the application and
Hudson supports versioning applications like SVN or CVS. Using tests on different machines is very important if part of our auto-
them for the management of automated scripts allows us to al- mated suites are performance tests. Saving time is obvious, but
ways run the newest version of tests scripts. Just before each run, it’s important if our test suite is long.
Hudson will check if there are any updates, and if any are found,
an update is made. Please check here if you need more info about configuration:
http://wiki.hudson-ci.org/display/HUDSON/Use+Hudson.

Figure 7 - Hudson logo Integrate automated tests with CI environment
Integration of Selenium with Hudson is quite easy. Mostly it re-
quires us to install the Selenium plug-in for Hudson - http://wiki.
hudson-ci.org/display/HUDSON/Seleniumhq+Plugin. You will
Another step is to configure how the job will run. Here are some have to install ant/maven and other applications that will be
options: used to run test suites/rebuild tested application.
• jobs are run only by user (on request)
For running automated test suites Selenium RC should be used.
• jobs are scheduled and run on a specific day and hour Ant is used for running tests. As you can see integration is qui-
• set relationships between jobs te easy and does not require any specific knowledge. If we add
some new features like screenshots we should write additional
By setting the relationship Build after other projects are built, Ant targets for them (example – clearing directory, copy Selenium
we can be sure that automated tests will always be run after re- reports/screenshots to archive, …)
building the application. Another way to run tests is to use the
schedule feature. Schedule should be used when an application The Selenium plug-in gives two additional pieces of functionality:
is rebuilt on another server, or when we want to run tests only at
• Add link to Selenium report - only for the latest run.
a specific time – for example at night.
• Add Selenium test result trend chart. Charts gather data
The Hudson server allows us to manage more than one machine. from the latest job runs and show trends. We can observe
how many test cases failed and how the number of automa-
Agents give us the possibility to use different machines for diffe-
ted tests is growing.
rent projects. It allows us to run tests in parallel or use different
environments. For example, if we have one application for testing

Figure 8: Hudson: Selenium plug-in installed on Hudson, Selenium Report link and Selenium Test Results Trend chart

Time rules
The answers to these questions are crucial for us.
Time is one of the most important subjects when we think about
integration of our automated tests with CI. Before we start, try to How often is it worthwhile to rebuild the application and run au-
answer the questions below. tomated test cases? Of course, as often as possible. Should it be
after each commit? Maybe daily? It depends how many develo-
• How often do we want to run/rebuild the application?
pers are working on a project and on your specific application.
• How much time is needed to rebuild applications and run Mostly one daily integration should be enough and night-time
automated tests? suites the best. There could be some issues when your application
• How much time can we spend on analyzing test results (re- is built by developers from around the world, but the most impor-
gression tests)? tant factor is the tester’s time zone. If we schedule builds at night,

www.testingexperience.com The Magazine for Professional Testers 31

everything should finish before the testers come to work. As a result of this
he can check the results, reports bugs and start doing his daily task. If there
are any critical issues, Scrum meetings will be a good place to discuss it.

The time needed to rebuild applications and run test suites is very impor-
tant, too. This time should not exceed 12 hours. If it takes longer, we should
divide it into smaller suites or choose important tests which are run daily on
week-days with all tests run at the weekend. Getting results everyday and
interrupting work to check results can be disturbing for the tester and we
should avoid it.

The main test engineer task during each iteration is testing new features.
If test engineers spend daily up to 30 minutes on automation (if the auto-
mated tests found any issues), it shouldn’t interfere with their daily tasks.
In total it won’t be longer than the time spent on regression at the end of
iteration. As a result of this, all critical issues will be found quickly and fixed
or raised to the client if needed.

Should we use open-source tools? Biography
Why is it worth using open-source tools? There are several reasons. The ex- The author of this article has more
ample above shows that we can integrate them successfully, we can extend than 6 years of experience in QA
functionality ourselves depending on our needs, or we can just find a solu- Engineering for big as well as small
tion on web. Considering the money that you might spend on licensing tool companies. Currently he works as Head
products, it may be worthwhile to use it for extending an open-source tool. of QA for Cognifide – a digital technolo-
In most of cases it will be cheaper, and you will have exactly what you need. gy agency.
Zbyszek has been involved in sever-
al projects with different sizes and
methodology where he could introduce
automation. His experience was used
to optimizing the time spent on au-
tomation getting maximum benefits.
This is very important, especially in
Agile methodologies, and it’s the area
in which he specializes.

Agile
Record
The Magazine for Agile Developers and Agile Testers

The Magazine for Agile Developers and Agile Testers
Pantone Process Blue U C. 100 // M. 0 // Y. 0 // K. 10

Pantone 2955 U C. 100 // M. 45 // Y. 0 // K. 37

subscribe at
October 2010
www.agilerecord.com
www.agilerecord.com free digital version made in Germany ISSN 2191-1320 issue 4
© Tyler Olson - Fotolia.com


Continuous Integration testing based on Selenium and Hudson

More Related Content

What's hot (20)

Similar to Continuous Integration testing based on Selenium and Hudson (20)

More from Zbyszek Mockun (20)

Recently uploaded (20)

Continuous Integration testing based on Selenium and Hudson