How to test dynamic query method with TestNG and mockito

[Brian Storenson]

I am new to unit testing, and I am trying to test the handleCriteria(). I wanted to verify that root.get(Person_.firstName) on line 26 occurred. But, I am getting a null pointer exception. I am having a hard time figuring out how to mock things, and use when(). I have read some of the mockito docs, and other tutorials. According to stack,

"A unit test should test a single codepath through a single method. When the execution of a method passes outside of that method, into another object, and back again, you have a dependency.

When you test that code path with the actual dependency, you are not unit testing; you are integration testing. While that's good and necessary, it isn't unit testing."

How can I test handleCriteria, and get rid of this null pointer exception?

@Repository
public class EntityManagerPersonDao extends EntityManagerDao<Person, Long> implements PersonDao {
    // sample sql query
    // SELECT p FROM Person p WHERE UPPER(p.FIRST_NAME) = UPPER('John') AND UPPER(P.LAST_NAME) = UPPER('Smtih');
    @Override
    protected CriteriaQuery<Person> handleCriteria(final EnumMap<?, Object> searchCriteria,
            final Class<Person> type,
            final CriteriaBuilder criteriaBuilder) {
       
        // this object defines a particular query that will navigagte over one or more entities.
        final CriteriaQuery<Person> criteriaQuery = criteriaBuilder.createQuery(type); // type is a Person.class
        // create the query root from which all navigation originates. It's similar to the FROM clause
       
        final Root<Person> root = criteriaQuery.from(type); // type is a Person.class
        
        // Create ArrayList for storing Dynamic Query
        final List<Predicate> predicates = new ArrayList<Predicate>();
        
        // Appends query if variable if not null
        if ( searchCriteria.get(Individual.IDNUM) != null ) { 
            // find the tuples where Person_.id is == to the searchCriteria's IDNUM
            predicates.add(criteriaBuilder.equal(root.get(Person_.id), searchCriteria.get(Individual.IDNUM)));
            }
        if ( searchCriteria.get(Individual.FIRSTNAME) != null ) {
            //    crit add search for fname
            predicates.add(criteriaBuilder.like(criteriaBuilder.upper(root.get(Person_.firstName)), searchCriteria.get(Individual.FIRSTNAME).toString().toUpperCase()));
            }
        if ( searchCriteria.get(Individual.LASTNAME) != null ) {
            //    crit add search for lname
            predicates.add(criteriaBuilder.like(criteriaBuilder.upper(root.get(Person_.lastName)), searchCriteria.get(Individual.LASTNAME).toString().toUpperCase()));
            }
        
        criteriaQuery.select(root).where(criteriaBuilder.and(predicates.toArray(new Predicate[0])));

        
        return criteriaQuery;
    }

}

public class EntityManagerPersonDaoTest {
    @InjectMocks
    private EntityManagerPersonDao entityManagerPersonDao = new EntityManagerPersonDao();
    @Mock
    private EntityManager entityManager;
   
    @Test
    public void testHandleCriteria_FirstNameAndLastName() {
        ////////////////////////
        // setup precondition //
        ////////////////////////
        //setup your test data for EnumMap argument
        final EnumMap searchCriteria = new EnumMap(Individual.class); //just use any enum so we don't have to define one
        //enter test data into EnumMap
        searchCriteria.put(Individual.FIRSTNAME, "John");
        searchCriteria.put(Individual.LASTNAME, "Smith");
        //setup type argument
        final Class<Person> type = Person.class;
        //setup criteriaBuilder argument
        final CriteriaBuilder criteriaBuilder = mock(CriteriaBuilder.class);
        ////////////////////////
        // setup query object //
        ////////////////////////
        final CriteriaQuery<Person> criteriaQuery = mock(CriteriaQuery.class);
        when(criteriaBuilder.createQuery(type)).thenReturn(criteriaQuery);        
        
        final Root<Person> root = mock(Root.class);
        when(criteriaQuery.from(type)).thenReturn(root); 
        
        final CriteriaQuery<Person> criteriaQueryResult = entityManagerPersonDao.handleCriteria(searchCriteria, type, criteriaBuilder);
        ///////////////////////////////////////
        // test that the methods were called //
        ///////////////////////////////////////
        // check to see if firstName predicates were added
        verify(root, atLeast(1)).get(Person_.firstName);
        
    }

[Junilu Lacar]

When something is difficult to test, sometimes it's an indication that either your test or class under test has a design flaw. Looking at the code you provided, I would say that it's primarily the design of the class under test that has some problems that you should fix.

The biggest smell is that of inappropriate assignment of responsibility. A Data Access Object is responsible for mapping the structure of data in the persistence mechanism (in this case, an RDBMS) to/from the object structure. The code you are trying to test supports this responsibility but doesn't necessarily fulfill it. My first inclination would be to refactor this code, extracting the criteria building functionality out to another class. Hints as to what class it should be extracted out to can be found in the method signature, which also has some code smells.

One of those code smells is that the method name "handleCriteria" doesn't really say much about the intent of the method and doesn't make a lot of sense semantically in the context of the declared return type and the parameters passed in. A name like "createQuery" or "createQueryFor" would make more sense to me, with only one parameter necessary: the criteria map.

Have a look at this example: http://www.petrikainulainen.net/programming/spring-framework/spring-data-jpa-tutorial-part-four-jpa-criteria-queries/ ; you'll see an alternative nomenclature as well as a proper assignment of responsibility.

[Brian Storenson]

Thanks Junilu!