In my first post on asserting exceptions with JUint, I showed how to test that a specific type of exception is thrown with expected substrings in the error message. In my second post, I showed how we can write a custom [Matcher] to inspect the contents of the exception. In this post, I’ll show you how to take advantage of the stock IsEqual matcher to accomplish the same task, but with less work.
IsEqual Matcher
This Matcher is straightforward - it evaluates whether two objects are equal by calling equals(Object) on one of the objects that isn’t null, passing in the other. So, to use it with our custom exception, we’ll need to make sure that our equals(Object) method correctly evaluates two of its instances.
The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).
This won’t help us here, because we’ll be comparing exceptions thrown in our code with one we instantiated in our unit test. We’re going to have to implement equals(Object) ourselves.
Implementing equals(Object)
Here’s my simple custom exception:
/**
* Error Code Exception - stores the error code that was generated
* when this exception was thrown.
*/publicclassErrorCodeExceptionextendsRuntimeException{privatestaticfinallongserialVersionUID=1L;/**
* The error code that triggered the exception.
*/privateinterrorCode;/**
* Constructor.
*
* @param errorCode
* the error code that triggered the exception
*/publicErrorCodeException(interrorCode){this.errorCode=errorCode;}/**
* Get the error code that triggered the exception.
*/publicintgetErrorCode(){returnerrorCode;}}
You have to be careful when implementing either equals(Object) or hashCode(). The rule is that if you implement either of these methods, then you need to implement both. Two objects that are equal must have the same hash code. If they don’t, and you try to add two distinct, but equal instances of a class to a Map, they’d both be accepted. This is because internally, the Map stores the items in ‘buckets’ based on their hash codes, and then only has to check equality within a bucket. If two objects have different hash codes, then they won’t be compared to each other.
Your IDE should have the ability to generate what we need here. If you’re using Eclipse (I recommend the STS version, right-click in the source file, select “Source”, and the select “Generate hashCode() and equals()”.
After selecting that option, choose which private members will be used in the two methods. I recommend selecting “‘Use blocks in ‘if’ statements” in order to help wrong code look wrong, should someone modify these methods down the road.
Here’s our final ErrorCodeException class with the newly generated code:
packageorg.blakecaldwell.tests.junitrules;/**
* error code exception - stores the error code that was generated
* when this exception was thrown.
*/publicclasserrorcodeexceptionextendsruntimeexception{privatestaticfinallongserialversionuid=1l;/**
* the error code that triggered the exception.
*/privateinterrorcode;/**
* constructor.
*
* @param errorcode
* the error code that triggered the exception
*/publicerrorcodeexception(interrorcode){this.errorcode=errorcode;}/**
* get the error code that triggered the exception.
*/publicintgeterrorcode(){returnerrorcode;}/**
* (non-javadoc)
*
* @see java.lang.object#hashcode()
*/@overridepublicinthashcode(){finalintprime=31;intresult=1;result=prime*result+errorcode;returnresult;}/**
* (non-javadoc)
*
* @see java.lang.object#equals(java.lang.object)
*/@overridepublicbooleanequals(objectobj){if(this==obj){returntrue;}if(obj==null){returnfalse;}if(getclass()!=obj.getclass()){returnfalse;}errorcodeexceptionother=(errorcodeexception)obj;if(errorcode!=other.errorcode){returnfalse;}returntrue;}}
Verifying _equals(Object) and hashCode()
Even though we generated this code, we still need to test it. Here’s the test fixture for ErrorCodeException:
packageorg.blakecaldwell.tests.junitrules;importorg.junit.Assert;importorg.junit.Test;/**
* Test fixture for ErrorCodeException.
*/publicclassErrorCodeExceptionTest{/**
* Test getErrorCode().
*/@TestpublicvoidtestGetErrorCode(){ErrorCodeExceptionexception=newErrorCodeException(500);Assert.assertEquals(500,exception.getErrorCode());}/**
* Test equals(Object) evaluates true for two equal instances.
*/@TestpublicvoidtestEqualsWhenEqual(){ErrorCodeExceptionexception1=newErrorCodeException(500);ErrorCodeExceptionexception2=newErrorCodeException(500);Assert.assertTrue(exception1.equals(exception2));// another way to testAssert.assertEquals(exception1,exception2);}/**
* Test equals(Object) evaluates as false for two unequal
* instances.
*/@TestpublicvoidtestEqualsWhenNotEqual(){ErrorCodeExceptionexception1=newErrorCodeException(500);ErrorCodeExceptionexception2=newErrorCodeException(501);Assert.assertFalse(exception1.equals(exception2));// another way to testAssert.assertNotEquals(exception1,exception2);}/**
* Test equals(Object) evaluates as false when we pass in null.
*/@TestpublicvoidtestEqualsWhenNull(){ErrorCodeExceptionexception1=newErrorCodeException(500);Assert.assertFalse(exception1.equals(null));// another way to testAssert.assertNotEquals(exception1,null);}/**
* Test that two equal objects have the same hash code. Note that
* two different objects don't need to have different hash codes.
*/@TestpublicvoidtestHashCodeForTwoEqualObjects(){ErrorCodeExceptionexception1=newErrorCodeException(500);ErrorCodeExceptionexception2=newErrorCodeException(500);// sanity check - make sure they're equalAssert.assertEquals(exception1,exception2);// make sure they have the same hash codeAssert.assertEquals(exception1.hashCode(),exception2.hashCode());}}
Using the IsEqual Matcher In Our Unit Tests
Now that we’ve implemented equals(Object) and hashCode() for our custom exception, we can use the IsEqual Matcher to setup an expectation for a specific exception.
packageorg.blakecaldwell.tests.junitrules;importorg.hamcrest.core.IsEqual;importorg.junit.Assert;importorg.junit.Rule;importorg.junit.Test;importorg.junit.rules.ExpectedException;/**
* Test fixture to demonstrate JUnit's ExpectedException @Rule with an
* IsEqual matcher.
*/publicclassExpectedExceptionRuleIsEqualMatcherTest{/**
* ExpectedException must be public.
*/@RulepublicExpectedExceptionexception=ExpectedException.none();/**
* Assert that we're throwing the exact exception that we're
* expecting by using an IsEqual Matcher.
*/@TestpublicvoidtestErrorCode500UsingIsEqualMatcher(){ErrorCodeExceptionexpectedException=newErrorCodeException(500);exception.expect(newIsEqual<ErrorCodeException>(expectedException));// Run your code that you expect will throw an// ErrorCodeException with error code 500. If this exception// is equal to our expectedException above, this test will// pass.thrownewErrorCodeException(500);}/**
* Here's the old way of asserting a specific exception. Yuck!
*/@TestpublicvoidtestErrorCode500WithoutJUnitRules(){ErrorCodeExceptionexception=null;try{thrownewErrorCodeException(500);}catch(Exceptionex){exception=(ErrorCodeException)ex;}Assert.assertEquals(500,exception.getErrorCode());}}
In the first test, I create an IsEqual Matcher with the exception that I want to compare the thrown exception to. No custom Matcher was required, and my custom exception is now more useful because of it.
In my second test, I include the ‘old way’ of checking exceptions to demonstrate how much easier and more readable exception tests are when using JUnit’s Rules feature.
In my previous post, I demonstrated how to use JUnit’sRules feature to assert expected assertions in your unit tests. In this post, I’ll show you how to write custom Matchers that will help give you more power when inspecting your exceptions.
We’ll start with a custom exception which does little more than remember the error code at the time the exception was thrown.
/**
* Error Code Exception - stores the error code that was generated
* when this exception was thrown.
*/publicclassErrorCodeExceptionextendsRuntimeException{privatestaticfinallongserialVersionUID=1L;/**
* The error code that triggered the exception.
*/privateinterrorCode;/**
* Constructor.
*
* @param errorCode
* the error code that triggered the exception
*/publicErrorCodeException(interrorCode){this.errorCode=errorCode;}/**
* Get the error code that triggered the exception.
*/publicintgetErrorCode(){returnerrorCode;}}
Our Exception Matcher
When we pass our Matcher to JUnit’s ExpectedException instance, we’re given a chance to match the exception itself, not the message. In this case, we’re going to write a Matcher that makes sure that the exception’s error code was as expected. We can only match on an instance of our _ ErrorCodeException_, so we’ll save some effort and extend TypeSafeMatcher.
TypeSafeMatcher : Convenient base class for Matchers that require a non-null value of a specific type. This simply implements the null check, checks the type and then casts.
importorg.hamcrest.Description;importorg.hamcrest.TypeSafeMatcher;/**
* ErrorCodeMatcher - matches when an ErrorCodeException has the same
* error code as expected.
*/publicclassErrorCodeExceptionMatcherextendsTypeSafeMatcher<ErrorCodeException>{/**
* The error code we're expecting.
*/privateintexpectedErrorCode;/**
* Constructor.
*
* @param expectedErrorCode
* the error code that we're expecting
*/publicErrorCodeExceptionMatcher(intexpectedErrorCode){this.expectedErrorCode=expectedErrorCode;}/**
* Describe the error condition.
*/@OverridepublicvoiddescribeTo(Descriptiondescription){description.appendText("Error code doesn't match");}/**
* Test if the input exception matches the expected exception.
*/@OverrideprotectedbooleanmatchesSafely(ErrorCodeExceptionexceptionToTest){returnexceptionToTest.getErrorCode()==this.expectedErrorCode;}}
Example Tests With ExpectedException and Our Custom Matcher
With the components in place, let’s start testing. Of course, if you only have one or two error test cases, then a custom Matcher might take more work than it saves, but you end up with code that any developer should be able to read, which might reduce maintenance costs.
packageorg.blakecaldwell.tests.junitrules;importorg.junit.Rule;importorg.junit.Test;importorg.junit.rules.ExpectedException;/**
* Test fixture to demonstrate JUnit's ExpectedException @Rule with a
* custom matcher.
*/publicclassExpectedExceptionRuleCustomMatcherTest{/**
* ExpectedException must be public.
*/@RulepublicExpectedExceptionexception=ExpectedException.none();/**
* Test exception error code 500 using our custom Matcher.
*/@TestpublicvoidtestErrorCode500UsingMatcher(){exception.expect(newErrorCodeMatcher(500));// Run your code that you expect will throw an// ErrorCodeException with// error code 500thrownewErrorCodeException(500);}/**
* Test exception error code 404 using our custom Matcher.
*/@TestpublicvoidtestErrorCodeUsingMatcher(){exception.expect(newErrorCodeMatcher(404));// Run your code that you expect will throw an// ErrorCodeException with// error code 404thrownewErrorCodeException(404);}}
Asserting Exceptions The Old Way
To demonstrate the benefits of using custom Matchers with JUnit’s ExcpectedException, here are the alternatives that you’re probably familiar with, with inline comments explaining why they’re not ideal.
packageorg.blakecaldwell.tests.junitrules;importorg.junit.Assert;importorg.junit.Test;/**
* Tests that demonstrate how to assert exceptions without
* ExpectedException @Rule and custom Matchers.
*/publicclassExceptionAssertingOldWayTest{/**
* Test that an ErrorCodeException was thrown with the "expected"
* parameter. The limitation here is that you can only test the
* type of Exception, not its parameters or the message.
*/@Test(expected=ErrorCodeException.class)publicvoidtestErrorCodeExceptionThrownOldWay1(){// Run your code that you expect will throw an// ErrorCodeException with// error code 500thrownewErrorCodeException(500);}/**
* Test exception error code 404 by capturing the Exception and
* inspecting it inside the catch.
*
* Remarks: We have to make sure to assert failure after our code
* was supposed to throw the exception, or we won't know if it
* never does. This nuance makes this method error prone for
* future modifications.
*/@TestpublicvoidtestErrorCodeExceptionThrownOldWay2(){try{// The "A".equals("A") is here just for this demo to// prevent an "Unreachable code" warning in Eclipse, since// we're throwing the exception directly instead of// calling code that throws it.if("A".equals("A")){// Run your code that you expect will throw an// ErrorCodeException with error code 404thrownewErrorCodeException(404);}// if we've gotten to this point, then no Exception was// thrownAssert.fail("Test case failed: no exception thrown");}catch(Exceptionex){Assert.assertEquals("Expected 404 error code exception",404,((ErrorCodeException)ex).getErrorCode());}}/**
* Test exception error code 404 by capturing the Exception and
* inspecting it outside the try/catch.
*
* Remarks: This is safer than asserting inside the catch (as
* above), since if the exception is never thrown, our assertion
* won't be valid, but still is not a very elegant solution.
*/@TestpublicvoidtestErrorCodeExceptionThrownOldWay3(){ExceptioncaughtException=null;try{// Run your code that you expect will throw an// ErrorCodeException// with error code 404thrownewErrorCodeException(404);}catch(Exceptionex){caughtException=ex;}// if the exception was never thrown, or was thrown and is an// incorrect// type or wrong code, this will failAssert.assertEquals("Expected 404 error code exception",404,((ErrorCodeException)caughtException).getErrorCode());}}
But, what if you want to be more specific, and check the message itself? I’ve always done the following:
/**
* Test the exception message the old way.
*/@TestpublicvoidtestExceptionMessageTheOldWay1(){Stringmessage=null;try{thrownewRuntimeException("Error!");}catch(Exceptione){message=e.getMessage();}Assert.assertEquals("Error!",message);}
Heres’s another variant you’re probably familiar with:
/**
* Test the exception message the old way.
*/@TestpublicvoidtestExceptionMessageTheOldWay2(){try{// this string test was necessary to avoid an "unreachable code" warning in Eclipseif("A".equals("A")){thrownewRuntimeException("Error!");}Assert.fail("Exception was expected.");}catch(Exceptione){Assert.assertEquals("Error!",e.getMessage());}}
Assert Exception Message With JUnit Rules
The above methods always felt like hacks. I recently came across JUnit’s @Rule feature, which saves tons of code and is much easier to read. You first define your public ExpectedException instance, and give it a @Rule annotation. Then, in each test case that wants to use it, you set what type of exception you’re expecting, and optionally a substring to look for in the exception message:
/**
* Our expected exception rule. This must be public.
*/@RulepublicExpectedExceptionexception=ExpectedException.none();/**
* Test the exception message with a single expectMessage substring match.
*/@TestpublicvoidtestExceptionIsThrownFullText(){exception.expect(RuntimeException.class);exception.expectMessage("Error!");thrownewRuntimeException("Error!");}
Since expectMessage is looking for substrings, you can use several of them to test more complicated exception messages:
/**
* Our expected exception rule. This must be public.
*/@RulepublicExpectedExceptionexception=ExpectedException.none();/**
* Test the exception message with multiple expectMessage substrings.
*/@TestpublicvoidtestExceptionIsThrownMultipleSubstrings(){exception.expect(RuntimeException.class);exception.expectMessage("Error: There was an issue processing ");exception.expectMessage(" of the notes.");thrownewRuntimeException("Error: There was an issue processing 5 of the notes.");}
More Advanced: Custom Matchers
In my next post, I’ll i describe how to implement a custom Matcher for more complicated Exception assertions.
Ideally, your unit test suites require no external dependencies - those should be mocked out. However, sometimes you want extra assurance that your code works with live endpoints via integration tests.
For example, you might want to make sure that your code can successfully navigate your corporate proxy and firewall to make external web requests. For this, we’ll write tests that only run when a command line parameter is defined.
This demonstration assumes that you’re using Spring’s JUnit Runner and Maven for running your tests. The @IfProfileValue annotation will tell the test runner to only include this test suite if our configured ProfileValueSource returns “true” for “live-external-tests-enabled”.
I’ve been working with Hibernate for several years now, yet I learn something new about it all the time. The more time I spend with the framework, the more concerned I am about how it will be used by developers new to it.
The simplicity of the entrance into the world of O/R mapping however gives a wrong impression of the complexity of these frameworks. Working with more complex applications you soon realize that you should know the details of framework implementation to be able to use them in the best possible way. In this article, we describe some common anti-patterns which may easily lead to performance problems.
The law of leaky abstractions means that whenever somebody comes up with a wizzy new code-generation tool that is supposed to make us all ever-so-efficient, you hear a lot of people saying “learn how to do it manually first, then use the wizzy tool to save time.” Code generation tools which pretend to abstract out something, like all abstractions, leak, and the only way to deal with the leaks competently is to learn about how the abstractions work and what they are abstracting. So the abstractions save us time working, but they don’t save us time learning.
Don’t stop learning about a framework once you figure out how to use it - that’s only the beginning.