Injection test

InjectionTest.java

import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.jersey.server.ResourceConfig;
import org.glassfish.jersey.servlet.ServletContainer;
import org.glassfish.jersey.test.DeploymentContext;
import org.glassfish.jersey.test.JerseyTest;
import org.glassfish.jersey.test.ServletDeploymentContext;
import org.glassfish.jersey.test.grizzly.GrizzlyWebTestContainerFactory;
import org.glassfish.jersey.test.spi.TestContainerFactory;
import org.junit.Test;

import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.container.ContainerRequestContext;
import javax.ws.rs.container.ContainerRequestFilter;
import javax.ws.rs.container.DynamicFeature;
import javax.ws.rs.container.ResourceInfo;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.FeatureContext;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;
import java.io.IOException;

import static org.junit.Assert.assertEquals;

/**
 * Run it like any other unit test.
 * 
 *  <dependency>
 *     <groupId>org.glassfish.jersey.test-framework.providers</groupId>
 *     <artifactId>jersey-test-framework-provider-grizzly2</artifactId>
 *     <version>${jersey2.version}</version>
 *     <scope>test</scope>
 *  </dependency>
 */
public class InjectionTest extends JerseyTest {

    private static class InsideFilter implements ContainerRequestFilter {

        @Context
        private HttpServletRequest request;

        @Override
        public void filter(ContainerRequestContext requestContext) throws IOException {
            requestContext.setProperty("remoteHost", request.getRemoteHost());
        }
    }

    private static class OutsideFilter implements ContainerRequestFilter {

        private final ContainerRequestFilter insideFilter;

        public OutsideFilter(ContainerRequestFilter insideFilter) {
            this.insideFilter = insideFilter;
        }

        @Override
        public void filter(ContainerRequestContext requestContext) throws IOException {
            this.insideFilter.filter(requestContext);
        }
    }

    private static class TestFeature implements DynamicFeature {

        private final ServiceLocator locator;

        @Inject
        public TestFeature(ServiceLocator locator) {
            this.locator = locator;
        }

        @Override
        public void configure(ResourceInfo info, FeatureContext featureContext) {
            InsideFilter insideFilter = new InsideFilter();
            locator.inject(insideFilter);
            featureContext.register(new OutsideFilter(insideFilter));
        }
    }

    @Path("test")
    public static class TestResource {
        @GET
        public String getRemoteHost(@Context ContainerRequestContext context) {
            return (String) context.getProperty("remoteHost");
        }
    }

    @Override
    public ResourceConfig configure() {
        return new ResourceConfig()
                .register(TestResource.class)
                .register(TestFeature.class)
                .register(new ExceptionMapper<Throwable>() {
                    @Override
                    public Response toResponse(Throwable ex) {
                        ex.printStackTrace();
                        return Response.serverError().entity(ex.getMessage()).build();
                    }
                });
    }

    @Override
    public TestContainerFactory getTestContainerFactory() {
        return new GrizzlyWebTestContainerFactory();
    }

    @Override
    public DeploymentContext configureDeployment() {
        return ServletDeploymentContext.forServlet(new ServletContainer(configure())).build();
    }

    @Test
    public void testIt() {
        final Response response = target("test")
                .request()
                .get();
        assertEquals(200, response.getStatus());
        assertEquals("localhost", response.readEntity(String.class));
    }
}