View Javadoc

1   /*
2    * $Id: ServletMuleMessageFactoryTestCase.java 20110 2010-11-07 17:17:05Z mike.schilling $
3    * --------------------------------------------------------------------------------------
4    * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
5    *
6    * The software in this package is published under the terms of the CPAL v1.0
7    * license, a copy of which has been included with this distribution in the
8    * LICENSE.txt file.
9    */
10  
11  package org.mule.transport.servlet;
12  
13  import org.mule.api.MuleMessage;
14  import org.mule.api.transport.MuleMessageFactory;
15  import org.mule.transport.AbstractMuleMessageFactoryTestCase;
16  import org.mule.transport.http.HttpConstants;
17  import org.mule.util.UUID;
18  
19  import com.mockobjects.dynamic.Mock;
20  
21  import java.io.ByteArrayInputStream;
22  import java.io.IOException;
23  import java.io.InputStream;
24  import java.util.Arrays;
25  import java.util.HashMap;
26  import java.util.Map;
27  import java.util.Vector;
28  
29  import javax.servlet.ServletInputStream;
30  import javax.servlet.http.HttpSession;
31  
32  public class ServletMuleMessageFactoryTestCase extends AbstractMuleMessageFactoryTestCase
33  {
34      private static final String CHARACTER_ENCODING_PROPERTY_KEY = ServletConnector.CHARACTER_ENCODING_PROPERTY_KEY;
35      private static final String CONTENT_TYPE_PROPERTY_KEY = ServletConnector.CONTENT_TYPE_PROPERTY_KEY;
36      private static final String PARAMETER_MAP_PROPERTY_KEY = ServletConnector.PARAMETER_MAP_PROPERTY_KEY;
37  
38      private static final String REQUEST_URI = MockHttpServletRequestBuilder.REQUEST_URI;
39  
40      private MuleMessageFactory factory;
41  
42      @Override
43      protected void doSetUp() throws Exception
44      {
45          super.doSetUp();
46          factory = createMuleMessageFactory();
47      }
48  
49      @Override
50      protected MuleMessageFactory doCreateMuleMessageFactory()
51      {
52          return new ServletMuleMessageFactory(muleContext);
53      }
54  
55      @Override
56      protected Object getValidTransportMessage() throws Exception
57      {
58          return new MockHttpServletRequestBuilder().buildRequest();
59      }
60  
61      @Override
62      protected Object getUnsupportedTransportMessage()
63      {
64          return "this is not a valid transport message for ServletMuleMessageFactory";
65      }
66  
67      /**
68       * Tests creating a MuleMessage from a GET request
69       */
70      @Override
71      public void testValidPayload() throws Exception
72      {
73          Object payload = getValidTransportMessage();
74          MuleMessage message = factory.create(payload, encoding);
75          assertNotNull(message);
76          assertEquals(REQUEST_URI, message.getPayload());
77      }
78  
79      public void testGetPayloadWithQueryParameter() throws Exception
80      {
81          MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
82          builder.queryString = "foo=bar";
83          Object payload = builder.buildRequest();
84  
85          MuleMessage message = factory.create(payload, encoding);
86          assertNotNull(message);
87          String expected = REQUEST_URI + "?" + builder.queryString;
88          assertEquals(expected, message.getPayload());
89      }
90  
91      public void testPostPayload() throws Exception
92      {
93          Object payload = buildPostRequest();
94          MuleMessage message = factory.create(payload, encoding);
95          assertNotNull(message);
96          assertTrue(message.getPayload() instanceof InputStream);
97      }
98  
99      public void testRequestParametersAreConvertedToMessageProperties() throws Exception
100     {
101         Object payload = buildPostRequest();
102         MuleMessage message = factory.create(payload, encoding);
103         assertRequestParameterProperty("foo-value", message, "foo");
104         assertRequestParameterProperty("bar-value", message, "bar");
105 
106         Map<String, Object> parameters = retrieveMapProperty(message, PARAMETER_MAP_PROPERTY_KEY);
107         assertNotNull(parameters);
108         assertEquals("foo-value", parameters.get("foo"));
109         assertEquals("bar-value", parameters.get("bar"));
110     }
111 
112     public void testContentEncodingWithCharsetLast() throws Exception
113     {
114         String contentType = "text/plain;charset=UTF-21";
115         Object payload = buildGetRequestWithContentType(contentType);
116         MuleMessage message = factory.create(payload, encoding);
117         assertEquals("UTF-21", message.getEncoding());
118         assertInboundScopedProperty(contentType, message, CONTENT_TYPE_PROPERTY_KEY);
119     }
120 
121     public void testContentEncodingWithCharsetFirst() throws Exception
122     {
123         String contentType = "charset=UTF-21;text/plain";
124         Object payload = buildGetRequestWithContentType(contentType);
125         MuleMessage message = factory.create(payload, encoding);
126         assertEquals("UTF-21", message.getEncoding());
127         assertInboundScopedProperty(contentType, message, CONTENT_TYPE_PROPERTY_KEY);
128     }
129 
130     public void testMessageIdFromHttpSession() throws Exception
131     {
132         String sessionId = UUID.getUUID();
133         Object payload = buildGetRequestWithSession(sessionId);
134         MuleMessage message = factory.create(payload, encoding);
135         assertEquals(sessionId, message.<Object>getInboundProperty(ServletConnector.SESSION_ID_PROPERTY_KEY));
136     }
137     
138     public void testCharacterEncodingFromHttpRequest() throws Exception
139     {
140         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
141         builder.characterEncoding = "UTF-21";
142         Object payload = builder.buildRequest();
143         
144         MuleMessage message = factory.create(payload, encoding);
145         assertInboundScopedProperty(builder.characterEncoding, message, CHARACTER_ENCODING_PROPERTY_KEY);
146     }
147         
148     public void testRequestPropertiesAreConvertedToMessageProperties() throws Exception
149     {
150         Object payload = buildGetRequestWithParameterValue("foo-param", "foo-value");
151         MuleMessage message = factory.create(payload, encoding);
152         assertInboundScopedProperty("foo-value", message, "foo-param");
153     }
154     
155     public void testRequestAttributesAreConvertedToMessageProperties() throws Exception
156     {
157         Object payload = buildGetRequestWithAttributeValue("foo-attribute", "foo-value");
158         MuleMessage message = factory.create(payload, encoding);
159         assertInboundScopedProperty("foo-value", message, "foo-attribute");
160     }
161 
162     public void testRequestHeadersAreConvertedToMessageProperties() throws Exception
163     {
164         Object payload = buildGetRequestWithHeaders();
165         MuleMessage message = factory.create(payload, encoding);
166         assertInboundScopedProperty("foo-value", message, "foo-header");
167         assertInboundScopedProperty("MULE_HEADER_VALUE", message, "MULE_HEADER");
168         assertInboundScopedProperty("localhost:8080", message, HttpConstants.HEADER_HOST);
169         
170         Object[] expected = new Object[] { "value-one", "value-two" };
171         assertTrue(Arrays.equals(expected, (Object[]) message.getInboundProperty("multi-value")));
172     }
173         
174     private void assertInboundScopedProperty(Object expected, MuleMessage message, String key)
175     {
176         Object value = message.getInboundProperty(key);
177         assertEquals(expected, value);
178     }
179     
180     private void assertRequestParameterProperty(String expected, MuleMessage message, String key)
181     {
182         String propertyKey = ServletConnector.PARAMETER_PROPERTY_PREFIX + key;
183         // message factory puts props in the inbound scope
184         Object value = message.getInboundProperty(propertyKey);
185         assertEquals(expected, value);
186     }
187 
188     private Map<String, Object> retrieveMapProperty(MuleMessage message, String key)
189     {
190         return message.getInboundProperty(key);
191     }
192 
193     private Object buildGetRequestWithContentType(String contentType)
194     {
195         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
196         builder.contentType = contentType;
197         return builder.buildRequest();
198     }
199 
200     private Object buildGetRequestWithSession(String sessionId)
201     {
202         Mock mockSession = new Mock(HttpSession.class);
203         mockSession.expectAndReturn("getId", sessionId);
204         HttpSession session = (HttpSession) mockSession.proxy();
205         
206         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
207         builder.session = session;
208         return builder.buildRequest();
209     }
210     
211     private Object buildGetRequestWithParameterValue(String key, String value)
212     {
213         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
214         builder.parameters = new HashMap<String, String[]>();
215         builder.parameters.put(key, new String[] { value });
216         return builder.buildRequest();
217     }
218 
219     private Object buildGetRequestWithAttributeValue(String key, String value)
220     {
221         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
222         builder.attributes.put(key, value);
223         return builder.buildRequest();
224     }
225 
226     private Object buildGetRequestWithHeaders()
227     {
228         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
229         builder.headers.put("foo-header", "foo-value");
230         builder.headers.put("X-MULE_HEADER", "MULE_HEADER_VALUE");
231         builder.headers.put(HttpConstants.HEADER_HOST, "localhost");
232         
233         Vector<String> multiValue = new Vector<String>();
234         multiValue.add("value-one");
235         multiValue.add("value-two");
236         builder.headers.put("multi-value", multiValue.elements());
237         
238         return builder.buildRequest();
239     }
240 
241     private Object buildPostRequest()
242     {
243         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
244         builder.method = HttpConstants.METHOD_POST;
245         
246         InputStream stream = new ByteArrayInputStream(TEST_MESSAGE.getBytes());
247         builder.inputStream = new MockServletInputStream(stream);
248         
249         builder.parameters = new HashMap<String, String[]>();
250         builder.parameters.put("foo", new String[] { "foo-value" });
251         builder.parameters.put("bar", new String[] { "bar-value" });
252 
253         return builder.buildRequest();
254     }
255     
256     private static class MockServletInputStream extends ServletInputStream
257     {
258         private InputStream input;
259 
260         public MockServletInputStream(InputStream dataStream)
261         {
262             super();
263             input = dataStream;
264         }
265 
266         @Override
267         public int read() throws IOException
268         {
269             return input.read();
270         }
271     }
272 }