Selenium Object Repository - Part 1

On the contrary to popular belief, Selenium (http://seleniumhq.org)  is not a test automation tool. By definition , Selenium is a web browser automation tool. Hence, we might not see rich features inherited to Test Automation tools such as QTP. However, Selenium works really well as a browser automation tool.  It's light weight, portable and fairly easy to run, and it works well with many web application development platforms such as Java, PHP, Python etc... Another reason for its immense popularity is that it works really well with different browsers.

As a browser automation tool, selenium can be used in conjunction with an application testing framework (such as Junit for Java) to automate web application testing.  It has been used like this as an alternative for expensive and  complex test automation tools. However, one of the key things that was missing is an object repository. Popular test automation tools such as QTP provides a comprehensive Object Repository where we can represent application elements as objects and reuse them within test cases.

By utilizing the page object pattern which represent the elements of your web application as a series of objects, we can create an Object Repository which can be used with selenium. This will provide us a huge advantage of not having to duplicate browser automation code in order to test different aspects of the application. For example in order to test an application with a user login, we might need to login to the application initially in every test. In the conventional way we will have to duplicate the code for login inside every test case. With selenium page object pattern we can encapsulate login method of the application within a "LoginArea " object which we'll be able to re-use in every test case.

Using page object pattern we can de-couple selenium logic from the test case. This is really important since test logic has nothing to do with selenium operations. Below example will clearly demonstrate the difference and advantage of using selenium page objects.
Code Listing below shows a typical traditional selenium and Junit test to test a web application. The objective of the code was to test Gmail login  and "Move To Spam" operations.

package com.selenium.standard.tests;

/**
 * URL of the application will be created by concatenating the APP_HOST And APP_PATH
 */
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.thoughtworks.selenium.SeleneseTestBase;

public class GmailTest extends SeleneseTestBase {
 public static final String APP_HOST = "http://www.gmail.com/";
 public static final String APP_PATH = "/";

 public static final String TEST_BROWSER = "*iexplore";
 public static final int SELENIUM_PORT = 4444;
 public static final String HOST = "localhost";
 public static final String MAX_TIME_OUT = "1000000000";

 @Before
 public void initialzeTests() throws Exception {
  setUp(APP_HOST, TEST_BROWSER, SELENIUM_PORT);
  selenium.open(APP_PATH);
  selenium.windowMaximize();
 }

 @Test
 public void testGmailLoginFail() throws Exception {
  // Enter a wrong login details first
  selenium.type("Email", "webappcenter");
  selenium.type("Passwd", "webappcenter123sds");
  selenium.click("signIn");
  String waitForXPath = "The username or password you entered is incorrect";
  selenium.waitForCondition("selenium.isTextPresent(\"" + waitForXPath
    + "\")", MAX_TIME_OUT);
  assertTrue(selenium
    .isTextPresent("The username or password you entered is incorrect."));
 }

 @Test
 public void testGmailLoginSucess() throws Exception {

  // login to gmail with correct logins
  selenium.type("Email", "webappcenter");
  selenium.type("Passwd", "webappcenter123");
  selenium.click("signIn");
  String waitForXPath = "//html/body/div/div[2]/div/div[2]/div/div/div/div[3]/div/div/div/div/div";
  selenium.waitForCondition("selenium.isElementPresent(\"" + waitForXPath
    + "\")", MAX_TIME_OUT);

  // test Login sucessfull
  assertTrue(selenium
    .isElementPresent("//html/body/div/div[2]/div/div/div[4]/div/div[2]/div/table/tbody/tr/td[2]/div[3]"));
 }

 @Test
 public void testMoveToSpan() throws Exception {
  // login to gmail with correct logins
  selenium.type("Email", "webappcenter");
  selenium.type("Passwd", "xxxpasswordxxx");
  selenium.click("signIn");
  String waitForXPath = "//html/body/div/div[2]/div/div[2]/div/div/div/div[3]/div/div/div/div/div";
  selenium.waitForCondition("selenium.isElementPresent(\"" + waitForXPath
    + "\")", MAX_TIME_OUT);

  // Get the UI to basic view
  selenium.click("//html/body/div/div[2]/div/div[2]/div/div[2]/div[2]/div[5]/div/div/a");
  waitForXPath = "You are currently viewing Gmail in basic HTML";
  selenium.waitForCondition("selenium.isTextPresent(\"" + waitForXPath
    + "\")", MAX_TIME_OUT);
  // Move first two items to span
  selenium.click("//html/body/table[3]/tbody/tr/td[2]/table/tbody/tr/td[2]/form/table[2]/tbody/tr/td/input");
  selenium.click("//html/body/table[3]/tbody/tr/td[2]/table/tbody/tr/td[2]/form/table[2]/tbody/tr[3]/td/input");
  selenium.click("//html/body/table[3]/tbody/tr/td[2]/table/tbody/tr/td[2]/form/table/tbody/tr/td/input[2]");
  waitForXPath = "2 conversations have been marked as spam.";
  selenium.waitForCondition("selenium.isTextPresent(\"" + waitForXPath
    + "\")", MAX_TIME_OUT);
  assertTrue(selenium
    .isTextPresent("2 conversations have been marked as spam."));
 }

 @After
 public void releaseTestResources() throws Exception {
  selenium.stop();
  selenium = null;
 }

}

As you can see, we clearly has mixed selenium operation logic with the test logic, this violate the single responsibility principle of good object oriented programming practices. Let's see if we can make it better. Below is the same test but with applied page object pattern.

package com.selenium.pageobject.tests;

import org.junit.Test;

import com.selenium.pageobject.libs.GmailEmailList;
import com.selenium.pageobject.libs.GmailLogin;
import com.selenium.pageobject.libs.GmailTopButtonPanel;
import com.selenium.pageobject.libs.common.PageObjectBaseTest;

public class GmailPageObjectTest extends PageObjectBaseTest {

 private GmailLogin loginPage; // This is the login page object
 private GmailEmailList emailListPanel; // This is the email list object
 private GmailTopButtonPanel buttonPanel; // This is the button Panel Object

 public GmailPageObjectTest() {
  loginPage = new GmailLogin(localSelenium);
  emailListPanel = new GmailEmailList(localSelenium);
  buttonPanel = new GmailTopButtonPanel(localSelenium);
 }

 @Test
 public void testGmailLoginFail() throws Exception {
  // Test for failed login
  loginPage.login("webappcenter", "adadjsdksdk");
  assertTrue(loginPage.verifyLoginFailure());
 }

 @Test
 public void testGmailLoginSuccess() throws Exception {

  // Test for successful login
  loginPage.login("webappcenter", "webappcenter123");
  assertTrue(loginPage.verifyLoginSuccess());
 }

 @Test
 public void testMoveToSpan() throws Exception {
  if (loginPage.loginBasicView("webappcenter", "xxxpasswordxxx")) {
   emailListPanel.selectFirstTwoEmails();
   buttonPanel.reportSpam();
   assertTrue(buttonPanel.verifyReportSpan(2));
  } else {
   fail("Could not login to basic view");
  }
 }
}

Firstly, we have 3 page objects defined (GmailLogin, GmailEmailList and GmailTopButtonPanel) and all the selenium logic to locate and handle these objects are now moved to the relevant object itself.  This approach has considerably improved our test by separating the selenium and test logic and improving the readability as well. Another advantage is that in most cases application changes are not affected to the test case. For example, say Google introduce a new login window  and IDs of text fields were changed, in the first code listing we'll have to change the test case itself in order to update this change. However, in the second example we only have update GmailLogin page object and our test case itself is not aware of this change at all.

During this series of articles we'll develop a fully functional  object repository for selenium which can be reused in any project. I'll be using  Java and related technologies as the development platform,  but with little changes you can implement the same for other platforms as well.
Having a clear understanding of the advantages of using a Object Repository, in the next article we'll start to implement our very own selenium Object Repository.

NB: It has been over a year since I've written the original article. Sorry I've never got the time to write the followup of this. However, the time isn't wasted. I have created a fully functional Selenium Object Repository in Java which you can use in your projects. Work of this framework is now completed. I'm in the process of documenting it. Please bare with me, I'll have all the details of using it in the next followup article to this.

TTL Formula for SCRUM

What are the key factors of a successful scrum team?  what is the magic formula that drive scrum teams to success? After wrestling around  with it for a while, I realized that 3 key factors, namely "Teamwork", "Talent" and "Leadership"  (TTL) determine success of a scrum team  above all else. and for the best performance, you need to arrange these factors in the correct order using a formula. Here's what I came up with

Collection of talented team players with leadership qualities = Successful Scrum Team
(Collection of Team Players)  X (Talent) X (Leadership ) = Successful Scrum Team

a(Teamwork)  X   b(Talent)   X    c(Leadership)   =  Successful Scrum Team

where a,b,c are constants.

As simple it may seems, I feel little description of this formula is necessary. It's obvious that each factor Teamwork, Talent and Leadership holds equal importance i.e. 0 value of any of these factors means a failing scrum team.

This surfaces the complexities of putting together a scrum team as well, you need to have the right combination of people. Also, it's vital that each individual of the team has leadership skills apart from talent and teamwork abilities, I feel this is a unique characteristic of scrum process. Unlike other SDLC processes having highly talented individuals with 0 leadership skills will not add any value to the success of the team.
Another point is , giving an effort to improve any of these factors (i.e. TTL) by increasing the constants (a, b and c) will have a direct impact on the success of the scrum team. I feel scrum teams need to put effort on improving these factors and try to improve teamwork, talent and leadership skills within the team to ensure the success.

Why we blog

an interesting internal workshop we had today was about social media and blogging played a major role in it. many things were discussed about the advantage of blogging to promote yourself, company etc.. but none of it completely made sense to me on the question of "Why we blog?"  I feel many people are trying to force themselves to blogging for all the wrong reasons. for example, blogging only to create a web presence and to build an image or blogging to promote the company that you work for.


I feel we should blog for ourselves, one of my mentors (Hasith Yaggahavita - http://blog.hasith.net/) has described in his blog that "Generally I write here to structure my own thinking". I feel that's a very good reason to blog (Actually I think that's what got me started blogging really). You need to understand that blogger is a great tool that allow you to write what's on your mind clearly, and for me, more I write or talk about a given subject, more clearer it gets. Hence, I am fully agreement with Hasith, and I blog for myself and to make the subject I write about  more clear to me. Of course others are more than welcome to voice their own ideas and contribute by commenting and challenging my views :)

Heroes, Humans and Success in Agile Software Development

I love agile software development methods and techniques, I'm also a big fan of Agile Scrum process. I believe it has revolutionized how we develop software and in a good way. Although  it might not be the Aladdin's lamp which will provide a total solution to all of software development issues, it's the closest we have at the moment.

I believe the majority of us has identified how Agile processes can be utilized in developing successful software applications. But I think it potent to find out why agile is successful, as it turns out many concepts and practices that we follow in Agile processes have been there for sometimes, things like iterative development is also available in RUP which is not an Agile process.  So, what makes agile different and what leads to its success? "Human aspect", yes, Agile processes take into account the Human aspect in a software development environment. It allows team members to decide for themselves and provides a free and equal environment for them to perform at their own pace. It also embrace the concept of "Team", and encourage people to work as a group rather than individually. Humans by nature are social creatures, we almost always hate solitude. Agile processes utilize this fact in a beautiful way by removing limiting boundaries within the team that would hinder interaction between team members.

While Agile process highlights and even relies on the "Human Aspect" for its success,  using the freedom allowed within the agile team needs to be used in a very responsible way. As the famous quote from Movie Spider Man goes "With Great Power  comes Grate Responsibility", in Agile, "With Great  Freedom comes Great Responsibility". In the old days of software development, many areas were filled with ambiguity, and large systems were built by a design that was done at the beginning of the project, even though the iterations were practiced, iteration cycles were long and often the deliverables didn't match the client requirement, simply put the situation was chaotic. Just like in any such situation, this messy environment paved the way for  "Heroes" to immerge, i.e. there were some team member(s) within any software application development team who had better understanding of the application domain or the programming language etc... the chaotic environment of software application development of the old days allowed people like this to shine among others in a team, usually these team members were considered "High Valued" resources by the company and they were well looked after. In highly procedural bound processes that didn't consider the value of the "Human" aspect these "Heroes" actually rescued projects, they single handedly sometimes dragged the project to finish line using the special skills they have and often the ordinary  team members (who would have added lot of value if given the opportunity) were shadowed by this process and the concept of "Team" was never embraced.

Agile processors has changed all of that, it has created an environment where everybody can interact and add value to the project they are working on. Success of an Agile based software application depended on the Team not on the skill levels of its individuals, by allowing each team member to contribute and by respecting and identifying the importance of the "Human" aspect, Agile processes has given the opportunity for each and every team member to become a Hero. However, each individual of an Agile team must understand their strength and success of the project relies on the Team not themselves, so, the Heroes within the team has a great responsibility to use their powers carefully. A true agile hero would embrace the team more than anything, they would use their special skills to improve and empower team members and almost always would try their level best to develop the team. They would also understand that a team consists of "Humans" and that each individual is unique in this world, it's important to respect ideas of each individual in a team. Also, all team members need to understand that their personal egos doesn't add any value to the team, it almost always hinder teamwork which will intern destroy the unity within the team.

All in all, It's not a must for Heroes to exists within an agile team. what's important is that each individual in the team embrace the Human factor and utilize property to drive the project to success.