testtagutils.java

structs源码

        try {
            url = tagutils.computeURLWithCharEncoding(pageContext, "foo", null,
                    null, null, null, null, null, false, true, true);
            fail("Exception not thrown");
        } catch (MalformedURLException e) {
            fail("MalformedURLException: " + e);
        } catch (UnsupportedOperationException e) {
            assertNull("url should be null", url);
        }
    }

    public void testComputeURLCharacterEncodingMultipleSpecifier() {
        verifyBadSetOfSpecifiers("foo", "foo", null, null);
        verifyBadSetOfSpecifiers("foo", null, "foo", null);
        verifyBadSetOfSpecifiers("foo", null, null, "foo");

        verifyBadSetOfSpecifiers(null, "foo", "foo", null);
        verifyBadSetOfSpecifiers(null, "foo", null, "foo");

        verifyBadSetOfSpecifiers(null, null, "foo", "foo");
    }

    public void testComputeURLCharacterEncodingAction() {
        ActionConfig actionConfig = new ActionConfig();

        actionConfig.setName("baz");
        actionConfig.setPath("/baz");

        moduleConfig.addActionConfig(actionConfig);

        request.setPathElements("/myapp", "/foo.do", null, null);

        Map map = new HashMap();

        map.put("foo1", "bar1");
        map.put("foo2", "bar2");

        String url = null;

        try {
            url = tagutils.computeURL(pageContext, null, null, null, "baz",
                    null, map, "anchor", false);
        } catch (MalformedURLException e) {
            fail("MalformedURLException: " + e);
        }

        assertNotNull("url present", url);
        assertTrue("url value",
            url.equals("/myapp/baz?foo1=bar1&foo2=bar2#anchor")
            || url.equals("/myapp/baz?foo2=bar2&foo1=bar1#anchor"));
    }

    // -------------------------------------------------------------- pageURL()
    // Default module (default pagePattern)
    public void testPageURL1() {
        request.setAttribute(Globals.MODULE_KEY, moduleConfig);
        request.setPathElements("/myapp", "/action.do", null, null);

        String page = null;
        String result = null;

        // Straight substitution
        page = "/mypages/index.jsp";
        result = tagutils.pageURL(request, page, moduleConfig);
        assertNotNull("straight sub found", result);
        assertEquals("straight sub value", "/mypages/index.jsp", result);
    }

    // Second module (default pagePattern)
    public void testPageURL2() {
        request.setAttribute(Globals.MODULE_KEY, moduleConfig2);
        request.setPathElements("/myapp", "/2/action.do", null, null);

        String page = null;
        String result = null;

        // Straight substitution
        page = "/mypages/index.jsp";
        result = tagutils.pageURL(request, page, moduleConfig2);
        assertNotNull("straight sub found", result);
        assertEquals("straight sub value", "/2/mypages/index.jsp", result);
    }

    // Third module (custom pagePattern)
    // TODO finish me
    public void testPageURL3a() {
        request.setAttribute(Globals.MODULE_KEY, moduleConfig3);
        request.setPathElements("/myapp", "/3/action.do", null, null);

        //        String page = null;
        //        String result = null;
    }

    // Third module (custom pagePattern)
    public void testPageURL3b() {
        request.setAttribute(Globals.MODULE_KEY, moduleConfig3);
        request.setPathElements("/myapp", "/3/action.do", null, null);

        String page = null;
        String result = null;

        // Straight substitution
        page = "/mypages/index.jsp";
        result = tagutils.pageURL(request, page, moduleConfig3);
        assertNotNull("straight sub found", result);
        assertEquals("straight sub value", "/3/mypages/index.jsp", result);
    }

    /**
     * Helper method that verifies the supplied specifiers.
     *
     * @param forward    The forward specified
     * @param href       The href specified
     * @param pageString The pageString specified
     * @param action     The action specified
     */
    private void verifyBadSetOfSpecifiers(String forward, String href,
        String pageString, String action) {
        String url = null;

        try {
            url = tagutils.computeURLWithCharEncoding(pageContext, forward,
                    href, pageString, action, null, null, null, false, true,
                    false);
        } catch (MalformedURLException e) {
            assertNull("url should be null", url);
        } catch (UnsupportedOperationException e) {
            fail("MalformedURLException not thrown");
        }
    }

    // -------------------------------------------------------------- encodeURL()
    // Default module (default pagePattern)
    public void testencodeURL1() {
        String encodedURL = null;

        encodedURL = tagutils.encodeURL("foo-bar.baz");
        assertEquals("encode url", "foo-bar.baz", encodedURL);
    }

    // ------------------------------------------ getActionErrors()
    // ActionErrors
    public void testGetActionErrors1a() {
        ActionMessages actionErrors = new ActionMessages();

        actionErrors.add("prop", new ActionMessage("key.key"));
        request.setAttribute("errors", actionErrors);

        try {
            ActionMessages errors =
                tagutils.getActionMessages(pageContext, "errors");

            assertNotNull("errors should not be null", errors);
            assertNotNull("errors prop should not be null", errors.get("prop"));

            String val = null;
            int i = 0;

            for (Iterator iter = errors.get("prop"); iter.hasNext();) {
                ActionMessage error = (ActionMessage) iter.next();

                val = error.getKey();
                i++;
            }

            assertEquals("only 1 error", i, 1);
            assertEquals("errors prop should match", val, "key.key");
        } catch (JspException e) {
            fail(e.getMessage());
        }
    }

    // String
    public void testGetActionErrors1b() {
        request.setAttribute("foo", "bar");

        try {
            ActionMessages errors =
                tagutils.getActionMessages(pageContext, "foo");

            assertNotNull("errors should not be null", errors);
            assertNotNull("errors prop should not be null", errors.get("prop"));

            String key = null;
            int i = 0;

            for (Iterator iter = errors.get(ActionMessages.GLOBAL_MESSAGE);
                iter.hasNext();) {
                ActionMessage error = (ActionMessage) iter.next();

                key = error.getKey();

                Object[] values = error.getValues();

                assertNull(values);
                i++;
            }

            assertEquals("only 1 error", i, 1);
            assertEquals("key should match", key, "bar");
        } catch (JspException e) {
            fail(e.getMessage());
        }
    }

    // String Array
    public void testGetActionErrors1c() {
        String[] vals = new String[] { "bar", "baz" };

        request.setAttribute("foo", vals);

        try {
            ActionMessages errors =
                tagutils.getActionMessages(pageContext, "foo");

            assertNotNull("errors should not be null", errors);
            assertNotNull("errors prop should not be null", errors.get("prop"));

            String key = null;
            int i = 0;

            for (Iterator iter = errors.get(ActionMessages.GLOBAL_MESSAGE);
                iter.hasNext();) {
                ActionMessage error = (ActionMessage) iter.next();

                key = error.getKey();

                Object[] values = error.getValues();

                assertNull((values));
                assertEquals("1st key should match", key, vals[i]);
                i++;
            }

            assertEquals("only 1 error", i, 2);
        } catch (JspException e) {
            fail(e.getMessage());
        }
    }

    // String Array (thrown JspException)
    public void testGetActionErrors1d() {
        request.setAttribute("foo", new MockFormBean());

        ActionMessages errors = null;

        try {
            errors = tagutils.getActionMessages(pageContext, "foo");
            fail("should have thrown JspException");
        } catch (JspException e) {
            assertNull("errors should be null", errors);
        }
    }

    // ActionErrors (thrown Exception)
    // TODO -- currently this does not hit the line for caught Exception
    public void testGetActionErrors1e() {
        ActionMessages actionErrors = new ActionMessages();

        actionErrors.add("prop", new ActionMessage("key.key"));
        request.setAttribute("errors", actionErrors);

        try {
            ActionMessages errors =
                tagutils.getActionMessages(pageContext, "does-not-exist");

            assertNotNull("errors should not be null", errors);
            assertNotNull("errors prop should not be null", errors.get("prop"));

            for (Iterator iter = errors.get("prop"); iter.hasNext();) {
                fail("Should not have any errors for does-not-exist");
            }
        } catch (JspException e) {
            fail(e.getMessage());
        }
    }

    // ------------------------------------------ getActionMappingName()
    public void testGetActionMappingName1() {
        String[] paths =
            {
                "foo", "foo.do", "foo?foo=bar", "foo?foo=bar&bar=baz",
                "foo?foo=bar&bar=baz"
            };

        String[][] prepends =
            {
                { "", "/foo" },
                { "/", "/foo" },
                { "bar/", "/bar/foo" },
                { "/bar/", "/bar/foo" }
            };

        String[] appends =
            {
                "", "#anchor", "?", "?#", "?foo=bar", "?foo1=bar1&foo2=bar2",
                "?foo1=bar1&foo2=bar2"
            };

        String finalResult = null;

        String path = null;
        String results = null;
        boolean equality = false;
        int ct = 0;

        for (int i = 0; i < appends.length; i++) {
            for (int j = 0; j < prepends.length; j++) {
                finalResult = prepends[j][1];

                for (int k = 0; k < paths.length; k++) {
                    path = prepends[j][0] + paths[k] + appends[i];
                    results = tagutils.getActionMappingName(path);
                    equality = finalResult.equals(results);

                    if (!equality) {
                        fail("Path does not return correct result\n"
                            + "\nexpected: " + results + "\nfound: " + path);
                    }

                    assertTrue("Path should translate to result", equality);
                    ct++;
                }
            }
        }

        log.debug(ct + " assertions run in this test");
    }

    public void testString_getActionMappingURL_String_PageContext() {
        ActionConfig actionConfig = new ActionConfig();

        actionConfig.setParameter("/foo");
        moduleConfig.addActionConfig(actionConfig);

        request.setAttribute(Globals.MODULE_KEY, moduleConfig);
        request.setPathElements("/myapp", "/foo.do", null, null);

        assertEquals("Check path /foo",
            tagutils.getActionMappingURL("/foo", pageContext), "/myapp/foo");
    }

    // use servlet mapping (extension mapping)
    public void testString_getActionMappingURL_String_String_PageContext_boolean1() {
        pageContext.getServletContext().setAttribute(Globals.SERVLET_KEY, "*.do");

        ActionConfig actionConfig = new ActionConfig();

        actionConfig.setParameter("/foo");
        moduleConfig.addActionConfig(actionConfig);

        request.setAttribute(Globals.MODULE_KEY, moduleConfig);
        request.setPathElements("/myapp", "/baz.do", null, null);

        assertEquals("Check path /foo",
            tagutils.getActionMappingURL("/foo", pageContext), "/myapp/foo.do");
    }

    // use servlet mapping (extension mapping)
    //  -- with params
    public void testString_getActionMappingURL_String_String_PageContext_boolean2() {
        pageContext.getServletContext().setAttribute(Globals.SERVLET_KEY, "*.do");

        ActionConfig actionConfig = new ActionConfig();

        actionConfig.setParameter("/foo");
        moduleConfig.addActionConfig(actionConfig);

        request.setAttribute(Globals.MODULE_KEY, moduleConfig);
        request.setPathElements("/myapp", "/baz.do?foo=bar", null, null);

        assertEquals("Check path /foo",
            tagutils.getActionMappingURL("/foo?foo=bar", pageContext),
            "/myapp/foo.do?foo=bar");
    }