conditiontest.java

jsp中 urlRewrite的源代码 很有用的喔

    public void testConditionCharacterEncoding() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("character-encoding");
        condition.setValue("utfcrazybig[0-9]+");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setCharacterEncoding("utfcrazybig13");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testConditionContentLength() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        request.setContentLength(120);
        Condition condition = new Condition();
        condition.setType("content-length");
        condition.setValue("100");
        condition.setOperator("greater");
        condition.initialise();
        assertTrue("condition must match", condition.matches(request));

        request.setContentLength(10);
        assertFalse("condition must not match", condition.matches(request));
    }

    public void testContentType() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        request.setContentType("bottlesandcans");
        Condition condition = new Condition();
        condition.setType("content-type");
        condition.setValue("bott[a-z]+");
        condition.initialise();
        assertTrue("condition must match", condition.matches(request));

        request.setContentType(null);
        assertFalse("condition must not match", condition.matches(request));
    }

    public void testContextPath() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        request.setContextPath("blah");
        Condition condition = new Condition();
        condition.setType("context-path");
        condition.setValue("[a-b]lah");
        condition.initialise();
        assertTrue("condition must match", condition.matches(request));

        request.setContextPath("qlah");
        assertFalse("condition must not match", condition.matches(request));
    }

    public void testCookie() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("cookie");
        condition.setName("tracker");
        condition.setValue(".*bass.*");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.addCookie(new Cookie("otherokie", "allyourbassisbelongtous"));
        assertFalse("condition must not match", condition.matches(request));

        request.addCookie(new Cookie("tracker", "allyourbassisbelongtous"));
        assertTrue("condition must match", condition.matches(request));
    }

    public void testLocalPort() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        request.setLocalPort(4);
        Condition condition = new Condition();
        condition.setType("local-port");
        condition.setValue("1004");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setLocalPort(1004);
        assertTrue("condition must match", condition.matches(request));
    }

    public void testParameter() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("parameter");
        condition.setName("reqparam");
        condition.setValue("[0-9]+");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.addParameter("reqparam", "1000245");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testPathInfo() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("path-info");
        condition.setValue("afr[aeiou]ca");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setPathInfo("africa");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testPathTranslated() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("path-translated");
        condition.setValue("/!@&");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setPathTranslated("/!@&");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testProtocol() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("protocol");
        condition.setValue("HTTP/1\\.[1-2]");
        condition.initialise();
        request.setProtocol("HTTP/2.0");
        assertFalse("condition must not match", condition.matches(request));

        request.setProtocol("HTTP/1.2");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testQueryString() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("query-string");
        condition.setValue(".*&param=[0-9]+.*");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setQueryString("?aaa=dsdsd&param=2333&asdsa=sdds");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testRemoteAddr() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("remote-addr");
        condition.setValue("192.168.[0-9]+.[0-9]+");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setRemoteAddr("192.168.184.23");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testRemoteHost() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("remote-host");
        condition.setValue("\\w+\\.tuckey.org");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setRemoteHost("toaster.tuckey.org");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testRemoteUser() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("remote-user");
        condition.setValue("p.\\w+");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setRemoteUser("p.smith");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testRequestedSessionId() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("requested-session-id");
        condition.setValue("\\w+\\.sec[0-6]+");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setRequestedSessionId("sdfjsdfhkjhk897fd.sec03");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testRequestUri() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("request-uri");
        condition.setValue("\\d");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setRequestURI("2");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testRequestUrl() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("request-url");
        condition.setValue("\\d");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setRequestURL("2");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testSessionAttribute() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("session-attribute");
        condition.setValue("someval");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        Condition condition2 = new Condition();
        condition2.setType("session-attribute");
        condition2.setName("someatt");
        condition2.setValue("someval");
        condition2.initialise();
        assertFalse("condition must not match", condition2.matches(request));

        request.getSession(true).setAttribute("someatt", "someval");

        Condition condition3 = new Condition();
        condition3.setType("session-attribute");
        condition3.setName("someatt");
        condition3.setValue("someval");
        condition3.initialise();
        assertTrue("condition must match", condition3.matches(request));
    }

    public void testSessionIsNew() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("session-isnew");
        condition.setValue("yes");
        condition.setOperator("notequal");
        condition.initialise();
        assertTrue("condition must match", condition.matches(request));

        request.setSessionNew(true);
        assertFalse("condition must not match", condition.matches(request));
    }

    public void testServerName() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("server-name");
        condition.setValue("dev.*");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setServerName("dev.googil.com");
        assertTrue("condition must match", condition.matches(request));
    }

    public void testScheme() throws UnsupportedEncodingException {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setType("scheme");
        condition.setValue("http");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setScheme("http");
        assertTrue("condition must match", condition.matches(request));
    }


    public void testConditionHeader() {
        MockRequest request = new MockRequest();
        Condition condition = new Condition();
        condition.setName("some header");
        condition.setValue("tester");
        condition.initialise();
        assertFalse("condition must not match", condition.matches(request));

        request.setHeader("some header", "tester");
        assertTrue("condition must match", condition.matches(request));

        Condition condition2 = new Condition();
        condition2.setName("  ");
        condition2.setValue("tester");
        assertFalse("condition must not initialise", condition2.initialise());
        assertFalse("condition must not match", condition2.matches(request));

        Condition condition3 = new Condition();
        condition3.setName("bonus");
        assertTrue("condition must initialise and check for exists", condition3.initialise());
        assertFalse("condition must not match", condition3.matches(request));
        request.setHeader("bonus", "tester");
        assertTrue("condition must match", condition3.matches(request));

        Condition condition4 = new Condition();
        condition4.setName("portashed");
        condition4.setOperator("notequal");

        assertTrue("condition must initialise and check for exists", condition4.initialise());
        assertTrue("condition must match", condition4.matches(request));
        request.setHeader("portashed", "tester");
        assertFalse("condition must not match", condition4.matches(request));

    }

    public void testConditionMethod() {
        MockRequest request = new MockRequest();
        request.setMethod("HEAD");
        Condition condition = new Condition();
        condition.setType("method");
        condition.setValue("H[A-Z]AD");
        condition.initialise();
        assertTrue("condition must match", condition.matches(request));
    }


    public void testConditionIsUserInRole() {
        MockRequest request = new MockRequest();
        request.addRole("devil");
        Condition condition = new Condition();
        condition.setType("user-in-role");
        condition.setName("devil");
        condition.initialise();
        assertTrue("user should be in this role", condition.matches(request));

        Condition condition2 = new Condition();
        condition2.setType("user-in-role");
        condition2.setName("angel");
        condition2.initialise();
        assertFalse("bad user in role must not match", condition2.matches(request));

        Condition condition3 = new Condition();
        condition3.setType("user-in-role");
        condition3.setValue("devil");
        condition3.initialise();
        assertTrue("value instead of name should match", condition3.matches(request));

        Condition condition4 = new Condition();
        condition4.setType("user-in-role");
        condition4.setValue("admin");
        condition4.setOperator("notequal");
        condition4.initialise();
        assertTrue("value instead of name should match", condition4.matches(request));
    }

    public void testConditionPort() {
        MockRequest request = new MockRequest();
        request.setServerPort(9001);
        Condition condition = new Condition();
        condition.setType("port");
        condition.setValue("9001");
        condition.initialise();
        assertTrue("condition must match", condition.matches(request));

        Condition condition2 = new Condition();
        condition2.setType("port");
        condition2.setValue(" 9001");
        condition2.initialise();
        assertTrue("condition must match", condition2.matches(request));
        // check re-init
        condition2.initialise();
        assertTrue("condition must match", condition2.matches(request));

        Condition condition3 = new Condition();
        condition3.setType("port");
        condition3.setValue("aaa");
        condition3.initialise();
        assertFalse("condition must not match", condition3.matches(request));
    }


}