Devoxx 2012 - Day 4

Unitils: full stack testing solution for enterprise applications by Thomas de Rycke and Jeroen Horemans

There are different types of test: unit tests (testing in isolation), integration tests (testing a subsystem) and system tests (testing the whole system). The higher you get in the hierarchy, the longer it will to execute, so you should have a lot of UT, some IT and just a few system tests.

Unit tests have to be super fast to execute, be easy to read and refactor, they also should tell you what went wrong without debugging. On the other hand, you’ve to write a lot of tests. Not writing unit tests will get you faster in the first phase, but when the application grows, it will drastically slows your productivity down. In enterprise settings, you’re better off with UT.

In order to avoid an explosion of testing frameworks, Unitils testing framework was chosen. Either JUnit or TestNG can be hooked into Unitils. The core itself is small (so as to be fast), the architecture being based on modules.

Let’s take for example a Greetings Card Sending application. -- the demoed code is nicely layered, with service and dao and uses Spring autowiring and transactions through annotations -- Unitils is available from Maven, so adding it to your classpath is just a matter of adding the right dep to the POM. Unitils provide some annotations:

  • @TestedObject to set on the target object
  • @Mock to inject the different collaborators (using EasyMock)
  • @InjectByType to hint at the injection strategy for Unitils to use

Even though testing POJOs (as well as DTOs) is not very cost-effective, a single test class can be created to check for JavaBean conventions.

Unit testing becomes trivial if you learn how to write testable code: designing good OO and dependency injection, seams in your code and avoid at all the use of global state (time for example). What about integration and systems? They tend to get complex and you’ll need a "magic" abstract superclass. Moreover, when an IT fails, you don’t know if the code is buggy or if the IT itself is. Besides, you’ll probably need to learn of frameworks (JSF comes with its own testing framework, JSFUnit).

As software developers, the same problems come back:

  • Database: is my schema up-to-date? How to manage my referential integritry to set up and tear down data?
  • Those operations are probably slow
  • Finally, how to deal with external problems?

Unitils provides a solution for each of these problems, through the use of a dedicated module for each. For example, a Webdriver module lets you use Selenium through Unitils, a DBUnit module does the same for DBunit and a Mail module creates a fake SMTP server.

-- speakers tells us that with Unitils, there’s no need for a magic abstract superclass anymore: IMHO, it has been replace with a magic black box testing framework --

Unitils benefits from a whole set of modules, which covers a single dedicated area: Swing, Batch, File, Spring, Joda Time,etc.

Modern software development anti-patterns by Martijn Verburg and Ben Evans

There are 10 anti-patterns to cover:

 Anti-pattern Diabolical programmers Voice of reason What to do

Conference-Driven Delivery

Real pros hack code and write their slides minutes before their talks


In order to improve your presentation skills, you can rehearse in front of the mirror. Let’s call it Test-Driven presentations. Begin with a supportive crew, then grow into larger and larger audience.

Mortgage-Driven Development

In order for others not to steal your job, don’t do any documentation. Even better, control your source code i.e keep the source on a USB key

Don’t succumb to fear: proper communication is key.

Developers who communicate have the most success. If you want one of your idea to go into source control, you’ll have to communicate about it.

Distracted by shiny

Always use the latest tech, it’ll put you ahead. Consider using the latest version of Eclipse, packed full of plugins

Prototype and evaluate: learn to separate the myth from the reality. As an example, web frameworks are an area you should tread carefully.

Code reviews are an asset, especially if everyone do them so as to share best practices.

Brown bag sessions are good, in order to test every possible options.

Design-Driven Design

UML Code generators are awesome. Print your UML diagrams on gigantic sheets, put them on the wall, and if someone asks you a question, reply that it’s obvious

Design for what you need to know: don’t try to do too much upfront. Successful teams are able to navigate between methodologies that suit them.

Less source code: pay your junior developers to produce code, and pay your senior to remove it. The less code, the less chances to have bugs. Be wary of maintainability, though (Clojure is a good example).

Pokemon pattern

Use all of the GoF patterns

The appropriate design pattern is your friend. Using a design pattern is adding a feature to a language which is missing it. As an example, Java concurrency works, but since mutability is deeply rooted, it’s hard. Of course, you could use actors (like in Scala), but you definitely would add a feature.

Whiteboard, whiteboard and whiteboard, to communicate with your colleagues. As a tip, carry whiteboard markers at all time (or alternatively pen and pencil).

Tuning by Folklore

Performance tune by lightning black candles. Remove string concatenations, add DB connections and so on

Measure, don’t guess. It’s the best approach to improve performance. If it sounds boring, it’s because it is. Remember that the problem is probably not where you think it is.

Shameless plug: go to jClarity


All the code in one file is easier to search. VB 6 is one of the most popular language because of it

Discrete components based on SOLID principles: Single Responsibility, Open to extension, Litskov substitution, etc.

Discuss with your team, don’t go screaming WTF, you’ll probably have issues. You need to use naming based on the domain model so as other developers can read your code

Lean Startup Ninja

A ninja ships its code when it compiles!Continuous delivery is a business enabler.

Tools are available to achieve continuosu delivery: Ant/Gradle/Maven + Jenkins + Puppet + Vagrant


The Tiobe index is your friend.

Just be good at the principles. Try different languages, because when learning another language can be applied to the language you’re currently programming in.

Being a Software Developer is better than a Programmer. The former understands the whole lifecycle of an application, which is much better.

I haz Cloud

Nothing can go wrong if you push your applications in the cloud

Evaluate and prototype

There are many providers available: EC2, Heroku, JElastic, CloudBees, OpenShift, etc. Again, a brown bag session is a great way to start

Can Haz Mobile

If you go into the mobile game, you’ll be a millionaire

HTML5 for the win

UX is so important. What are your UX needs?

Think about what pisses you off…​

Big Data

MongoDB is web scale

What type of data are you storing?

Simplicity in Scala Design by Bill Venners

The main thing is to show how to:

  • Design to simplify tasks for your users
  • Design for busy teams. Don’t assume your users are expert in your libraries. It’s something like driving a car you’ve never driven before: it should be so obvious users shouldn’t have to check the documentation
  • Make it obvious, guessable or easy to remember, by order of preference. The choice process for the plusOrMinus in ScalaTest is a good example.
  • Design for readers, then writers, in that order. To choose the name for the invokePrivate is a good example: better use something semantically significant than some symbol
  • Make errors impossible (or difficult at last). In particular, use Scala’s rich type system to achieve this. Using the compiler to flag errors is the best
  • Exploit familiarity. James Gosling used familiar C++ keywords in Java, but without memory management so as to leverage this principle. So is the way ScalaTest is using JUnit constructs but enforcing a label on each test.
  • Document with examples
  • Minimize redudancy. A Zen of Python states:
    There should be one and preferably only one obvious way to do it.

    A good practice would be to put a Recommended Usage blocks for each class.

  • Maximize consistency. ScalaTest offers a GivenWhenThen trait as well as the Suite class. But when you mixin the latter with the former, you do not need to set the name of the test. However, enforcing the Single Responsibility Principle and introducing Spec solves the problem.
  • Use symbols when your users are already experts in them. Scala provides ` instead of `plus`, and `*` instead of `multiply`. On the contrary, in SBT some symbols prove to be problematic: `~=`, `<<=`, `<=, <<++=. Likewise, it’s better to use foldLeft() than /:. However, there are situations where you shouldn’t be able to use words at all (like in algebra).
  • Use a functional style by default, but switch to an imperative style where it improves usability. For example, test functions in a suite, it registers the tests typed inside the braces.

    Remember what tools are for. They are for solving problems, not finding problems to solve

Re-imagining the browser with AngularJS by Igor Minar and Misko Hevery

-- I attend this session in order to open my mind about HATEOAS applications. I so do hope it’s worth it! --

Browsers were really simple at one time. 16 years later, browsers offer many more features, going as far as allowing people to develop through a browser! For a user, this is a good, for a developer not so much because of complexity.

In a static page, you tell the browser what you want. In JavaScript, you have to take care of how browsers work and the difference between them (hello IE). As an example, remember rounded corner before CSS border-radius? In HTML or the DOM API, there doesn’t seem to be such improvement. Even if you use jQuery, you’re doing imperative programming. The solution to look for is declarative! Databinding helps with this situation. If your model changes, the view should be automatically updated. On the contrary, with two-ways data binding updates in the view should change the underlying model. Advanced templating can be used with collections. Actually, 90% of JavaScript is only to synchronize between the model and the view.

AngularJS takes care of this now, while a specification is under work for this should be part of how browser works. HTML can be verbose, tabs are a good example: they currently use div while they should be using tab. From a more general point-of-view, AngularJS brings such components to the table. Also, the Web Components is an attempt at standardization of this feature.

-- here comes a demo --

AngularJS works by importing the needed js files, creating a module in JS and adding custom attribute to HTML tags.

Testacular is a JavaScript testing framework adapted to AngularJS.

Apache TomEE, JavaEE 6 Web Profile on Tomcat by David Blevins

Apache TomEE is trying to solve the problem in that you run with Tomcat unlike you hit the wall and go to another server. TomEE is a certified Web Profile stack, it is a Tomcat with the Apache libraries to bridge the gap. Core values include being small, being certified and stay Tomcat.

What is the Web Profile anyway? In order to solve the bloated image of JavaEE, v6 specs introduced kepping only about half the specs of the full JavaEE specs (12 on 24). Things that are not included:

  • CMP
  • JAX-RS
  • JAX-WS
  • JMS
  • Connectors

The last 4 are especially lacking so TomEE comes into 3 flavors: Web Profile including JavaMail (certified), JAX-RS (certified) and Plus which includes JAX-WS, Connector and JMS (not certified). Note that in JavaEE 7 will certainly change those distributions, since profiles themselves will change. TomEE began in 2011 with 1.0.0.beta 1 and October saw the release of 1.5.0. TomEE is know for its performance but also its lack of extended support.

-- here comes the TomEE demo, including its integration with Eclipse (which is exactly the same as for Tomcat bare --

TomcatEE is just Tomcat with a couple of JAR in both lib and endorsed, extra-configuration in conf and a launcher for each OS in bin. Also, there’s Java agent (-- for some reason I couldn’t catch --).

Testing is done with Arquillian and runs within an hour. Certifications tests are executed on Amazon EC2 instances, each having 613 max memory (and runs in +hundred hours): note that TCK pass with default JVM memory. The result is quite interesting with a 27Mb download, with only 64Mb memory taken at runtime. It would be a bad idea to integrate all stacks yourself, not only because it’s just a waste of time, but also because there’s a gap between aggregating all components individually and the integration that was done in TomEE.

Important features of TomEE include integration of Arquillian and Maven. A key point of TomEE is that deployment errors are printed out all at the same time and do not force you to correct those errors one by one as it’s the case with other application servers.

Nicolas Fränkel

Nicolas Fränkel

Developer Advocate with 15+ years experience consulting for many different customers, in a wide range of contexts (such as telecoms, banking, insurances, large retail and public sector). Usually working on Java/Java EE and Spring technologies, but with focused interests like Rich Internet Applications, Testing, CI/CD and DevOps. Also double as a trainer and triples as a book author.

Read More
Devoxx 2012 - Day 4
Share this