Tu I Jo Asseguts A La Barra D’un Bar, Sona Bona Música I Som Davant Del Mar (Al Mar - Manel)

In current post I am going to talk about differences between Hamcrest and Fest Fluent Assertions. The reason of this post is not to tell you if you should use one or the other. I only want to show you how both implementations resolve the problem of writing readable assertions.

To compare both APIs I have created two JUnits, one using Hamcrest assertions and one where Fest assertions are used.

The comparision is done using only common operations (Logical, Object, Collections, Number, Text) and creation of new matchers. I am not going to compare which ones have implemented more matchers or kinds of matchers, because I think this is not a parameter to use for choosing what library fits better to your project. Moreover in both APIs you can extend them for creating your own matchers.

Let's start showing model representing a simple modelling of Studio Ghibli http://en.wikipedia.org/wiki/Studio_Ghibli movies information. 

	private static final Director hayao = new Director("Hayao Miyazaki", 70);
	private static final Director goro = new Director("Goro Miyazaki", 44);
	private static final Character totoro = new Character("Totoro", false);
	private static final Character satsuki = new Character("Satsuki Kusakabe", true);
	private static final Character mei = new Character("Mei Kusakabe", true);
	private static final Character tatsuo = new Character("Tatsuo Kusakabe", true);
	private static final Movie myNeighborTotoro = new Movie("My Neighbor Totoro", hayao);
	private static final Character sheeta = new Character("Lusheeta Toel Ur Laputa", true);
	private static final Character pazu = new Character("Pazu", true);
	private static final Movie castleInTheSky = new Movie("Castle In The Sky", hayao);
	private static final Character arren = new Character("Arren", true);
	private static final Character therru = new Character("Therru", false);
	private static final Movie talesFromEarthSea = new Movie("Tales From Eathsea", goro);
	private static final List<Object> movies = new ArrayList<Object>();
	private static final Map<Movie, Character> mainCharacters = new HashMap<Movie, Character>();
	@Before
	public void setup() {
	myNeighborTotoro.addCharacter(tatsuo);
	myNeighborTotoro.addCharacter(satsuki);
	myNeighborTotoro.addCharacter(mei);
	myNeighborTotoro.addCharacter(totoro);
	movies.add(myNeighborTotoro);
	mainCharacters.put(myNeighborTotoro, totoro);
	castleInTheSky.addCharacter(pazu);
	castleInTheSky.addCharacter(sheeta);
	movies.add(castleInTheSky);
	mainCharacters.put(castleInTheSky, pazu);
	talesFromEarthSea.addCharacter(arren);
	talesFromEarthSea.addCharacter(therru);
	movies.add(talesFromEarthSea);
	mainCharacters.put(talesFromEarthSea, arren);
	}

view raw StudioGhibli.java hosted with ❤ by GitHub

Imports:

Hamcrest requires 11 imports:

	import static org.hamcrest.text.IsEqualIgnoringCase.equalToIgnoringCase;
	import static org.hamcrest.core.IsEqual.equalTo;
	import static org.hamcrest.core.IsNot.not;
	import static org.hamcrest.core.IsInstanceOf.instanceOf;
	import static org.hamcrest.core.IsNull.notNullValue;
	import static org.hamcrest.core.IsSame.sameInstance;
	import static org.hamcrest.collection.IsMapContaining.hasKey;
	import static org.hamcrest.collection.IsMapContaining.hasValue;
	import static org.hamcrest.CoreMatchers.hasItem;
	import static org.hamcrest.number.OrderingComparison.greaterThan;
	import static org.hamcrest.beans.HasPropertyWithValue.hasProperty;

view raw HamcrestAssertions.java hosted with ❤ by GitHub

while Fest requires 2 imports:

	import static org.fest.assertions.Assertions.assertThat;
	import static org.fest.assertions.MapAssert.entry;

view raw FestAssertions.java hosted with ❤ by GitHub

in fact this is not a good or bad thing how many imports are required, but it is always a headache remember where a required assertion is packaged. Because Fest uses Fluent Interfaces approach with two imports all operations are available with IDE's "auto-completation" feature.

Simple asserts:

Not much difference between Hamcrest and Fest, in case of Fest verb is also added in method name creating a much readable assert.

Hamcrest

	assertThat(hayao.getFullName(), equalTo("Hayao Miyazaki"));
	assertThat(hayao.getAge(), equalTo(70));

view raw HamcrestAssertions.java hosted with ❤ by GitHub

Fest

	assertThat(hayao.getFullName()).isEqualTo("Hayao Miyazaki");
	assertThat(hayao.getAge()).isEqualTo(70);

view raw FestAssertions.java hosted with ❤ by GitHub

Logical asserts:

In this case we find a big difference. Hamcrest supports logical operations and can be used independently, meanwhile logical operations in Fest are a part of the method:

Hamcrest

assertThat(myNeighborTotoro.getDirectedBy(), not(equalTo(goro)));

view raw HamcrestAssertions.java hosted with ❤ by GitHub

Fest

assertThat(myNeighborTotoro.getDirectedBy()).isNotEqualTo(goro);

view raw FestAssertions.java hosted with ❤ by GitHub

Object asserts:

Same object operations are provided in both APIs. There is only one difference, in Fest you can chain callings of methods, so number of asserts compared to Hamcrest are fewer.

Hamcrest

	assertThat(mei, instanceOf(Character.class));
	assertThat(mei, notNullValue());
	assertThat(goro, sameInstance(goro));

view raw HamcrestAssertions.java hosted with ❤ by GitHub

Fest

	assertThat(mei).isInstanceOf(Character.class).isNotNull();
	assertThat(goro).isSameAs(goro);

view raw FestAssertions.java hosted with ❤ by GitHub

Collection asserts:

In case of Collections is where they differ more from each other. Hamcrest deals with Collections and Maps with methods like hasKey, hasValue, hasItem. Fest uses a more generic calling like includes, excludes, entry; I have not found any way for asserting key instead of key-value in Fest.
Moreover in this example I also compare how to access a bean property in each elements of collection. From my point of view I think that Fest has a better approach resolving this case.

Hamcrest

	assertThat(mainCharacters, hasKey(myNeighborTotoro));
	assertThat(mainCharacters, hasValue(totoro));
	assertThat(movies, hasItem(hasProperty("name", equalTo("Tales From Eathsea"))));

view raw HamcrestAssertions.java hosted with ❤ by GitHub

Fest

	assertThat(mainCharacters).includes(entry(myNeighborTotoro, totoro));
	assertThat(movies).onProperty("name").contains("Tales From Eathsea");

view raw FestAssertions.java hosted with ❤ by GitHub

Number asserts:

As in simple asserts, there is no much difference between them.

Hamcrest

assertThat(hayao.getAge(), greaterThan(goro.getAge()));

view raw HamcrestAssertions.java hosted with ❤ by GitHub

Fest

assertThat(hayao.getAge()).isGreaterThan(goro.getAge());

view raw FestAssertion.java hosted with ❤ by GitHub

String asserts:


Hamcrest

assertThat(sheeta.getName(), equalToIgnoringCase("lusheeta toel ur laputa"));

view raw FestAssertion.java hosted with ❤ by GitHub

Fest

assertThat(sheeta.getName()).isEqualToIgnoringCase("lusheeta toel ur laputa");

view raw FestAssertions.java hosted with ❤ by GitHub

As you have noted Hamcrest and Fest are very similar, but I think that Fest solves the same problem but in much cleaner way.

Although both solutions offer very similar matchers, each implementation is so different, so creation of a custom matcher is different too. In Hamcrest you should create a class that extends from TypeSafeMatcher. In Fest there are two possibilities, first one is extending Fest-assertions with custom condition (using already Fest structure and defined types), and the second one is extending with custom assertion (creating a new assertThat implementation for required type).

Hamcrest extension for asserting that a character is a human:

	public class IsCharacterHuman extends TypeSafeMatcher<Character> {
	public void describeTo(Description description) {
	description.appendText("a human");
	}
	@Override
	protected boolean matchesSafely(Character character) {
	return character.isHuman();
	}
	@Factory
	public static <T> Matcher<Character> isHuman() {
	return new IsCharacterHuman();
	}
	}
	import static org.assertions.IsCharacterHuman.isHuman;
	assertThat(arren, isHuman());

view raw IsCharacterHuman.java hosted with ❤ by GitHub

In case of Fest there are two approaches, the first one, that requires that our class extends from Condition. As I told previously, extending Condition implies using the same kind of types supported by org.fest.assertions.Assertions.assertThat method (object, int, short, list, array, ...). In previous case our type is Character, and of course does not exist an overload of Assertions.assertThat method with Character, but java.lang.Object. So our class should be:

	public class CharacterHumanCondition extends Condition<Object> {
	@Override
	public boolean matches(Object character) {
	return ((Character)character).isHuman();
	}
	public static CharacterHumanCondition human() {
	return new CharacterHumanCondition();
	}
	}

view raw CharacterHumanCondition.java hosted with ❤ by GitHub

As you probably noted, you need to cast character variable to Character, neither a clean solution nor optimal. But of course you can use second method, extending from GenericAssert. This class (a Fluent class) will be the responsible of implementing an assertThat that accepts Character objects, and moreover will implement matcher methods. And I say methods because unlike Hamcrest, Fest can contain more than one matcher in each class. For example if there are some tests that we are asserting if character is human, and in another ones asserting if is human and if has a name, in Hamcrest we should create two classes. In Fest you don't have this restriction.

	public class CharacterAssert extends GenericAssert<CharacterAssert, Character> {
	public CharacterAssert(Character character) {
	this(CharacterAssert.class, character);
	}
	protected CharacterAssert(Class<CharacterAssert> selfType, Character actual) {
	super(selfType, actual);
	}
	public static CharacterAssert assertThat(Character actual) {
	return new CharacterAssert(actual);
	}
	public CharacterAssert isHuman() {
	isNotNull();
	String errorMessage = String.format("Expected Human Character but <%s> found.", actual.isHuman());
	Assertions.assertThat(actual.isHuman()).overridingErrorMessage(errorMessage).isTrue();
	return this;
	}
	public CharacterAssert hasName(String name) {
	isNotNull();
	String errorMessage = String.format("Expected Character Name <%s> but <%s> found.", actual.getName(), name);
	Assertions.assertThat(actual.getName()).overridingErrorMessage(errorMessage).isEqualTo(name);
	return this;
	}
	}

view raw CharacterAssert.java hosted with ❤ by GitHub

As it is told in Fest site "Which one to use? Hamcrest or FEST-Assert? It is up to you...it depends on the needs of your project and your coding style!"

Download code.

Music: http://www.youtube.com/watch?v=GjWLXZ4WdQU