2009/05/20 - Apache Shale has been retired.

   /*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to you under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.shale.remoting.impl;
  
  import javax.faces.el.EvaluationException;
  import javax.faces.el.MethodNotFoundException;
  import junit.framework.Test;
  import junit.framework.TestSuite;
  import org.apache.shale.remoting.Constants;
  import org.apache.shale.test.base.AbstractJsfTestCase;
  import org.apache.shale.test.mock.MockPrintWriter;
  import org.apache.shale.test.mock.MockServletOutputStream;
  
  /***
   * <p>Test case for <code>org.apache.shale.remoting.impl.MethodBindingProcessor</code>.</p>
   */
  public class MethodBindingProcessorTestCase extends AbstractJsfTestCase {
      
  
      // ------------------------------------------------------------ Constructors
  
  
      // Construct a new instance of this test case.
      public MethodBindingProcessorTestCase(String name) {
          super(name);
      }
  
  
      // ----------------------------------------------------------- Setup Methods
  
  
      // Set up instance variables for this test case.
      protected void setUp() throws Exception {
  
          super.setUp();
          processor = new MethodBindingProcessor();
          processor.setExcludes(Constants.DYNAMIC_RESOURCES_EXCLUDES_DEFAULT);
          processor.setIncludes(Constants.DYNAMIC_RESOURCES_INCLUDES_DEFAULT);
          servletContext.setAttribute("business", new MethodBindingProcessorBusinessObject());
  
      }
  
  
      // Return the tests included in this test case.
      public static Test suite() {
  
          return (new TestSuite(MethodBindingProcessorTestCase.class));
  
      }
  
  
      // Tear down instance variables for this test case.
      protected void tearDown() throws Exception {
  
          servletContext.removeAttribute("business");
          processor = null;
          super.tearDown();
  
      }
  
  
      // -------------------------------------------------------- Static Variables
  
  
      // Resource identifiers that should be rejected by the default
      // include/exclude rules
      private static final String[] DEFAULT_EXCLUDES =
      { "/applicationScope/clear",
        "/requestScope/clear",
        "/response/flushBuffer",
        "/response/getOutputStream",
        "/response/getWriter",
        "/response/reset",
        "/response/resetBuffer",
        "/sessionScope/clear",
      };
  
  
      // ------------------------------------------------------ Instance Variables
  
  
      // The Processor instance to be tested
      private MethodBindingProcessor processor = null;
  
 
     // ------------------------------------------------------------ Test Methods
 
 
     // Test attempt to execute a resource id on the implicitly rejected list
     public void testImplicitExclude() throws Exception {
 
         for (int i = 0; i < DEFAULT_EXCLUDES.length; i++) {
             try {
                 processor.process(facesContext, DEFAULT_EXCLUDES[i]);
                 assertEquals("Should return 404 for '" + DEFAULT_EXCLUDES[i] + "'",
                              404, response.getStatus());
             } catch (Exception e) {
                 fail("Should have returned 404 for '" + DEFAULT_EXCLUDES[i] +
                      "' instead of exception " + e.getMessage());
             }
         }
 
     }
 
 
     // Test attempt to execute an expression with an invalid bean name
     public void testInvalidBean() throws Exception {
 
         try {
             processor.process(facesContext, "/invalid/directStream");
             fail("Should have thrown EvaluationException");
         } catch (EvaluationException e) {
             ; // Expected result
         }
 
     }
 
 
     // Test attempt to execute an expression with an invalid method name
     public void testInvalidMethod() throws Exception {
         
         try {
             processor.process(facesContext, "/business/invalidMethod");
             fail("Should have thrown MethodNotFoundException");
         } catch (MethodNotFoundException e) {
             ; // Expected result
         }
 
     }
 
 
     // Test mapping of resource identifiers to expressions
     public void testMapping() {
 
         assertEquals("#{business.directStream}",
                      processor.mapResourceId(facesContext, "/business/directStream").getExpressionString());
         assertEquals("#{business.directWriter}",
                      processor.mapResourceId(facesContext, "/business/directWriter").getExpressionString());
         assertEquals("#{business.indirectStream}",
                      processor.mapResourceId(facesContext, "/business/indirectStream").getExpressionString());
         assertEquals("#{business.indirectWriter}",
                      processor.mapResourceId(facesContext, "/business/indirectWriter").getExpressionString());
 
     }
 
 
     // Test attempt to execute an expression for an excluded pattern
     public void testPatternExcluded() throws Exception {
 
         processor.setExcludes("/business/*");
         processor.process(facesContext, "/business/directWriter");
         assertEquals(404, response.getStatus());
 
     }
 
 
     // Test attempt to execute an expression for an included pattern
     public void testPatternIncluded() throws Exception {
 
         processor.setIncludes("/business/*");
         processor.process(facesContext, "/business/directWriter");
         assertEquals(200, response.getStatus());
 
     }
 
 
     // Test attempt to execute an expression for a mixed exclude/include case
     public void testPatternMixed() throws Exception {
 
         processor.setExcludes("/bar/*");
         processor.setIncludes("/business/*");
         processor.process(facesContext, "/business/directWriter");
         assertEquals(200, response.getStatus());
 
     }
 
 
     // Test a pristine instance of the Processor to be tested
     public void testPristine() {
 
         assertNotNull(processor);
         assertNotNull(servletContext.getAttribute("business"));
         assertNull(servletContext.getAttribute("invalid"));
 
     }
 
 
     // Test output sent directly to the servlet response ServletOutputStream
     public void testDirectStream() throws Exception {
 
         processor.process(facesContext, "/business/directStream");
         assertEquals("application/x-binary", response.getContentType());
         MockServletOutputStream stream =
           (MockServletOutputStream) response.getOutputStream();
         assertNotNull(stream);
         assertEquals(10, stream.size());
         byte content[] = stream.content();
         for (int i = 0; i < 10; i++) {
             assertEquals("Byte at position " + i, (byte) i, content[i]);
         }
         assertTrue(facesContext.getResponseComplete());
 
     }
 
 
     // Test output sent directly to the servlet response PrintWriter
     public void testDirectWriter() throws Exception {
 
         processor.process(facesContext, "/business/directWriter");
         assertEquals("text/x-plain", response.getContentType());
         MockPrintWriter writer = (MockPrintWriter) response.getWriter();
         assertNotNull(writer);
         assertEquals(10, writer.size());
         char content[] = writer.content();
         for (int i = 0; i < 10; i++) {
             assertEquals("Character at position " + i, (char) ('a' + i), content[i]);
         }
         assertTrue(facesContext.getResponseComplete());
 
     }
 
 
     // Test output sent indirectly to the servlet or portlet response stream
     public void testIndirectStream() throws Exception {
 
         processor.process(facesContext, "/business/indirectStream");
         assertEquals("application/x-binary", response.getContentType());
         MockServletOutputStream stream =
           (MockServletOutputStream) response.getOutputStream();
         assertNotNull(stream);
         assertEquals(10, stream.size());
         byte content[] = stream.content();
         for (int i = 0; i < 10; i++) {
             assertEquals("Byte at position " + i, (byte) i, content[i]);
         }
         assertTrue(facesContext.getResponseComplete());
 
     }
 
 
     // Test output sent indirectly to the servlet or portlet response writer
     public void testIndirectWriter() throws Exception {
 
         processor.process(facesContext, "/business/indirectWriter");
         assertEquals("text/x-plain", response.getContentType());
         MockPrintWriter writer = (MockPrintWriter) response.getWriter();
         assertNotNull(writer);
         assertEquals(10, writer.size());
         char content[] = writer.content();
         for (int i = 0; i < 10; i++) {
             assertEquals("Character at position " + i, (char) ('a' + i), content[i]);
         }
         assertTrue(facesContext.getResponseComplete());
 
     }
 
 
     // --------------------------------------------------------- Support Methods
 
 
 
 }