Example usage for org.springframework.mock.web MockFilterConfig MockFilterConfig

List of usage examples for org.springframework.mock.web MockFilterConfig MockFilterConfig

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.mock.web.*
  5. MockFilterConfig
  6. MockFilterConfig

Introduction

In this page you can find the example usage for org.springframework.mock.web MockFilterConfig MockFilterConfig.

Prototype

public MockFilterConfig()

Source Link

Document

Create a new MockFilterConfig with a default MockServletContext .

Usage

From source file:fr.xebia.servlet.filter.XForwardedFilterTest.java

@Test
public void testInvokeAllProxiesAreTrusted() throws Exception {

    // PREPARE/*from  w  w  w  .j  a va 2  s  . co  m*/
    XForwardedFilter xforwardedFilter = new XForwardedFilter();
    MockFilterConfig filterConfig = new MockFilterConfig();
    filterConfig.addInitParameter(XForwardedFilter.INTERNAL_PROXIES_PARAMETER,
            "192\\.168\\.0\\.10, 192\\.168\\.0\\.11");
    filterConfig.addInitParameter(XForwardedFilter.TRUSTED_PROXIES_PARAMETER, "proxy1, proxy2, proxy3");
    filterConfig.addInitParameter(XForwardedFilter.REMOTE_IP_HEADER_PARAMETER, "x-forwarded-for");
    filterConfig.addInitParameter(XForwardedFilter.PROXIES_HEADER_PARAMETER, "x-forwarded-by");

    xforwardedFilter.init(filterConfig);
    MockFilterChain filterChain = new MockFilterChain();
    MockHttpServletRequest request = new MockHttpServletRequest();

    request.setRemoteAddr("192.168.0.10");
    request.setRemoteHost("remote-host-original-value");
    request.addHeader("x-forwarded-for", "140.211.11.130, proxy1, proxy2");

    // TEST
    xforwardedFilter.doFilter(request, new MockHttpServletResponse(), filterChain);

    // VERIFY
    String actualXForwardedFor = ((HttpServletRequest) filterChain.getRequest()).getHeader("x-forwarded-for");
    assertNull("all proxies are trusted, x-forwarded-for must be null", actualXForwardedFor);

    String actualXForwardedBy = ((HttpServletRequest) filterChain.getRequest()).getHeader("x-forwarded-by");
    assertEquals("all proxies are trusted, they must appear in x-forwarded-by", "proxy1, proxy2",
            actualXForwardedBy);

    String actualRemoteAddr = ((HttpServletRequest) filterChain.getRequest()).getRemoteAddr();
    assertEquals("remoteAddr", "140.211.11.130", actualRemoteAddr);

    String actualRemoteHost = ((HttpServletRequest) filterChain.getRequest()).getRemoteHost();
    assertEquals("remoteHost", "140.211.11.130", actualRemoteHost);
}

From source file:fr.xebia.servlet.filter.ExpiresFilterTest.java

protected void validate(HttpServlet servlet, Integer expectedMaxAgeInSeconds, int expectedResponseStatusCode)
        throws Exception {
    // SETUP/*w w  w .  ja  v a  2  s.c om*/
    int port = 6666;
    Server server = new Server(port);
    Context context = new Context(server, "/", Context.SESSIONS);

    MockFilterConfig filterConfig = new MockFilterConfig();
    filterConfig.addInitParameter("ExpiresDefault", "access plus 1 minute");
    filterConfig.addInitParameter("ExpiresByType text/xml; charset=utf-8", "access plus 3 minutes");
    filterConfig.addInitParameter("ExpiresByType text/xml", "access plus 5 minutes");
    filterConfig.addInitParameter("ExpiresByType text", "access plus 7 minutes");
    filterConfig.addInitParameter("ExpiresExcludedResponseStatusCodes", "304, 503");

    ExpiresFilter expiresFilter = new ExpiresFilter();
    expiresFilter.init(filterConfig);

    context.addFilter(new FilterHolder(expiresFilter), "/*", Handler.REQUEST);

    context.addServlet(new ServletHolder(servlet), "/test");

    server.start();
    try {
        Calendar.getInstance(TimeZone.getTimeZone("GMT"));
        long timeBeforeInMillis = System.currentTimeMillis();

        // TEST
        HttpURLConnection httpURLConnection = (HttpURLConnection) new URL("http://localhost:" + port + "/test")
                .openConnection();

        // VALIDATE
        Assert.assertEquals(expectedResponseStatusCode, httpURLConnection.getResponseCode());

        for (Entry<String, List<String>> field : httpURLConnection.getHeaderFields().entrySet()) {
            System.out.println(field.getKey() + ": "
                    + StringUtils.arrayToDelimitedString(field.getValue().toArray(), ", "));
        }

        Integer actualMaxAgeInSeconds;

        String cacheControlHeader = httpURLConnection.getHeaderField("Cache-Control");
        if (cacheControlHeader == null) {
            actualMaxAgeInSeconds = null;
        } else {
            actualMaxAgeInSeconds = null;
            // System.out.println("Evaluate Cache-Control:" +
            // cacheControlHeader);
            StringTokenizer cacheControlTokenizer = new StringTokenizer(cacheControlHeader, ",");
            while (cacheControlTokenizer.hasMoreTokens() && actualMaxAgeInSeconds == null) {
                String cacheDirective = cacheControlTokenizer.nextToken();
                // System.out.println("\tEvaluate directive: " +
                // cacheDirective);
                StringTokenizer cacheDirectiveTokenizer = new StringTokenizer(cacheDirective, "=");
                // System.out.println("countTokens=" +
                // cacheDirectiveTokenizer.countTokens());
                if (cacheDirectiveTokenizer.countTokens() == 2) {
                    String key = cacheDirectiveTokenizer.nextToken().trim();
                    String value = cacheDirectiveTokenizer.nextToken().trim();
                    if (key.equalsIgnoreCase("max-age")) {
                        actualMaxAgeInSeconds = Integer.parseInt(value);
                    }
                }
            }
        }

        if (expectedMaxAgeInSeconds == null) {
            Assert.assertNull("actualMaxAgeInSeconds '" + actualMaxAgeInSeconds + "' should be null",
                    actualMaxAgeInSeconds);
            return;
        }

        Assert.assertNotNull(actualMaxAgeInSeconds);

        int deltaInSeconds = Math.abs(actualMaxAgeInSeconds - expectedMaxAgeInSeconds);
        Assert.assertTrue("actualMaxAgeInSeconds: " + actualMaxAgeInSeconds + ", expectedMaxAgeInSeconds: "
                + expectedMaxAgeInSeconds + ", request time: " + timeBeforeInMillis + " for content type "
                + httpURLConnection.getContentType(), deltaInSeconds < 2000);

    } finally {
        server.stop();
    }
}

From source file:fr.xebia.servlet.filter.XForwardedFilterTest.java

@Test
public void testInvokeAllProxiesAreTrustedAndRemoteAddrMatchRegexp() throws Exception {

    // PREPARE//from  ww  w.  j  a  v a  2s .  c o  m
    XForwardedFilter xforwardedFilter = new XForwardedFilter();
    MockFilterConfig filterConfig = new MockFilterConfig();
    filterConfig.addInitParameter(XForwardedFilter.INTERNAL_PROXIES_PARAMETER,
            "127\\.0\\.0\\.1, 192\\.168\\..*, another-internal-proxy");
    filterConfig.addInitParameter(XForwardedFilter.TRUSTED_PROXIES_PARAMETER, "proxy1, proxy2, proxy3");
    filterConfig.addInitParameter(XForwardedFilter.REMOTE_IP_HEADER_PARAMETER, "x-forwarded-for");
    filterConfig.addInitParameter(XForwardedFilter.PROXIES_HEADER_PARAMETER, "x-forwarded-by");

    xforwardedFilter.init(filterConfig);
    MockFilterChain filterChain = new MockFilterChain();
    MockHttpServletRequest request = new MockHttpServletRequest();

    request.setRemoteAddr("192.168.0.10");
    request.setRemoteHost("remote-host-original-value");
    request.addHeader("x-forwarded-for", "140.211.11.130, proxy1, proxy2");

    // TEST
    xforwardedFilter.doFilter(request, new MockHttpServletResponse(), filterChain);

    // VERIFY
    String actualXForwardedFor = ((HttpServletRequest) filterChain.getRequest()).getHeader("x-forwarded-for");
    assertNull("all proxies are trusted, x-forwarded-for must be null", actualXForwardedFor);

    String actualXForwardedBy = ((HttpServletRequest) filterChain.getRequest()).getHeader("x-forwarded-by");
    assertEquals("all proxies are trusted, they must appear in x-forwarded-by", "proxy1, proxy2",
            actualXForwardedBy);

    String actualRemoteAddr = ((HttpServletRequest) filterChain.getRequest()).getRemoteAddr();
    assertEquals("remoteAddr", "140.211.11.130", actualRemoteAddr);

    String actualRemoteHost = ((HttpServletRequest) filterChain.getRequest()).getRemoteHost();
    assertEquals("remoteHost", "140.211.11.130", actualRemoteHost);
}

From source file:fr.xebia.servlet.filter.XForwardedFilterTest.java

@Test
public void testInvokeAllProxiesAreTrustedOrInternal() throws Exception {

    // PREPARE/*  w  ww .j  a  v a 2  s .c o m*/
    XForwardedFilter xforwardedFilter = new XForwardedFilter();
    MockFilterConfig filterConfig = new MockFilterConfig();
    filterConfig.addInitParameter(XForwardedFilter.INTERNAL_PROXIES_PARAMETER,
            "192\\.168\\.0\\.10, 192\\.168\\.0\\.11");
    filterConfig.addInitParameter(XForwardedFilter.TRUSTED_PROXIES_PARAMETER, "proxy1, proxy2, proxy3");
    filterConfig.addInitParameter(XForwardedFilter.REMOTE_IP_HEADER_PARAMETER, "x-forwarded-for");
    filterConfig.addInitParameter(XForwardedFilter.PROXIES_HEADER_PARAMETER, "x-forwarded-by");

    xforwardedFilter.init(filterConfig);
    MockFilterChain filterChain = new MockFilterChain();
    MockHttpServletRequest request = new MockHttpServletRequest();

    request.setRemoteAddr("192.168.0.10");
    request.setRemoteHost("remote-host-original-value");
    request.addHeader("x-forwarded-for", "140.211.11.130, proxy1, proxy2, 192.168.0.10, 192.168.0.11");

    // TEST
    xforwardedFilter.doFilter(request, new MockHttpServletResponse(), filterChain);

    // VERIFY
    String actualXForwardedFor = ((HttpServletRequest) filterChain.getRequest()).getHeader("x-forwarded-for");
    assertNull("all proxies are trusted, x-forwarded-for must be null", actualXForwardedFor);

    String actualXForwardedBy = ((HttpServletRequest) filterChain.getRequest()).getHeader("x-forwarded-by");
    assertEquals("all proxies are trusted, they must appear in x-forwarded-by", "proxy1, proxy2",
            actualXForwardedBy);

    String actualRemoteAddr = ((HttpServletRequest) filterChain.getRequest()).getRemoteAddr();
    assertEquals("remoteAddr", "140.211.11.130", actualRemoteAddr);

    String actualRemoteHost = ((HttpServletRequest) filterChain.getRequest()).getRemoteHost();
    assertEquals("remoteHost", "140.211.11.130", actualRemoteHost);
}

From source file:fr.xebia.servlet.filter.XForwardedFilterTest.java

@Test
public void testInvokeNotAllowedRemoteAddr() throws Exception {
    // PREPARE//from w  ww  . ja  v a 2s .  c om
    XForwardedFilter xforwardedFilter = new XForwardedFilter();
    MockFilterConfig filterConfig = new MockFilterConfig();
    filterConfig.addInitParameter(XForwardedFilter.INTERNAL_PROXIES_PARAMETER,
            "192\\.168\\.0\\.10, 192\\.168\\.0\\.11");
    filterConfig.addInitParameter(XForwardedFilter.TRUSTED_PROXIES_PARAMETER, "proxy1, proxy2, proxy3");
    filterConfig.addInitParameter(XForwardedFilter.REMOTE_IP_HEADER_PARAMETER, "x-forwarded-for");
    filterConfig.addInitParameter(XForwardedFilter.PROXIES_HEADER_PARAMETER, "x-forwarded-by");

    xforwardedFilter.init(filterConfig);
    MockFilterChain filterChain = new MockFilterChain();
    MockHttpServletRequest request = new MockHttpServletRequest();

    request.setRemoteAddr("not-allowed-internal-proxy");
    request.setRemoteHost("not-allowed-internal-proxy-host");
    request.addHeader("x-forwarded-for", "140.211.11.130, proxy1, proxy2");

    // TEST
    xforwardedFilter.doFilter(request, new MockHttpServletResponse(), filterChain);

    // VERIFY
    String actualXForwardedFor = ((HttpServletRequest) filterChain.getRequest()).getHeader("x-forwarded-for");
    assertEquals("x-forwarded-for must be unchanged", "140.211.11.130, proxy1, proxy2", actualXForwardedFor);

    String actualXForwardedBy = ((HttpServletRequest) filterChain.getRequest()).getHeader("x-forwarded-by");
    assertNull("x-forwarded-by must be null", actualXForwardedBy);

    String actualRemoteAddr = ((HttpServletRequest) filterChain.getRequest()).getRemoteAddr();
    assertEquals("remoteAddr", "not-allowed-internal-proxy", actualRemoteAddr);

    String actualRemoteHost = ((HttpServletRequest) filterChain.getRequest()).getRemoteHost();
    assertEquals("remoteHost", "not-allowed-internal-proxy-host", actualRemoteHost);
}

From source file:fr.xebia.servlet.filter.XForwardedFilterTest.java

@Test
public void testInvokeUntrustedProxyInTheChain() throws Exception {
    // PREPARE//w  ww .  ja  v a  2s  .  com
    XForwardedFilter xforwardedFilter = new XForwardedFilter();
    MockFilterConfig filterConfig = new MockFilterConfig();
    filterConfig.addInitParameter(XForwardedFilter.INTERNAL_PROXIES_PARAMETER,
            "192\\.168\\.0\\.10, 192\\.168\\.0\\.11");
    filterConfig.addInitParameter(XForwardedFilter.TRUSTED_PROXIES_PARAMETER, "proxy1, proxy2, proxy3");
    filterConfig.addInitParameter(XForwardedFilter.REMOTE_IP_HEADER_PARAMETER, "x-forwarded-for");
    filterConfig.addInitParameter(XForwardedFilter.PROXIES_HEADER_PARAMETER, "x-forwarded-by");

    xforwardedFilter.init(filterConfig);
    MockFilterChain filterChain = new MockFilterChain();
    MockHttpServletRequest request = new MockHttpServletRequest();

    request.setRemoteAddr("192.168.0.10");
    request.setRemoteHost("remote-host-original-value");
    request.addHeader("x-forwarded-for", "140.211.11.130, proxy1, untrusted-proxy, proxy2");

    // TEST
    xforwardedFilter.doFilter(request, new MockHttpServletResponse(), filterChain);

    // VERIFY
    String actualXForwardedFor = ((HttpServletRequest) filterChain.getRequest()).getHeader("x-forwarded-for");
    assertEquals("ip/host before untrusted-proxy must appear in x-forwarded-for", "140.211.11.130, proxy1",
            actualXForwardedFor);

    String actualXForwardedBy = ((HttpServletRequest) filterChain.getRequest()).getHeader("x-forwarded-by");
    assertEquals("ip/host after untrusted-proxy must appear in  x-forwarded-by", "proxy2", actualXForwardedBy);

    String actualRemoteAddr = ((HttpServletRequest) filterChain.getRequest()).getRemoteAddr();
    assertEquals("remoteAddr", "untrusted-proxy", actualRemoteAddr);

    String actualRemoteHost = ((HttpServletRequest) filterChain.getRequest()).getRemoteHost();
    assertEquals("remoteHost", "untrusted-proxy", actualRemoteHost);
}

From source file:fr.xebia.servlet.filter.XForwardedFilterTest.java

/**
 * Test {@link XForwardedFilter} in Jetty
 *///w  ww.ja v a 2  s .co  m
@Test
public void testWithJetty() throws Exception {

    // SETUP
    int port = 6666;
    Server server = new Server(port);
    Context context = new Context(server, "/", Context.SESSIONS);

    // mostly default configuration : enable "x-forwarded-proto"
    XForwardedFilter xforwardedFilter = new XForwardedFilter();
    MockFilterConfig filterConfig = new MockFilterConfig();
    filterConfig.addInitParameter(XForwardedFilter.PROTOCOL_HEADER_PARAMETER, "x-forwarded-proto");
    // Following is needed on ipv6 stacks..
    filterConfig.addInitParameter(XForwardedFilter.INTERNAL_PROXIES_PARAMETER,
            InetAddress.getByName("localhost").getHostAddress());
    xforwardedFilter.init(filterConfig);
    context.addFilter(new FilterHolder(xforwardedFilter), "/*", Handler.REQUEST);

    MockHttpServlet mockServlet = new MockHttpServlet();
    context.addServlet(new ServletHolder(mockServlet), "/test");

    server.start();
    try {
        // TEST
        HttpURLConnection httpURLConnection = (HttpURLConnection) new URL("http://localhost:" + port + "/test")
                .openConnection();
        String expectedRemoteAddr = "my-remote-addr";
        httpURLConnection.addRequestProperty("x-forwarded-for", expectedRemoteAddr);
        httpURLConnection.addRequestProperty("x-forwarded-proto", "https");

        // VALIDATE

        Assert.assertEquals(HttpURLConnection.HTTP_OK, httpURLConnection.getResponseCode());
        HttpServletRequest request = mockServlet.getRequest();
        Assert.assertNotNull(request);

        // VALIDATE X-FOWARDED-FOR
        Assert.assertEquals(expectedRemoteAddr, request.getRemoteAddr());
        Assert.assertEquals(expectedRemoteAddr, request.getRemoteHost());

        // VALIDATE X-FORWARDED-PROTO
        Assert.assertTrue(request.isSecure());
        Assert.assertEquals("https", request.getScheme());
        Assert.assertEquals(443, request.getServerPort());
    } finally {
        server.stop();
    }
}

From source file:fr.xebia.servlet.filter.XForwardedFilterTest.java

private void test302RedirectWithJetty(final String sendRedirectLocation, String expectedLocation,
        int httpsServerPortParameter) throws Exception {
    // SETUP/*  w  w  w.  j  a  va 2 s.  c o  m*/
    int port = 6666;
    Server server = new Server(port);
    Context context = new Context(server, "/", Context.SESSIONS);

    // mostly default configuration : enable "x-forwarded-proto"
    XForwardedFilter xforwardedFilter = new XForwardedFilter();
    MockFilterConfig filterConfig = new MockFilterConfig();
    filterConfig.addInitParameter(XForwardedFilter.PROTOCOL_HEADER_PARAMETER, "x-forwarded-proto");
    filterConfig.addInitParameter(XForwardedFilter.HTTPS_SERVER_PORT_PARAMETER,
            String.valueOf(httpsServerPortParameter));
    // Following is needed on ipv6 stacks..
    filterConfig.addInitParameter(XForwardedFilter.INTERNAL_PROXIES_PARAMETER,
            InetAddress.getByName("localhost").getHostAddress());
    xforwardedFilter.init(filterConfig);
    context.addFilter(new FilterHolder(xforwardedFilter), "/*", Handler.REQUEST);

    HttpServlet mockServlet = new HttpServlet() {

        private static final long serialVersionUID = 1L;

        @Override
        public void service(HttpServletRequest request, HttpServletResponse response)
                throws ServletException, IOException {
            response.sendRedirect(sendRedirectLocation);
        }

    };
    context.addServlet(new ServletHolder(mockServlet), "/test");

    server.start();
    try {
        // TEST
        HttpURLConnection httpURLConnection = (HttpURLConnection) new URL("http://localhost:" + port + "/test")
                .openConnection();
        httpURLConnection.setInstanceFollowRedirects(false);
        String expectedRemoteAddr = "my-remote-addr";
        httpURLConnection.addRequestProperty("x-forwarded-for", expectedRemoteAddr);
        httpURLConnection.addRequestProperty("x-forwarded-proto", "https");

        // VALIDATE
        Assert.assertEquals(HttpURLConnection.HTTP_MOVED_TEMP, httpURLConnection.getResponseCode());
        String actualLocation = httpURLConnection.getHeaderField("Location");
        assertEquals(expectedLocation, actualLocation);

    } finally {
        server.stop();
    }
}