View Javadoc

1   /*
2    * $Id: ServletMuleMessageFactoryTestCase.java 22387 2011-07-12 03:53:36Z dirk.olmes $
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 java.io.ByteArrayInputStream;
20  import java.io.InputStream;
21  import java.util.Arrays;
22  import java.util.HashMap;
23  import java.util.Map;
24  import java.util.Vector;
25  
26  import javax.servlet.http.HttpSession;
27  
28  import org.junit.Test;
29  
30  import static org.junit.Assert.assertEquals;
31  import static org.junit.Assert.assertFalse;
32  import static org.junit.Assert.assertNotNull;
33  import static org.junit.Assert.assertTrue;
34  import static org.mockito.Mockito.mock;
35  import static org.mockito.Mockito.when;
36  
37  public class ServletMuleMessageFactoryTestCase extends AbstractMuleMessageFactoryTestCase
38  {
39      private static final String CHARACTER_ENCODING_PROPERTY_KEY = ServletConnector.CHARACTER_ENCODING_PROPERTY_KEY;
40      private static final String CONTENT_TYPE_PROPERTY_KEY = ServletConnector.CONTENT_TYPE_PROPERTY_KEY;
41      private static final String PARAMETER_MAP_PROPERTY_KEY = ServletConnector.PARAMETER_MAP_PROPERTY_KEY;
42  
43      private static final String REQUEST_URI = MockHttpServletRequestBuilder.REQUEST_URI;
44  
45      private MuleMessageFactory factory;
46  
47      @Override
48      protected void doSetUp() throws Exception
49      {
50          super.doSetUp();
51          factory = createMuleMessageFactory();
52      }
53  
54      @Override
55      protected MuleMessageFactory doCreateMuleMessageFactory()
56      {
57          return new ServletMuleMessageFactory(muleContext);
58      }
59  
60      @Override
61      protected Object getValidTransportMessage() throws Exception
62      {
63          return new MockHttpServletRequestBuilder().buildRequest();
64      }
65  
66      @Override
67      protected Object getUnsupportedTransportMessage()
68      {
69          return "this is not a valid transport message for ServletMuleMessageFactory";
70      }
71  
72      /**
73       * Tests creating a MuleMessage from a GET request
74       */
75      @Override
76      public void testValidPayload() throws Exception
77      {
78          Object payload = getValidTransportMessage();
79          MuleMessage message = factory.create(payload, encoding);
80          assertNotNull(message);
81          assertEquals(REQUEST_URI, message.getPayload());
82      }
83  
84      @Test
85      public void testGetPayloadWithQueryParameter() throws Exception
86      {
87          MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
88          builder.queryString = "foo=bar";
89          Object payload = builder.buildRequest();
90  
91          MuleMessage message = factory.create(payload, encoding);
92          assertNotNull(message);
93          String expected = REQUEST_URI + "?" + builder.queryString;
94          assertEquals(expected, message.getPayload());
95      }
96  
97      @Test
98      public void testPostPayload() throws Exception
99      {
100         Object payload = buildPostRequest();
101         MuleMessage message = factory.create(payload, encoding);
102         assertNotNull(message);
103         assertTrue(message.getPayload() instanceof InputStream);
104     }
105 
106     @Test
107     public void testRequestParametersAreConvertedToMessageProperties() throws Exception
108     {
109         Object payload = buildPostRequest();
110         MuleMessage message = factory.create(payload, encoding);
111         assertRequestParameterProperty("foo-value", message, "foo");
112         assertRequestParameterProperty("bar-value", message, "bar");
113 
114         Map<String, Object> parameters = retrieveMapProperty(message, PARAMETER_MAP_PROPERTY_KEY);
115         assertNotNull(parameters);
116         assertEquals("foo-value", parameters.get("foo"));
117         assertEquals("bar-value", parameters.get("bar"));
118     }
119 
120     @Test
121     public void testContentEncodingWithCharsetLast() throws Exception
122     {
123         String contentType = "text/plain;charset=UTF-21";
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     @Test
131     public void testContentEncodingWithCharsetFirst() throws Exception
132     {
133         String contentType = "charset=UTF-21;text/plain";
134         Object payload = buildGetRequestWithContentType(contentType);
135         MuleMessage message = factory.create(payload, encoding);
136         assertEquals("UTF-21", message.getEncoding());
137         assertInboundScopedProperty(contentType, message, CONTENT_TYPE_PROPERTY_KEY);
138     }
139 
140     @Test
141     public void testMessageIdFromHttpSession() throws Exception
142     {
143         String sessionId = UUID.getUUID();
144         Object payload = buildGetRequestWithSession(sessionId);
145         MuleMessage message = factory.create(payload, encoding);
146         assertEquals(sessionId, message.<Object>getInboundProperty(ServletConnector.SESSION_ID_PROPERTY_KEY));
147     }
148 
149     /**
150      * Test for MULE-5101
151      */
152     @Test
153     public void testUniqueMessageId() throws Exception
154     {
155         String sessionId = UUID.getUUID();
156         Object payload = buildGetRequestWithSession(sessionId);
157         Object payload2 = buildGetRequestWithSession(sessionId);
158         MuleMessage message = factory.create(payload, encoding);
159         MuleMessage message2 = factory.create(payload2, encoding);
160         assertEquals(sessionId, message.<Object>getInboundProperty(ServletConnector.SESSION_ID_PROPERTY_KEY));
161         assertEquals(sessionId, message2.<Object>getInboundProperty(ServletConnector.SESSION_ID_PROPERTY_KEY));
162 
163         assertFalse(message.getUniqueId().equals(message2.getUniqueId()));
164     }
165 
166     @Test
167     public void testCharacterEncodingFromHttpRequest() throws Exception
168     {
169         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
170         builder.characterEncoding = "UTF-21";
171         Object payload = builder.buildRequest();
172 
173         MuleMessage message = factory.create(payload, encoding);
174         assertInboundScopedProperty(builder.characterEncoding, message, CHARACTER_ENCODING_PROPERTY_KEY);
175     }
176 
177     @Test
178     public void testRequestPropertiesAreConvertedToMessageProperties() throws Exception
179     {
180         Object payload = buildGetRequestWithParameterValue("foo-param", "foo-value");
181         MuleMessage message = factory.create(payload, encoding);
182         assertInboundScopedProperty("foo-value", message, "foo-param");
183     }
184 
185     @Test
186     public void testRequestAttributesAreConvertedToMessageProperties() throws Exception
187     {
188         Object payload = buildGetRequestWithAttributeValue("foo-attribute", "foo-value");
189         MuleMessage message = factory.create(payload, encoding);
190         assertInboundScopedProperty("foo-value", message, "foo-attribute");
191     }
192 
193     @Test
194     public void testRequestHeadersAreConvertedToMessageProperties() throws Exception
195     {
196         Object payload = buildGetRequestWithHeaders();
197         MuleMessage message = factory.create(payload, encoding);
198         assertInboundScopedProperty("foo-value", message, "foo-header");
199         assertInboundScopedProperty("MULE_HEADER_VALUE", message, "MULE_HEADER");
200         assertInboundScopedProperty("localhost:8080", message, HttpConstants.HEADER_HOST);
201 
202         Object[] expected = new Object[] { "value-one", "value-two" };
203         assertTrue(Arrays.equals(expected, (Object[]) message.getInboundProperty("multi-value")));
204     }
205 
206     private void assertInboundScopedProperty(Object expected, MuleMessage message, String key)
207     {
208         Object value = message.getInboundProperty(key);
209         assertEquals(expected, value);
210     }
211 
212     private void assertRequestParameterProperty(String expected, MuleMessage message, String key)
213     {
214         String propertyKey = ServletConnector.PARAMETER_PROPERTY_PREFIX + key;
215         // message factory puts props in the inbound scope
216         Object value = message.getInboundProperty(propertyKey);
217         assertEquals(expected, value);
218     }
219 
220     private Map<String, Object> retrieveMapProperty(MuleMessage message, String key)
221     {
222         return message.getInboundProperty(key);
223     }
224 
225     private Object buildGetRequestWithContentType(String contentType) throws Exception
226     {
227         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
228         builder.contentType = contentType;
229         return builder.buildRequest();
230     }
231 
232     private Object buildGetRequestWithSession(String sessionId) throws Exception
233     {
234         HttpSession session = mock(HttpSession.class);
235         when(session.getId()).thenReturn(sessionId);
236 
237         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
238         builder.session = session;
239         return builder.buildRequest();
240     }
241 
242     private Object buildGetRequestWithParameterValue(String key, String value) throws Exception
243     {
244         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
245         builder.parameters = new HashMap<String, String[]>();
246         builder.parameters.put(key, new String[] { value });
247         return builder.buildRequest();
248     }
249 
250     private Object buildGetRequestWithAttributeValue(String key, String value) throws Exception
251     {
252         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
253         builder.attributes.put(key, value);
254         return builder.buildRequest();
255     }
256 
257     private Object buildGetRequestWithHeaders() throws Exception
258     {
259         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
260         builder.headers.put("foo-header", "foo-value");
261         builder.headers.put("X-MULE_HEADER", "MULE_HEADER_VALUE");
262         builder.headers.put(HttpConstants.HEADER_HOST, "localhost");
263 
264         Vector<String> multiValue = new Vector<String>();
265         multiValue.add("value-one");
266         multiValue.add("value-two");
267         builder.headers.put("multi-value", multiValue.elements());
268 
269         return builder.buildRequest();
270     }
271 
272     private Object buildPostRequest() throws Exception
273     {
274         MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
275         builder.method = HttpConstants.METHOD_POST;
276 
277         InputStream stream = new ByteArrayInputStream(TEST_MESSAGE.getBytes());
278         builder.inputStream = new MockServletInputStream(stream);
279 
280         builder.parameters = new HashMap<String, String[]>();
281         builder.parameters.put("foo", new String[] { "foo-value" });
282         builder.parameters.put("bar", new String[] { "bar-value" });
283 
284         return builder.buildRequest();
285     }
286 }