As I have mentioned in my Introduction to Generic Fixture post that we can use Generic Fixture to write acceptance tests to validate almost any type of Java application. In my previous posts I demonstrated how to make use of Generic Fixture to write automated web tests and testing EJBs. Let's now see how to use Generic Fixture for writing queries against an Oracle database.

We shall keep the database connection parameters in a separate SetUp page as well as the connection closing code in a separate TearDown page. After that we shall write our query in main test page. That way we can utilize SetUp and TearDown pages in all of our test pages without repeating that code again and again in for each test.

I am assuming that your FitNesse server process is running on localhost on post 8000. If that is not the case then please change the URLs accordingly.

To test a database we shall need the database vendor supplied JDBC driver to be able to make JDBC calls. In this example since we are using Oracle we are going to need Oracle's JDBC driver jar file. You can place your JDBC driver jar file anywhere on your system where FitNesse server is running and give the path in !path directive of FitNesse.

Open a browser and enter this URL: http://localhost:8000/FitNesse.OracleSuite
Since this page doesn't already exist, it will give you a link "create this page", go ahead the click on this link to create a new page. Enter following text in the new page's source.

!*> Class Path
!path ojdbc14.jar
*!
----
>SetUp
>TearDown
 * >SelectQuery

Please note that here I kept JDBC driver jar file (ojdbc14.jar) in FitNesse install directory therefore I could give this directive !path ojdbc14.jar. If you want to keep ojdbc14.jar at some other path then just provide your path here using !path /your/path/to/ojdbc14.jar

Save your changes. Now FitNesse will show question marks ? links next to >SetUp, >TearDown and >SelectQuery text, since these pages do not already exist. Go ahead and click on the ? link next to >SetUp text and enter following text in the new page's source.

'''Connect to Database'''
!| Generic Fixture | oracle.jdbc.pool.OracleDataSource |
| setDriverType | thin |
| setServerName | localhost |
| setPortNumber | 1521 |
| setDatabaseName | testdb |
| setUser | scott |
| setPassword | tiger |
| conn=getConnection |

Customize database connection parameters above to suite your environment. Save your changes. Now click on the ? link next to >TearDown text and enter following text in the new page's source.

'''Close the Statement'''
!| Generic Fixture | stmt= |
| close |

'''Close the Connection'''
!| Generic Fixture | conn= |
| close |
| is closed | | true |

Save your changes. Now click on the ? link next to >SelectQuery text and enter following text in the new page's source.

'''Prepare your query'''
!| Generic Fixture | conn= |
| stmt=prepareStatement | select  age, title from emp where id = ? |

'''Execute your query'''
!| Generic Fixture | stmt= |
| setInt | 1 | 1234 |
| resultSet=executeQuery |

'''Examine the Result Set'''
!| Generic Fixture | resultSet= |
| meta=getMetaData |
| meta=.getColumnCount | | 2 |
| next |
| getInt | age | | 30 |
| getString | title | | Sr Manager |

Save your changes. Click on properties and check the Test check-box to make FitNesse.OracleSuite.SelectQuery a test page. Click on "Save Properties".

Click on the Test button in top left menu to run your database query and view the results. Here in above test I am expecting result of select query to be 30, Sr Manager. FitNesse will mark these 2 cells green or red depending upon the actual query results.

Even though I took Oracle as database in my example above but Generic Fixture is not tied with any database. You can drop the jar file of any JDBC driver and set the classpath as instructed above to test any database. I have personally used Oracle, Sybase and MySQL in my testing without any problems.

So you can see how easy it is to do database testing using Generic Fixture without ever writing a single line of Java code.

Now lets take a look at another example:

!| Generic Fixture | Address | 123 | Nutley Street | New York | 21019 | NY |
| getStreetNo | | 123 |
| getCity | | New York |
| state=getState | | NY |
| getFullAddress | | 123 Nutley Street, New York, NY - 21019 |
| setStreetNo | 111 |
| setPostcode | 20133 |
| getPostcode | | 20133 |
| getStreetNo | | 111 |
| getState | | state= |
| setName | John Smith |
| name=getName | | John Smith |

!| Generic Fixture | Address$Name | name= |
| getSurname | | Smith |
| getFirstname | | John |
| toString | | John Smith |

!| Generic Fixture | name= |
| getSurname | | Smith |
| getFirstname | | John |
| toString | | John Smith |

Here first I am storing return value of getState() (String type) in a variable "state" and later using state to compare return value of getState in the test.

We are also using another variable called "name" to store return value of getName() which is of Address$Name type. We are using variable "name" in the constructor of a new new table that operates on Address$Name class. And in the 3rd table we are once again using variable "name" without instantiating a new class by marking variable "name" as SUT.

These examples show how variables can be used to store all standard Java as well as user defined objects.

Code for class Address and inner Address$Name is attached here for reference:

Source Code Address.java

public class Address {
 public static class Name {
    private String surname = null;
    private String firstname = null;       

    public Name() {
    }       

    public Name(Name n) {
       this.surname = n.surname;
       this.firstname = n.firstname;
    }       

    public static Object parse(String s) {
       Name n = new Name();
       String[] arr = s.split(" ");
       if (arr.length == 2) {
          n.setFirstname(arr[0]);
          n.setSurname(arr[1]);
       }
       return n;
    }       

    @Override
    public String toString() {
       return this.firstname + " " + this.surname;
    }       

    public String getSurname() {
       return surname;
    }       

    public void setSurname(String surname) {
       this.surname = surname;
    }       

    public String getFirstname() {
       return firstname;
    }       

    public void setFirstname(String firstname) {
       this.firstname = firstname;
    }
 }       

 private int streetNo = 0;
 private String street = null;
 private String city = null;
 private int postcode = 0;
 private String state = null;
 private Name name = null;       

 public Address() {
    super();
 }       

 public Address(Integer streetNo, String street, String city, int postcode,
       String state) {
    super();
    setAddress(streetNo, street, city, postcode, state);
 }       

 public void setAddress(Integer streetNo, String street, String city,
       int postcode, String state) {
    this.streetNo = streetNo.intValue();
    this.street = street;
    this.city = city;
    this.postcode = postcode;
    this.state = state;
 }       

 public void setStreetNo(Integer streetNo) {
    this.streetNo = streetNo;
 }       

 public Integer getStreetNo() {
    return this.streetNo;
 }       

 public String getStreet() {
    return this.street;
 }       

 public void setCity(String city) {
    this.city = city;
 }       

 public String getCity() {
    return this.city;
 }       

 public void setPostcode(int postcode) {
    this.postcode = postcode;
 }       

 public int getPostcode() {
    return this.postcode;
 }       

 public String getFullAddress() {
    return this.streetNo + " " + this.street + ", " + this.city + ", "
          + this.state + " - " + this.postcode;
 }       

 public void setStreet(String street) {
    this.street = street;
 }       

 public String getState() {
    return state;
 }       

 public void setState(String state) {
    this.state = state;
 }       

 public Name getName() {
    return name;
 }       

 public void setName(Name name) {
    this.name = name;
 }
}

How to input Array parameter: Simply start the value with array: suffix and use delimiter comma ',' to separate out items in array. For example array:G,e,n,e,r,i,c,F,i,x,t,u,r,e means an array of characters or array:1,4,9,16,25 means an array of integers.

Let's take a look at another example where simple type, this type and array type variables are being used.

!| Generic Fixture | java.lang.String | It's a cool fixture |
| toString | |
| i=indexOf | cool | | 7 |
| this=concat | ; indeed | | It's a cool fixture; indeed |
| equals | It's a cool fixture; indeed | | true |
| equalsIgnoreCase | blank | | false |
| str=concat | blank | | It's a cool fixture; indeed |
| equals | str= | | true |
| matches | ^.*cool fix.*$ | | true |
| indexOf | cool | | i= |
| arr=toCharArray | |
| concat | !!! | | It's a cool fixture; indeed !!! |        

!| Generic Fixture | java.lang.String | arr= |
| toString | | str= |
| toCharArray | | arr= |        

!| Generic Fixture | java.lang.String | str= |
| toString | | str= |
| toCharArray | | arr= |       

!| Generic Fixture | java.lang.String | array:G,e,n,e,r,i,c,F,i,x,t,u,r,e |
| toString | | GenericFixture |
| toCharArray | | G,e,n,e,r,i,c,F,i,x,t,u,r,e |       

!| Generic Fixture | java.lang.Math |
| abs | i= | | 7 |

You can see how I am using this to overwrite the value of the object itself on which all the methods are being executed. Execution of above test will produce below result. Note how actual value of a variable is appended in the result. Also note the use of array type variable "arr" in various operations.

UPDATE:
Added support of in-table variable.method() invocation. eg: if you already have a return value stored in a variable called "myvar" then calling a method foo() on myvar is now allowed in the same test table. Just use following syntax:
| myvar.foo | arg1 | arg2 | | ret |
Take a look at this example:

!| Generic Fixture | java.lang.String | It's a cool fixture |
| toString | |
| i=indexOf | cool | | 7 |
| this=concat | ; indeed | | It's a cool fixture; indeed |
| equals | It's a cool fixture; indeed | | true |
| equalsIgnoreCase | blank | | false |
| str=concat | blank | | It's a cool fixture; indeed |
| equals | str= | | true |
| str=.substring | 21 | | indeed |
| matches | ^.*cool fix.*$ | | true |
| indexOf | cool | | i= |
| arr=toCharArray | |
| concat | !- !!!-! | | It's a cool fixture; indeed !!! |
| substring | 3 | |
| str=.toCharArray | | arr= |

Note how this test table is using variable "str" to store original string and then calling methods directly on variable "str" using str=.substring and str=.toCharArray calls. You can even do substr=str=.substring to create another variable "substr" to store return value of str=.substring call. ]]> http://anubhava.wordpress.com/?p=18 Thu, 27 Mar 2008 03:25:04 +0000 anubhava http://anubhava.wordpress.com/?p=18

Syntax of defining DSL: It is basically a mapping of DSL and Java method calls. All of your DSL mappings will be in a FitNesse table with DSLAdapter as the class name, appearing in first column of the first row

Basic Syntax is: DSL follwed by Actual Java Method call

Each argument to DSL & Java method appears in a separate table cell. All arguments of DSL appear as %. All the arguments to a Java method call are defined as positional parameters of DSL such as {1}, {2},...{n} delimited by comma character ",".

So for a method called max(arg1, arg2) if you want to define a DSL such as "get the max of 2 numbers num1 and num2" then it would look like this:

!| DSL Adapter |
| get the max of 2 numbers | % | and | % | max | {1}, {2} |

% is just a place holder over here for arguments and {1} is the first argument in DSL and {2} is second parameter in DSL. Once defined now to use this DSL in writing tests simply write this:

| get the max of 2 numbers | 25 | and | 28 | |

Once you take a look at some more examples it will be much more clear how to create and modify your own DSL.

Let’s take a look at some more examples:

While writing web tests using Selenium there often is a need for pausing the test for 1 or 2 sec to let Selenium do frame loading (esp needed in Frames based testing where main page has loaded but some iframe still needs time to load). Selenium doesn't have a pause method and ONLY way to pause it is by calling sleep(long ms) method in java.lang.Thread. Testers can simple write: | java.lang.Thread.sleep | 2000 | to get 2 second pause but since it is a pure Java call and sometimes too technical for test authors it is better to define a DSL for that using following syntax:

!| DSL Adapter |
| pause the test for | % | seconds | java.lang.Thread.sleep | {1}000 |

Having defined this DSL now test authors will just need to write this in their web tests:

| pause the test for | 2 | seconds |

which is much more readable and user friendly.

Now lets take a look at my DSL for Selenium API. Define this DSL in a SetUp page to make it available for all the test pages.

!| DSL Adapter |
| user starts the browser | start | |
| user opens the URL | % | open | {1} |
| page has the title | getTitle | |
| user types | % | into | % | field | type | {2}, {1} |
| user sees the text on the page | % | isTextPresent | {1} |
| page has an element named | % | isElementPresent | {1} |
| page loads in less than | % | seconds | waitForPageToLoad | {1}000 |
| page has URL | getLocation | |
| user clicks on the submit button | click | //button[@type='submit'] |
| user clicks on the link named | % | click | link={1} |
| user clicks on the button named | % | clickAt | {1},"" |
| get text from element named | % | getText | xpath=id('{1}') |
| get xpath text from address | % | getText | xpath={1} |
| user removes the cookie named | % | at path | % | deleteCookie | {1}, {2} |
| user selects an option | % | from the drop-down | % | select | {2}, label={1} |
| pause the test for | % | seconds | java.lang.Thread.sleep | {1}000 |
| user stops the browser | stop | |

Using above DSL my Google web test will look like this. First add this test table to start Selenium test in SetUp page:

!define ds {com.thoughtworks.selenium.DefaultSelenium}
!define site {http://www.google.com}
!| Generic Fixture | selenium=${ds} | localhost | 4444 | *pifirefox | ${site} |
| user starts the browser |

And write this test table in your main test page GoogleTest:

!define q {fitnesse generic fixture}
!| Generic Fixture | selenium= |
| user opens the URL | http://www.google.com |
| page has the title | | Google |
| page has an element named | q | | true |
| page has an element named | btnG | | true |
| user types | ${q} | into | q | field |
| user clicks on the button named | btnG |
| page loads in less than | 5 | seconds |
| page has the title | | ${q} - Google Search |
| user clicks on the link named | Next |
| page loads in less than | 5 | seconds |
| user clicks on the link named | Next |
| page loads in less than | 5 | seconds |
| user sees the text on the page | Results 21 - 30 | | true |

and finally this small test table in TearDown page to stop the Selenium test:

!| Generic Fixture | selenium= |
| user stops the browser |

Few important things to be noted here are:

1. A new instance of Selenium is being created in SetUp page and being used in main page and TearDown page using a variable selenium=.
2. By using a variable to store Selenium instance and reusing it, you can move common initialization code in SetUp and common cleanup code in TearDown page. Also it will make sure that in the event of an exception being thrown (and that may happen often in web testing) your cleanup (TearDown page) will ALWAYS be called.
3. Test tables are not calling any of the Selenium APIs, only DSL is being used to direct Selenium run all the test steps.
4. Even though Selenium's waitForPageToLoad method expects you to pass milli seconds, using DSL we pass seconds value only by appending 000 in the argument. Using this approach you can always hide the complexity of the method arguments from the test authors.
5. Customizing this DSL is super easy. Lets say some user doesn't like the text user opens the URL and wants user opens a page instead. In that case just go to the above FitNesse's SetUp page and edit the table that starts with DSL Adapter and replace the text so it will become like this:
   | user opens a page | http://www.google.com |
6. If the underlying class (Selenium in this case) adds some new APIs with its new release, any other Fixture implementation approach would require a corresponding code change and new release. Whereas this DSL adapter just needs couple of new lines in a FitNesse SetUp page to define new "mapping" between DSL and new API calls.

Here is a sample Java code of a typical EJB client. Any Java developer who has ever written code to call EJBs will be well aware of following Java code snippet.

import javax.naming.InitialContext;
import javax.naming.Context ;
import com.sales.Product.*;public void TestPrice() {
   try
   {
      // create and load properties
      Properties props = new Properties();
      props.put(Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory");
      props.put(Context.PROVIDER_URL, "t3://localhost:7001");

      // get initial context using loaded properties
      InitialContext context = new InitialContext(props);

       // JNDI lookup
      Object jndi = context.lookup("ProductHome");

       // narrow down remote object to get remote home
      ProductHome home = (ProductHome) javax.rmi.PortableRemoteObject.narrow(jndi,
                                   ProductHome.class);

      // create service from remote home
      ProductService productService = home.create();

      // check if Product IDs exist in Database
      boolean result1 = productService.isValid(1801);
      boolean result1 = productService.isValid(9999);

      // assert our results
      assertEquals( result1, true );
      assertEquals( result2, false );
   }
   catch (Exception ex)
   {
       ex.printStactTrace();
   }
}

This code is first trying to do a lookup for JNDI object "ProductHome" (remote home) deployed on a Weblogic application server. Upon a successful lookup it creates a service object from remote home and finally calls isValid(int) method on the service class.

Now let's see how are we going to implement this code in a FitNesse test table using Generic Fixture.

!path weblogic.jar
!path productEjbs.jar

'''Set debug ON for Generic Fixture'''
!| Generic Fixture | Generic Fixture |
| set debug | true |'''Load the required properties'''
!| Generic Fixture | props=java.util.Properties |
| put | javax.naming.Context.INITIAL_CONTEXT_FACTORY | weblogic.jndi.WLInitialContextFactory |
| put | javax.naming.Context.PROVIDER_URL | t3://localhost:7001 |
| toString | |

'''Load the Remote Home class'''
!| Generic Fixture | java.lang.Class |
| homeClass=forName | com.sales.Product.ProductHome |

'''Lookup JNDI from Initial Context'''
!| Generic Fixture | javax.naming.InitialContext | props= |
| jndi=lookup | ProductHome |
| obj=javax.rmi.PortableRemoteObject.narrow | jndi= | homeClass= |

'''Cast Narrowed object to Remote Home object'''
!| Generic Fixture | homeClass= |
| homeObj=cast | obj= |

'''Create service object from remote home object'''
!| Generic Fixture | homeObj= |
| service=create |

'''Check if given Product IDs exist in Database'''
!| Generic Fixture | service= |
| isValid | 1801 | | true |
| isValid | 7000 | | false |

Since we had to operate on multiple objects and classes, we have heavily used the variables feature of Generic Fixture. Most of the test code is self explanatory with the comments provided on top of each table. Only tricky thing is to call Class.Cast(Object) method to get the casting right for ProductHome home = (ProductHome) javax.rmi.PortableRemoteObject.narrow(jndi, ProductHome.class) call in Java code.

Go ahead and give it a try.

So using Generic Fixture we completely eliminated the need to write Java code given in above section to test our ProductHome EJB. Writing EJB test in Generic Fixture of course has huge advantage over writing Java code. These test tables can be altered by any non-developer. For ex: if there is a new requirement to test validity of Product ID: 5319 then it is as simple as adding this line in the last table:

| isValid | 5319 | | true |

Which is much easier than finding a developer to change and re-compile the Java code.

I intentionally chose a simple operation on ProductHome EJB here to pass on the idea but almost any operation on EJBs can be performed using this approach, thus giving us the ability to build really robust and useful acceptance tests without writing any Java code.

Go to http://fitnesse.org/FitNesse.DownLoad and download the the "Full Distribution (fitnesse200#####.zip)". Unpack the zip into c:\program files. Once extracted you must have a directory c:\program files\fitnesse.

Download Selenium Remote Control

Go to http://selenium-rc.openqa.org/download.jsp and download the latest version (1.0-beta-1 at the time of writing this page). Unpack the zip into c:\program files. Once extracted you must have a directory c:\program files\selenium. Current version for Selenium-RC is 1.0-beta-1 and these instructions are written assuming you are using this version.

Create a smart start script

Copy and paste following script into a file called run.vbs under the directory "C:\Program Files\selenium\selenium-remote-control-1.0-beta-1\selenium-server-1.0-beta-1". This script will start both FitNesse servers and Selenium remote control servers on their default ports 8000 and 4444 respectively. This script will ONLY start these processes if these processes are not running, so this script can be safely run any time.

PS: Please note that this script is starting Selenium in an experimental Proxy Injection Mode which lets you run your web test across multiple domains. If you don't want to use this feature feel free to change this start script.

Function IsProcessRunning( strServer, strProcess )
   Dim Process, strObject
   IsProcessRunning = False
   strObject   = "winmgmts://" & strServer
   For Each Process in GetObject( strObject ).InstancesOf( "win32_process" )
       If UCase( Process.name ) = UCase( strProcess ) Then
           IsProcessRunning = True
           Exit Function
       End If
   Next
End Function

sServer = "."      ' "." for local machine
Set objShell = WScript.CreateObject("WScript.Shell")
Set objEnv = objShell.Environment("Process")

FitNesse = "java -cp fitnesse.jar fitnesse.FitNesse -p 8000"
If( IsProcessRunning( sServer, FitNesse ) = False ) Then
   objshell.CurrentDirectory  = "C:\program files\fitnesse"
   f = objshell.Run  ( FitNesse, 6, false )
End If

Selenium = "java -jar selenium-server.jar -browserSessionReuse -proxyInjectionMode"
If( IsProcessRunning( sServer, Selenium ) = False ) Then
   objshell.CurrentDirectory = _
"C:\program files\selenium\selenium-remote-control-1.0-beta-1\selenium-server-1.0-beta-1"
   result = objshell.Run  ( Selenium, 5, true )
End If

Wscript.Quit

Download and Install Generic Fixture

Just follow simple instructions at this page or just drop genericfixture.jar into "C:\Program Files\fitnesse" directory.
Copy selenium-java-client-driver.jar from "C:\program files\selenium\selenium-remote-control-1.0-beta-1\selenium-java-client-driver-1.0-beta-1" to "C:\program files\fitnesse" directory.

Run startup script

Using Windows explorer go to the directory "C:\Program Files\selenium\selenium-remote-control-1.0-beta-1\selenium-server-1.0-beta-1" and double click on the run.vbs. This will start 2 Java process in 2 separate command windows with Selenium window in normal and FitNesse window in minimized state.

Create a page on FitNesse for Google Web Test using Generic Fixture

1. Open your browser and goto the URL http://localhost:8000/FrontPage. Look for the Edit button on the left hand navigation column. If Edit button is not present then goto the URL http://localhost:8000/FrontPage?properties and select the "Edit" check box and click on Save Properties. Now click on Edit button and once on the Edit Page add a new line at the end of all the text already there and save your changes.

   |[[Web Test Suites][FitNesse.SuiteWebTests]]|FitNesse's suite of Web Tests|

2. Now on the Front Page it will display a text like "Web Test Suites?" with ? as hyper link. Click on ? link.
3. Once in the Edit Page copy paste following text into text area and save your changes:

   !*> Class Path & Global Defines
   !path selenium-java-client-driver.jar
   !path genericfixture.jar
   !define IE {*piiexplore}
   !define FF {*pifirefox}
   !define sel {selenium=}
   !define ds {com.thoughtworks.selenium.DefaultSelenium}
   !define host {localhost}
   !define port {4444}
   !define COLLAPSE_SETUP {true}
   !define COLLAPSE_TEARDOWN {true}
   *!
   ----
   SuiteWebTests.SetUp
   SuiteWebTests.TearDown
   SuiteWebTests.GoogleTest

4. You will notice 3 ? links on the page. Now lets create each and every missing page.
5. Click on the ? link next to SuiteWebTests.SetUp text and on the "Edit Page" text area copy-paste following code an save your changes.

   !| DSL Adapter |
   | user types | % | into | % | field | type | {2}, {1} |
   | user starts the browser | start | |
   | users opens the URL | % | open | {1} |
   | page has the title | getTitle | |
   | user sees the text on the page | % | isTextPresent | {1} |
   | page has an element named | % | isElementPresent | {1} |
   | page loads in less than | % | seconds | waitForPageToLoad | {1}000 |
   | page has URL | getLocation | |
   | user clicks on submit button | click | //button[@type='submit'] |
   | user clicks on the link named | % | click | link={1} |
   | user clicks on the button named | % | clickAt | {1},"" |
   | get text from element named | % | getText | xpath=id('{1}') |
   | user stops the browser | stop | |
   | add a key-value with key | % | and value | % | put | {1}, {2} |
   | get value for the key | % | get | {1} |
   | show | toString | |
   
   !|Generic Fixture|${sel}{ds}|${host}|${port}|${FF}|http://${host}|
   | user starts the browser |

6. Go back to the page: http://localhost:8000/FitNesse.SuiteWebTests
7. Click on the ? link next to SuiteWebTests.TearDown text and on the "Edit Page" text area copy-paste following code an save your changes.

   !| Generic Fixture | ${sel} |
   | user stops the browser |

8. Again go back to the page: http://localhost:8000/FitNesse.SuiteWebTests
9. Now click on ? link next to SuiteWebTests.GoogleTest text and on the "Edit Page" text area copy-paste following code an save your changes.

   !define q {fitnesse generic fixture}
   !| Generic Fixture | ${sel} |
   | users opens the URL | http://www.google.com |
   | page has the title | | Google |
   | page has an element named | q | | true |
   | page has an element named | btnG | | true |
   | user types | ${q} | into | q | field |
   | user clicks on the button named | btnG |
   | page loads in less than | 5 | seconds |
   | page has the title | | ${q} - Google Search |
   | user clicks on the link named | Next |
   | page loads in less than | 5 | seconds |
   | user clicks on the link named | Next |
   | page loads in less than | 5 | seconds |
   | user sees the text on the page | Results 21 - 30 | | true |

10. After saving your changes click on Properties button from the left hand navigation menu and click on check box left to Test property and save your changes. Now you should see Test button on the top of the lest navigation menu.

Execute your Google Web Test Page on FitNesse using Selenium

Just click on the Test click on this page: http://localhost:8000/FitNesse.SuiteWebTests.GoogleTest and watch the magic of web test being run. Test will open a new Firefox browser and go to www.google.com and search Google with query text "fitnesse generic fixture"
Upon completion of test you should see this on the top of the results page:

Assertions: 5 right, 0 wrong, 0 ignored, 0 exceptions

Optional but Recommended Installations

You are all set to to write your test tables in FitNesse.

However if you are doing web testing using Selenium, there are two very handy add-ons for Firefox that will be extremely useful for writing web tests:

1. XPath Checker: Download it from https://addons.mozilla.org/en-US/firefox/addon/1095
2. Selenium IDE: Download it from http://selenium-ide.openqa.org/download.jsp

For testing business logic in my back end applications I mostly used ColumnFixture, TableFixture and RowFixture for defining inputs and output data sets. All I needed to write was a thin adapter or mapper Java class that extends any of these fixtures. That thin adapter Java class just gets input data from wiki and use that data to make a call to my back end application. At the end of the call it just makes the result available for FitNesse to display on wiki page. This thin adapter class is fully Fixture aware and developer of this class must know how to map data between back end application and FitNesse front end wiki page.

So far so good no major complains here, it worked great for us.

But I found this requirement to write the thin fixture adapter class for each new transaction a little annoying and have always toyed with the idea of building a generic Table/Fixture, one that will not require a developer to understand and be aware of the various fixtures coding conventions. In other words a fixture/table style where testers can write acceptance tests without needing development support of writing fixture specific code for each new transaction.

That became the main driving force behind the thought of developing a Generic Fixture where you just drop your class in FitNesse's class path, write your test tables in wiki and be ready to test without having to write a single line of Java code. This idea is simple enough to understand but not so simple to implement because of the complexity of Java classes. Each class is different, it can have various type of constructors and methods (even overloaded ones). Each method can be returning different type of values (or not returning at all if method is void). We have to define some rules of defining class names, constructors, method names and their return types on wiki test tables first.

So here they are:

1. Name of the class to test or system under test (SUT) and arguments to the SUT's constructor must come in a separate cell of the very first row of the table. (Starting from 2nd cell, since 1st cell is reserved for name of the Fixture Class itself). eg:
   !| Generic Fixture | java.lang.String | It's a cool fixture |
2. Each row of the table will have a method name in the 1st cell followed by method parameters appearing each in a separate cell.
3. Leave an empty cell after end of parameters and start of return values. eg:
   | indexOf | cool | | 7 | | concat | !! | | It's a cool fixture!! |
4. Class that is being tested can have methods accepting parameters of all primitive types (int, float, double etc) as well as of all the primitive Java wrapper classes (Integer, Double, String, Number Date etc).
5. If methods need to accept user defined object in parameters then those user defined types must provide a method: public static Object parse(String str) { ... }. An example of this is provided below in the Address class.
6. Methods with return types of all primitive types (int, float, double etc) as well as of all the primitive Java wrapper classes (Integer, Double, String, Number etc) should be supported.
7. Methods can also return array of all primitive types (int, float, double etc) as well as of all the primitive Java wrapper classes (Integer, Double, String, Number etc).
8. Class that is being tested can be a non-instantiating class like java.lang.Math. In this case all methods will be invoked statically.
9. Calls to static method must be allowed in the form of CanonicalClassName.MethodName eg:
   | java.lang.Thread.sleep | 1000 |
10. Should be able to operate with overloaded methods in a class. For example abs() method in java.lang.Math class:
    | abs | -5.72 | | 5.72 |
11. It should be able to store return value of a method into variables and a variable can be of any type. And later on this variable can be used anywhere in the test to pass a value, compare a return value, creating a new class or becoming a target itself. Please visit my other post Use of variables, arrays and complex types in Generic Fixture for more details.

Putting it all together: Lets write a simple test table for testing java.lang.String class. Lets say we have a Java code like this:

And here is the FitNesse equivalent of above Java code using Generic Fixture:

Click on Test button and you will get these results:
Assertions: 7 right, 0 wrong, 0 ignored, 0 exceptions

In this test we tested java.lang.String class and some of its methods. Notice last call in the test table above is String.toCharArray(), here we are not validating output of this call just getting output displayed. Nice thing is that we did not write any Java code for the String class we tested above. Looks pretty simple, isn't it?

Let's write another test table for java.lang.Math class where all the methods are declared as static:

Click on Test button and you will get:

Assertions: 4 right, 0 wrong, 0 ignored, 0 exceptions

Again this Generic fixture was able to do the magic behind the scene and run all the static methods of java.lang.Math class. Did you notice I am calling | java.lang.Thread.sleep | 1000 | for introducing a delay of 1000 ms (1 sec) between max and abs method calls. This is the equivalent Java code for above fixture:

So far we tested 2 Java classes without writing any code. You must be thinking why are we wasting our time testing standard core Java classes that everybody knows are working fine. How to write a meaningful acceptance test for a class of our own? So let's take an example of a trivial Address class. Code is included here for reference:

Source Code Address.java

public class Address {
   public static class Name {
      private String surname = null;
      private String firstname = null;

      public Name() {
      }

      public Name(Name n) {
         this.surname = n.surname;
         this.firstname = n.firstname;
      }

      public static Object parse(String s) {
         Name n = new Name();
         String[] arr = s.split(" ");
         if (arr.length == 2) {
            n.setFirstname(arr[0]);
            n.setSurname(arr[1]);
         }
         return n;
      }

      @Override
      public String toString() {
         return this.firstname + " " + this.surname;
      }

      public String getSurname() {
         return surname;
      }

      public void setSurname(String surname) {
         this.surname = surname;
      }

      public String getFirstname() {
         return firstname;
      }

      public void setFirstname(String firstname) {
         this.firstname = firstname;
      }
   }

   private int streetNo = 0;
   private String street = null;
   private String city = null;
   private int postcode = 0;
   private String state = null;
   private Name name = null;

   public Address() {
      super();
   }

   public Address(Integer streetNo, String street, String city, int postcode,
     String state) {
      super();
      setAddress(streetNo, street, city, postcode, state);
   }

   public void setAddress(Integer streetNo, String street, String city,
     int postcode, String state) {
      this.streetNo = streetNo.intValue();
      this.street = street;
      this.city = city;
      this.postcode = postcode;
      this.state = state;
   }

   public void setStreetNo(Integer streetNo) {
      this.streetNo = streetNo;
   }

   public Integer getStreetNo() {
      return this.streetNo;
   }

   public String getStreet() {
      return this.street;
   }

   public void setCity(String city) {
      this.city = city;
   }

   public String getCity() {
      return this.city;
   }

   public void setPostcode(int postcode) {
      this.postcode = postcode;
   }

   public int getPostcode() {
      return this.postcode;
   }

   public String getFullAddress() {
      return this.streetNo + " " + this.street + ", " + this.city + ", "
        + this.state + " - " + this.postcode;
   }

   public void setStreet(String street) {
      this.street = street;
   }

   public String getState() {
      return this.state;
   }

   public void setState(String state) {
      this.state = state;
   }

   public Name getName() {
      return this.name;
   }

   public void setName(Name name) {
      this.name = name;
   }
}

Let's assume I compiled this Address class and added it in FitNesse classpath. Now let's go about writing an acceptance test table for this Address class using Generic Fixture.

Click on Test button and you will get:

Assertions: 8 right, 0 wrong, 0 ignored, 0 exceptions

Pay special attention to setName method in above test table. This method is taking a user defined object of Name type. Since I have implemented public static Object parse(String str) method in above code, generic Fixture is able to construct a Name object from the entered string "John Smith" in the table cell.

For the reference purpose above fixture is executing this Java code using Java reflection APIs:

That's it, writing acceptance tests could be as simple as that. One more good thing about this Generic Fixture is that it eliminates the need of writing a separate Unit test class (eg: JUnit) for testing your business class.

Generic Fixture download and install instructions can be found on this page. And here is the complete source code for Generic Fixture for browsing. Please leave your comments, suggestions, bug reports, area of improvements and criticism for this effort.

Next Part: Use of variables, arrays and complex types in Generic Fixture

Coming up: Writing web application tests using this Generic Fixture In the next post I will demonstrate use of this Generic Fixture in writing some useful acceptance tests for Web applications.

Visit FitNesse Group Forum for a meaningful and thought provoking discussion on Generic Fixture. ]]> http://code4j.wordpress.com/2007/09/10/testing-von-webapps-mit-selenium/ Mon, 10 Sep 2007 19:54:59 +0000 xandrox http://code4j.wordpress.com/2007/09/10/testing-von-webapps-mit-selenium/ Am Wochenende bin ich zufällig auf das Selenium IDE Firefox Addon gestoßen. Ich hatte bereits in der Vergangenheit von Selenium und seiner unkonventionellen Funktionsweise gehört, doch nun musste es Testen. Ich gebe zu: das Firefox klicki bunti Plugin mach an :-).

Bild der Selenium IDE:

Selenium ist ein Acceptance Testing Framework für Webanwendungen. Die Revolutionäre Idee daran ist das nicht wie bei den Üblichen Test-Frameworks ein Proxy zwischen Client und Server geschalten wird, der dann nur stur die Aufgenommenen Requests abspult, sondern der Browser selbst spielt den Test ab.

Der Vorteil liegt auf der Hand: Erstmals ist es möglich die Anwendung einschließlich Client vollständig zu testen. Javascripts / AJAX und jegliches Client Verhalten lässt sich mit testen. Einfach genial. Ich persönlich hätte nie geglaubt das man irgendwann vernünftige Webclient-Tests mit erträglichen Aufwenden realisieren kann.

Und das beste ist es funktioniert erstaunlich gut. In wenigen Minuten hatte ich mein erstes Testcase mittels der Selenium IDE erstellt. Prüfungen lassen sich intuitiv per Markierung und dem Command "verifyTextPresent" dem Test hinzufügen.

Was für mich nach dem ganzen geklicke noch wichtig war ist die Test Automatisierung. Hierfür gibts Selenium RC (Remote Control), eine Art Server der die aufgezeichneten Tests in einem Browser automatisiert abspielen lässt. Fernbedient wird das ganze dann wahlweise durch die JUnit Tests die durch Senenium IDE generiert wurden. Ach hier muss man sagen es funktioniert wenngleich die Release Version 0.9.0 nicht zu den JUnit Tests passte. Mit 0.9.1-SNAPSHOT hat dann jedoch alles funktioniert.

Ein bisschen Ärger hatte ich noch mit SSL und Selenium RC aber die getestete Anwendung war auch kein "Hello World" Beispiel. Mit SSL basierten Webanwendungen die Ihre Ressourcen von einem Server beziehen sollte es kein Problem geben.

Somit bleibt mir nur zu sagen: Check it Out!

Sobald ich die ersten Projekterfahrungen habe werde ich wieder Berichten.

You must have FitNesse framework installed on your computer and FitNesse server must be running on the computer where Generic Fixture is being installed.

To download Generic Fixture

Download the jar file genericfixture.jar containing full source code and compiled classes from Generic Fixture Sourceforge Site. Included classes have been generated using Sun's JDK 1.5 Java compiler. Should you need to build Generic Fixture with any other JVM then make sure to put fitnesse.jar and fitlibrary.jar (provided in all the Fitnesse releases) in your CLASSPATH.

To install Generic Fixture

Save genericfixture.jar somewhere on your computer where FitNesse server is running. Then simply add genericfixture.jar in your classpath on FitNesse Wiki. eg:

!path /path/to/download/dir/genericfixture.jar

Examples and Tutorial

Please visit http://genericfixture.wiki.sourceforge.net/Introducing+Geneic+Fixture+for+FitNesse