Mockito with Jersey Test and JAX-RS - UnsatisfiedDependencyException

Question

Trying to test a fairly simple JAX-RS endpoint

@ApplicationScoped
@Path("mypath")
public class MyRestService {
    @Inject
    private Logger logger;

    @Inject
    private EjbService ejbService;

    @GET
    public String myMethod() {
        logger.info("...");
        return ejbService.myMethod();
    }
}

with Mockito and Jersey Test

@RunWith(MockitoJUnitRunner.class)
public class MyRestServiceTest extends JerseyTest {
    @Mock
    private EjbService ejbService;

    @Mock
    private Logger logger;

    @InjectMocks
    private MyRestService myRestService;

    ...

    @Override
    protected Application configure() {
        MockitoAnnotations.initMocks(this);
        return new ResourceConfig().register(myRestService);
    }
}

The Grizzly container is returning a org.glassfish.hk2.api.UnsatisfiedDependencyException for Logger and EjbService even thought the dependencies are injected correctly by Mockito.

Seems Grizzly is trying, correctly, to ovverride the Mockito mocks. If I register an AbstractBinder in the configure method, everything works fine.

.register(new AbstractBinder() {
    @Override
    protected void configure() {
        bind(ejbService).to(EjbService.class);
        bind(logger).to(Logger.class);
    }
});

But I don't feel it's the best way to accomplish injection. Mockito style is better imho. What do I need to do to solve this issue?

Answer 1

I was able to create the following base class in order to achieve integration between JerseyTest and Mockito such as the OP aimed for:

package org.itest;

import com.google.common.collect.Maps;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.glassfish.jersey.internal.inject.AbstractBinder;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.server.ServerProperties;
import org.glassfish.jersey.test.JerseyTestNg;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.util.ReflectionUtils;

import javax.ws.rs.core.Application;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author Nom1fan
 */
public abstract class JerseyTestBase extends JerseyTestNg.ContainerPerClassTest {

    @Override
    protected Application configure() {
        MockitoAnnotations.openMocks(this);
        ResourceConfig application = new ResourceConfig();
        Object resourceUnderTest = getResourceUnderTest();
        application.register(resourceUnderTest);

        Map<String, Object> properties = Maps.newHashMap();
        properties.put(ServerProperties.BV_SEND_ERROR_IN_RESPONSE, true);
        properties.put("contextConfigLocation", "classpath:applicationContext.xml");

// Retrieve the fields annotated on subclass as @Mock via reflection and keep each instance 
// and its type on an entry in the map, later used to bind to Jersey infra.
        HashMap<Object, Class<?>> mocksToBindMap = Maps.newHashMap();
        List<Field> fieldsWithMockAnnotation = FieldUtils.getFieldsListWithAnnotation(getClass(), Mock.class);
        for (Field declaredField : fieldsWithMockAnnotation) {
            declaredField.setAccessible(true);
            Object fieldObj = ReflectionUtils.getField(declaredField, this);
            mocksToBindMap.put(fieldObj, declaredField.getType());
        }

        application.setProperties(properties);
        application.register(new AbstractBinder() {
            @Override
            protected void configure() {
                for (Map.Entry<Object, Class<?>> mockToBind : mocksToBindMap.entrySet()) {
                    bind(mockToBind.getKey()).to(mockToBind.getValue());
                }
            }
        });
        return application;
    }

    protected abstract Object getResourceUnderTest();
}

The hook getResourceUnderTest must be implemented by the extending test class, providing the instance of the resource it wishes to test.

Test class example:

import org.itest.JerseyTestBase;
import org.mockito.InjectMocks;
import org.mockito.Mock;

public class MyJerseyTest extends JerseyTestBase {
    
    @Mock
    private MockA mockA;
    @Mock
    private MockB mockB;
    @InjectMocks
    private MyResource myResource;


    @Override
    protected Object getResourceUnderTest() {
        return myResource;
    }


    @Test
    public void myTest() {
        when(mockA.foo()).thenReturn("Don't you dare go hollow");
        when(mockB.bar()).thenReturn("Praise the Sun \\[T]/");

        // Test stuff
        target("url...").request()...
    }
}

MyResource class looks something like this:

@Path("url...")
@Controller
public class MyResource {
   
    private final MockA mockA;
    private final MockB mockB;

   @Autowired        // Mocks should get injected here
   public MyResource(MockA mockA, MockB mockB) {
      this.mockA = mockA; 
      this.mockB = mockB;
   }

   @GET
   public Response someAPI() {
     mockA.foo(); 
     mockB.bar();
   }
}

NOTE: I used Spring's and Apache's reflection utils to make things easier but it's not mandatory. Simple reflection code which can be written by hand.

Answer 2

The MockitoJUnitRunner is for unit tests and JerseyTest is for integration tests.

When using Mockito, your tests will call directly the declared myRestService and Mockito dependency injection will take place.

When using JerseyTest, a new web container is created and your tests talk to MyRestService via an HTTP call. Inside this container, the real dependency injection is happening, the classes are not even seeing you declared mocks.

You can use JerseyTest and Mockito together, exactly as you did. It just requires some extra configurations (as you already found) and the @RunWith annotation is not necessary.