Measuring in Cubics

Using MySQL connection pool in Glassfish V3

2009-06-14T21:26:00.011+02:00

I tried with a simple data source in Spring, but it isn't meant for production environments. So I wanted to move from:

<bean id="simpleDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/database"/> <property name="username" value="database"/> <property name="password" value="s3cr3t"/> </bean>

to:

<bean id="jndiDataSource" class="org.springframework.jndi.JndiObjectFactoryBean"> <property name="jndiName" value="jdbc/databasePool" /> </bean>

where jdbc/databasePool is configured in Glassfish. The reason for this is that the connection handling is a lot better when using a proper connection pool.

First we need to install the mysql library in Glassfish. I use Ubuntu so:

sudo apt-get install libmysql-java

then I linked it into the Glassfish classpath:

sudo -u glassfish ln -s /usr/share/java/mysql.jar /opt/glassfishv3-prelude/glassfish/lib/mysql.jar

If you don't use the Ubuntu just add the mysql.jar to the /opt/glassfishv3-prelude/glassfish/lib folder.

Then restart the server to get it added to the classpath. (Look at my previous post for further instructions.)

Then install the connection-pool:

./asadmin create-jdbc-connection-pool --datasourceclassname com.mysql.jdbc.jdbc2.optional.MysqlDataSource --allownoncomponentcallers=true --property user=database:password=s3cr3t:DatabaseName=database:ServerName=localhost:port=3306 database-pool

The --allownoncomponentcallers=true parameter is important to let Spring access the resource directly.

Test the connection:

./asadmin ping-connection-pool database-pool

To make it avaliable to the spring configuration:

./asadmin create-jdbc-resource --connectionpoolid database-pool jdbc/databasePool

That's it! Good luck!

Installing Glassfish V3 on Ubuntu

2009-05-22T08:13:00.007+02:00

I've been using Tomcat for some time but I'd like to use Glassfish V3 instead as I think it's (going to be) an amazing application server. This is a tutorial based on how I installed it on Ubuntu 9.04 Jaunty Jackalope.

If you haven't install JDK6 do that first.


sudo apt-get install sun-java6-jdk

Get glassfish (I use the zip file as the sh file didn't complete the download).


wget http://download.java.net/glassfish/v3-prelude/release/glassfish-v3-prelude.zip

Unziping glassfish (I didn't have unzip so I installed it first by running: sudo apt-get install unzip )


sudo unzip glassfish-v3-prelude.zip

Move it to the opt folder


sudo mv glassfishv3-prelude /opt

First add a glassfish system user


sudo useradd --system glassfish -d /opt/glassfishv3-prelude

Set admin group


sudo chgrp -R admin /opt/glassfishv3-prelude

Set glassfish as the owner


sudo chown -R glassfish glassfishv3-prelude

Go into the install directory


cd glassfishv3-prelude

Set the executable files:


sudo chmod -R +x bin/
sudo chmod -R +x glassfish/bin/

Start the default glassfish domain (domain1)


sudo -u glassfish bin/asadmin start-domain domain1

To have Glassfish start automatically when you start Ubuntu. You need to add a glassfish file to the /etc/init.d/ folder. Pick you favorite editor (I use vim).


sudo vim /etc/init.d/glassfish

Enter the following:


#! /bin/sh




GLASSFISHPATH=/opt/glassfishv3-prelude/bin




case "$1" in


start)


echo "starting glassfish from $GLASSFISHPATH"


sudo -u glassfish $GLASSFISHPATH/asadmin start-domain domain1


;;


restart)


$0 stop


$0 start


;;


stop)


echo "stopping glassfish from $GLASSFISHPATH"


sudo -u glassfish $GLASSFISHPATH/asadmin stop-domain domain1


;;


*)


echo $"usage: $0 {start|stop|restart}"


exit 3


;;


esac


:

Changing the users rights


sudo chmod a+x /etc/init.d/glassfish

Then install it on all runlevels:


sudo update-rc.d glassfish defaults

That is it! I hope this tutorial was helpfull.

I got help from all around the world to complete this tutorial but special thanks to computing with jasper.

concordion:run

2008-06-25T11:15:00.012+02:00

I just became a committer at Concordion.org and I'm really happy for the confidence.

The basic questions: What have I committed?

The answer is: concordion:run which is a way to run another Concordion testes form this test. An example (would be handy right about now):

check this test

code:


<html>...<body>
...
<a href="checkThis.html" concordion:run="concordion">check this test</a>
...
</body></html>

This test will run the "checkThis.html" concordion test.

You might think that it doesn't matter what you put in attribute value. That it's just there for completeness and the story would end there, but that’s not the case.

One to rule them all

I think that a lot of people have invested a lot of time and effort in learning other frameworks like FIT, CubicTest and so on. So why can’t we just write Concordion tests like this:

Given users in the database when Bob logs in with password "password" and changes password to "secret" then the password is "secret".

code:

<html> ... <body> ... <a href="../fit/userSetup.html" concordion:run="fit">Given users in the database </a> when Bob <a href="../cubictest/login.aat" concordion:run="cubictest">logs in</a> with password "password" and <a href="../cubictest/changePassword.aat" concordion:run="cubictest">changes password </a> to "secret" then the password is "secret". ... </body> </html>

I've just used FIT to set up the database as I had that functionality in a fit test already, then I used concordion to set what user to log in with in CubicTest and changed the username with CubicTest before I used Concordion to check the database to see if the new password was set. The functionality isn’t there yet, but it’s coming.

CubicTest 1.8.6 is just released

2008-06-14T11:53:00.003+02:00

The vision of CubicTest is to be the leading functional Web Testing IDE. The 1.8.6 release is a great step towards that vision.

There are a lot of different functional web testing frameworks out there but CubicTest stands out. What truly makes CubicTest different is its ability to clearly communicate web interaction to a wide variety of stakeholders. You don’t have to be a programmer to understand CubicTest as it focuses on testing "what you see" on the page, and not "testing the HTML source". It strongly supports principles like DRY and test first. DRY or Don’t Repeat Yourself is made easy with features like “Commons”, parameterization and abstraction through subtests. CubicTest was designed to be used with test first methodologies with features like graphical modeling and html export.

CubicTest uses the power of outstanding frameworks like Selenium and Watir to drive the tests but in a graphical way which make these frameworks easier to understand and use. Prior to the 1.8.6 release CubicTest users haven’t been able to use the full power of Selenium. Now that is changed and in the near future it will change for Watir as well. The new “Custom Test Step” feature enables that functionality.

The new features in the CubicTest 1.8.6 release:

Support for frames – now you may model frames in the graphical test editor
Internationalization support – one test may be launched with different languages to make it easy to support multilingual web sites
Custom test steps with debug possibilities – now CubicTest isn’t limited to only the elements and possibilities in the editing palette but to the limitation in the underlying test framework like Selenium and Watir
Capturing HTML and image of failing test page – whenever a test fails in the new launcher CubicTest records the HTML source code and take a screenshot

I hope you like it!

SpecTool 2.0 - solutions

2008-05-05T13:01:00.003+02:00

I think that there are two ways to specify a requirement that can be executed by a computer. First we got a natural API or we got the XHTML way.

API

To use an API for specification requires a DSL(Domain Specific Language) and a natural language interface for nontechnical persons to understand what is going on. At least without being thought how it works. The advantage is that it is code. It makes it a lot easier to use for programmers. Most IDEs (like eclipse) will report syntax errors and got good refactoring support which is an advantage.

For this kind of tests I think that we have (most of) the technology that we need. I think that the main focus should be in establishing good patterns and give better understanding.

XHTML

To write specifications in xhtml gives a lot of flexibility in presentation. It is possible to use tables (frameworks like FIT, Concordion), plain text (Concordion) or what ever that fits the problem. This requires fixtures on different frameworks to bridge the gap between specifications and code. This abstraction is good in the sence that it keeps specifications "stable" despite changes in the domain model. I think that this is good.

The problem with tools like Concordion and FIT is that they don't work well together. I think that having a framework that is an umbrella framework to the current frameworks is the way to go. So I can use FIT for some database setup and runt the webtests in CubicTest and do some checks in Concordion. I should be able take some data from one of the frameworks over to another to make these work seamleasly together. The umbrella framework should also support the ide of tags to support the ide of structuring the sepecifications.

10 ways to screw up with Scrum and XP

2008-04-06T23:35:00.004+02:00

Henrik Kniberg has published his slides from the 10 ways to screw up with Scrum and XP presentation he held at JavaForum conference in Malmö. I wasn't there but the slides are excelent. I hope you enjoy them as much as I do!

Agile means that tests are second class citizens

2008-03-30T12:00:00.002+02:00

The Agile Manifesto states working software over comprehensive documentation. Working software is what the customer really wants and will always be the first class citizen in agile methodologies. Your tests is part of your documentation (at least to some extent). Hence tests are second class citizens.

By the way I would not like to develop software without tests.

Exploratory Testing Google Video

2008-03-30T10:19:00.002+02:00

Exploratory testing has become quite an interesting topic at the AAFTT user group. Matt Heusser came up with this link: Exploratory Testing at Google Video. For me this is very interesting so I figured I should pass it on.

Enjoy!

Selenium User Meetup

2008-03-06T11:55:00.001+01:00

I've been using Selenium for quite a while and I think it's amazing what they have done. CubicTest has of course support for Selenium and uses it for recording as well as running. It's been a Selenium User Meetup at Mountain View (at Googleplex). There are two youtube videos out there from the meetup (as shown under). I personally think that it's quite cool that WebDriver is going to be under the Selenium umbrella.

The presentation:

The Q&A:

SpecTool2.0

2007-12-04T19:49:00.001+01:00

At Smidig2007 I invited to an open space session called "SpecTool2.0". The purpose was to look at what the next specification (I prefer that to test) tool would be like. The specifications should of course be executable. It was quite a lot of people that came around to the open space.

According to the people attending the requirements for spec tool would be:

Abstraction - the need for rather high level specifications that can be defined in more detail another place.
Readability - make sure that most people with different background can read the specifications.
Representations - support different kinds of data representations:
- Table - data intensive specifications (data driven tests)
- Text - plain text. This is the power of Concordion.
- Graphics - support other types of graphical presentations.
Domain language - make it possible to support the domain language that is used in the application.
Tags - possible to find specifications based on tags. It is really handy when you got a lot of specifications. It also got to do with having places to put and group things. This could also aid in the execution of the specifications. You might want to only execute tests that are tagged with "database".

Pattern support was another interesting point in the discussion. The tool should display examples and guidelines to aid the user in creating good specifications.

You might ask yourself what my mind has been spinning around after this open space. Well I guess it is possible to do some things in this area. I've got few ideas. I'll come back to them. If you want to do this with me please don't hesitate to contact me.

Incremental Continuous Integration - Testing the differences

2007-11-30T17:33:00.000+01:00

The speed of a test execution and the amount of tests can make the continuous integration quite slow. I personally think that a test that takes 5 seconds isn't too bad. However if you got a thousand tests that takes 5 seconds running in sequence it will amount to way over an hour. Not very short feedback loop and it is way under the 10 minutes that are recommended as a maximum. I know of projects that have got a lot of web tests that takes a few hours to run all together. Distributing the tests on different machines surely reduces the time but it still takes a lot of time. So I understand why some people think that web tests suck even if I think they are great.

In the world of backup one wouldn't make a complete backup every time but the first time and then periodically like every week or month. Then every day between those periods the files that have changed are backed up. This is called an incremental backup and it means that only a few files are backed up most of the time. Otherwise the amounts of data stored would be too great. The best backup algorithms can handle changes on parts of large files as well. This means that only parts of the files are backed up every day. This makes a good balance between storage space and speed of restore.

Why isn't the same idea used on continuous integration. Why are we executing all the tests every time? I think that all tests should be executed every night as part of the nightly build. However integrations hooks on commits should not run all the tests as it possibly makes feedback loops way too long. To fix this problem one should only run the tests that are likely to break meaning an incremental continuous integration.

The algorithm for doing the incremental continuous integration isn’t very difficult. On check-ins one should only run tests that have changed or been added. One should also track all the application code a test touches when it runs. When application code is changed one can look up which tests that executed that application code and only execute those tests in the build. In some applications there are also some resources like configuration files that have great impact on the application. When these resources changes one might have to execute all tests depending on the configuration file.

Examples:

An application with 900 tests that each runs in 4 seconds. The initial nightly build takes at least 3600 seconds to execute if the tests are executed sequentially. That is an hour. This is no problem for a nightly build as it’s done way before people get back to work the next morning.

If one checks in a new test that takes 4 seconds the complete build will still take more than an hour. I think that is way to long. In an incremental approach it should run in 4 seconds. The same is the case if a test is changed.

Let’s look at a subset of the tests and classes where the Xs describes which classes a given test executes:

	Test A	Test B	Test C	Test D
Class 1	X		X
Class 2	X
Class 3	X	X		X
Class 4			X	X

So if there is a change in Class 4 only Test 3 and Test 4 should be executed as the other tests doesn't touch the code in Class 4. This gives us only 8 seconds of test execution instead an hour.

This means 12 seconds in total when adding 4 second for the new test and 8 seconds for the tests that executes the class that had changed. This is quite short compared to the hour a complete build would take.

The idea for incremental continuous integration would have to be supported in the continuous integration tools or the build tools. I think test coverage reports can be handy for identifying which tests to run. Another solution would be to use AOP for the same reason. However it shouldn’t be very difficult to do. I hope that build tools and continuous integration tools will support this idea in the future.

Presentations from Agile Alliance Functional Test Tools Visioning Workshop

2007-11-24T09:50:00.000+01:00

Quite a few of the presentations at Agile Alliance Functional Test Tools Visioning Workshop in Portland Oregon this year have be published at Google Video. Christian Schwarz and I was there to present CubicTest as it is a graphical test tool for modeling functional web tests.

I'll hold a lightning talk at Smidig 2007 where I'll be talking about the different tools presented at the workshop. If you are interrested please check it out.

Concordion

2007-11-08T16:34:00.000+01:00

I've been looking at concordion lately. It looks like a step in the right direction. I think that it might be a way to push CubicTest even further by extending it beyond functional web testing.

Stay tuned!

Multi touch screen

2007-10-27T12:07:00.000+02:00

Perceptive Pixel have an outstanding touch screen. I guess it comes with a large pricetag, but it will hopefully drop quite a bit when it is introduced. For those of us that can't afford it there are other possiblities. First of all MicroSoft Surface.

I personally think that the Apple iPhone got an amazing user interface mostely due to its multi touch interface. I've got a Nokia N95 but despite all it's cool features the user interface is rather slow, with messy menues. I woun't even go into graphics and the battery capacity. The iPhone is easy to use because of the touch screen but also due to better menues. I guess for us living in a country not being able to buy an iPhone a iPod touch is quite all right as well.

There are rumors around on the internett about an apple laptop with multi touch screen. I would really like one of those. It probably gone cost me, but I think if Apple does it will be pretty amazing to work with. At least when I get used to it.

To summarize I would say that touch screens are amazing and the way to go.

Web Test Framework API

2007-10-17T16:15:00.000+02:00

I've looked at different kinds of testing tools (API) to use them as runners for CubicTest. The various tools have their own API that provides different kinds of features. They also access the browser in different ways; either through JavaScript like Selenium, taking over the browser like WebDriver and Watir or being the browser it self like JWebUnit which relays on HtmlUnit to run.

I think that there should be a basic set of features that a web test tool should have. There might even be a common set of test to pass in order to support the basics. An example could be the JWebUnit-Commons-Test that ensures that every API that JWebUnit uses meats their requirements. It is a natural thing for test tool.

There are two parts of testing web applications in addition to setup (connecting to the website) and teardown. First is the assertion or lookup for elements on the page. The other part is performing some sort of action on the elements. This is pretty simple. Ones should be able to support most kind events. For example an onclick event should be fired with a click action. Some events should not be supported. I guess events that are not implemented on most modern browser. Also events that don’t represent user actions like onload, should be omitted.

I personally think that the system should be object oriented (at least it makes sense to me as a Java and JavaScript programmer). This means that in order to perform actions on objects one should look the up first. This also applies to asserting elements.

Ways of looking up elements are:

By id or name – this is most common. It is supported by pretty much all modern browsers. However it isn’t very handy for element that doesn’t have an id and for element where its id may changes rapidly due to the web framework in use. Example code (Java):
```
Element element = document.get(ELEMENT.id("myId"));
assertThat(element, notNull());
```
By other attributes present – there are different ways to do this. Selenium got support for CSS style lookup. A more common way of doing it is by using XPath. I personally prefer XPath to CSS, but for most people it’s a mater of taste. I think that just being able to look for more than one attribute is as powerful. Example code (Java):
```
Element element = document.get(ELEMENT.id("myId")
     .class("myCSSClass"));
assertThat(element, notNull());
```
By parts of attribute – One should be able to look up elements that have an attribute that is equal to, begins with, ends with or contains a certain value. Even logic like and/or might be useful. Example code (Java):
```
Element element = document.get( ELEMENT.id("myId")
     .class(contains("myCSSClass").
           or(contains("otherCSSClass"))));
assertThat(element, notNull());
```
By probability – Another way to ensure that stuff doesn’t break is to add probability. I guess that I would like to lookup elements that should have an attribute like one value and can have another attribute like another value. One should be able to find the element (or elements) that are the best fit. To push this even further we may use edit distance to handle misspelling. I guess that this might return the wrong element. So the returned element should know how well it fits the element looked for. An element that only fits 65% might be wrong. This raises the question of what attributes the element found actually got. The strength of this is the ability to adjust the lookup attributes to better fit the reality of the web application. I guess this improves robustness and enables tests that run with a “warning” to complete instead of just throwing an exception. Example code (Java):
```
TableRow row = document.get(TR.id( SHOULD, equal("myId")
 .class(MUST, contain("myCSSClass")
 .or(contains("otherCSSClass"))));
assertThat(row, notNull());
if(row.getScore() < 100){
 println("Element might be wrong"); 
 println("id: " + row.getId());
 println("class: " + row.getClass());
 println("Contains button: " + row.get(BUTTON));
 println("Contains text: " + row.contains(
 text("mySuper product")));
}
assertThat(row.getScore(), greaterThan(65));
```

By negative - One should not be constrained to one attribute or the only asking for positive. Should not is equally valid. Example code (Java):

TableRow row = document.get(TR.id( SHOULD, equal("myId").class(MUST, 
        contain("myCSSClass"). or(contains("otherCSSClass")))
        .class(MUST_NOT, contain("alianCSSClass"))
        .contains(BUTTON, text("mySuper product")));
assertThat(row, notNull());
if(row.getScore() < 100){
 println("Element might be wrong"); 
 //... figure out what really happende
}
assertThat(row.getScore(), greaterThan(65));

When testing web shop application’s product overview I like to be able to say that I’m looking for a table row (which is tend to be a lot of in a table) that contains a buy button (which typically is found in every row) and some text describing the product I’m looking for. This text is only found in the row that I’m looking for. This enables us to create less fragile tests. If I was to look for a row with a given attribute (like id) it would make my test fragile in quite a few web frameworks as it tends to change. I could have said that it should be the fifth row but that can also change quite rapidly. I guess the same “pattern” for testing can be used in different settings. It might be that one shouldn’t have to know what kind of container the button and the text is within. It probably should not be tied to know that it is table row. Example code (Java):
```
TableRow row = document.get(TR.contains(BUTTON, 
     text("mySuper product")));
assertThat(row, notNull());
// to actually get the button to click:
row.get(BUTTON).click();
```

I think that by adding these features it should be possible to create robust test. I also think that this kind of code is quite readable, at least for Java programmers that don’t know CSS or XPath very well.

I hope that some framework will add this functionality. We – the CubicTest developers – would sure love to have it.

Reflections from the Agile Alliance Functional Testing Tools Visioning Workshop

2007-10-16T16:12:00.000+02:00

I’ve just been at the Agile Alliance Functional Testing Tools Visioning Workshop (AA-FTT) in Portland Oregon which was a great place to be. A lot of bright people have created some amazing tools or have an awesome understanding of testing. It is really interesting see different angels than we have had on CubicTest. I’ve personally learned a lot from the others and I think the others might have learned a great deal as well.

We (the workshop) got a workshop homepage which is going to be opened up now as the workshop is over. Please check it out.

Sadly enough we didn’t come up with a great leap in functional testing tools. It might even be that the progress isn’t a new tool but a new way of thinking. One of the big things I’ve learned lately is that patterns for testing are really important. I’ve just bought "xUnit Test Patterns" by Gerard Meszaros (who was at the workshop). Letting applications be testable from the inside by building in testability from the start might be a better solution. An example of an amazing such an application is Ward Cunningham’s Swim.

Most innovations are baby step or just combining different ideas in a new way. I personally think integrating tools might also bring us further. Ways to do that is letting existing tools do new things for example if CubicTest can learn from model based test tools like what Ben Simo the Quality Frog - Questioning Software have done testing a calculator. However we figured out that enabling different levels of abstractions is really smart in order to quickly create tests new tests and to get an easy overview.