RestTemplateIntegrationTests-白红宇

摘录RestTemplate的集成测试类

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. *

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 ormons.fileupload.FileItem;

37. import ormons.fileupload.FileItemFactory;

38. import ormons.fileupload.FileUploadException;

39. import ormons.fileupload.disk.DiskFileItemFactory;

40. import ormons.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 orre.io.ClassPathResource;

50. import orre.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.;

58. import org.springframework.;

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/");

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