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 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
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 }