httpservletrequesttest.java

这是远程web服务调用的一个包,可以将JSP直接作为服务

    public void testGetSessionForFirstTime() throws MalformedURLException {
        WebRequest wr = new GetMethodWebRequest( "http://localhost/simple" );
        ServletUnitContext context = _context;
        assertEquals( "Initial number of sessions in context", 0, context.getSessionIDs().size() );

        ServletUnitHttpRequest request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, context, new Hashtable(), NO_MESSAGE_BODY );
        assertNull( "New request should not have a request session ID", request.getRequestedSessionId() );
        assertNull( "New request should not have a session", request.getSession( /* create */ false ) );
        assertEquals( "Number of sessions in the context after request.getSession(false)", 0, context.getSessionIDs().size() );

        HttpSession session = request.getSession();
        assertNotNull( "No session created", session );
        assertTrue( "Session not marked as new", session.isNew() );
        assertEquals( "Number of sessions in context after request.getSession()", 1, context.getSessionIDs().size() );
        assertSame( "Session with ID", session, context.getSession( session.getId() ) );
        assertNull( "New request should still not have a request session ID", request.getRequestedSessionId() );
    }

    /**
     * Test recognition of cookies defined on the client.
     */
    public void testGetUserCookies() throws Exception {
        String FIRST_COOKIE = "RANDOM_COOKIE";
        String SECOND_COOKIE = "ANOTHER_COOKIE";
        String FIRST_COOKIE_VALUE = "cookie1";
        String SECOND_COOKIE_VALUE = "cookie2";

        ServletRunner sr = new ServletRunner();
        sr.registerServlet( "testServlet", "ServletName" );
        ServletUnitClient m_sc = sr.newClient();
        m_sc.putCookie( FIRST_COOKIE, FIRST_COOKIE_VALUE );
        m_sc.putCookie( SECOND_COOKIE, SECOND_COOKIE_VALUE );

        InvocationContext invocation = m_sc.newInvocation( "http://localhost/testServlet" );
        HttpServletRequest requ = invocation.getRequest();

        Cookie[] cookies = requ.getCookies();
        assertEquals( 2, cookies.length );
        Cookie firstActualCookie = cookies[0];
        Cookie secondActualCookie = cookies[1];

        assertEquals( FIRST_COOKIE, firstActualCookie.getName() );
        assertEquals( SECOND_COOKIE, secondActualCookie.getName() );

        assertEquals( FIRST_COOKIE_VALUE, firstActualCookie.getValue() );
        assertEquals( SECOND_COOKIE_VALUE, secondActualCookie.getValue() );
    }


    /**
     * Verifies that even when session creation is not explicitly requested, the inclusion of a session cookie
     * will cause a session to be made available.
     */
    public void testRetrieveSession() throws Exception {
        ServletUnitContext context = _context;
        final ServletUnitHttpSession session = context.newSession();
        final String sessionID = session.getId();

        WebRequest wr = new GetMethodWebRequest( "http://localhost/simple" );
        wr.setHeaderField( "Cookie", ServletUnitHttpSession.SESSION_COOKIE_NAME + '=' + sessionID);

        ServletUnitHttpRequest request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, context, new Hashtable(), NO_MESSAGE_BODY );
        assertEquals( "Requested session ID defined in request", sessionID, request.getRequestedSessionId() );

        assertSame( "Session returned when creation not requested", session, request.getSession( /* create */ false ) );
        assertSame( "Session returned when creation requested", session, request.getSession( true ) );
    }


    public void testAccessForbiddenToInvalidSession() throws Exception {
        ServletUnitContext context = _context;

        HttpSession session = context.newSession();
        session.setAttribute( "Initial", new Integer( 1 ) );
        Enumeration attributeNames = session.getAttributeNames();
        assertTrue( attributeNames.hasMoreElements() );
        assertEquals( "Initial", attributeNames.nextElement() );

        session.invalidate();

        try {
            session.getAttributeNames().hasMoreElements();
            fail( "Should not be able to access an invalid session's attributes" );
        } catch (IllegalStateException ex) {
        }

        try {
            session.getAttribute( "Initial" );
            fail( "Should not be able to access an invalid session's attributes" );
        } catch (IllegalStateException ex) {
        }
    }


    /**
     * Verifies that a request for a session when the current one is invalid will result in a new session.
     *
     * Obtains a new session, invalidates it, and verifies that
     */
    public void testSessionInvalidation() throws Exception {
        ServletUnitContext context = _context;
        HttpSession originalSession = context.newSession();
        String originalID = originalSession.getId();

        WebRequest wr = new GetMethodWebRequest( "http://localhost/simple" );
        wr.setHeaderField( "Cookie", ServletUnitHttpSession.SESSION_COOKIE_NAME + '=' + originalID);

        ServletUnitHttpRequest request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, context, new Hashtable(), NO_MESSAGE_BODY );
        originalSession.setAttribute( "Initial", new Integer( 1 ) );
        Enumeration attributeNames = originalSession.getAttributeNames();
        assertTrue( attributeNames.hasMoreElements() );
        assertEquals( "Initial", attributeNames.nextElement() );

        originalSession.invalidate();

        assertNull( "Invalidated session returned", request.getSession( false ) );

        HttpSession newSession = request.getSession( true );
        assertNotNull( "getSession(true) did not return a session", newSession );
        assertNotSame( "getSession(true) returned the original invalidated session", originalSession, newSession );
        assertSame( "session returned by getSession(false)", newSession, request.getSession( false ) );
        assertSame( "Session in context with new ID", newSession, context.getSession( newSession.getId() ) );
    }


    /**
     * Verifies that a request with a bad session ID causes a new session to be generated only when explicitly requested.
     */
    public void testGetSessionWithBadCookie() throws Exception {
        ServletUnitContext context = _context;
        HttpSession originalSession = context.newSession();
        String originalID = originalSession.getId();

        WebRequest wr = new GetMethodWebRequest( "http://localhost/simple" );
        wr.setHeaderField( "Cookie", ServletUnitHttpSession.SESSION_COOKIE_NAME + '=' + originalID);

        ServletUnitHttpRequest request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, context, new Hashtable(), NO_MESSAGE_BODY );
        request.getSession();

        wr.setHeaderField( "Cookie", ServletUnitHttpSession.SESSION_COOKIE_NAME + '=' + (originalID + "BAD"));
        request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, context, new Hashtable(), NO_MESSAGE_BODY );

        assertNull( "Unexpected session returned for bad cookie", request.getSession( false ) );
        assertNotNull( "Should have returned session when asked", request.getSession( true ));
        assertNotSame( "Created session", originalSession, request.getSession( true ) );
    }


    public void testGetRequestURI() throws Exception {
        ServletUnitContext context = _context;
        WebRequest wr = new GetMethodWebRequest( "http://localhost/simple" );

        ServletUnitHttpRequest request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, context, new Hashtable(), NO_MESSAGE_BODY );
        assertEquals("/simple", request.getRequestURI());
        assertEquals( "http://localhost/simple", request.getRequestURL().toString() );

        wr = new GetMethodWebRequest( "http://localhost/simple?foo=bar" );
        request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, context, new Hashtable(), NO_MESSAGE_BODY );
        assertEquals("/simple", request.getRequestURI());
        assertEquals( "http://localhost/simple", request.getRequestURL().toString() );
    }


    public void testDefaultLocale() throws Exception {
        WebRequest wr = new GetMethodWebRequest( "http://localhost/simple");

        ServletUnitHttpRequest request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, _context, new Hashtable(), NO_MESSAGE_BODY );
        Locale[] expectedLocales = new Locale[] { Locale.getDefault() };
        verifyLocales( request, expectedLocales );

    }


    public void testSecureProperty() throws Exception {
        WebRequest wr = new GetMethodWebRequest( "http://localhost/simple");
        ServletUnitHttpRequest request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, _context, new Hashtable(), NO_MESSAGE_BODY );
        assertFalse( "Incorrectly noted request as secure", request.isSecure() );

        WebRequest secureReq = new GetMethodWebRequest( "https://localhost/simple");
        request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, secureReq, _context, new Hashtable(), NO_MESSAGE_BODY );
        assertTrue( "Request not marked as secure", request.isSecure() );
    }


    private void verifyLocales( ServletUnitHttpRequest request, Locale[] expectedLocales ) {
        assertNotNull( "No default locale found", request.getLocale() );
        assertEquals( "default locale", expectedLocales[0], request.getLocale() );

        final Enumeration locales = request.getLocales();
        assertNotNull( "local enumeration not returned", locales );
        for (int i = 0; i < expectedLocales.length; i++) {
            assertTrue( "Expected " + expectedLocales.length + " locales, only found " + i, locales.hasMoreElements() );
            assertEquals( "Locale #" + (i+1), expectedLocales[i], locales.nextElement() );
        }
        assertFalse( "Too many locales returned", locales.hasMoreElements() );
    }


    public void testSpecifiedLocales() throws Exception {
        WebRequest wr = new GetMethodWebRequest( "http://localhost/simple");
        wr.setHeaderField( "Accept-language", "fr, en;q=0.6, en-us;q=0.7" );

        ServletUnitHttpRequest request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, _context, new Hashtable(), NO_MESSAGE_BODY );
        verifyLocales( request, new Locale[] { Locale.FRENCH, Locale.US, Locale.ENGLISH } );
    }


    public void ntestSpecifiedCharEncoding() throws Exception {    // xxx turn this back on
        String hebrewValue = "\u05d0\u05d1\u05d2\u05d3";
        String paramString = "param1=red&param2=%E0%E1%E2%E3";  // use iso-8859-8 to encode the data
        WebRequest wr = new PostMethodWebRequest( "http://localhost/simple" );
        wr.setHeaderField( "Content-Type", "application/x-www-form-urlencoded; charset=ISO-8859-8" );
        ServletUnitHttpRequest request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, _context, new Hashtable(), paramString.getBytes( "iso-8859-1" ) );
        assertEquals( "param1 value", "red", request.getParameter( "param1") );
        assertEquals( "param2 value", hebrewValue, request.getParameter( "param2") );
    }


    public void ntestSpecifiedCharEncoding2() throws Exception {
        String hebrewValue = "\u05d0\u05d1\u05d2\u05d3";
        HttpUnitOptions.setDefaultCharacterSet( "iso-8859-8" );
        WebRequest wr = new PostMethodWebRequest( "http://localhost/simple" );
        wr.setParameter( "param1", "red" );
        wr.setParameter( "param2", hebrewValue );
        wr.setHeaderField( "Content-Type", "application/x-www-form-urlencoded; charset=ISO-8859-8" );
        ServletUnitClient client = ServletUnitClient.newClient( null );
        ByteArrayOutputStream messageBody = client.getMessageBody( wr );
        ServletUnitHttpRequest request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, _context, new Hashtable(), messageBody.toByteArray() );
        String parameter = request.getParameter( "param2");
        assertEquals( "param2 value", hebrewValue, parameter );
        assertEquals( "param1 value", "red", request.getParameter( "param1") );
    }


    public void ntestSuppliedCharEncoding() throws Exception {   // xxx turn this back on
        String hebrewValue = "\u05d0\u05d1\u05d2\u05d3";
        String paramString = "param1=red&param2=%E0%E1%E2%E3";  // use iso-8859-8 to encode the data, then string is URL encoded
        WebRequest wr = new PostMethodWebRequest( "http://localhost/simple" );
        ServletUnitHttpRequest request = new ServletUnitHttpRequest( NULL_SERVLET_REQUEST, wr, _context, new Hashtable(), paramString.getBytes( "ISO-8859-1" ) );
        request.setCharacterEncoding( "ISO-8859-8" );
        assertEquals( "param1 value", "red", request.getParameter( "param1") );
        assertEquals( "param2 value", hebrewValue, request.getParameter( "param2") );
    }


    private final static byte[] NO_MESSAGE_BODY = new byte[0];

    private final static ServletMetaData NULL_SERVLET_REQUEST = new ServletMetaData() {

        public Servlet getServlet() throws ServletException {
            return null;
        }


        public String getServletPath() {
            return null;
        }


        public String getPathInfo() {
            return null;
        }


        public FilterMetaData[] getFilters() {
            return null;
        }
    };
}