Skip to main content

Spring TestContext Framework

I'm somewhat surprised that there hasn't been more noise around in the blogosphere about Spring 2.1's TestContext Framework. I had the pleasure of working with Juergen Hoeller for a day after JavaZone. Among other things, I learned about the fancy @Autowired annotation that you can use to make your autowiring much safer. Normally autowiring is considered bad practice, but it was Juergen's advice that now it is okay to use. This means in practice that all your service beans will still be declared in an applicationContext.xml file, but the dependencies and object graphs will be annotated in the Java files (or atleast where you see fit).

After this I had a deeper look into the features of Spring 2.1. Note the point about "our next-generation Spring TestContext Framework with support for JUnit4". Now this is cool.

Why we need it (or something like it)

For a long while I (and many of my colleagues and peers) have been annoyed by the disability to manage tests as the amount grows. There hasn't been any good framework around for doing any kind of categorization of tests. Each project would have to invent their own set of hacks in order to control their test suites, be it a TestFactory picking up system variables, or using different Maven profiles and source folders for different categories of tests. In short, inventing some sort of convention for seperating tests: put them in different folders, use name conventions like *Test.java, and *IntegrationTest.java.

Have you ever been in a project where you and your team dropped automated testing because you couldn't manage the mass of tests? Well, tools are starting to appear now that can save your hiney.

TestNG solves this. Why don't you just use that?
The first solution that many have become aware of is TestNG. I really like the feauteres, but as of Alex presentation on JavaZone, Maven's surefire plugin still has issues running TestNG. Also, Eclipse (our standard IDE) has built in support for JUnit4. And finally, Spring comes with a bunch of lovely standard testbase classes that make your integration tests nicer. Oh, wait. You don't want your test to inherit from a Spring class? Read on to find out. Final reason: everyone knows JUnit and not too many know TestNG (sorry Alex..).

There's a new kid in town
Spring TestContext Framework introduces a wide range of new annotations for doing tests, my absolute favourite being the @IfProfileValue that you can use to specify testing environment (in other words implement the test categorization I spoke of above). There is only one implemented ProfileValueSource (being the logic that decides which profile it is) that checks for system variables, but it is easy to extend with your own ProfileValueSource class that contains the logic for deciding which tests to run.

As promised: avoid extending Spring's testbase classes: Use the @RunWith(SpringJUnit4ClassRunner.class annotation instead.

You got the regular nifty annotations like @Repeat (guess what it does) @Timed (fails if the tests exceeds a time limit, different from JUnit 4's timeout attribute), plus a bunch of Spring environment controlling transactions and Spring contexts. You don't need to use the @ExpectedException any more because JUnit4 supplied us with the @Test(expected=RuntimeException.class) functionality. Spring people recommend that you use JUnit's way of doing it.

"Caching between testing", and "injection of test fixtures". Sounds lovely, doesn't it? Sounds alot like the presentation of TestNG, but hey, it's JUnit :)

There is also a pretty cool @ContextConfiguration annotation for declaring which Spring bean XML files you want to use for a particular test.

Actually, instead of me repeating the whole documentation, why don't you take a look for yourself. Note that I haven't actually played around with this properly yet (well, we got as far as getting the M4 build into our maven repository) cause I left my laptop in work. I'm gonna try setting up the machine here tonight and see if I can get something done before bedtime.

By the way, some shameless company promotion: My employer is doing a course on Spring 2 with Interface21 in Oslo in the beginning of November. Per is a really friendly guy, so don't hesitate to give him a call and ask about it if you're curious :)

Popular posts from this blog

Encrypting and Decrypting with Spring

I was recently working with protecting some sensitive data in a typical Java application with a database underneath. We convert the data on its way out of the application using Spring Security Crypto Utilities. It "was decided" that we'd be doing AES with a key-length of 256, and this just happens to be the kind of encryption Spring crypto does out of the box. Sweet!

The big aber is that whatever JRE is running the application has to be patched with Oracle's JCE in order to do 256 bits. It's a fascinating story, the short version being that U.S. companies are restricted from exporting various encryption algorithms to certain countries, and some countries are restricted from importing them.

Once I had patched my JRE with the JCE, I found it fascinating how straight forward it was to encrypt and decrypt using the Spring Encryptors. So just for fun at the weekend, I threw together a little desktop app that will encrypt and decrypt stuff for the given password and sa…

Managing dot-files with vcsh and myrepos

Say I want to get my dot-files out on a new computer. Here's what I do:

# install vcsh & myrepos via apt/brew/etc
vcsh clone https://github.com/tfnico/config-mr.git mr
mr update

Done! All dot-files are ready to use and in place. No deploy command, no linking up symlinks to the files. No checking/out in my entire home directory as a Git repository. Yet, all my dot-files are neatly kept in fine-grained repositories, and any changes I make are immediately ready to be committed:

config-atom.git
    -> ~/.atom/*

config-mr.git
    -> ~/.mrconfig
    -> ~/.config/mr/*

config-tmuxinator.git  
    -> ~/.tmuxinator/*

config-vim.git
    -> ~/.vimrc
    -> ~/.vim/*

config-bin.git   
    -> ~/bin/*

config-git.git          
    -> ~/.gitconfig

config-tmux.git  
    -> ~/.tmux.conf    

config-zsh.git
    -> ~/.zshrc

How can this be? The key here is to use vcsh to keep track of your dot-files, and its partner myrepos/mr for operating on many repositories at the same time.

I discovere…

Always use git-svn with --prefix

TLDR: I've recently been forced back into using git-svn, and while I was at it, I noticed that git-svn generally behaves a lot better when it is initialized using the --prefix option.

Frankly, I can't see any reason why you would ever want to use git-svn without --prefix. It even added some major simplifications to my old git-svn mirror setup.

Update: Some of the advantages of this solution will disappear in newer versions of Git.

For example, make a standard-layout svn clone:

$ git svn clone -s https://svn.company.com/repos/project-foo/

You'll get this .git/config:

[svn-remote "svn"]
        url = https://svn.company.com/repos/
        fetch = project-foo/trunk:refs/remotes/trunk
        branches = project-foo/branches/*:refs/remotes/*
        tags = project-foo/tags/*:refs/remotes/tags/*

And the remote branches looks like this (git branch -a):
    remotes/trunk
    remotes/feat-bar

(Compared to regular remote branches, they look very odd because there is no remote name i…

Considerations for JavaScript in Modern (2013) Java/Maven Projects

Disclaimer: I'm a Java developer, not a JavaScript developer. This is just what I've picked up the last years plus a little research the last days. It's just a snapshot of my current knowledge and opinions on the day of writing, apt to change over the next weeks/months.

We've gone all modern in our web applications, doing MVC on the client side with AngularJS or Ember, building single-page webapps with REST backends. But how are we managing the growing amount of JavaScript in our application?
You ain't in Kansas anymore So far we've just been doing half-random stuff. We download some version of a library and throw it into our src/main/webapp/js/lib, or we use it from a CDN, which may be down or unreachable when we want to use the application..

Some times the JS is minified, other times it's not. Some times we name the file with version number, other times without. Some times we get the latest library of master branch and name it with the commit-id in the fi…

Microsoft ups their Git efforts another notch

This week Microsoft announced first class Git support embedded in the coming version of Visual Studio.

Now, it's not completely shocking. We could have seen it coming since Microsoft started offering Git repos on CodePlex, and more recently offering a Git client for TFS. In any case, these are some big news. Scott Hanselman weighs on some features and some more background here.

For those who are a bit unaware of what the Git situation on Windows looks like these days, I've dotted down these notes:
Some explanation on these:

msysGit has long been The Way to use Git on Windows. It's basically a port of Git itself, so it's a command-line tool.GitExtensions (includes Visual Studio integration), TortoiseGit, Git Shell, posh-git and most other tools are powered by msysGit.libgit2 is a native library for doing Git stuff. It is developed completely separate from Git itself. The above tools could (and should) probably use libgit2 instead of hooking onto and around msysGit.Github…