Simple Tech Talks

Java - Enum Type Sample usage

2010-10-28T00:50:00.000-07:00

Recently I got problem where i need to use, the type enum which i never used before,

The Problem: We have clustered DataBase Setup, So the Automation test should connect to the DataBase server based on some requirement. (Say it has an Activation pair, and DataStorage pairs.)

So here the typical way is we need to define the connection properties for each pair and connect then accordingly. But when we need to repeat this in a lot of tests, So here the use of the type enum comes.

Usage:

1. Define public enum DataBaseServer
2. Define the connection properties

      private String dbDriver ;
      private String dbServerUrl ;
      private String userName ;
      private String password ;
      private String port;

3. Now initialize the DataBaseServer based on the Type For example for a primary activation server.

PRIMARY_ACTIVATION_SERVER("Primary Registry Database Server"){

       public String getDbDriver() {
           return "PrimaryRegistryDBDriver";
       }
       public String getDbServerUrl() {
           return "PrimaryRegistryDBUrl";
       }
       public String getPort() {
           return "PrimaryRegistryDBPort";
       }
       public String getUserName() {
              return "PrimaryRegistryDBUsername";
       }
       public String getPassword() {
         return "PrimaryRegistryDBPassword";
       }
}, SECONDARY_ACTIVATION_SERVER("Primary Registry Database Server"){ //init code here, check the primary code},
PRIMARY_DATA_SERVER("Primary Registry Database Server"){ //init code here},
SECONDARY_DATA_SERVER("Primary Registry Database Server"){ //init code here} ;

4. In your data base connection call you can just specify the type like this

DBConnector.connect(DataBaseServer.PRIMARY_DATA_SERVER);

note that the connect will accept the DataBaseServer Type and based on it will get the properties..

-------

Defining and Using Custom Java Annotations

2010-03-10T23:29:00.000-08:00

When we look in to java annotation definition it will say like this “Annotations provide data about a program that is not part of the program itself or Annotations are java’s way to provide some information to the java compiler”. For example when we look in to @Deprecated annotation, we can see that it says to the compiler that the annotated type is deprecated. That’s fine, great but in reality where I can use my own annotations and what are the scenarios? Recently I came in to a situation where I could see the right use of Custom annotation. When I searched for this it was pretty difficult to find out the right it formation, all tutorials talk about how to write custom annotation and what are the features and syntax but the information I wanted was when to write custom annotation or why do I write a custom annotation. So I just thought of posting one of the most important use of Custom annotation.

The requirement: I have a set of classes which are of 2 types, say example “DBUpdate” classes and “DBInsert” Classes. When run time I need to do actions based on which type of class is executing

Solutions:

    1. Use a super class and do a type check in run time. But here the issue is both classes are extending from   same super class “DataBase.”

    2. Define a marker interface “DataBaseUpdate” and implement this interface for the classes which are doing “DataUpdate”. (This works fine..!!!) But need to define 2 interfaces and should be careful about implementing right Interface etc

   3. The alternative solution is define a custom annotation “DataBase” and mark your classes with this. (We will see how to do this”)

Define the Custom Annotation:

   @Target(ElementType.TYPE)
   @Retention(RetentionPolicy.RUNTIME)
   public @interface DataBase {
        String dbTask() default “”;
   }

Use @Interface before the annotation name.(dOwe see any relationship between the solution number 2 and the keyword @iInterface!!!!!!) Note that there are 2 other annotations used for defining an Annotation .. :). @Target will define the scope of the annotation (method, class, constructor..etc. Refer Javadoc for all the Target element Types and to know the RetentionPolicy)

Process the Annotation at Runtime:

Here a method which will process when it found our annotation

@SuppressWarnings("unchecked")
public static String processAnnotation()
{
    // getting the classes in execution
   // getAllClassesInExecution definition is not added here

    Class[] classesInExecution = getAllClassesInExecution();
    for(int i=0; i<classesInExecution.length; i++)
    {
          if(classesInExecution[i].isAnnotationPresent(DataBase.class)){
               DataBase db = classesInExecution[i].getAnnotation(DataBase.class);
               String dbTask = db.dbTask();
               if (dbTask.equalsIgnoreCase(“update”) {
                          //Do db update here.
               }
               else if (dbTask.equalsIgnoreCase(“insert”) {
                        //Do db isert here.
         }
   }
}

Using the Annotation:

Now Use this Annotation at class level. (We used Target(ElementType.TYPE))
   @DataBase(dbTask =”update”)
   Public class MyDBTest{
       processSQL();
    }

Now we are ready with our own annotation when the code is executed based on the dbTask we provided the system will do the task accordingly. Now keep defining your custom annotations and start enjoying.
(Don’t forget to refer the performance issues and other things while using the runtime processing)

Reading a config XML file from Ant Build

2010-02-18T00:04:00.000-08:00

Yesterday I was breaking my head to figure out how can I access the properties defined in and XML file. We used to define a config.properies file and access this property file in ANT. But these days writing configuration file in XML is useful we need to communicate with other applications.

I was working on developing a SeleniumTestFrameWork in java, so I defined an XML file "testconfig.xml" to store my properties for the test framework. But for the ANT build to execute the test cases, I need to get the property of the testNG group "testgroup" which is defiend in the testconfig.xml file. Finally I found the solution which as simple as accessing config.properties file in ANT.

Here the example and sample build file for it.

Sample XML File: samplconfig.xml

<root>
<parent1>
<child1>child value </child1>
</parent1>
<parent2>parent2 value</parent2>
<parent3>parent3 value</parent3>
<root>

Now Here the ANT Build is,

<project basedir="." name="XML Property Test">
<xmlproperty collapseattributes="true" file="${basedir}/config/samplconfig.xml">
<target name="Sample xml properties">
<echo>Parent2 Value is: ${root.parent2} </echo>
<echo>chile1 Value is: ${root.parent1.child1} </echo>
</target>
</project>

When you run the build the output will be like this...

Buildfile: E:\workspace\mytest\build.xml
Sample xml properties:
[echo] Parent2 Value is: Parent2 value
BUILD SUCCESSFUL
Total time: 141 milliseconds

Now start defining your property files as XMLs, and start enjoying.... :)

Part 7: Beginners How to Start With??

2009-10-20T00:25:00.000-07:00

If you are new to selenium and going through these posts you will be thinking Selenium RC is good and powerful and I am proficeient in my favourite programming language so I should start with Selenium RC. But the answer is NO, you should start with SElenium IDE to know about the selenium Commands and actions.

1. Download Selenium IDE using Firefox (Tools-->Add-ons)
2. After doing that click on Tools you will see Selenium IDE there.
3. Click on Selenium IDE
4. ByDefault selenium IDE with open with HTML as format.
5. If you want to chnage the format go to Options-->Format and choose the format you want.
6. Now click on File --> New Test Case whcih effectively create a new test case, click on the record button from the toolbar (right most)
7. Enter the base url of your application in the Base URL TextField. Do soem actions on the application under test and you can see that the selenium IDE records the action you do.
8. Now click on the "play current test case button" and verify that the test executed currectly.
9. We can view the log in the lower pane of the Selenium IDE window.
10. Now you can save the test and re-open and run it again.

(Seleniums wait methods wait for pre-defined milli seconds bydefault it will be "30000" you can change this by going to Options-->options-->Default value for recorded command)

More importantly give special attention to the middle pane of the selenium IDE window. Where we will see the Command, Target and Value

Command is the Selenium Command/Method to be executed
Target is on what field command should be executed (Target is nothing but locator)
Value is the input value of the field (for Text, DropDown, etc)

So to get good control over selenium you should check the auto help option from Command Filed" Type any character in the command Field Selenium IDE will list the commands starts with that character. Now select any of the listed command, If you look at the bottom pane we can see that the pane is changed to References and it displays the description the selected Command.

Work and play with the IDE commands and be ready by yourselves to move to the next level

Part 6: Running The Tests

2009-10-19T09:34:00.001-07:00

Using Selenium IDE

• We can open the html tests and click on Run Tests button
• To run all the tests we have we need to create test suites. B default selenium looks for TestSuite.html, so we can either add all the html tests to TestSuite.html
•Or we can override the TestRunner url b replacing the TestSuite.html with our own test suite name Ex: http://localhost/TestRunner.html?test=AllTests.html

Using Selenium RC

•Running tests using selenium RC is up to the framework developer. The common steps to follow are,
1. Starting the selenium Server
2. Initializing the DefaultSelenium object with the application url, browser and other desired properties.
3. call the start method of selenium object (selenium.start())
4. Starting your test (Either we can make use of any other unit testing frameworks like junit, nunit, testNG etc or can use the programming languages technique but in this case you may loose the flexibility and advantages of a testing framework so nobody does that)

Part 5: Locating the Elements in a Web Page (Object Spying)

2009-10-19T09:30:00.000-07:00

For testing our web application we need to enter the data and verify the outputs, how we are going to do this. In other words how we are going to identify the web components on the web page. Its known as spying the objects. For example if we need to do an action on a component, all we need is uniquely identify the component. If we have only a button in the page and it has a unique id or name then we are blessed. What if we have so many buttons and all have no id but the same name(Since all are doing the same action but in different situations so the developer decides to give the same name) These kind of situations we need to do something tricky which help us to identify each button uniquely

Selenium uses the following types to locate the objects on a web page.

1. ID or NAME Locator(The element with @id, @name attributes which is unique in the page.).

2. XPATH Locators.

(Xpath locators are beginning with “//” xpaths are useful when we don't have unique id or name in this case we ma need to use the combination of other attributes like alt, value, class, span etc..)

3. DOM Locators

(We can use the DOM model to traverse the document and locate the objects. The DOM locators must begin with document Ex: document.acme.forms.loginForm.username)

4. CSS Locators

CSS locators are like other XPATH locators but here we will make use of CSS attributes. When we started with IE as test browser I used to face so many problems with XPATH locators. The test execution was extremely slow and in few places the way IE translates the Pages was bit different from Firefox which I used to locate elements. So it will be much appreciated if you use CSS locators over XPATHs. It will increase the execution speed in IE and in AJAX rich applications it will reduce the chances of failures by dynamic object id generation

Example:
For example in our login page we need to test the following scenario. (Note that I will be using java code for samples)

1. Open the login page
2. Verify the login page opened
3. Type the username
4. Type the password
5. Click on the login button
6. Verify the login is successful

Here we need to locate 3 elements 1. Username Textfield 2. Password field 3. Login button. We can use the Selenium IDE to record teh actions there b figuring out the locators but if you are more experience ou can find out locators directly from the html source, DOM, or some locator tools.
Ok when we opened the html we could see that the following code

input id=username value =’Enter username here’ size=10, onKePres= “Do something”
input id=password value =’’ size=10, class= pwd
button id=loginButton value =’’ size=10 name= login

Here all the 32 elements have ids we can make use of it. Hence our code will be look like this

Selenium.type(“username”);
Selenium.type(“password”);
Selenium.click(“loginButton”);
Selenium.wait(“60000”);
The same code can use XPATH/DOM like this (Note that I am not showing the DOM or CSS definition for the page all I need is to show the usage or syntax)
Selenium.tpe(“//input[@value=’ ’Enter username here’]”); //XPATH
Selenium.tpe(“css=div[class=pwd]”); //CSS
Selenium.click(“document.LoginForm.loginButton”); //DOM
Tools which helps us to identify the attributes of a field
1. Firebug (Firefox pluggin) (search for firefox addons)
2. IE Developers Toolbar “http://chrispederick.com/work/webdeveloper/”
3. Xpath Checker (Firefox addon)

Part 4: How Does Selenium work

2009-10-19T09:28:00.000-07:00

1.Selenium is developed by using JavaScript and implemented with browser technology.
2.Tests run directly in the browser.
3.Selenium deploys its own BrowserBot with our application for this selenium engine uses JavaScript and Iframes.
4.Since Selenium uses Javascript it works with an Java-Script enabled browser.

The above statements are the technical description of Selenium as A Tool but as a user you ma not need to dig in to how it works or how it developed and all. All you want is how it works for you.
1. Selenium loads our application b the specified url, the command use for this is selenium.open(url)
2.Selenium identifying the elements in the web page under test b using the element locators
3.Selenium does Actions on the web page under test by using the locators and its action methods (type, click, select, check..etc)
4.After the output generated or the resultant page loads (selenium waits for the pageload)Selenium does verifications using assert or verify methods.
5.Accessors (getter methods): After generating the out put we can get and store it.
6.We can refine our tests using other methods like storing values, waiting for a pageload etc. Doing some operations on the output values etc.

Make use of selenium's auto help from selenium IDE (type the method/Acton name’s first character and refer the description comes along with the method)or use the appropriate drivers documentation to learn more about the methods in selenium (If you are using selenium RC and an of the drivers you will get the DOC for the appropriate drivers.)

Part 3: Selenium Flavors (Components)

2009-10-19T09:25:00.000-07:00

There are 3 types of Selenium Components available in now.

1. Selenium Core:

Selenium Core is the test execution framework for all selenium flavors.
Even though users can use Selenium Core as the testing tool but not encouraged
It is the engine of both, Selenium IDE and Selenium RC
Selenium core is written in DHTML.
Selenium developers it self says that the Selenium Core will be deprecated in recent future, hence I am not at all bothering about Selenium core in any of the topics.

2. Selenium IDE

Selenium IDE is a record and playback tool. Selenium IDE is a firfox extension so as I mentioned before this is its biggest limitation. So if you want to run our tests on different browsers you may need to go for Selenium RC. But we can run our tests which has been recorded b IDE in an browser using Selenium RC.
Selenium IDE provides auto complete for all the selenium commands.
Can save the recorded tests in to different supported formats (html, java, rub, etc..)
we can also set debug and break points.

3. Selenium RC (Remote Control)

Selenium Remote Control (RC) allows us to write the tests in any programming language against any HTTP website using any javascript-enabled browser.
Selenium RC has a server which automatically launches and kills browsers, and acts as a HTTP proxy for web requests.
Selenium Client Driver libraries for our favorite computer languages HTML, Java, C#, Perl, PHP, Python, and Ruby..
The RC server also bundles Selenium Core, and automatically loads it into the browser.

4. Selenium-Grid

Grid allows the Selenium-RC test suites that must be run in multiple environments and allows for running tests in parallel
Multiple instances of Selenium-RC are running on various operating systems and browser configurations, each of these when launching register with a selenium hub. When tests are sent to the hub they are then redirected to an available Selenium-RC, which will launch the browser and run the test. This allows for running tests in parallel.

Part 2: Why Not Selenium

2009-10-19T09:17:00.000-07:00

When we discuss about a tool if we are not considering the cons then the discussion is not complete. Yes some of the advantages will come as disadvantages.
1. Open Source Tool difficult to get the right support.
2. Need to put great effort to design the right framework
3. Need the right knowledge to design and integrate different tools for the framework (Ex. You may need to integrate with Reporting tools, build, integration, other utils.
4. Record and Playback only available with FireFox browser
5. If you are planning to run our tests on multiple browsers then need special care for the object locators (We will discuss about this in the element locators section.)

Here I was not listing the selenium’s limitations to handle some situations in the application, instead I was listing the disadvantages as a testing tool. We may find some tricky situations where selenium is failing to handle our requests, in such situations its our responsibility to find out the solutions.

Part 1: Why Selenium

2009-10-13T06:57:00.000-07:00

Its a simple question arise when you think about selecting your automation tool. The answer is pretty simple.

1. Its Open sourse!!
2. Its easy to learn and impliment..
3. Supports multiple browsers.
4. Supports multiple scripting/programming languages.
5. Flexible to your choice, simple record and playback (IDE), Comple Framework design to your choice by using your favorite programming language.
6. Supports parellel execution.

Automating the Web Application With Selenium.

2009-10-13T03:56:00.000-07:00

I was thinking to share my knowledge about selenium from the day I started working with it. I like the tool with all of its strengths and limitations. Is an excellent tool currently available in the open source testing tools world to test your web application. If you are just in development phase of your project and you are planning to automate your tests using selenium just take a precaution from the development side; put a unique identifier for your javascript objects as much as possible...

In the following sections I will share my knowledge as much as possible, when I started with selenium 2 years back there where no such tutorials or tips were not available.. But now you can find out a lot of documents and tutorials available over Internet. The selenium document ion itself is pretty described and well documented now. I refereed the document recently after long time I surprised with the content and the excelled way of describing the features and techniques in fact one moment I thought of not to write this posts. Anyways it was a though which I had from past two years so y do I stop? OK I will continue with my decision...