SELENIUM
1 (SELENIUM RC)
(http://seleniumhq.org/docs/05_selenium_rc.html)
Introduction
As
you can read in Brief
History of The Selenium Project,
Selenium RC was the main Selenium project for a long time, before the
WebDriver/Selenium merge brought up Selenium 2, the newest and more
powerful tool.
Selenium
1 is still actively supported (mostly in maintenance mode) and
provides some features that may not be available in Selenium 2 for a
while, including support for several languages (Java, Javascript,
PRuby, HP, Python, Perl and C#) and support for almost every browser
out there.
How Selenium RC Works
First,
we will describe how the components of Selenium RC operate and the
role each plays in running your test scripts.
RC Components
Selenium
RC components are:
• The
Selenium Server which launches and kills browsers, interprets and
runs the Selenese commands passed from the test program, and acts as
an HTTP
proxy,
intercepting and verifying HTTP messages passed between the browser
and the AUT.
• Client
libraries which provide the interface between each programming
language and the Selenium RC Server.
Here
is a simplified architecture diagram....
for
execution. Then the server passes the Selenium command to the browser
using Selenium-Core JavaScript commands. The browser, using its
JavaScript interpreter, executes the Selenium command. This runs the
Selenese action or verification you specified in your test script.
Selenium Server
Selenium
Server receives Selenium commands from your test program, interprets
them, and reports back to your program the results of running those
tests. The RC server bundles Selenium Core and automatically injects
it into the browser. This occurs when
your
test program opens the browser (using a client library API function).
Selenium-Core is a JavaScript program, actually a set of JavaScript
functions which interprets and executes Selenese commands using the
browser’s built-in JavaScript interpreter.
The
Server receives the Selenese commands from your test program using
simple HTTP GET/POST requests. This means you can use any programming
language that can send HTTP requests to automate Selenium tests on
the browser.
Client Libraries
The
client libraries provide the programming support that allows you to
run Selenium commands from a program of your own design. There is a
different client library for each supported language. A Selenium
client library provides a programming interface (API), i.e., a set of
functions, which run Selenium commands from your own program. Within
each interface, there is a programming function that supports each
Selenese command.
The
client library takes a Selenese command and passes it to the Selenium
Server for processing a specific action or test against the
application under test (AUT). The client library also receives the
result of that command and passes it back to your program. Your
program can receive the result and store it into a program variable
and report it as a success or failure, or possibly take corrective
action if it was an unexpected error.
So
to create a test program, you simply write a program that runs a set
of Selenium commands using a client library API. And, optionally, if
you already have a Selenese test script created in the Selenium- IDE,
you can generate
the Selenium RC code.
The Selenium-IDE can translate (using its Export menu item) its
Selenium commands into a client-driver’s API function calls. See
the Selenium-IDE chapter for specifics on exporting RC code from
Selenium-IDE.
Installation
After
downloading the Selenium RC zip file from the downloads
page,
you’ll notice it has several subfolders. These folders have all the
components you need for using Selenium RC with the programming
language of your choice. Once you’ve chosen a language to work
with, you simply need to:
• Install
the Selenium RC Server.
• Set
up a programming project using a language specific client driver.
Installing Selenium Server
The
Selenium RC server is simply a Java jar
file
(selenium-server.jar),
which doesn’t require any special installation. Just downloading
the zip file and extracting the server in the desired directory is
sufficient.
Running Selenium Server
Before
starting any tests you must start the server. Go to the directory
where Selenium RC’s server is located and run the following from a
command-line console.
java
-jar selenium-server.jar
This
can be simplified by creating a batch or shell executable file (.bat
on Windows and .sh on Linux) containing the command above. Then make
a shortcut to that executable on your desktop and simply double-click
the icon to start the server. For the server to run you’ll need
Java installed and the PATH environment variable correctly configured
to
run it from the console. You can check that you have Java correctly
installed by running the following on a console:
java
-version
If
you get a version number (which needs to be 1.5 or later), you’re
ready to start using Selenium RC.
Using the .NET Client Driver
• Download
Selenium RC from the SeleniumHQ downloads
page
• Extract
the folder
• Download
and install NUnit
(
Note: You can use NUnit as your test engine. If you’re not familiar
yet with NUnit, you can also write a simple main() function to run
your tests; however NUnit is very useful as a test engine.)
• Open
your desired .Net IDE (Visual Studio, SharpDevelop, MonoDevelop)
• Create
a class library (.dll)
• Add
references to the following DLLs: nmock.dll, nunit.core.dll, nunit.
framework.dll,
ThoughtWorks.Selenium.Core.dll,
ThoughtWorks.Selenium.IntegrationTests.dll and
Thought-Works.Selenium.UnitTests.dll
• Write
your Selenium test in a .Net language (C#, VB.Net), or export a
script from Selenium-IDE to a C# file and copy this code into the
class file you just created.
• Write
your own simple main() program or you can include NUnit in your
project for running your test. These concepts are explained later in
this chapter.
• Run
Selenium server from console
• Run
your test either from the IDE, from the NUnit GUI or from the command
line
For
specific details on .NET client driver configuration with Visual
Studio, see the appendix .NET
client driver configuration.
Selenese as Programming Code
Here
is the test script exported (via Selenium-IDE) to each of the
supported programming languages. If you have at least basic knowledge
of an object- oriented programming language, you will understand how
Selenium runs Selenese commands by reading one of these examples. To
see an example in a specific language, select one of these buttons.
In
C#:
using
System;
using
System.Text;
using
System.Text.RegularExpressions;
using
System.Threading;
using
NUnit.Framework;
using
Selenium;
namespace
SeleniumTests
{
[TestFixture]
public
class NewTest
{
private
ISelenium
selenium;
private
StringBuilder
verificationErrors;
[SetUp]
public
void SetupTest()
{
selenium
= new
DefaultSelenium(
"localhost" , 4444,
"*firefox" , "http://www.selenium.Start();
verificationErrors
= new
StringBuilder();
}
[TearDown]
public
void TeardownTest()
{
try
{
selenium.Stop();
}
catch
(Exception)
{
//
Ignore errors if unable to close the browser
}
Assert.AreEqual(
"" , verificationErrors.ToString());
}
[Test]
public
void TheNewTest()
{
selenium.Open(
"/" );
selenium.Type(
"q" , "selenium rc" );
selenium.Click(
"btnG" );
selenium.WaitForPageToLoad(
"30000" );
Assert.AreEqual(
"selenium rc - Google Search" , selenium.GetTitle());
}
}
}
Programming Your Test
Now
we’ll illustrate how to program your own tests using examples in
programming language. There are essentially two tasks:
• Generate
your script into a programming language from Selenium-IDE, optionally
modifying the result.
• Write
a very simple main program that executes the generated code.
Optionally, you can adopt a test engine platform NUnit for .NET.
C#
The
.NET Client Driver works with Microsoft.NET. It can be used with any
.NET testing framework
like
NUnit or the Visual Studio 2005 Team System.
Selenium-IDE
assumes you will use NUnit as your testing framework. You can see
this in the generated
code
below. It includes the using
statement
for NUnit along with corresponding NUnit attributes
identifying
the role for each member function of the test class.
You
will probably have to rename the test class from “NewTest” to
something of your own choosing.
Also,
you will need to change the browser-open parameters in the statement:
selenium
= new DefaultSelenium("localhost", 4444, "*iehta",
"http://www.google.com/");
The
generated code will look similar to this.
using
System;
using
System.Text;
using
System.Text.RegularExpressions;
using
System.Threading;
using
NUnit.Framework;
using
Selenium;
namespace
SeleniumTests
{
[TestFixture]
public
class NewTest
{
private
ISelenium
selenium;
private
StringBuilder
verificationErrors;
[SetUp]
public
void SetupTest()
{
selenium
= new
DefaultSelenium(
"localhost" , 4444,
"*iehta" ,
"http://www.google.com/"
);
selenium.Start();
verificationErrors
= new
StringBuilder();
}
[TearDown]
public
void TeardownTest()
{
try
{
selenium.Stop();
}
catch
(Exception)
{
//
Ignore errors if unable to close the browser
}
Assert.AreEqual(
"" , verificationErrors.ToString());
}
[Test]
public
void TheNewTest()
{
//
Open Google search engine.
selenium.Open(
"http://www.google.com/" );
//
Assert Title of page.
Assert.AreEqual(
"Google" , selenium.GetTitle());
//
Provide search term as "Selenium OpenQA"
selenium.Type(
"q" , "Selenium OpenQA" );
//
Read the keyed search term and assert it.
Assert.AreEqual(
"Selenium OpenQA" , selenium.GetValue( "q" ));
//
Click on Search button.
selenium.Click(
"btnG" );
//
Wait for page to load.
selenium.WaitForPageToLoad(
"5000" );
//
Assert that "www.openqa.org" is available in search
results.
Assert.IsTrue(selenium.IsTextPresent(
"www.openqa.org" ));
//
Assert that page title is - "Selenium OpenQA - Google Search"
Assert.AreEqual(
"Selenium OpenQA - Google Search" ,
selenium.GetTitle());
}
}
}
You
can allow NUnit to manage the execution of your tests. Or
alternatively, you can write a simple main() program that
instantiates the test object and runs each of the three methods,
SetupTest(), The- NewTest(), and TeardownTest() in turn.
Learning the API
The
Selenium RC API uses naming conventions that, assuming you understand
Selenese, much of the interface will be self-explanatory. Here,
however, we explain the most critical and possibly less obvious
aspects.
Starting the Browser
In
C#:
selenium
= new
DefaultSelenium(
"localhost" , 4444,
"*firefox" , "http://www.google.com/"
selenium.Start();
This
example opens the browser and represents that browser by assigning a
“browser instance” to a program variable. This program variable
is then used to call methods from the browser. These methods execute
the Selenium commands, i.e. like open
or
type
or
the verify
commands.
The parameters required when creating the browser instance are:
host
Specifies
the IP address of the computer where the server is located. Usually,
this is the same machine as where the client is running, so in this
case localhost
is
passed. In some clients this is an optional parameter.
port
Specifies
the TCP/IP socket where the server is listening waiting for the
client to establish a connection. This also is optional in some
client drivers.
browser
The
browser in which you want to run the tests. This is a required
parameter.
url
The
base url of the application under test. This is required by all the
client libs and is integral information for starting up the
browser-proxy-AUT communication.
Note
that some of the client libraries require the browser to be started
explicitly by calling its start()
method.
