摘录RestTemplate的集成测试类

/*
2. * Copyright 2002-2010 the original author or authors.
3. *
4. * Licensed under the Apache License, Version 2.0 (the "License");
5. * you may not use this file except in compliance with the License.
6. * You may obtain a copy of the License at
7. *
8. * http://www.apache.org/licenses/LICENSE-2.0
9. *
10. * Unless required by applicable law or agreed to in writing, software
11. * distributed under the License is distributed on an "AS IS" BASIS,
12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13. * See the License for the specific language governing permissions and
14. * limitations under the License.
15. */
16.
17. package org.springframework.web.client;
18.
19. import java.io.IOException;
20. import java.io.UnsupportedEncodingException;
21. import java.net.URI;
22. import java.net.URISyntaxException;
23. import java.nio.charset.Charset;
24. import java.util.Collections;
25. import java.util.EnumSet;
26. import java.util.List;
27. import java.util.Set;
28. import javax.servlet.GenericServlet;
29. import javax.servlet.ServletException;
30. import javax.servlet.ServletRequest;
31. import javax.servlet.ServletResponse;
32. import javax.servlet.http.HttpServlet;
33. import javax.servlet.http.HttpServletRequest;
34. import javax.servlet.http.HttpServletResponse;
35.
36. import org.apache.commons.fileupload.FileItem;
37. import org.apache.commons.fileupload.FileItemFactory;
38. import org.apache.commons.fileupload.FileUploadException;
39. import org.apache.commons.fileupload.disk.DiskFileItemFactory;
40. import org.apache.commons.fileupload.servlet.ServletFileUpload;
41. import org.junit.AfterClass;
42. import org.junit.Before;
43. import org.junit.BeforeClass;
44. import org.junit.Test;
45. import org.mortbay.jetty.Server;
46. import org.mortbay.jetty.servlet.Context;
47. import org.mortbay.jetty.servlet.ServletHolder;
48.
49. import org.springframework.core.io.ClassPathResource;
50. import org.springframework.core.io.Resource;
51. import org.springframework.http.HttpEntity;
52. import org.springframework.http.HttpHeaders;
53. import org.springframework.http.HttpMethod;
54. import org.springframework.http.HttpStatus;
55. import org.springframework.http.MediaType;
56. import org.springframework.http.ResponseEntity;
57. import org.springframework.http.client.CommonsClientHttpRequestFactory;
58. import org.springframework.http.client.FreePortScanner;
59. import org.springframework.util.FileCopyUtils;
60. import org.springframework.util.LinkedMultiValueMap;
61. import org.springframework.util.MultiValueMap;
62.
63. import static org.junit.Assert.*;
64.
65. /** @author Arjen Poutsma */
66. public class RestTemplateIntegrationTests {
67.
68. private RestTemplate template;
69.
70. private static Server jettyServer;
71.
72. private static String helloWorld = "H\u00e9llo W\u00f6rld";
73.
74. private static String baseUrl;
75.
76. private static MediaType contentType;
77.
78. @BeforeClass
79. public static void startJettyServer() throws Exception {
80. int port = FreePortScanner.getFreePort();
81. jettyServer = new Server(port);
82. baseUrl = "http://localhost:" + port;
83. Context jettyContext = new Context(jettyServer, "/");
84. byte[] bytes = helloWorld.getBytes("UTF-8");
85. contentType = new MediaType("text", "plain", Collections.singletonMap("charset", "utf-8"));
86. jettyContext.addServlet(new ServletHolder(new GetServlet(bytes, contentType)), "/get");
87. jettyContext.addServlet(new ServletHolder(new GetServlet(new byte[0], contentType)), "/get/nothing");
88. jettyContext.addServlet(
89. new ServletHolder(new PostServlet(helloWorld, baseUrl + "/post/1", bytes, contentType)),
90. "/post");
91. jettyContext.addServlet(new ServletHolder(new ErrorServlet(404)), "/errors/notfound");
92. jettyContext.addServlet(new ServletHolder(new ErrorServlet(500)), "/errors/server");
93. jettyContext.addServlet(new ServletHolder(new UriServlet()), "/uri/*");
94. jettyContext.addServlet(new ServletHolder(new MultipartServlet()), "/multipart");
95. jettyServer.start();
96. }
97.
98. @Before
99. public void createTemplate() {
100. template = new RestTemplate(new CommonsClientHttpRequestFactory());
101. }
102.
103. @AfterClass
104. public static void stopJettyServer() throws Exception {
105. if (jettyServer != null) {
106. jettyServer.stop();
107. }
108. }
109.
110. @Test
111. public void getString() {
112. String s = template.getForObject(baseUrl + "/{method}", String.class, "get");
113. assertEquals("Invalid content", helloWorld, s);
114. }
115.
116. @Test
117. public void getEntity() {
118. ResponseEntity<String> entity = template.getForEntity(baseUrl + "/{method}", String.class, "get");
119. assertEquals("Invalid content", helloWorld, entity.getBody());
120. assertFalse("No headers", entity.getHeaders().isEmpty());
121. assertEquals("Invalid content-type", contentType, entity.getHeaders().getContentType());
122. assertEquals("Invalid status code", HttpStatus.OK, entity.getStatusCode());
123. }
124.
125. @Test
126. public void getNoResponse() {
127. String s = template.getForObject(baseUrl + "/get/nothing", String.class);
128. assertEquals("Invalid content", "", s);
129. }
130.
131. @Test
132. public void postForLocation() throws URISyntaxException {
133. URI location = template.postForLocation(baseUrl + "/{method}", helloWorld, "post");
134. assertEquals("Invalid location", new URI(baseUrl + "/post/1"), location);
135. }
136.
137. @Test
138. public void postForLocationEntity() throws URISyntaxException {
139. HttpHeaders entityHeaders = new HttpHeaders();
140. entityHeaders.setContentType(new MediaType("text", "plain", Charset.forName("ISO-8859-15")));
141. HttpEntity<String> entity = new HttpEntity<String>(helloWorld, entityHeaders);
142. URI location = template.postForLocation(baseUrl + "/{method}", entity, "post");
143. assertEquals("Invalid location", new URI(baseUrl + "/post/1"), location);
144. }
145.
146. @Test
147. public void postForObject() throws URISyntaxException {
148. String s = template.postForObject(baseUrl + "/{method}", helloWorld, String.class, "post");
149. assertEquals("Invalid content", helloWorld, s);
150. }
151.
152. @Test
153. public void notFound() {
154. try {
155. template.execute(baseUrl + "/errors/notfound", HttpMethod.GET, null, null);
156. fail("HttpClientErrorException expected");
157. }
158. catch (HttpClientErrorException ex) {
159. assertEquals(HttpStatus.NOT_FOUND, ex.getStatusCode());
160. assertNotNull(ex.getStatusText());
161. assertNotNull(ex.getResponseBodyAsString());
162. }
163. }
164.
165. @Test
166. public void serverError() {
167. try {
168. template.execute(baseUrl + "/errors/server", HttpMethod.GET, null, null);
169. fail("HttpServerErrorException expected");
170. }
171. catch (HttpServerErrorException ex) {
172. assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, ex.getStatusCode());
173. assertNotNull(ex.getStatusText());
174. assertNotNull(ex.getResponseBodyAsString());
175. }
176. }
177.
178. @Test
179. public void optionsForAllow() throws URISyntaxException {
180. Set<HttpMethod> allowed = template.optionsForAllow(new URI(baseUrl + "/get"));
181. assertEquals("Invalid response",
182. EnumSet.of(HttpMethod.GET, HttpMethod.OPTIONS, HttpMethod.HEAD, HttpMethod.TRACE), allowed);
183. }
184.
185. @Test
186. public void uri() throws InterruptedException, URISyntaxException {
187. String result = template.getForObject(baseUrl + "/uri/{query}", String.class, "Z\u00fcrich");
188. assertEquals("Invalid request URI", "/uri/Z%C3%BCrich", result);
189.
190. result = template.getForObject(baseUrl + "/uri/query={query}", String.class, "foo@bar");
191. assertEquals("Invalid request URI", "/uri/query=foo@bar", result);
192.
193. result = template.getForObject(baseUrl + "/uri/query={query}", String.class, "T\u014dky\u014d");
194. assertEquals("Invalid request URI", "/uri/query=T%C5%8Dky%C5%8D", result);
195. }
196.
197. @Test
198. public void multipart() throws UnsupportedEncodingException {
199. MultiValueMap<String, Object> parts = new LinkedMultiValueMap<String, Object>();
200. parts.add("name 1", "value 1");
201. parts.add("name 2", "value 2+1");
202. parts.add("name 2", "value 2+2");
203. Resource logo = new ClassPathResource("/org/springframework/http/converter/logo.jpg");
204. parts.add("logo", logo);
205.
206. template.postForLocation(baseUrl + "/multipart", parts);
207. }
208.
209. @Test
210. public void exchangeGet() throws Exception {
211. HttpHeaders requestHeaders = new HttpHeaders();
212. requestHeaders.set("MyHeader", "MyValue");
213. HttpEntity<?> requestEntity = new HttpEntity(requestHeaders);
214. ResponseEntity<String> response =
215. template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity, String.class, "get");
216. assertEquals("Invalid content", helloWorld, response.getBody());
217. }
218.
219. @Test
220. public void exchangePost() throws Exception {
221. HttpHeaders requestHeaders = new HttpHeaders();
222. requestHeaders.set("MyHeader", "MyValue");
223. requestHeaders.setContentType(MediaType.TEXT_PLAIN);
224. HttpEntity<String> requestEntity = new HttpEntity<String>(helloWorld, requestHeaders);
225. HttpEntity<?> result = template.exchange(baseUrl + "/{method}", HttpMethod.POST, requestEntity, null, "post");
226. assertEquals("Invalid location", new URI(baseUrl + "/post/1"), result.getHeaders().getLocation());
227. assertFalse(result.hasBody());
228. }
229.
230. /** Servlet that returns and error message for a given status code. */
231. private static class ErrorServlet extends GenericServlet {
232.
233. private final int sc;
234.
235. private ErrorServlet(int sc) {
236. this.sc = sc;
237. }
238.
239. @Override
240. public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
241. ((HttpServletResponse) response).sendError(sc);
242. }
243. }
244.
245. private static class GetServlet extends HttpServlet {
246.
247. private final byte[] buf;
248.
249. private final MediaType contentType;
250.
251. private GetServlet(byte[] buf, MediaType contentType) {
252. this.buf = buf;
253. this.contentType = contentType;
254. }
255.
256. @Override
257. protected void doGet(HttpServletRequest request, HttpServletResponse response)
258. throws ServletException, IOException {
259. response.setContentType(contentType.toString());
260. response.setContentLength(buf.length);
261. FileCopyUtils.copy(buf, response.getOutputStream());
262. }
263. }
264.
265. private static class PostServlet extends HttpServlet {
266.
267. private final String s;
268.
269. private final String location;
270.
271. private final byte[] buf;
272.
273. private final MediaType contentType;
274.
275. private PostServlet(String s, String location, byte[] buf, MediaType contentType) {
276. this.s = s;
277. this.location = location;
278. this.buf = buf;
279. this.contentType = contentType;
280. }
281.
282. @Override
283. protected void doPost(HttpServletRequest request, HttpServletResponse response)
284. throws ServletException, IOException {
285. assertTrue("Invalid request content-length", request.getContentLength() > 0);
286. assertNotNull("No content-type", request.getContentType());
287. String body = FileCopyUtils.copyToString(request.getReader());
288. assertEquals("Invalid request body", s, body);
289. response.setStatus(HttpServletResponse.SC_CREATED);
290. response.setHeader("Location", location);
291. response.setContentLength(buf.length);
292. response.setContentType(contentType.toString());
293. FileCopyUtils.copy(buf, response.getOutputStream());
294. }
295. }
296.
297. private static class UriServlet extends HttpServlet {
298.
299. @Override
300. protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
301. resp.setContentType("text/plain");
302. resp.setCharacterEncoding("UTF-8");
303. resp.getWriter().write(req.getRequestURI());
304. }
305. }
306.
307. private static class MultipartServlet extends HttpServlet {
308.
309. @Override
310. protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
311. assertTrue(ServletFileUpload.isMultipartContent(req));
312. FileItemFactory factory = new DiskFileItemFactory();
313. ServletFileUpload upload = new ServletFileUpload(factory);
314. try {
315. List items = upload.parseRequest(req);
316. assertEquals(4, items.size());
317. FileItem item = (FileItem) items.get(0);
318. assertTrue(item.isFormField());
319. assertEquals("name 1", item.getFieldName());
320. assertEquals("value 1", item.getString());
321.
322. item = (FileItem) items.get(1);
323. assertTrue(item.isFormField());
324. assertEquals("name 2", item.getFieldName());
325. assertEquals("value 2+1", item.getString());
326.
327. item = (FileItem) items.get(2);
328. assertTrue(item.isFormField());
329. assertEquals("name 2", item.getFieldName());
330. assertEquals("value 2+2", item.getString());
331.
332. item = (FileItem) items.get(3);
333. assertFalse(item.isFormField());
334. assertEquals("logo", item.getFieldName());
335. assertEquals("logo.jpg", item.getName());
336. assertEquals("image/jpeg", item.getContentType());
337. }
338. catch (FileUploadException ex) {
339. throw new ServletException(ex);
340. }
341.
342. }
343. }
344.
345. } [color=darkred][/color]