1. TDD, Unit Testing(Spring) &
Code Coverage
- Jahangir
(md.jahangir27@gmail.com)

2. What is TDD?
 Software development process.
 Test-first programming concepts.

4. Advantages
 Code quality
 Focus and better understanding of requirements
 Modular, loosely coupled code

5. Shortcomings
 TDD brings in a sense of confidence, but not in the cases when developer
misunderstands the requirements.
 Bad written tests are hard to maintain. Tests need as much attention as the
code itself if not more.

6. How to TDD with Spring?
 Basics don’t change.
 STEPS:
 Code to interface(e.g. StudentService) , then code the skeleton concrete
implementation(e.g. StudentServiceImpl) without details. Say, we need to write a method
which takes studentId and classId as arguments and returns a Boolean indicating whether
the student is registered for a class. In this example, in the concrete implementation as a
first step should just return false.
 Create your test class. – Add a test case.
 In the test method for above scenario: pass in a valid studentId who is registered to a
class, you would assert for true, but it returns false. – Fail a test case.

7. How to TDD with Spring?
 Now, write some code in the class to pass the test case i.e. access the Student
DAO to make sure given a valid studentId and classId, it returns true – Pass the
test case.
 Consider the requirements once again like what should be returned if studentId
passed is null or classId is null(assuming non-primitives are passed). – Write tests
for these cases, fail again. Forces you to think from business/functional
perspective.
 Make necessary changes to your implementation to handle these cases. –
Refactoring.
 Repeat from 1st step again.

8. Useful Unit testing Annotations
 @RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(context xml loaded from classpath)
or
 @ContextConfiguration(classes={StudentServiceImplTestConfig.class})
Best practice: Create as minimum number of beans as possible as it’s a unit
test case and shouldn’t hinder your CI(Continous Integration).

9. Sample Spring Unit test
//Reference from spring documentation
package com.example;
@RunWith(SpringJunit4ClassRunner.class)
@ContextConfiguration(classes=OrderServiceConfiguration.class, loader=AnnotationConfigContextLoader.class)
Public class OrderServiceTest{
@Autowired
Private OrderService orderService;
@Test
Public void testOrderService(){
//test the service.
}
}

10. Resolving Dependencies of beans not under
test
 Scenario: Assume there is a “StudentService” bean which we talked about
and has a new requirement - when the students logins using the studentId,
it needs to return class ids the student is registered.
 Desired output: If the studentId doesn’t exist, throw an error message
saying “Student ID doesn’t exist”. Else, return the class ids.
 Dependency: Now, it has a dependency on a Student DAO to check whether
studentID exists and if it does, get the class ids.
 Best practice: Write tests in isolation i.e. if we are testing StudentService,
then test only StudentService and not StudentDao.

11. Mockito
 Mocks creation.
 Verification.
 Stubbing.

12. Simple Mockito flavor
 http://pastebin.com/v4qRNv17 -- Sample code.

13. Scenario
public List<integer> getClassIds (Integer studentId) throws
InvalidStudentException{
if(studentId== null ||studentId.isEmpty()){
throw new InvalidStudentException(”Student ID is
empty, please enter it");
}
if(studentDao.checkValidStudent(studentId))
return
studentDao.getClassIdsByStudentId(studentId);
else
throw new InvalidUserException("Invalid student
ID");
}

14. As we can see, there is dependency on DAO, we can mock DAO something like
below:
StudentDao mockStudentDao = Mockito.mock(StudentDao.class);
when(mockUserDao.checkValidStudent(”1234")).thenReturn(true);
List<Integer> listOfClassIds = new ArrayList<Integer>();
listOfClassIds.add(101);
listOfClassIds.add(102);
when(mockUserDao.getClassIdsByStudentId(”1234")).thenReturn(listOfClassId
s);

15. Test case
@Test
public void testClassIds(){
List<Integer> listOfClassIds = new ArrayList<Integer>();
listOfClassIds.add(101);
listOfClassIds.add(102);
Assert.assertEquals("Display class ids for a valid
student”,listOfClassIds, studentService.getClassIds(”1234"));
} //Now this takes care of studentDao as it’s mocked.

16. Mock HTTP
Mocks for various HTTP related stuff:
http://static.springsource.org/spring/docs/3.0.x/api/org/springframework/mo
ck/web/

17. Code Coverage
 Measure of how much code is tested.
 Very useful when you didn’t start the project with TDD, but adding tests
later. It gives you a measure of how effective your tests are in covering your
code.

18. EclEmma
 Java code coverage tool for Eclipse.
 Drill-down of coverage to method level.
 Source high-lighting.

19. References
 http://blog.springsource.org/2011/06/21/spring-3-1-m2-testing-with-
configuration-classes-and-profiles/
 http://blogs.msdn.com/b/wesdyer/archive/2007/12/07/musings-on-
software-testing.aspx (Image reference)
 http://code.google.com/p/mockito/ (Mockito)
 http://www.eclemma.org/ (EclEmma)
 http://static.springsource.org/spring/docs/3.0.x/api/org/springframework/
mock/web/