1
2
3
4
5
6
7
8
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
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
139
140
141
142 public void testUniqueMessageId() throws Exception
143 {
144 String sessionId = UUID.getUUID();
145 Object payload = buildGetRequestWithSession(sessionId);
146 Object payload2 = buildGetRequestWithSession(sessionId);
147 MuleMessage message = factory.create(payload, encoding);
148 MuleMessage message2 = factory.create(payload2, encoding);
149 assertEquals(sessionId, message.<Object>getInboundProperty(ServletConnector.SESSION_ID_PROPERTY_KEY));
150 assertEquals(sessionId, message2.<Object>getInboundProperty(ServletConnector.SESSION_ID_PROPERTY_KEY));
151
152 assertFalse(message.getUniqueId().equals(message2.getUniqueId()));
153 }
154
155
156 public void testCharacterEncodingFromHttpRequest() throws Exception
157 {
158 MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
159 builder.characterEncoding = "UTF-21";
160 Object payload = builder.buildRequest();
161
162 MuleMessage message = factory.create(payload, encoding);
163 assertInboundScopedProperty(builder.characterEncoding, message, CHARACTER_ENCODING_PROPERTY_KEY);
164 }
165
166 public void testRequestPropertiesAreConvertedToMessageProperties() throws Exception
167 {
168 Object payload = buildGetRequestWithParameterValue("foo-param", "foo-value");
169 MuleMessage message = factory.create(payload, encoding);
170 assertInboundScopedProperty("foo-value", message, "foo-param");
171 }
172
173 public void testRequestAttributesAreConvertedToMessageProperties() throws Exception
174 {
175 Object payload = buildGetRequestWithAttributeValue("foo-attribute", "foo-value");
176 MuleMessage message = factory.create(payload, encoding);
177 assertInboundScopedProperty("foo-value", message, "foo-attribute");
178 }
179
180 public void testRequestHeadersAreConvertedToMessageProperties() throws Exception
181 {
182 Object payload = buildGetRequestWithHeaders();
183 MuleMessage message = factory.create(payload, encoding);
184 assertInboundScopedProperty("foo-value", message, "foo-header");
185 assertInboundScopedProperty("MULE_HEADER_VALUE", message, "MULE_HEADER");
186 assertInboundScopedProperty("localhost:8080", message, HttpConstants.HEADER_HOST);
187
188 Object[] expected = new Object[] { "value-one", "value-two" };
189 assertTrue(Arrays.equals(expected, (Object[]) message.getInboundProperty("multi-value")));
190 }
191
192 private void assertInboundScopedProperty(Object expected, MuleMessage message, String key)
193 {
194 Object value = message.getInboundProperty(key);
195 assertEquals(expected, value);
196 }
197
198 private void assertRequestParameterProperty(String expected, MuleMessage message, String key)
199 {
200 String propertyKey = ServletConnector.PARAMETER_PROPERTY_PREFIX + key;
201
202 Object value = message.getInboundProperty(propertyKey);
203 assertEquals(expected, value);
204 }
205
206 private Map<String, Object> retrieveMapProperty(MuleMessage message, String key)
207 {
208 return message.getInboundProperty(key);
209 }
210
211 private Object buildGetRequestWithContentType(String contentType)
212 {
213 MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
214 builder.contentType = contentType;
215 return builder.buildRequest();
216 }
217
218 private Object buildGetRequestWithSession(String sessionId)
219 {
220 Mock mockSession = new Mock(HttpSession.class);
221 mockSession.expectAndReturn("getId", sessionId);
222 HttpSession session = (HttpSession) mockSession.proxy();
223
224 MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
225 builder.session = session;
226 return builder.buildRequest();
227 }
228
229 private Object buildGetRequestWithParameterValue(String key, String value)
230 {
231 MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
232 builder.parameters = new HashMap<String, String[]>();
233 builder.parameters.put(key, new String[] { value });
234 return builder.buildRequest();
235 }
236
237 private Object buildGetRequestWithAttributeValue(String key, String value)
238 {
239 MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
240 builder.attributes.put(key, value);
241 return builder.buildRequest();
242 }
243
244 private Object buildGetRequestWithHeaders()
245 {
246 MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
247 builder.headers.put("foo-header", "foo-value");
248 builder.headers.put("X-MULE_HEADER", "MULE_HEADER_VALUE");
249 builder.headers.put(HttpConstants.HEADER_HOST, "localhost");
250
251 Vector<String> multiValue = new Vector<String>();
252 multiValue.add("value-one");
253 multiValue.add("value-two");
254 builder.headers.put("multi-value", multiValue.elements());
255
256 return builder.buildRequest();
257 }
258
259 private Object buildPostRequest()
260 {
261 MockHttpServletRequestBuilder builder = new MockHttpServletRequestBuilder();
262 builder.method = HttpConstants.METHOD_POST;
263
264 InputStream stream = new ByteArrayInputStream(TEST_MESSAGE.getBytes());
265 builder.inputStream = new MockServletInputStream(stream);
266
267 builder.parameters = new HashMap<String, String[]>();
268 builder.parameters.put("foo", new String[] { "foo-value" });
269 builder.parameters.put("bar", new String[] { "bar-value" });
270
271 return builder.buildRequest();
272 }
273
274 private static class MockServletInputStream extends ServletInputStream
275 {
276 private InputStream input;
277
278 public MockServletInputStream(InputStream dataStream)
279 {
280 super();
281 input = dataStream;
282 }
283
284 @Override
285 public int read() throws IOException
286 {
287 return input.read();
288 }
289 }
290 }