Today I had the pleasure to play with the current CVS version of jMock 2.

Most important changes in jMock 2:


1.
In jMock 1 the method signature of expected method calls had to be coded as a string and so refactoring mocked classes was not very easy.
Now expected method calls in my mocks are now easily refactorable since jMock 2 makes use of generics.

2.
jMock 1 was depending heavily on JUnit.
jMock 2 is test framework independent, it has special “plugins” for each framework. – The only plugin I’m currently missing is one for TestNG, but it’s on the TODO list – though you can use it with TestNG even without a plugin.

3.
The great constraints api from jMock 1 is now a seperate framework called Ham Crest (which is a anagram of matchers ;o)). It’s completely safe to use with and without jMock or any other (test) framework.

My conclusion after day one with jMock 2: The successor to the great jMock 1 is now even better and yet very stable for a pre-beta release.
Kudos to the whole jMock Team.

The last few days i’ve tried to find a bug in a bean that had session scope, so I attempted to do some integration testing with the new bean scopes. I’ve searched the spring forums, but I found no convenient way to do this.

Then I had a look at the RequestContextFilterTests (RequestContextFilter or RequestContextListener is needed for doing these new scope things). I thought there should be a way to get some integration testing with the filter. And it seems to work nicely!

Now lets look at the code – here (the code display of wordpress is not very nice)!

With this testcase I can now really do integration testing with the new scopes introduced in spring 2.0. I simply put my application context configs with the scoped beans into my test and implement the doFilter method of the filter chain.

For example – here.

I would like to know what you spring guys out there think about it! Please drop me a line!

Since I’ve played with integrating a servlet engine (Jetty5) into my unit tests I ran into problems when it comes to jsp page compiling. The Jasper 2 Compiler from Apache (which Jetty5 uses) gives me the following stack trace, every 2nd or 3rd time the application is deployed within a unit test:

java.io.IOException: tmpFile.renameTo(classFile) failed
at org.apache.jasper.compiler.SmapUtil$SDEInstaller.install(SmapUtil.java:245)
at org.apache.jasper.compiler.SmapUtil.installSmap(SmapUtil.java:164)
at org.apache.jasper.compiler.JDTCompiler.generateClass(JDTCompiler.java:424)
at org.apache.jasper.compiler.Compiler.compile(Compiler.java:297)
at org.apache.jasper.compiler.Compiler.compile(Compiler.java:276)
at org.apache.jasper.compiler.Compiler.compile(Compiler.java:264)
at org.apache.jasper.JspCompilationContext.compile(JspCompilationContext.java:563)
at org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:303)
at org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:314)
at org.apache.jasper.servlet.JspServlet.service(JspServlet.java:264)
at javax.servlet.http.HttpServlet.service(HttpServlet.java:810)
at org.mortbay.jetty.servlet.ServletHolder.handle(ServletHolder.java:428)
at org.mortbay.jetty.servlet.WebApplicationHandler.dispatch(WebApplicationHandler.java:473)
at org.mortbay.jetty.servlet.Dispatcher.dispatch(Dispatcher.java:286)
at org.mortbay.jetty.servlet.Dispatcher.forward(Dispatcher.java:171)
...

It seems this is a known bug and it’s tracked under #38713.

My solution for now is to precompile all my JSP pages for the embedded-server-test. See: Jasper 2 JSP Engine How To – Web Application Compilation

Selenium is a great framework for testing the user interface of web applications. I’m very impressed by the simplicity of it and the yet powerful features it has.

In my opinion selenium is the missing piece in test driven development for web applications. Yeah I know HttpUnit, but with selenium there is no more need to reinvent functionality provided by the web UI. It also solves the problem with testing AJAX functionality on web pages.

I’ve personally used Selenium IDE and Selenium RC to do some testing with Firefox/Java/JUnit.

The only problem I have with the Selenium RC framework is that before I even can run a test I have to:

1. start an application server
2. start a selenium server

After the tests I also have to restart the deployment on the application server to get a clean environment to rerun the test.

My current solution to this problem is to get the application and selenium server up and running within a “unit” test. I developed a simple framework which can fire up an application server/servlet engine (Jetty, because it’s easier to embed than Tomcat) and a selenium server within a test, so I can easily deploy web applications for testing. After a test-class (or after each test-method) the application server deployment will be restarted/redeployed. I’ve tried to use JUnit 4 for implementing this, but the static @BeforeClass and @AfterClass methods were to inflexible for me.

So I’ve switched to TestNG which provides even more @Before… and @After… annotations to be even more flexible in setting these tests up.

If anybody is interested in this embedded server testing framework, I’ll ask my employer if I can share some code with you.

Fluent interfaces can definitly make your software worth reading. We’re already using JMock as a mock framework in our product, we’ll also try Eric Evans Time and Money library.

I like the style of coding in sentences, which is similiar in the AspectJ language.

Another good article about fluent interfaces can be found here.

At work we’re currently evaluating development methods for our new product. After using the great XT framework developed by Sergio Bossa, I came up to google his blog and found this interesting idea of building view objects.

Constructing View objects with the Builder pattern

Our Team agreed to definitly use this pattern, with some enhancements (using a seperate DAO – with named queries – for constructing view objects, JPA/Hibernate can construct objects from a select query)

View objects contructed this way can definitly improve performance and reduce ORM calls to the database. And it’s also a nice way to build various characteristics of views.