Embrace Unit Testing

JUG Roma 26 th September 2006 “ Embrace Unit Testing” Alessio Pace alessio.pace [AT] gmail.com http://www.jroller.com/page/alessiopace

3 things about me.. Master Degree in Computer Engineering Java fan Just “Puccio” for the friends

About this presentation What you will find: definition and survey of the benefits of Unit Testing reusing material from the Web and books (see references at the end) a little coding example to get the feeling of Unit Testing using JUnit, EasyMock and XMLUnit What you won't find: an in-depth explanation about the internals of the above testing frameworks a Test Driven example

Agenda Introduction: The programmer life without Unit Testing What is and what is not Unit Testing The benefits of Unit Testing Bad rumours about Unit Testing, and the answers to them Practical example in Java: JUnit + EasyMock JUnit + EasyMock + XMLUnit

Programmer life without Unit Testing Write a lot of code...and someday something doesn't work / stops working Just fixing a bug is easy, but finding it can be a nightmare: hours in front of the debugger interact like a monkey with the browser or reading the output on console Fixing it could break other parts The bug could appear again later

What is Unit Testing A unit test is an automated and self-checked procedure used to validate that a particular module of source code works correctly a module: a single Java class The procedure is to write tests for all the methods or functions of the module The class under test should be tested in isolation

“A set of Unit Testing rules” A test is not a unit test if: It talks to the database It communicates across the network It touches the file system It can't run at the same time as any of your other unit tests You have to do special things to your environment (such as editing config files) to run it You are not testing a class in isolation from other concrete classes

The benefits of Unit Testing (1) Isolate each part of the program and check that the individual parts work Strict, written contract that the piece of code must satisfy Allows to refactor code and make sure it still works correctly ( regression testing )

The benefits of Unit Testing (2) Simplifies integration : testing the parts of a program first and then testing their integration Provides documentation : clients and other developers can look at the unit tests to gain a basic understanding of the APIs and determine how to use the module to fit their needs Improves code quality : code that cannot be easily tested is not factored properly

The benefits of Unit Testing (3) Separation of interface from implementation : a class may have some collaborator classes, testing that class can frequently lead into testing the other classes.. unit test should never go outside of its own class boundary: abstract an interface around the collaborator class, and implements that interface with a mock object (see later). This results in loosely coupled code, minimizing dependencies in the system

Bad rumours about Unit Testing “ It requires time, and I am always overscheduled” “ It is a waste of time: if I change my classes, I have to rewrite the tests!” “ My code is rock solid, I don't need tests!”

Answers to the bad rumours (1/2) The “I'm in hurry” issue leads to a vicious cycle: more pressure you feel -> less tests you write less tests you write -> less productive you are and the less stable your code becomes the less productive and accurate you are -> more pressure you feel

Answers to the bad rumours (2/2) Unit Testing speeds up your development : automated and self-checked code reduces the time to manually debug your code writing unit tests immediately after you code new features (or even better, before ) lets you find bugs sooner and isolated (easy to correct) Unit Testing lets you refactor safely: a change in code that causes a regression is immediately found

A short parenthesis on Refactoring Refactoring , a definition: “ A change made to the internal structure of software to make it easier to understand and cheaper to modify without changing its observable behaviour” (“Refactoring”, Martin Fowler) Unit Testing and Refactoring go together: before refactoring a section of code you better have solid tests that cover it test, small change, test, small change, test, ..

Let's get into a coding example! A practical example showing the very basics of: JUnit 4.x + EasyMock 2.2 JUnit 4.x + EasyMock 2.2 + XMLUnit See the References at the end for more tutorials and explanations about the internals of the frameworks

Our example: a high level description Suppose we are already given a IBookService interface, which defines a method to retrieve an IBook by its code Suppose also we are already given an implementation of it: RemoteBookService We want to implement and test: a trivial CachedIBookService implementation, which decorates an IBookService by caching subsequent calls for the same book code value

Our example: UML Class Diagram We have to implement and test the CachedBookService class

Constructor implementation of CachedBookService public class CachedBookService implements IBookService { private IBookService remoteBookService ; public CachedBookService(IBookService bookService){ if(bookService == null){ throw new IllegalArgumentException(); } this.remoteBookService = bookService; } public IBookService getRemoteBookService() { return remoteBookService; } public IBook getBook(String code) throws NoSuchElementException { // implementation left out for the moment throw new NotImplementedException(); } } Ok, let's test the constructor

How to automatically test the constructor? We must check that: when passing a valid argument the object state after the construction is correct (the instance variable remoteBookService is set) when passing a null argument an IllegalArgumentException is thrown We will use a testing framework: JUnit

JUnit: description JUnit is just a general testing framework which provides assertion methods You can use it to do unit testing : testing a single class in isolation, eventually using EasyMock (or other mock objects frameworks) to mock collaborators classes You can use it to do integration testing : testing the interactions of a class with real collaborator classes Almost a de-facto standard in the Java field (but have a look also at TestNG ..)

Writing a JUnit 4.x test class A test class is just a Java class Test methods must be annotated with @Test Two configuration levels: before/after each test method call ( @Before / @After annotated methods) before/after the test class is processed ( @BeforeClass / @AfterClass annotated methods) Launch the test class from an IDE (“run as JUnit Test”) or the command line

Testing object state after constructor import static org.junit.Assert.*; import org.junit.Test; public class CachedBookServiceTest { @Test public void testConstructor () { // anonymous class to test in isolation CachedBookService constructor IBookService bookServiceParameter = new IBookService(){ public IBook getBook(String code) throws NoSuchElementException { return null; } }; CachedBookService cachedBookService = new CachedBookService(bookServiceParameter); assertNotNull ("Assert not null", cachedBookService.getRemoteBookService()); /* 3 identical ways to test the reference value: */ assertTrue ("Assert same reference", bookServiceParameter == cachedBookService.getRemoteBookService()); // assertSame ("Assert same reference", bookServiceParameter, cachedBookService.getRemoteBookService()); // assertEquals (“Assert same reference”, bookServiceParameter, cachedBookService.getRemoteBookService()) }

Testing exception is thrown // CachedBookServiceTest.java @Test(expected=IllegalArgumentException.class) public void testConstructorWithNullArg () { // should throw IllegaArgumentException with null arg new CachedBookService( null ); } }

Now let's implement getBook() method public class CachedBookService implements IBookService { private IbookService remoteBookService; private Map<String, IBook> cache; public CachedBookService(IBookService bookService){ if(bookService == null){ throw new IllegalArgumentException(); } this.remoteBookService = bookService; this.cache = new HashMap<String, IBook>(); } public IBook getBook(String code) throws NoSuchElementException { IBook ibook = cache.get(code); if(ibook != null){ return ibook; }else{ IBook result = this.remoteBookService.getBook(code); this.cache.put(code, result); return result; } } Ok, let's test getBook()

How to test getBook()? The class must be tested in isolation: we don't want to rely on a concrete IBookService collaborator object We must test the interactions of the class under test with the collaborator object: first request for an IBook code must be delegated to the remoteBookService following requests for the same IBook code must be served from the cache We are going to use JUnit with a Mock Objects framework: EasyMock

What are Mock Objects? Most software units do not work alone, but collaborate with other units To test a unit in isolation , the collaborators must be simulated Mock objects have the same interfaces of the objects they mimic a mock is configured to simulate the object behaviour that it replaces In contrast to a stub , a mock object also verifies whether it is used as expected

Why are Mocks useful? Isolate bugs Depend on an interface and not on an implementation (which couldn't exist yet) Endo testing : not just testing the output of a method, but testing the interactions of a unit with the collaborator object(s) also called “interaction based testing” (as opposed to “state based testing” )

EasyMock 2.2 EasyMock 2.2, two libraries: one to generate mocks for interfaces only ( easymock ) one to generate mocks for non-final concrete classes and interfaces ( easymock-classextension ) Benefits: hand writing mocks is not needed supports compiler check and refactoring supports method return values and exceptions supports checking the order and count of method calls ...

How to get a mock object with EasyMock 2.2 create a Mock Object for the interface to simulate record the expected behavior switch the mock object to replay state perform the method call to the class under test that is supposed to interact with the mock obejct verify the mock has been used correctly

Testing getBook() - 1 st test method @Test public void testGetBook () { // (1) create the mock for the collaborating object IBookService mockBookService = EasyMock.createMock(IBookService.class); // a mock with no behaviour as return value of getBook() IBook mockBook = EasyMock.createMock(IBook.class); // (2) record the expected behaviour EasyMock.expect(mockBookService.getBook("id123")).andReturn(mockBook); // (3) switch the mock to replay state EasyMock.replay(mockBookService); CachedBookService cachedBookService = new CachedBookService(mockBookService); // (4) perform the call to the class under test which interacts with the mock IBook result = cachedBookService.getBook("id123"); assertSame(“Assert same reference”, mockBook, result); // (5) verify the mock has been used as expected EasyMock.verify(mockBookService); }

Testing getBook() - 2 nd test method @Test public void testGetBookTwoDifferentCodes () { // (1) create the mock for the collaborating object IBookService mockBookService = EasyMock.createMock(IBookService.class); // a mock with no behaviour as return value of getBook() IBook mockBook = EasyMock.createMock(IBook.class); IBook mockBook2 = EasyMock.createMock(IBook.class); // (2) record two expected calls EasyMock.expect(mockBookService.getBook("id123")).andReturn(mockBook); EasyMock.expect(mockBookService.getBook("id456")).andReturn(mockBook2); // (3) switch the mock to replay state EasyMock.replay(mockBookService); CachedBookService cachedBookService = new CachedBookService(mockBookService); // (4) perform the call to the class under test which interacts with the mock IBook result = cachedBookService.getBook("id123"); assertSame(“Assert same reference”, mockBook, result); IBook result2 = cachedBookService.getBook("id456"); assertSame(“Assert same reference”, mockBook2, result2); // (5) verify the mock has been used as expected EasyMock.verify(mockBookService); }

Testing getBook() - 3 rd test method @Test public void testGetSameBookTwoTimes () { IBookService mockBookService = EasyMock.createMock(IBookService.class); IBook mockBook = EasyMock.createMock(IBook.class); // record only one call EasyMock.expect(mockBookService.getBook("id123")).andReturn(mockBook); EasyMock.replay(mockBookService); CachedBookService cachedBookService = new CachedBookService(mockBookService); IBook result = cachedBookService.getBook("id123"); assertSame(mockBook, result); IBook secondResult = cachedBookService.getBook("id123"); assertSame(result, secondResult); EasyMock.verify(mockBookService); }

Adding an IBookXmlSerializer We are already given an IBookXmlSerializer interface to serialize an IBook to XML We have to implement and test a simple IBookXmlSerializerImpl which writes an XML representation of an IBook

IBookXmlSerializerImpl public class IBookXmlSerializerImpl implements IBookXmlSerializer { public String serialize(IBook book) { StringBuilder sb = new StringBuilder(""); sb.append("<book>"); sb.append(" <code>" + book.getCode() + "</code>"); sb.append(" <title>" + book.getTitle() + "</title>"); sb.append(" <author>" + book.getAuthor() + "</author>"); sb.append("</book>"); return sb.toString(); } } Ok, let's test serialize()

How to test serialize()? We must check that the XML output is correct We must test the class in isolation: we can't rely on a concrete IBook implementation (we don't have it..) We are going to use JUnit, EasyMock and XMLUnit

Testing XML with XMLUnit “ XMLUnit extends JUnit to simplify unit testing of XML” “ It compares a control XML document to a test document or the result of a transformation, validates documents against a DTD, and compares the results of XPath expressions”

IbookXmlSerializerTest - Part 1 import org.custommonkey.xmlunit.XMLTestCase; public class IBookXmlSerializerImplTest { private IBookXmlSerializer serializer; private IBook book; private XMLTestCase xmlTestCase; @Before public void setUp() throws Exception { this.serializer = new IBookXmlSerializerImpl(); this.book = EasyMock.createMock(IBook.class); this.xmlTestCase = new XMLTestCase(); } // .... The method annotated with @Before is executed before every @Test method execution

IbookXmlSerializerTest - Part 2 @Test public void testSerialize() throws Exception { final String code = "id1"; EasyMock.expect(this.book.getCode()).andReturn(code); final String title = "Unit Testing"; EasyMock.expect(this.book.getTitle()).andReturn(title); final String author = "Mario Rossi"; EasyMock.expect(this.book.getAuthor()).andReturn(author); // switch to replay state EasyMock.replay(this.book); String xml = this.serializer.serialize(book); this.xmlTestCase.assertXpathExists("/book", xml); this.xmlTestCase.assertXpathEvaluatesTo(code, "/book/code", xml); this.xmlTestCase.assertXpathEvaluatesTo(title, "/book/title", xml); this.xmlTestCase.assertXpathEvaluatesTo(author, "/book/author", xml); // verify mock EasyMock.verify(this.book); }

If you appreciated Unit Testing... ...you will want to try also: Test Driven Development (TDD) Continous Integration Test Coverage tools ..

Some references 1/2 Wikipedia: http://en.wikipedia.org/wiki/Unit_testing http://en.wikipedia.org/wiki/Mock_object “ A Set of Unit Testing Rules” by Michael Feathers: http://www.artima.com/weblogs/viewpost.jsp?thread=126923 “ Extreme Programing Explained / Installed” by Kent Beck / Ron Jeffries “ Refactoring” by Martin Fowler “ JUnit Test Infected: Programmers Love Writing Tests”: http://junit.sourceforge.net/doc/testinfected/testing.htm JUnit 4.x Cookbok: http://junit.sourceforge.net/doc/cookbook/cookbook.htm

Some references 2/2 “ Endo-Testing: Unit Testing with Mock Objects”: www.connextra.com/aboutUs/mockobjects.pdf EasyMock 2.2 Documentation: http://easymock.org/EasyMock2_2_Documentation.html http://easymock.org/EasyMock2_2_ClassExtension _Documentation.html “ Partial Mocks with EasyMock”: http://www.jroller.com/page/alessiopace?entry=partial_mocks_with_easymock “ Making more objects mockable with ASM Definalizer” http://sixlegs.com/blog/java/definalizer.html XMLUnit: http://xmlunit.sourceforge.net/

Embrace Unit Testing

More Related Content

Embrace Unit Testing