Retrieve a managed bean from a JerseyTest container with jersey-spring3

Question

This question is a follow on from a previous question Specify Custom Application Context.

We are migrating some of our data services from Jersey 1.x using jersey-spring to Jersey 2.x using jersey-spring3.

We have a few test classes that inherit from JerseyTest. Some of these classes use custom applicationContext.xml files that are not specified in the web.xml file.

For object mocking purposes we would mock out some components in our Jersey Resources.

In Jersey 1.x we could mock objects in the application context file by

<bean id="mockBean" class="org.easymock.EasyMock" 
    factory-method="createStrictMock" autowire="byName">
    <constructor-arg index="0" value="com.xxx.xxx.ClassToMock" /> 
</bean>

and retrieve these mocked instances as follows

ClassToMock obj = (ClassToMock)ContextLoader
    .getCurrentWebApplicationContext()
    .getAutowireCapableBeanFactory()
    .getBean("mockBean");

How can the same be achieved with Jersey 2.x using jersey-spring3?

I have combed through the API docs, user guides and some of the sources but was unable to find an answer.

Thank you.

EDIT:

We will be using the mocked beans inside of our JAX-RS resources. We have service interfaces that are @Autowired into our resources.

e.g.

@Path(ProductResource.RESOURCE_PATH)
@Component
@Scope("prototype")
public class ProductResource 
extends GenericResource<Product, BaseModel> {

    /*
     * Members
     */

    public static final String RESOURCE_PATH = "product/";

    @Autowired
    protected ProductService productService;

    ...

We want to mock out the and set the expectations on these services.

e.g.

<bean id="productService" class="org.easymock.EasyMock" 
    factory-method="createStrictMock">
    <constructor-arg index="0" 
        value="com.xxx.xxx.service.ProductService" /> 
</bean>

Answer 1

Note: I am not a Spring expert and I consider this to be rather a work-around than a recommended approach. Hopefully someone will come up with a better solution.

You can't obtain an ApplicationContext instance by calling ContextLoader#getCurrentWebApplicationContext() because Jersey 2.x runtime is by default initialized outside of a Servlet container when using Jersey Test Framework (JerseyTest) for unit/e2e tests.

In this case you need to use a little work-around to obtain an ApplicationContext by implementing an ApplicationContextAware interface in your test package:

public class ApplicationContextUtils implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    @Override
    public void setApplicationContext(final ApplicationContext applicationContext) throws BeansException {
        ApplicationContextUtils.applicationContext = applicationContext;
    }
}

Once you have this class, don't forget to mention it in your application context descriptor:

...
<bean class="org.glassfish.jersey.examples.helloworld.spring.ApplicationContextUtils" />
...

And you can use it in your tests:

public class JerseySpringResourceTest extends JerseyTest {

    // ... Configure ...

    @Before
    public void mockUp() throws Exception {
        // ApplicationContext is ready in your @Before methods ...
        assertThat(ApplicationContextUtils.getApplicationContext(), notNullValue());
    }

    @Test
    public void testJerseyResource() {
        // ... as well as in your test methods.
        assertThat(ApplicationContextUtils.getApplicationContext(), notNullValue());
    }
}

Note: If you want to deploy your application to a Servlet container and run your (JerseyTest) tests against it, consult Jersey Test Framework chapter in the Users Guide (especially External container section).

Answer 2

You can inject your test class to Jersey context if you don't have any objections for that.

For example:

@Override
protected Application configure() {
    final TestJerseyApplication application = new TestJerseyApplication();

    final Map<String, Object> properties = new HashMap<>();
    properties.put("contextConfigLocation", "classpath:test-spring-context.xml");
    application.setProperties(properties);

    application.register(this);
    return application;
}

After that the @Autowired annotation will work for you.

Answer 3

For the Jersey 2.X users, here's what worked for me:

  public class AccountResourceTest extends JerseyTest {

    private ApplicationContext context;

    private BeanA beanA;

    private BeanB beanB;

    public AccountResourceTest() throws TestContainerException {
        super();

        beanA = context.getBean(BeanA.class);
        beanB = context.getBean(BeanB.class);
    }

    @Override
    protected Application configure() {
        context = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        final ResourceConfig config = new JerseyConfiguration().property("contextConfig", context);
        return config;
    }

    @Override
    protected void configureClient(final ClientConfig config) {
        config.register(JacksonJsonProvider.class);
    }

    ...
}

This allows me to use JavaConfig for my Jersey tests, and access the beans in the context as well. Here's the link to where I got the idea: http://geowarin.github.io/spring-boot/jersey/2014/01/31/a-simple-spring-boot-and-jersey-application.html

Answer 4

With Jersey version 2.4.x, the class JerseyConfiguration does not exist anymore and has been replaced by ResourceConfig which does not understand the contextConfig property. Here is my solution :

package ch.vd.test;

import java.net.URI;

import javax.ws.rs.core.Application;

import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.jersey.server.ApplicationHandler;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.test.JerseyTest;
import org.glassfish.jersey.test.grizzly.GrizzlyTestContainerFactory;
import org.glassfish.jersey.test.spi.TestContainer;
import org.glassfish.jersey.test.spi.TestContainerException;
import org.glassfish.jersey.test.spi.TestContainerFactory;
import org.junit.Test;
import org.springframework.context.ApplicationContext;

public class ExampleTest extends JerseyTest {

    private ServiceLocator serviceLocator;

    @Override
    public void setUp() throws Exception {
        super.setUp();
        final ApplicationContext context = serviceLocator.getService(ApplicationContext.class, "SpringContext");
        final Object bean = context.getBean("someBean");
    }

    @Override
    protected Application configure() {
        final ResourceConfig config = new ResourceConfig(RestResources.class);
        config.property("contextConfigLocation", "classpath:example-context.xml");
        return config;
    }

    @Override
    protected TestContainerFactory getTestContainerFactory() throws TestContainerException {
        return new GrizzlyTestContainerFactory() {
            @Override
            public TestContainer create(URI uri, ApplicationHandler appHandler) throws IllegalArgumentException {
                serviceLocator = appHandler.getServiceLocator();
                return super.create(uri, appHandler);
            }
        };
    }

    @Test
    public void testStuff() throws Exception {
        ...
    }
}