如何使用Mockito来模拟包含EntityManager

Question

Currently in school we are working on a rather large project. However testing in Java wasn't really explained that well so I didn't really work TDD like I was suppose to.

protected EntityManager getEntityManager() {
    return EntityController.getEntityManager();
}

// Get all exam skeletons from the DB
@Override
public List<ExamSkeleton> getAllSkeletons() {
    EntityManager entityManager = getEntityManager();
    try {
        TypedQuery<ExamSkeleton> query = entityManager.createQuery("SELECT NEW ExamSkeleton (s.id, s.filename, s.course, s.visible) FROM ExamSkeleton as s", ExamSkeleton.class);

        List<ExamSkeleton> skeletons = query.getResultList();

        return skeletons;
    } catch (IllegalArgumentException exception) {
        LOGGER.error(exception);
    }
        return Collections.emptyList();
}

So my question is, how do I test this method using Mockito?

Answer 1

Approach 1: Test the Code As Is

The getEntityManager method is private and it invokes a static method so, as things stand, you would need to use PowerMockito to provide a mocked instance of EntityManager in your test. For example:

@RunWith(PowerMockRunner.class)
@PrepareForTest({EntityController.class})
public class SomeTest {

    @Test
    public void aTest() {
        PowerMockito.mockStatic(EntityController.class);

        EntityManager entityManager = Mockito.mock(EntityManager.class);
        Mockito.when(EntityController.getEntityManager()).thenReturn(entityManager);

        TypedQuery<ExamSkeleton> query = (TypedQuery<ExamSkeleton>) Mockito.mock(TypedQuery.class);

        Mockito.when(entityManager.createQuery("SELECT NEW ExamSkeleton (s.id, s.filename, s.course, s.visible) FROM ExamSkeleton as s")).thenReturn(query);

        List<ExamSkeleton> expected = new ArrayList<>();
        Mockito.when(query.getResultList()).thenReturn(expected);

        ExamRepository examRepository = new ExamRepository();

        List<ExamSkeletons> actual = examRepository.getAllSkeletons();

        // this assertion verifies that getAllSkeletons gives you the result of the above SQl query
        assertSame(expected, actual);
    }
}

Approach 2: Refactor For Separation of Concerns and Ease of Testing

However, you could simplify things, from a testing and design perspective, by externalising the creation of the entity manager into a factory, for example.

public class EntityManagerFactory {

    public EntityManager create() {
        return EntityController.getEntityManager();
    }
} 

Next, inject an instance of EntityManagerFactory into whatever class contains getAllSkeletons() (ie the class you are testing). The simplest way of doing this is to declare it as a constructor argument:

public class SomeDao {
    private final EntityManagerFactory entityManagerFactory;

    public SomeDao(EntityManagerFactory entityManagerFactory) {
        this.entityManagerFactory = entityManagerFactory;
    }

    @Override
    public List<ExamSkeleton> getAllSkeletons() {
        try {
            TypedQuery<ExamSkeleton> query = entityManager.createQuery("SELECT NEW ExamSkeleton (s.id, s.filename, s.course, s.visible) FROM ExamSkeleton as s", ExamSkeleton.class);

            List<ExamSkeleton> skeletons = query.getResultList();

            return skeletons;
        } catch (IllegalArgumentException exception) {
            LOGGER.error(exception);
        }
            return Collections.emptyList();
    }
}

Now, you can test this code using vanilla mockito. For example:

public class SomeDaoTest {

    @Test
    public void canGetAllSkeletons() {
       EntityManagerFactory entityManagerFactory = Mockito.mock(EntityManagerFactory.class);

       Mockito.when(entityManagerFactory.create()).thenReturn(entityManager);

       SomeDao sut = new SomeDao(entityManagerFactory.class);

       // now SomeDao will use your mocked EntityManager so you can set expectations
       // on createQuery etc to drive your test scenarios
       // ...
    }
}

Answer 2

1) The EntityManager should not be associated to the controller :

return EntityController.getEntityManager();

In terms of design, it is not desirable : low layer and high layer should not be mixed, otherwise why use them ?
In terms of testing for getAllSkeletons() , this coupling will also make the unit test harder to set and to write.

2) The actual method doesn't have logic to test but the exception case : you just create a query, execute it and return the result.
It is a good case for an integration test (without mocking the DB layer), less for an unit test.
As it will make the unit test complex and with not a lot of value.

---

Example of what you could get with Mockito and that I don't recommend.
Make the EntityManager a dependency of the class under test : with injection or not.
In your unit test, mock this dependency.
It could look like :

@Mock
EntityManager entityManagerMock;

@Test
public void getAllSkeletons(){
   TypedQuery<ExamSkeleton> queryByMock =  (TypedQuery<ExamSkeleton>)   Mockito.mock(TypedQuery.class);
   Mockito.when(entityManagerMock.createQuery("SELECT NEW ExamSkeleton (s.id, s.filename, s.course, s.visible) FROM ExamSkeleton as s"))
          .thenReturn(queryByMock);
   List<ExamSkeleton> skeletons = new ArrayList<>();
   Mockito.when(queryByMock.getResultList())
          .thenReturn(skeletons);
   Foo foo = new Foo(); 
   foo.setEntityManager(entityManagerMock);
   // action
   List<ExamSkeleton> actualSkeletons = foo.getAllSkeletons();
   // assertion
   Assert.assertSame(skeletons, actualSkeletons);        
}

Really don't write this kind of code that just describes the flow of invocations.
It makes just a test brittle that will very rarely catch regressions.