Selenium : web application testing system

Software Testing by mPower ITG in Bangalore City, India

2010-11-21T21:44:00.000-08:00

Software Testing by mPower ITG in Bangalore City, India

Extend Selenium Server with the help of Default Selenium

2010-11-15T01:30:00.000-08:00

Default Selenium
DefaultSelenium is the base class that you instantiate early on in your test class to get the selenium object which you later use in almost every line of you test script.

.
.
Selenium selenium=new DefaultSelenium("localhost",4444,"*chrome","http://www.google.com/");  
selenium.start();
selenium.open("/");
.
.
.

OR


/*Creates a new DefaultSelenium object and starts it using the specified baseUrl and browser string*/                     
setUp("http://www.imdb.com/", "*firefox");
selenium.open("/");
selenium.click("nb15go_image");
.
.
.

does that ring a bell?

What do you mean by extending the default selenium?
Extending the default selenium means enhancing or customizing or modifying the existing features of selenium class. We are reusing the existing class after adding some enhancements so as to customize the existing features to our taste and requirement. Programming languages such as JAVA provide the facility of extending/modifying the behavior of a class without having to re-write the entire class. We can create a new class that inherits the attributes and methods of another. We don't need a copy of the original source code (as is the case with many other languages) to extend the usefulness of a class/library.

Why do I need to extend selenium?
If you want certain operations to be done every time before a step is executed then you would have to extend the default selenium. For example let’s say that you wish to wait 5 seconds after every step or you want to highlight the element before clicking on it or you want to record every step in log file or you want to poll for a element’s existence for a certain amount of time before performing an operation (click, type) on it. For all these to happen you would have to extend the default selenium class that you use in your RC test script.

Below is a simple example that demonstrates this concept. The class MySelenium extends the class DefaultSelenium. The methods click and type of the base class have been over-ridden in such a way that the target element (which is to be clicked on or typed into) is highlighted thrice before the click or type operation. The class UsingMySelenium by the means of a simple example demonstrates the usage of our extended class.

Class MySelenium

package seleniumExtention;

import com.thoughtworks.selenium.DefaultSelenium;

public class MySelenium  extends DefaultSelenium{

public MySelenium(String seleniumSeverHost, int port,String browserString,String autURL){     
super(seleniumSeverHost, port,browserString, autURL);
}

@Override
public void click(String target) {
try {
for (int i=0;i<3;i++){ i="0;i<3;i++){">

Class UsingMySelenium

package seleniumExtention;

import org.junit.Test;
import org.junit.BeforeClass;
import org.openqa.selenium.server.SeleniumServer;

import com.thoughtworks.selenium.SeleneseTestCase;

public class UsingMySelenium extends SeleneseTestCase{
public MySelenium selenium;

@BeforeClass
public void setUp() throws Exception {

SeleniumServer seleniumserver=new SeleniumServer();
seleniumserver.boot();
seleniumserver.start();

/*using the customized selenium class that we created earlier instead of the default selenium*/
selenium=new MySelenium ("localhost",4444,"*iexplore","http://www.google.com/");
selenium.start();
selenium.windowMaximize();

}

@Test
public void testSimpleGoogleSearch() throws Exception {
selenium.open("/");
selenium.waitForPageToLoad("5000");
selenium.type("q", "Aston Martin volante");
selenium.click("//input[@value='Google Search']");
selenium.waitForPageToLoad("5000");
selenium.click("xpath=/descendant::a[text()=' - The Cars']/em[text()='Aston Martin']/parent::a");
selenium.waitForPageToLoad("25000");
Thread.sleep(5000);
}
}

To make this work you need to do the following
1) Create a package seleniumExtention inside the java project.
2) Create the classes MySelenium & UsingMySelenium and copy paste the content as given above.
3) Run the testSimpleGoogleSearch() given in the class UsingMySelenium (right click Run As-->JUnit Test).

*Following jars need to be referenced
selenium-server.jar
selenium-java-client-driver.jar
junit.jar

good luck with this and keep the questions coming!

Handling popups and browser dialogs in selenium for firefox

2010-11-09T20:44:00.001-08:00

Hi,

Here i have mentioned steps to handling the pop-ups and browser dialogs in selenium for firefox

Suggested settings for your Selenium Profile

1. From “View\Toolbars” tab, uncheck “Bookmarks Toolbar”

2. Right click from toolbar and click “Customize”

3. Remove “Google search” by dragging it to the “Customize Toolbar” window

4. From the “Customize Toolbar” window, click “Use Small Icons” check box then hit “Done”

5. Click “Tools\Options” then set the following:

a. “Main” tab

- set Home Page to “about:blank”

- uncheck “Show the Downloads..” option

b. “Tabs” tab

- Select “a new window” for new pages

- Uncheck all warning options

c. “Content” tab

- uncheck “Block pop-up” windows option

d. “Privacy” tab

- uncheck all “History” options

e. “Security” tab

- uncheck all “Security” options

- click “Settings” and uncheck all warning options

f. “Advanced” tab

- Uncheck “autoscrolling” option from “General” tab

- uncheck “warn me …” and “Ssearch Engines”option from “Update” tab

6. From “Tools\Add-ons” install the following:

- Firebug: allows you to edit, debug, and monitor CSS, HTML, and JavaScript on your application under test

- Selenium IDE: allows you to record, edit, and debug Selenium tests

- ScreenGrab: saves entire webpages as images.

7. From the address bar type “about:config” and add the following by right-click anywhere on the page and selecting “new”

- extensions.update.notifyUser (type=boolean; value=false)

- extensions.newAddons (type=boolean; value=false)

SIMPLIUM-Simple test framework for Selenium.

2010-11-03T02:06:00.000-07:00

Overview

Simplium aids the developer to create selenium based unit test that can be executed in different browsers and environment. With environment means the same test can be run against the developers own machine as well as a test machine somewhere on the network or even the production machine.

A Simplium unit tests doesn't have any reference to which URL the test is executed against as well as no reference to which browser the test should be executed in. Instead the Simplium test cases are annotated with Simplium specific annotations which allow Simplium to take control of the test cases when executed.

Simplium looks for which environment it is executed in (development, test or production) and based on this information Simplium will execute the test cases against different servers, against a local selenium remote control or selenium grid and execute each test in the browsers that the environment has specified.

Download:

Download the latest version of Simplium from http://simplium.sektor.se/download.html
Current version is 0.4.

Quick Example

Take a look at a ordinary Selenium test case.

import junit.framework.TestCase;

import com.thoughtworks.selenium.*;

public class ExampleSeleniumTest extends TestCase {

    private Selenium selenium;

    public void setUp() {

        selenium = new DefaultSelenium("localhost",

                4444, "*firefox", "http://www.google.com");

        selenium.start();    }

    public void testGoogleForSomeThings() throws InterruptedException {

        selenium.open("/");

        assertEquals("Google", selenium.getTitle());

    public void tearDown() {

        browser.stop();

This test case has the selenium server host and port specificed in the source code, as well as the browser to run the test case in and also which URL the test should run against.

What if we would like to run this test against our development machine and test machine as well? And what if we also would like to run this test in Internet Explorer, Safari and Chrome? It is here Simplium comes to the rescue.

A Simplium based Selenium test case can look like this

package com.company.test;

import junit.framework.Assert;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.simplium.SimpliumWebTest;

import org.simplium.junit.SimpliumJUnitRunner;

@MyCompanyWebTest

@RunWith(SimpliumJUnitRunner.class)

public class ASimpliumGoogleTest extends SimpliumWebTest {

        @Test
     public void testGoogleTitle() {

               selenium.open("/");

               Assert.assertEquals("Google", selenium.getTitle());        }}

The @MyCompanyWebTest is a meta annotation that contains a number of Simplium specific annotation. This annotation combine with a specific JUnit Runner the Simplium can in the backgrund determine the current enviroment, what browser to execute the test case in and to set up a Selenium server.

package com.company.test;

import java.lang.annotation.Documented;

import java.lang.annotation.Inherited;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import org.simplium.annotation.Browsers;

import org.simplium.annotation.Enviroments;

import org.simplium.annotation.Screenshot;

import org.simplium.annotation.Screenshot.CaptureRule;

@Browsers

@Enviroments(

        development = {"localhost","4444","http://localhost:8080"},

        test = {"grid.company.com","4444","http://test.google.com" },

        production = {"grid.company.com","4444","http://www.google.com"}

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

public @interface MyCompanyWebTest {

The @MyCompanyWebTest is listed abow. The @Browsers indicates what browser to use. For now the default browsers are used which means that each test case run in the development enviroment is run in Firefox and Internet Explorer. When using test it is run in a number of other browsers as well.

@Enviroment defines the Selenium server host, port and the URL to test against for each of the three specificed enviroments. This means that for @MyCompanyWebTest a local Selenium server is started in development enviroment and the test is executed against localhost:8080. When running in test Simplium lets a Selenium grid execute the test cases. The grid is located at grid.company.com:4444. The test cases are then executed against test.google.com. Prodution also uses the Selenium grid but the test cases are executed against www.google.com.

To take control of which browser that the test should be executed in and not use the default ones the @Browsers annotation can be feed with this information.

@Browsers(

        development = {"*iexplorer","*firefox"},

        test = {"*iexplorer","*firefox","*googlechrome","*opera","*safari"},

        production = {"*iexplorer","*firefox","*googlechrome","*opera","*safari"}

The @Browsers annotation can also be used on a test case method to override the @Browser annotation on the class level. This if some part of the web application can't be executed with certain browser(s).

Simplium also aids the developer to find out why a test case fails. When Simplium javacode that a test case fails, through a assert or by a unknown not caught exception Simplium can be instructed to take a screenshot of the browser so that developer can see exactly what happened on the screen when the fail occured. This is done by marking the meta annotation with the @Screenshot annotation.

@Screenshot(CaptureRule.CAPTURE_WHEN_EXCEPTION_OCCURES)

public @interface MyCompanyWebTest {

Simplium will create a .png under the tmp directory followed by the current execution time and the test class that failed.

There is a number of other annotation that also can be used, @Delay, @RunOnlyInDevelopment, @RunOnlyInTest and @RunOnlyInProduction.

How to setup a simple Simplium testcase

Step 1 - Create annotation

First we need to create an annotation that all our Simplium test cases must be annotated with.

package com.company.test;

import java.lang.annotation.Documented;

import java.lang.annotation.Inherited;

@Documented

@Inherited

public @interface MyCompanyWebTest {

Note that we annotate this annotation with other annotation making this a so called meta annotation. The @Inherited makes sure that this annotation is inherited for all sub classes to a MyCompanyWebTest annotated super class. @Documented makes this annotation show up in JavaDoc.

Step 2 - Define the enviroments

The newly created annotation must define to Simplium the test enviroments for development, test and production.

package com.company.test;

import java.lang.annotation.Documented;

import java.lang.annotation.Inherited;

import org.simplium.annotation.Enviroments;

@Enviroments(

        development = {"localhost","4444","http://localhost:8080"},

        test = {"grid.selenium.com","4444","http://testenviroment.com" },

        production = {"grid.selenium.com","4444","http://www.company.com"}

@Documented

@Inherited

@Retention(RetentionPolicy.RUNTIME)

public @interface MyCompanyWebTest {

Each enviroment takes three parameters, the host name of where the selenium server is located, the port the selenium server is listing on and where the selenium test case should be executed against.

In development if there doesn't exist an selenium server on the specified host and port a server is started in the background. For test and production the selenium grid should be used.

The base url where the selenium test case is executed should in the development mode be set to the developers machine, localhost, combined with the port for the local test enviroment. The base url for test and production should point on some test enviroment and the production URL. When running in test or production enviroment these URL can be changed with a system property.

Step 3 - Define the browsers

So we have definied the enviroment but not which browsers that the test cases should be run in.

package com.company.test;

import java.lang.annotation.Documented;

import java.lang.annotation.Inherited;

import org.simplium.annotation.Enviroments;

@Enviroments(

        development = {"localhost","4444","http://localhost:8080"},

        test = {"grid.selenium.com","4444","http://testenviroment.com"},

        production = {"grid.selenium.com","4444","http://www.company.com" }

@Browsers(

        development = { "*iexplore"   "*firefox"      },

        test = {

               "*firefox on Windows"

               "*firefox on MacOS"

               "*firefox on Linux"

               "*iexplore on Windows"

               "*iexplore on MacOS"

               "*safari on MacOS"

               "*safari on Windows"

               "*opera on Windows"

               "*opera on MacOS"

               "*opera on Linux"

               "*googlechrome on Windows"

},

        production = {

               "as test"

@Documented

@Inherited

@Retention(RetentionPolicy.RUNTIME)

public @interface MyCompanyWebTest {

With the use of the @Browser annotation we define that in the development enviroment the test case should be executed in iexplore and firefox. For the test enviroment the same test case is run in a number of browser on different plattforms. Here we use Selenium grid to distribute the execution of the test case to machines running the different plattforms and having the different browsers installed. So the machine that starts the test cases doesn't need to have any browsers installed. For production we simply use the same set as for the test enviroment.

Step 4 - Create your Simplium test case

Now we are ready to start developing the test case.

package com.company.test;

import junit.framework.Assert;

 import org.junit.Test;

import org.junit.runner.RunWith;

import org.simplium.SimpliumWebTest;

import org.simplium.junit.SimpliumJUnitRunner;

@MyCompanyWebTest

@RunWith(SimpliumJUnitRunner.class)

public class ASeleniumTest extends SimpliumWebTest {

        @Test

        public void myTestMethod() {

               selenium.open("/mywebapp");

               Assert.assertEquals("Example", selenium.getTitle()); }}

The test case must be annotated with the created annotation @MyCompanyWebTest. To run the test case with JUnit the @RunWith annotation should be presented and the SimpliumJunitRunner class must be used. Also the test case must extend the SimpliumWebTest.

Note that the test case doesn't have any information about the executing enviroment such as where the selenium server is located or which browser the test should be executed in.

Step 5 - Run in development mode

When running the test case in any modern IDE (here in Eclipse) Simplium execute the test cases in the different browsers specified by the @Browsers annotation.

Note that the test case is run twice, on for each browser definied in the development enviroment.

Step 6 - Run in test mode

So now the developer has tested the application on his developer machine but what about running the test case again but now against a test machine? Simplium makes this simple. Just add the VM argument -Denviroment=test when running the test cases and Simplium will automaticly use the Selenium grid definied under test and execute the test cases with the browsers that has been defined under test.

Step 7 - Run in production mode

The same applies for running in production mode. Use the VM argument -Denviroment=production to make Simplium execute the test cases with the production settings.

Step 8 - The rest

There is a number of annotation that hasn't been mention so far so to get familiar with these this section explain the usage.

@Screenshot

@Screenshot(CaptureRule.CAPTURE_WHEN_EXCEPTION_OCCURES)

public @interface MyCompanyWebTest {

@Delay

@Delay marks a class or method that all selenium API calls should be delayed. This is usable when debugging a test case. The defaul delay is 1000ms (1s) and this can be changed by setting the delay with the annotation, @Delay(2000) gives 2 second delay.

package com.company.test;

 import junit.framework.Assert;

 import org.junit.Test;

import org.junit.runner.RunWith;

import org.simplium.SimpliumWebTest;

import org.simplium.junit.SimpliumJUnitRunner;

 @MyCompanyWebTest

@RunWith(SimpliumJUnitRunner.class)

public class ASeleniumTest extends SimpliumWebTest {

    @Test

   @Delay

   public void searchOnGoogleForGoogle() {

      selenium.open("/");

      selenium.type("q", "google");

      selenium.click("btnG");  }}

@RunOnlyIn*

There are three annotations @RunOnlyInDevelopment, @RunOnlyInTest and @RunOnlyInProduction that can be used to mark classes or method so that it is only run in the specified enviroment. In below example the test case searchOnGoogleForGoogle will only be run under the developmen enviroment. When run in test or production this test case will be ignored.

package com.company.test;

 import junit.framework.Assert;

 import org.junit.Test;

import org.junit.runner.RunWith;

import org.simplium.SimpliumWebTest;

import org.simplium.junit.SimpliumJUnitRunner;

 @MyCompanyWebTest

@RunWith(SimpliumJUnitRunner.class)

public class ASeleniumTest extends SimpliumWebTest {

    @Test

   @RunOnlyInTest

   public void searchOnGoogleForGoogle() {

      selenium.open("/");

      selenium.type("q", "google");

      selenium.click("btnG");

@Timeout

Annotation that can be used as a meta annotation, class annotation or method annotation to indicate the timeout time Selenium will use for its "open" and the "waitFor*" actions. It is specified in milliseconds.

package com.company.test;

 import junit.framework.Assert;

 import org.junit.Test;

import org.junit.runner.RunWith;

import org.simplium.SimpliumWebTest;

import org.simplium.junit.SimpliumJUnitRunner;

@MyCompanyWebTest

@RunWith(SimpliumJUnitRunner.class)

public class ASeleniumTest extends SimpliumWebTest {

    @Test

   @Timeout(60000)

   public void searchOnGoogleForGoogle() {

      selenium.open("/");

      selenium.type("q", "google");

      selenium.click("btnG");

Selenium Overview

2010-11-01T22:31:00.000-07:00

Selenium Overview:-

Selenium is a suite of tools to automate web app testing across many platforms. It is a GUI based automation tool. Initially it is built by ThoughtWorks. It supports various browsers on various platforms

Selenium Projects
Selenium has many projects. Following projects are mostly used by testers.

Selenium IDE (IDE)
Selenium IDE can be used only in FireFox. It is an add-on for FireFox. User can record the actions and can edit and debug the tests. It can be used to identify IDs, name and XPath of objects. Only one test at a time.
Selenium Core (CORE)
Selenium Core is the original Javascript-based testing system. This technique should work with any JavaScript enabled browser. It is the engine of both, Selenium IDE and Selenium RC (driven mode), but it also can be deployed on the desired application server. It is used specifically for the acceptance testing.
User can record the tests using Selenium IDE and can use the same tests to run in other browsers with minimal modifications. It provides support to run the tests in HTA (HTML Applications) Mode. This mode works only in IE.
Selenium Remote Control (RC)
Selenium Remote Control is a test tool that allows user to write automated web application UI tests in few programming languages against any HTTP website using any mainstream JavaScript-enabled browser. User can write the tests (More expressive programming language than the Selenese HTML table format) in Java, DotNet, Perl, Ruby and PHP. Also it supports few testing frameworks.
Selenium Grid
Selenium Grid allows easily to run multiple tests in parallel, on multiple machines, in an
heterogeneous environment by cutting down the time required for test execution. Using this, user can run multiple instances of Selenium Remote Control in parallel.

Supported browsers
Selenium tools can run in following browsers.

Internet Explorer
FireFox
Opera
Safari
Seamonkey

Supported Operating Systems
Users can execute the selenium tests in following OS.

Windows
Linux
Solaris
OS X

Supported Programming languages
Below languages are supported by Selenium RC.

C# (DotNet)
Java
Perl
Ruby
Python
PHP

Sample Code

Following program tells how to launch a browser and to play around with text,list,combobox objects we find normally in any website

package Orkut;
import com.thoughtworks.selenium.*;
import com.thoughtworks.selenium.DefaultSelenium;
 
public class MySelenium {
static Selenium selenium;
static boolean val,val1;
public static void main(String arg[]) throws Exception
{
selenium = new DefaultSelenium("localhost",
4444, "*iexplore", "http://www.ge.com");
 
selenium.start();
 
Thread.sleep(4000);
 
selenium.windowMaximize();
selenium.windowFocus();
selenium.open("/index.html");
 
selenium.click("//div[@id='ge_footer']/ul/li[2]/a");
 
val=selenium.isElementPresent("//img[@alt='GE: imagination at work']");
for (int second = 0;second<=10; second++) {
    val=selenium.isElementPresent("//img[@alt='GE: imagination at work']");
 
     if (val)
 
     {
         System.out.println(val);
         break;
     }
     else
     {
 
         if (second==10)
         {
             System.out.println("Page not found :=GE: imagination at work");
             selenium.stop();
 
         }
         Thread.sleep(4000);
     }
 
    }
 
selenium.click("//ul[@id='ge_secondaryNav']/li[2]/a");
 
val1=selenium.isElementPresent("//div[@id='secondary_content']/div/h3");
 
for (int second = 0;second<=10; second++) {
    val1=selenium.isElementPresent("//div[@id='secondary_content']/div/h3");
 
     if (val1)
     {
         System.out.println(val1);
         break;
     }
     else
     {
 
         if (second==10)
         {
             System.out.println("Element not found :=GE: Other Contact Resources");
             selenium.stop();
 
         }
         Thread.sleep(4000);
     }
 
    }
 
selenium.click("//input[@id='contact_type_press']");
selenium.select("//select[@id='contact_subject']", "label=Other");
selenium.select("//select[@id='contact_country']", "label=Algeria");
selenium.type("//input[@id='contact_email']", "abc@vvv.com");
selenium.type("//textarea[@id='contact_comments']", "testing");
 
//selenium.click("//form[@id='contact_form']/p/input");
 
}
 
}

Extending Selenium server with custom commands

2010-10-28T23:38:00.000-07:00

In this posting I document extending Selenium server with a custom javascript method, getAllRadios(), to return all radio button elements in a page. It’s based on the getAllButtons() that is stock in Selenium.

I will demonstrate two ways to add this custom method. The first strategy is to add the custom method to the native javascript files that ship with Selenium server. This is not the recommended way to extend Selenium but it is an almost guaranteed way to be sure the server picks up my new method and that frees me to focus on getting my client syntax right for calling the new method using the client’s doCommand() method.

Method 1 – selenium-browserbot.js + selenium-api.js

Unpack the server jar into a temporary directory to get access to the selenium-browserbot.js and selenium-api.js files.

[20:54 20090906 crashing@server /selenium-server-1.0.1/temp]
$ jar xf ../selenium-server.jar

The new custom method is added to core/scripts/selenium-browserbot.js. It is a slightly modified version of getAllButtons() which is defined in the same file.

BrowserBot.prototype.getAllRadios = function() {
var elements = this.getDocument().getElementsByTagName('input');
var result = [];
for (var i = 0; i < elements.length; i++) {
if (elements[i].type == 'radio') {
result.push(elements[i].id);
}
}
return result;
};

and then the new method is exposed to the Selenium API in core/scripts/selenium-api.js, again modeling after getAllButtons() in selenium-api.js.

Selenium.prototype.getAllRadios = function() {
return this.browserbot.getAllButtons();
};

Now rebundle the updated javascript into a new server jar, replacing the original.

[21:01 20090906 crashing@server /selenium-server-1.0.1/temp]
$ jar cmf META-INF/MANIFEST.MF ../selenium-server.jar .

Method 2 – user-extension.js

The better way to extend Selenium is to add methods to the user-extensions.js file. This avoids screwing around with the native server jar. I initiall had some trouble getting this working, hence the Method 1 approach, but after a bit of futzing I finally got this to work.

Selenium.prototype.getAllRadios = function() {
var elements = this.browserbot.getDocument().getElementsByTagName('input');
var result = [];
for (var i = 0; i < elements.length; i++) {
if (elements[i].type == 'radio') {
result.push(elements[i].id);
}
}
return result;
};

This is basically the same method used in selenium-browserbot.js. The important changed bits are (1) the method is attached to the Selenium object instead of the BrowserBot (Selenium.prototype rather than BrowserBot.prototype) and (2) calling getDocument() on the browserbot instance.

I start the Selenium server with the -userExtensions option pointing to the user-extensions.js file.

java -jar \
/selenium-server-1.0.1/selenium-server.jar \
-userExtensions /user-extensions.js

Client Coding

For either of the above methods of extending the Selenium server, I call this new method in my client code with the doCommand().

/** incomplete code **/

proc = new HttpCommandProcessor(seleniumServerHost,
seleniumServerPort, brower, seleniumServerStartUrl);
selenium = new DefaultSelenium(proc);

selenium.open(url);

// radio buttons returned as comma-delimited strings
String allRadios = proc.doCommand("getAllRadios", null);

// alternatively, get radio buttons as a String array
String[] radios = proc.getStringArray("getAllRadios", null);
for (String radio : radios) {
System.out.println(radio);
}

To call custom doCommand()‘s, it’s necessary to instantiate with DefaultSelenium(proc) to inject the HttpCommandProcessor into the DefaultSelenium object.

Use regex in Selenium locators

2010-10-26T00:10:00.000-07:00

To use regex in Xpath locators.

You need to use the regex matches() function, like this:

xpath=//div[matches(@id,'che.*boxes')]



this will click the div with 'id=checkboxes', or 'id=cheANYTHINGHEREboxes')

To get all the links elements with attribute href that match:

http://[^/]*\d+com

Use
sel.get_attribute( '//a[regx:match(@href,
                   "http://[^/]*\d+.com")]/@name' )
which will  return a list of the name attribute of
all the links that match the regex.

Be aware,  that the matches function is not supported by all 
native browser implementations of Xpath
(most conspicuously, using this  in FF3 will throw an error: invalid xpath[2]).

If you have trouble with your particular browser (as I did with FF3), try using Selenium's allowNativeXpath("false") to switch over to the JavaScript Xpath interpreter. It'll be slower,
but it does seem to work with more Xpath functions, including 'matches' and 'ends-with'.

Installing ANT on Windows

2010-10-22T01:16:00.001-07:00

1. Download ANT

2. Unzip the zip file and put it in your comfortable folder (say D:/ant/)

3. Set ANT_HOME environment variable to the Ant location

(MyComputer Rt.Click >> Properties >> Advanced >> Environment Variables >> User Variables for Administrator >> Set New Variable Name as "ANT_HOME" and set New Variable Value as D:/ant)

4. Now set Path variable to point to your ANT bin directory

(User Variables for Administrator >> Click on Path variable >> Append the ANT bin directory location , say%ANT_HOME%\bin)

5. Open a command prompt and type "ant" , you should see it working now . In case of any failure try the below command and see the value for ANT_HOME

c:\echo %ANT_HOME% // This should print your current ANT directory

How to use selenium fire event

2010-09-08T03:46:00.001-07:00

I recently faced the challenge of using Selenium to automate a web application that stubbornly resisted my attempts to automate it - until I found the fireEvent!

No need to know the name of the application in question, but the basic situation I faced involved a form with a 'save' button.

I used Selenium to fill in the details in the form and click the save button.

When I run selenium I can see the text I enter on the form, and when the 'save' gets a click the little Ajax image for 'saving' appears, but when I check the data saved - nothing got saved.

I struggled with this on my own for a while then paired with someone to help.

Pairing brings a number of benefits:

* 2 minds instead of one
* you engage in the 'ah!' moments that only happen when you explain something to others
* you get a fresh perspective on the problem

So instead of focusing on the 'save' event we had a look at the form input fields.

The input fields had a few events - one having an onblur event. The onblur event code seemed to suggest that it persisted the form data into an in-memory store which the 'save' event then processed. So the problem did not seem to involve the save event - the type command did not trigger an onblur when it 'moved' between fields.

Onblur fires when you lose focus so we first tried clicking on the other fields to make that happen.

But that didn't work.

And then we noticed the Selenium API command fireEvent. This lets you trigger the event for a particular element on a page so we simply fired the 'blur' event for the component

selSession.fireEvent("edit_field_1", "blur");

And that worked - deep joy.

So lessons learned for me:

* Selenium has a large API - which I need to spend more time learning the scope and extent of
* When testing I need to use the Firefox/Firebug 'inspect element' functionality to learn a bit more about the app under test
* I need to use fireEvent more instead of some of the fudges present in my existing tests - this might help make them more robust.

General lessons:

* Any testing you do, learn the technology that underpins it
* Work with developers and use their technical knowledge to help

How to create selenium cookies

2010-09-07T23:17:00.000-07:00

create cookie as:

selenium.createCookie("name=cookieone", "path=/");
selenium.createCookie("name=cookietwo", "max_age=60");

display it as:
String cook1=selenium.getCookie();
System.out.println("cookie"+cook1);

delete it:
selenium.deleteAllVisibleCookies();

How to use Selenium ClickAt Command

2010-09-07T22:18:00.001-07:00

Folks nowadays I'm working on automation and open source tool selenium is been used. Frankly speaking, tool is awesome but still it has some loop holes, workarounds need to be done to get work done. I was trying to click on the rows on the grid and took me 2 hours to figure out how to do.

Here with an example I will tell how and what needs to be done.

Problem description: You had a grid with rows have values and need to click on the basis of values.

Grid looks like this.

abc	Some-Description1	Date1	Comments1
def	Some-Description2	Date2	Comments2
ghi	Some-Description3	Date3	Comments3
jkl	Some-Description4	Date4	Comments4
mno	Some-Description5	Date5	Comments5
pqr	Some-Description6	Date6	Comments6

Now, the requirement says, click on ghi which might open another window. (How to capture the window is not dealt here). When recording from selenium IDE, gave me click command with some XPATH but when I ran same command from IDE, it wasn't working at all.

Solution: Use clickAt(String locator, String co-ordinates)

Selenium IDE do not records clickAt(this was the catch here). I changed click to clickAt and it worked perfectly fine.

so command becomes :

selenium.clickAt("//div[contains(text(),\"ghi\")]","");

locator = "//div[contains(text(),\"ghi\")]"

co-ordinates = ""

This command says, click at the link (given by the XPATH) which has text ghi with no co-ordinates.

Same way to click on grid abc =

selenium.clickAt("//div[contains(text(),\"abc\")]","");

How to capture screenshot in selenium

2010-09-07T02:41:00.000-07:00

Its easy to take a screenshot in selenium . We just need to use the below command.

selenium.captureEntirePageScreenshot("F:\\fullscreenshot","background=#CCFFDD" );

Screenshot will be taken at the time of execution of testcase and will be stored as png file in respective folder as mentioned .In our case it is F:\ fullscreenshot.png.

Enjoy Testing
www.mpowerglobal.com

Running your first selenium test case in eclipse

2010-09-02T20:48:00.001-07:00

1- In FireFox ,Start Your Selenium-IDE from tools->Selenium IDE
2- Record your script
3- Go to File->Export test case as->Choose the programing language as JAVA and save your script.
4-Save it with .java extension

The next step is to open your eclipse and create a project.

1- Creating your java project in eclipse
The first step in eclipse is to create/add your project. To do this follow the steps below:
-> Launch Eclipse
-> Right click in navigator->Create a java project named TestProject (for example)

2- The next step is to add JUnit Libraries which consists of following steps:
-> Go to Project Properties
-> Go to Java Build Path
-> Click on Add external-jar button in Libraries tab
-> Browse and go to the location where u stored ur junit.jar.

4-Add Selenium Java Client Jar into Project:-
Once you added the Junit jars , the next step is to add selenium jar file. you can find selenium-server.jar under selenium-remote-control\selenium-java-client-driver folder what you have downloaded from

http://selenium-rc.openqa.org/download.html

To add this Jar file follow the below steps:
-> Go to Project Properties
-> Go to Java Build Path
-> Click on Libraries tab
-> Click on 'Add External Jars' button
-> Browse and add the 'selenium-server.jar' from the source where you had saved it.

5- Initiating the Selenium Test Server
To start the selenium test server, first go to the location where your selenium-server.jar is placed.
and then Run the command java -jar selenium-server.jar

This will start you selenium server.

6- Adding your test (Java class ) in our Project
To add you test (which you have saved earlier) as a java class file to the project (TestProject, already saved) follow the steps:
-> In eclipse go to create a new java class
-> Create it with name MyFirstTestCase (for example) and paste the code from the file u had saved it
-> Choose "com.thoughtworks.selenium.SeleneseTestCase" as its super class
-> Finish it

7- Modifying your test script (java class)
Once you are done with ur class file, it will look like,

Package.*
import com.thoughtworks.selenium.SeleneseTestCase ;
public class MyFirstTestCase extends SeleneseTestCases {
public void setUp() throws Exception {
setUp( " http://www.google.com/ " , "*firefox'); }

............ You test script..............
}

In case you want to run this in diff browser then simply you can change your script
setUp( " http://www.google.com/ " , "*firefox');
to setUp( " http://www.google.com/ " , "*chrome'); or whatever browser you need to run with.

8- Running your test
Finally we are ready to tun our first test. To run this in eclipse you click on Run button
select option Run as "JUnit Test'

So finally I am done with your end to end execution of ur java test case using selenium RC in eclipse. For report generation using JUnit in eclipse,check my other post Thanks.

For more info,check blogs of http://www.mpowerglobal.com

how to create report in JUnit

2010-09-02T20:31:00.000-07:00

Its very simple to create JUnit reports using eclipse

follow these steps and it worked for me

1) First generate an Ant build file for your project.
In the Export page select "Ant Buildfiles" it is under General. Then select a
project that contains your JUnit tests. The default JUnit output directory is
appropriately named "junit".

2) Next resolve dependencies by making sure that the junit.jar is added to Ant's
"Global Entries."
Window->Preferences->Ant->Runtime->Global Entries and Add External JARs...
Navigate to your "eclipse" directory (where eclipse is installed). It is under
"plugins" directory and presently the junit.jar is in a directory named
"org.junit_3.8.1". If this is missing then you will see error messages since
junit is an optional Ant task.

3) Run then right click on the Ant build file (by default build.xml) and Run
As->Ant Build... This will display a list of targets. All of the launch
configurations you have previously configured will have a corresponding target
in your Ant build file. Select the desired target(s), and also select the
"junitreport" target. Check the "Target execution order" text area to make sure
the junitreport is run last.

Whenever you run a test case it will generate results and will be placed in the
junit output directory. These results are formatted into an HTML report by the
junitreport target and stored in the junit output directory. This is a quick explanation of the process, but hopefully it helps get you off your feet.

For more info,check out http://www.mpowerglobal.com/web/guest/blog

Integrate jmeter with selenium junit

2010-09-02T20:19:00.001-07:00

Step1. Record and convert your script to selenium java-junit format
using selenium ide.

Step2. open the eclipse and save that file as a java file.

Step3. Using junit run that file but before that you need to add
selenium-server.jar file in eclipse.

Step4. After that test runs successfully you will get .class file
under bin folder.

Step5. Setup your Run configuration settings for converting java file
to jar.

Step6. Select .java file and .class together and convert to .jar file.

Step7. Paste that .jar file into lib/junit folder.

Step8. start your j-meter server and see the magic.

Become JUnit expert from installation to examples

2010-08-26T02:36:00.000-07:00

JUnit

JUnit is a simple, open source framework to write and run repeatable tests. It is an instance of the xUnit architecture for unit testing frameworks.

JUnit features include:

Assertions for testing expected results
Test fixtures for sharing common test data
Test runners for running tests.

Download JUnit: The latest version of JUnit is available on SourceForge.

Install: To install JUnit on Windows, Unzip the junit.zip distribution file to a directory referred to as %JUNIT_HOME%. Add JUnit to the classpath:

set CLASSPATH=%CLASSPATH%;%JUNIT_HOME%\junit.jar

For Unix (bash) Unzip the junit.zip distribution file to a directory referred to as $JUNIT_HOME. Add JUnit to the classpath:

export CLASSPATH=$CLASSPATH:$JUNIT_HOME/junit.jar

while using eclipse u just need to add the external jar file to your project.

Easy way to set ClassPath: Add JUnit jar file to Path variable. To add jar file, go to my computer, right click, properties, environment variables, add jar file location to class path user variable.

Variable Values

CLASSPATH ------ E:\junit-4.8.2.jar;

Framework of JUnit

Structure:

l setUp(): Storing the fixture's objects in instance variables of your TestCase subclass and initialize them by overriding the setUp method

l tearDown(): Releasing the fixture’s

l testCase() :Defining how to run a test suite.

Writing our tests: Step by Step procedure

Create a class:

import org.junit.*;

import static org.junit.Assert.*;

import java.util.*;

public class SimpleTest {

Write a test method (annotated with @Test) that asserts expected results on the object under test

@Test

public void testEmptyCollection() {

Collection collection = new ArrayList();

assertTrue(collection.isEmpty());

}

If you are running your JUnit 4 tests with a JUnit 3.x runner, write a suite() method that uses the JUnit4TestAdapter class to create a suite containing all of your test methods:

public static junit.framework.Test suite() {

return new junit.framework.JUnit4TestAdapter(SimpleTest.class);

}

Although writing a main() method to run the test is much less important with the advent of IDE runners, it's still possible:

public static void main(String args[]) {

org.junit.runner.JUnitCore.main("junitfaq.SimpleTest");

}

Run the test:

To run the test from the console, type:

java org.junit.runner.JUnitCore junitfaq.SimpleTest .

To run the test with the test runner used in main(), type:

java junitfaq.SimpleTest

The passing test results in the following textual output:

Time: 0

OK (1 tests)

]

Text Fixture:

A test fixture is useful if you have two or more tests for a common set of objects. Using a test fixture avoids duplicating the code necessary to initialize (and cleanup) the common objects.

Tests can use the objects (variables) in a test fixture, with each test invoking different methods on objects in the fixture and asserting different expected results. Each test runs in its own test fixture to isolate tests from the changes made by other tests. That is, tests don't share the state of objects in the test fixture. Because the tests are isolated, they can be run in any order.

To create a test fixture, declare instance variables for the common objects. Initialize these objects in a public void method annotated with @Before. The JUnit framework automatically invokes any @Before methods before each test is run.

The following example shows a test fixture with a common Collection object.

package junitfaq;

import org.junit.*;

import static org.junit.Assert.*;

import java.util.*;

public class SimpleTest {

private Collection collection;

@Before

public void setUp() {

collection = new ArrayList();

}

@Test

public void testEmptyCollection() {

assertTrue(collection.isEmpty());

}

@Test

public void testOneItemCollection() {

collection.add("itemA");

assertEquals(1, collection.size());

}

Given this test, the methods might execute in the following order:

setUp()

testEmptyCollection()

setUp()

testOneItemCollection()

The ordering of test-method invocations is not guaranteed, so testOneItemCollection() might be executed before testEmptyCollection(). But it doesn't matter, because each method gets its own instance of the collection.

Although JUnit provides a new instance of the fixture objects for each test method, if you allocate any external resources in a @Before method, you should release them after the test runs by annotating a method with @After. The JUnit framework automatically invokes any @After methods after each test is run. For example:

package junitfaq;

import org.junit.*;

import static org.junit.Assert.*;

import java.io.*;

public class OutputTest {

private File output;

@Before

public void createOutputFile() {

output = new File(...);

}

@After

public void deleteOutputFile() {

output.delete();

}

@Test

public void testSomethingWithFile() {

...

}

With this test, the methods will execute in the following order:

createOutputFile()

testSomethingWithFile()

deleteOutputFile()

Testing a method which doesn’t return anything: Often if a method doesn't return a value, it will have some side effect. Actually, if it doesn't return a value AND doesn't have a side effect, it isn't doing anything.

There may be a way to verify that the side effect actually occurred as expected. For example, consider the add() method in the Collection classes. There are ways of verifying that the side effect happened (i.e. the object was added). You can check the size and assert that it is what is expected:

@Test

public void testCollectionAdd() {

Collection collection = new ArrayList();

assertEquals(0, collection.size());

collection.add("itemA");

assertEquals(1, collection.size());

collection.add("itemB");

assertEquals(2, collection.size());

}

Another approach is to make use of MockObjects.

A related issue is to design for testing. For example, if you have a method that is meant to output to a file, don't pass in a filename, or even a FileWriter. Instead, pass in a Writer. That way you can pass in a StringWriter to capture the output for testing purposes. Then you can add a method (e.g. writeToFileNamed(String filename)) to encapsulate the FileWriter creation.

Writing a test that passes when an expected exception is thrown: Add the optional expected attribute to the @Test annotation. The following is an example test that passes when the expected IndexOutOfBoundsException is raised:

@Test(expected=IndexOutOfBoundsException.class)

public void testIndexOutOfBoundsException() {

ArrayList emptyList = new ArrayList();

Object o = emptyList.get(0);

}

Writing a test that fails when an unexpected exception is thrown:

Declare the exception in the throws clause of the test method and don't catch the exception within the test method. Uncaught exceptions will cause the test to fail with an error.

The following is an example test that fails when the IndexOutOfBoundsException is raised:

@Test

public void testIndexOutOfBoundsExceptionNotRaised()

throws IndexOutOfBoundsException {

ArrayList emptyList = new ArrayList();

Object o = emptyList.get(0);

}

Where to keep our programs:You can place your tests in the same package and directory as the classes under test.

For example:

src

com

xyz

SomeClass.java

SomeClassTest.java

For more info,check blogs of http://www.mpowerglobal.com