ruletest.java

UrlRewriteFilter 是一个不错的URL转换工具

        Condition condition2 = new Condition();
        condition2.setType("user-in-role");
        condition2.setValue("boss");
        condition2.setOperator("notequal");
        rule.addCondition(condition2);
        rule.initialise(null);

        MockRequest request = new MockRequest("from");
        RewrittenUrl rewrittenUrl = rule.matches(request.getRequestURI(), request, response);
        assertEquals("should be rewritten", "to", rewrittenUrl.getTarget());

        request.addRole("boss");
        RewrittenUrl rewrittenUrl2 = rule.matches(request.getRequestURI(), request, response);
        assertNull("should not be rewritten", rewrittenUrl2);
    }

    /**
     * <rule>
     * <name>Bild redirect test</name>
     * <from>logo.gif</from>
     * <to type="permanent-redirect">http://de010009.de.ina.com:8080/urlrewrite/artifact_type.gif</to>
     * </rule>
     */
    public void testBlindRedirect() throws IOException, ServletException, InvocationTargetException {
        NormalRule rule = new NormalRule();
        rule.setFrom("^/logo\\.gif$");
        rule.setToType("permanent-redirect");
        rule.setTo("http://de010009\\.de\\.ina\\.com:8080/urlrewrite/artifact_type\\.gif");
        rule.initialise(null);
        MockRequest request = new MockRequest("/logo.gif");
        NormalRewrittenUrl rewrittenUrl = (NormalRewrittenUrl) rule.matches(request.getRequestURI(), request, response);
        assertEquals("http://de010009.de.ina.com:8080/urlrewrite/artifact_type.gif", rewrittenUrl.getTarget());
        assertTrue(rewrittenUrl.isPermanentRedirect());
        assertFalse(rewrittenUrl.isEncode());
    }


    public void testRuleHighChar() throws IOException, ServletException, InvocationTargetException {
        NormalRule rule = new NormalRule();
        rule.setFrom("/aa\\?a=(.*)");
        rule.setEncodeToUrl(true);
        rule.setTo("$1");
        rule.setToType("permanent-redirect");
        rule.initialise(null);
        String highStr = new String("\u00F6\u236a\u2E88".getBytes(), "UTF8");
        MockRequest request = new MockRequest("/aa?a=" + highStr);
        RewrittenUrl rewrittenUrl = rule.matches(request.getRequestURI(), request, response);
        assertEquals(highStr, rewrittenUrl.getTarget());
    }

    /**
     * <rule>
     * <condition type="cookie" name="SAJKLHDSKJHDSKJHD" />
     * <from>/a\.jsp</from>
     * <to>/b.jsp</to>
     * </rule>
     * <p/>
     * (Which I think it means: "if the user asks for a.jsp and the cookie
     * SAJKLHDSKJHDSKJHD is not set, redirect him to b.jsp") the rule stops
     * working. Maybe it's because the cookie is null instead of an empty
     * string, I don't know.
     */
    public void testRuleCookieEmpty() throws IOException, ServletException, InvocationTargetException {
        Condition c = new Condition();
        c.setType("cookie");
        c.setName("abcdef");
        NormalRule rule = new NormalRule();
        rule.setFrom("/a\\.jsp");
        rule.setTo("/b.jsp");
        rule.addCondition(c);
        rule.initialise(null);
        RewrittenUrl rewrittenUrl = rule.matches("/a.jsp", request, response);
        assertTrue(request.getCookies() == null);
        assertTrue(rewrittenUrl == null);

        c = new Condition();
        c.setType("cookie");
        c.setName("abcdef");
        c.setOperator("notequal");
        rule = new NormalRule();
        rule.setFrom("/a\\.jsp");
        rule.setTo("/b.jsp");
        rule.addCondition(c);
        rule.initialise(null);
        rewrittenUrl = rule.matches("/a.jsp", request, response);
        assertTrue(request.getCookies() == null);
        assertEquals("/b.jsp", rewrittenUrl.getTarget());

    }

    public void testRuleWildcard1() throws IOException, ServletException, InvocationTargetException {
        wildcardRuleTestHelper("/*/", "/b/", "/a12sfg-+\\?#/", "/b/");
        wildcardRuleTestHelper("/*/*/", "/b/c/", "/z23434/-+=asd/", "/b/c/");
        wildcardRuleTestHelper("/*/*/", "/to/", "/a/b/c/", "/a/b/c/");
        wildcardRuleTestHelper("/**/", "/to/", "/a/b/c", "/a/b/c");
        wildcardRuleTestHelper("/**/", "/to/", "/a/b/c/", "/to/");
        wildcardRuleTestHelper("**.html", "/to/", "/a/b/c/sldwe.html", "/to/");
        wildcardRuleTestHelper("*.html", "/to/", "/a/b/c/sldwe.html", "/a/b/c/sldwe.html");
        wildcardRuleTestHelper("/a/b/c/*.html", "/to/", "/a/b/c/sldwe.html", "/to/");
    }


    public void testRuleWildcard2() throws IOException, ServletException, InvocationTargetException {
        wildcardRuleTestHelper("/*.h", "/$1", "/a.h", "/a");
        wildcardRuleTestHelper("/**", "/d/$1", "/a/b/c", "/d/a/b/c");
        // test same with conds
        wildcardRuleTestHelper("/*/a/*/aa", "/a/$2$1", "/w/a/c/aa", "/a/cw");
    }


    public void testRuleWildcardCond() throws IOException, ServletException, InvocationTargetException {
        MockRequest request = new MockRequest("/from");

        request.setServerName("dev.googil.com");
        ruleWildcardCondHelper("server-name", "dev*", request);

        request.setContentType("image/jpeg");
        ruleWildcardCondHelper("content-type", "image/*", request);

        request.setContextPath("/a/b/c");
        ruleWildcardCondHelper("context-path", "/a/**", request);

    }


    public void ruleWildcardCondHelper(String type, String value, MockRequest request) throws IOException, ServletException, InvocationTargetException {
        Condition condition = new Condition();
        condition.setType(type);
        condition.setValue(value);

        NormalRule rule = new NormalRule();
        rule.setFrom("/from");
        rule.setMatchType(" wildcard    ");
        rule.setTo("/to");
        rule.addCondition(condition);
        rule.initialise(null);

        RewrittenUrl rewrittenUrl = rule.matches(request.getRequestURI(), request, response);
        assertEquals("/to", rewrittenUrl == null ? "/from" : rewrittenUrl.getTarget());

    }

    public void wildcardRuleTestHelper(String from, String to, String req, String assertEq)
            throws IOException, ServletException, InvocationTargetException {
        NormalRule rule = new NormalRule();
        rule.setFrom(from);
        rule.setMatchType(" wildcard    ");
        rule.setTo(to);
        rule.initialise(null);
        MockRequest request = new MockRequest(req);
        RewrittenUrl rewrittenUrl = rule.matches(request.getRequestURI(), request, response);
        assertEquals(assertEq, rewrittenUrl == null ? req : rewrittenUrl.getTarget());
    }

    public void wildcardRuleTestHelperCond(String from, String to, List conditions, String req, String assertEq)
            throws IOException, ServletException, InvocationTargetException {
        NormalRule rule = new NormalRule();
        rule.setFrom(from);
        rule.setMatchType(" wildcard    ");
        rule.setTo(to);
        if (conditions != null) {
            for (int i = 0; i < conditions.size(); i++) {
                Condition c = (Condition) conditions.get(i);
                rule.addCondition(c);
            }
        }
        rule.initialise(null);
        MockRequest request = new MockRequest(req);
        RewrittenUrl rewrittenUrl = rule.matches(request.getRequestURI(), request, response);
        assertEquals(assertEq, rewrittenUrl == null ? req : rewrittenUrl.getTarget());
    }


    public void testRuleNoFrom() throws IOException, ServletException, InvocationTargetException {
        NormalRule rule = new NormalRule();
        rule.setTo("to");
        Condition condition = new Condition();
        condition.setType("port");
        condition.setValue("90");
        rule.addCondition(condition);
        rule.initialise(null);
        MockRequest request = new MockRequest("from");
        request.setServerPort(88);
        RewrittenUrl rewrittenUrl = rule.matches(request.getRequestURI(), request, response);
        assertNull("should not be rewritten", rewrittenUrl);

        request.setServerPort(90);
        RewrittenUrl rewrittenUrl2 = rule.matches(request.getRequestURI(), request, response);
        assertNotNull("should be rewritten", rewrittenUrl2);
    }

    public void testConditionAndSet() throws IOException, ServletException, InvocationTargetException {
        Condition condition = new Condition();
        condition.setType("header");
        condition.setName("user-agent");
        condition.setValue("iexplore");

        SetAttribute s = new SetAttribute();
        s.setType("request");
        s.setName("browser");
        s.setValue("ie");

        NormalRule rule = new NormalRule();
        rule.addCondition(condition);
        rule.addSetAttribute(s);
        rule.initialise(null);

        MockRequest request = new MockRequest("from");
        request.setHeader("user-agent", "firefox");
        RewrittenUrl rewrittenUrl = rule.matches(request.getRequestURI(), request, response);
        assertNull("should not be rewritten", rewrittenUrl);
        assertNull(request.getAttribute("browser"));

        request.setHeader("user-agent", "iexplore");
        RewrittenUrl rewrittenUrl2 = rule.matches(request.getRequestURI(), request, response);
        assertNull("should not be rewritten", rewrittenUrl2);
        assertEquals("ie", request.getAttribute("browser"));
    }

    public void testForum20080613() throws InvocationTargetException, IOException, ServletException {
        NormalRule rule = new NormalRule();
        rule.setFrom("^/[^/]+/(.+)-S_[0-9]+\\.html$");
        rule.setTo("/liste/query/${replace:$1:-:+}/");
        rule.initialise(null);
        MockRequest request = new MockRequest("/ab/as-as-S_12.html");
        NormalRewrittenUrl rewrittenUrl = (NormalRewrittenUrl) rule.matches(request.getRequestURI(), request, response);

        assertEquals("forward should be default type", "forward", rule.getToType());
        assertEquals("/liste/query/as+as/", rewrittenUrl.getTarget());
        assertTrue("Should be a forward", rewrittenUrl.isForward());
    }


    public void testContext() throws InvocationTargetException, IOException, ServletException {
        NormalRule rule = new NormalRule();
        rule.setFrom("^/goanothercontext/");
        rule.setTo("/other/");
        rule.setToContextStr("othercontext");
        rule.initialise(new MockServletContext());
        MockRequest request = new MockRequest("/goanothercontext/aaa.html");
        NormalRewrittenUrl rewrittenUrl = (NormalRewrittenUrl) rule.matches(request.getRequestURI(), request, response);

        assertEquals("forward should be default type", "forward", rule.getToType());
        assertEquals("/other/aaa.html", rewrittenUrl.getTarget());
        assertNotNull("Should be not empty", rewrittenUrl.getTargetContext());
    }



}