urlrewritertest.java

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

    public void testBadConf() throws IOException, ServletException, InvocationTargetException {
        Conf conf = new Conf();
        NormalRule rule1 = new NormalRule();
        conf.addRule(rule1);
        conf.initialise();
        UrlRewriter urlRewriter = new UrlRewriter(conf);
        MockRequest request = new MockRequest("/aaa");
        RewrittenUrl rewrittenRequest = urlRewriter.processRequest(request, response);
        assertNull(rewrittenRequest);
    }

    /**
     * Goal is to be able to process 2000 reqs a second for a simple rule set of 10000.
     * Performance is obviously very CPU dependant, so we establish a benchmark for the machine the
     * test is running on then base performance on that. This is a horribly rough way of determining
     * performance, but it is good enough for this simple test case. 
     */
    public void testLoadsOfRules() throws IOException, ServletException, InvocationTargetException {
        // turn off logging
        Log.setLevel("ERROR");

        // benchmark this machine to see what it can do...
        float bench = new BenchmarkRunner().establishBenchmark();
        float timePerRule = bench * (float) 0.0003; // ms per rule... 0.03% of the benchmark
        System.out.println("using " + timePerRule + "ms per rule as the standard");

        float testAmount = 10000; // number of times to run test

        // test with 1000 rules, more than anybody would normally have
        Conf conf = new Conf();
        for (int i = 0; i < 1000; i++) {
            NormalRule rule = new NormalRule();
            rule.setFrom("^/([a-z]+)/([0-9]+)/" + i + "/$");
            rule.setTo("/blah/a/$2/");
            conf.addRule(rule);
        }
        conf.initialise();
        UrlRewriter urlRewriter = new UrlRewriter(conf);

        MockRequest request = new MockRequest("/dir/999/45/");
        // warm up
        urlRewriter.processRequest(request, response);

        long timeStart = System.currentTimeMillis();
        for (float i = 0; i < testAmount; i++) {
            urlRewriter.processRequest(request, response);
            if (i % 500 == 0 && i > 0) {
                System.out.println("avg so far " + ((System.currentTimeMillis() - timeStart) / i) + "ms per rule");
            }
        }
        long took = System.currentTimeMillis() - timeStart;
        System.out.println("took " + took + "ms " + (took / testAmount) + "ms  per rule");
        assertTrue("should take less than " + timePerRule + "ms per rule", (took / testAmount) < timePerRule);
    }


    /**
     * Special test for rule application with no to element.
     */
    public void testNoToElement() throws IOException, ServletException, InvocationTargetException {
        NormalRule rule1 = new NormalRule();
        rule1.setFrom(".*");
        Condition condition1 = new Condition();
        condition1.setType("header");
        condition1.setName("accept");
        condition1.setValue(".*image/gif.*");
        SetAttribute setAttribute1 = new SetAttribute();
        setAttribute1.setName("imageType");
        setAttribute1.setValue("gif");
        rule1.addSetAttribute(setAttribute1);
        rule1.addCondition(condition1);
        rule1.initialise(null);

        NormalRule rule2 = new NormalRule();
        rule2.setFrom(".*");
        Condition condition2 = new Condition();
        condition2.setType("header");
        condition2.setName("accept");
        condition2.setValue(".*image/jpeg.*");
        SetAttribute setAttribute2 = new SetAttribute();
        setAttribute2.setName("imageType");
        setAttribute2.setValue("jpeg");
        rule2.addSetAttribute(setAttribute2);
        rule2.addCondition(condition2);
        rule2.initialise(null);

        NormalRule rule3 = new NormalRule();
        rule3.setFrom(".*");
        Condition condition3 = new Condition();
        condition3.setType("header");
        condition3.setName("accept");
        condition3.setValue(".*image/png.*");
        SetAttribute setAttribute3 = new SetAttribute();
        setAttribute3.setName("imageType");
        setAttribute3.setValue("png");
        rule3.addSetAttribute(setAttribute3);
        rule3.addCondition(condition3);
        rule3.initialise(null);

        NormalRule rule4 = new NormalRule();
        rule4.setFrom(".*");
        Condition condition4 = new Condition();
        condition4.setType("header");
        condition4.setName("user-agent");
        condition4.setValue("SonyEricssonT68.*");
        SetAttribute setAttribute4 = new SetAttribute();
        setAttribute4.setName("imageType");
        setAttribute4.setValue("png");
        rule4.addSetAttribute(setAttribute4);
        rule4.addCondition(condition4);
        rule4.initialise(null);

        Conf conf = new Conf();
        conf.addRule(rule1);
        conf.addRule(rule2);
        conf.addRule(rule3);
        conf.addRule(rule4);

        conf.initialise();
        UrlRewriter urlRewriter = new UrlRewriter(conf);

        MockRequest request = new MockRequest("/images/my.png");
        request.setHeader("accept", "image/png,*/*;q=0.5");

        RewrittenUrl rewrittenUrl1 = urlRewriter.processRequest(request, response);

        assertEquals("png", (String) request.getAttribute("imageType"));
        assertEquals(null, rewrittenUrl1);

    }



    public void testRuleDecode() throws IOException, ServletException, InvocationTargetException {
        Conf conf = new Conf();
        NormalRule rule = new NormalRule();
        rule.setFrom("^/test decode/(.+?)$");
        rule.setTo("/TestHandler$1");
        conf.addRule(rule);
        conf.setDecodeUsing("utf-8");
        conf.initialise();
        UrlRewriter urlRewriter = new UrlRewriter(conf);
        MockRequest request = new MockRequest("/test+decode/?string=black%26white+green");
        MockResponse response = new MockResponse();
        RewrittenUrl rewrittenUrl = urlRewriter.processRequest(request, response);
        assertEquals("forward should be default type", "forward", rule.getToType());
        assertEquals("/TestHandler?string=black&white green", rewrittenUrl.getTarget());
    }


    public void testRuleChain() throws IOException, ServletException, InvocationTargetException {
        Conf conf = new Conf(servletContext, null, null, null);

        Run run = new Run();
        run.setClassStr(TestRunObj.class.getName());
        run.setMethodStr("runWithChainParam( req, res, chain )");

        NormalRule rule = new NormalRule();
        rule.setFrom("^/$");
        rule.addRun(run);
        conf.addRule(rule);

        Run run2 = new Run();
        run2.setClassStr(TestRunObj.class.getName());
        run2.setMethodStr("runWithReturnedObj");

        NormalRule rule2 = new NormalRule();
        rule2.setFrom("^/$");
        rule2.setTo("null");
        rule2.addRun(run2);
        rule2.setToLast("true");
        conf.addRule(rule2);

        conf.initialise();

        assertTrue("conf should be initialised", conf.isOk());

        UrlRewriter urlRewriter = new UrlRewriter(conf);

        run.execute(request, response, null, chain );
        urlRewriter.processRequest(request, response);

        assertEquals("chain chould have been called once", 1, chain.getInvocationCount());
        assertEquals("forward should be default type", "forward", rule.getToType());
        long diff = TestRunObj.getRunWithChainParamAfterDoFilter() - MockRewriteMatch.getCalledTime();
        assertTrue("run2 should be invoked after chain " + diff, diff > 0 );
    }


	public void testNoSubstitutionLast() throws IOException, ServletException, InvocationTargetException {
		final NormalRule rule1 = new NormalRule();
		rule1.setFrom("noSub");
		rule1.setTo("-");
		rule1.setToLast("true");
		rule1.initialise(null);

		final NormalRule rule2 = new NormalRule();
		rule2.setFrom("noS");
		rule2.setTo("changed");
		rule2.initialise(null);

		final Conf conf = new Conf();
		conf.addRule(rule1);
		conf.addRule(rule2);

		conf.initialise();
		final UrlRewriter urlRewriter = new UrlRewriter(conf);

		final MockRequest request1 = new MockRequest("/path/noSub");
		final RewrittenUrl rewrittenUrl1 = urlRewriter.processRequest(request1, response);
		assertNotNull(rewrittenUrl1);
		assertEquals("/path/noSub", rewrittenUrl1.getTarget());

		final MockRequest request2 = new MockRequest("/path/noSu");
		final RewrittenUrl rewrittenUrl2 = urlRewriter.processRequest(request2, response);
		assertNotNull(rewrittenUrl2);
		assertEquals("/path/changedu", rewrittenUrl2.getTarget());
	}

}