protocol_handler_util_unittest.mm 8.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238
  1. // Copyright 2012 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #import "ios/net/protocol_handler_util.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "base/memory/ptr_util.h"
  8. #include "base/run_loop.h"
  9. #include "base/strings/sys_string_conversions.h"
  10. #include "base/test/task_environment.h"
  11. #include "net/base/elements_upload_data_stream.h"
  12. #import "net/base/mac/url_conversions.h"
  13. #include "net/base/upload_bytes_element_reader.h"
  14. #include "net/http/http_request_headers.h"
  15. #include "net/http/http_response_headers.h"
  16. #include "net/url_request/url_request.h"
  17. #include "net/url_request/url_request_context.h"
  18. #include "net/url_request/url_request_context_builder.h"
  19. #include "net/url_request/url_request_filter.h"
  20. #include "net/url_request/url_request_interceptor.h"
  21. #include "net/url_request/url_request_job.h"
  22. #include "net/url_request/url_request_test_util.h"
  23. #include "testing/gtest/include/gtest/gtest.h"
  24. #include "testing/gtest_mac.h"
  25. #include "testing/platform_test.h"
  26. #include "url/gurl.h"
  27. #if !defined(__has_feature) || !__has_feature(objc_arc)
  28. #error "This file requires ARC support."
  29. #endif
  30. // When C++ exceptions are disabled, the C++ library defines |try| and
  31. // |catch| so as to allow exception-expecting C++ code to build properly when
  32. // language support for exceptions is not present. These macros interfere
  33. // with the use of |@try| and |@catch| in Objective-C files such as this one.
  34. // Undefine these macros here, after everything has been #included, since
  35. // there will be no C++ uses and only Objective-C uses from this point on.
  36. #undef try
  37. #undef catch
  38. namespace net {
  39. namespace {
  40. const char* kTextHtml = "text/html";
  41. class HeadersURLRequestJob : public URLRequestJob {
  42. public:
  43. explicit HeadersURLRequestJob(URLRequest* request) : URLRequestJob(request) {}
  44. ~HeadersURLRequestJob() override {}
  45. void Start() override {
  46. // Fills response headers and returns immediately.
  47. NotifyHeadersComplete();
  48. }
  49. bool GetMimeType(std::string* mime_type) const override {
  50. *mime_type = GetContentTypeValue();
  51. return true;
  52. }
  53. void GetResponseInfo(HttpResponseInfo* info) override {
  54. // This is called by NotifyHeadersComplete().
  55. std::string header_string("HTTP/1.0 200 OK");
  56. header_string.push_back('\0');
  57. header_string += std::string("Cache-Control: max-age=600");
  58. header_string.push_back('\0');
  59. if (request()->url().path_piece() == "/multiplecontenttype") {
  60. header_string += std::string(
  61. "coNteNt-tYPe: text/plain; charset=iso-8859-4, image/png");
  62. header_string.push_back('\0');
  63. }
  64. header_string += std::string("Content-Type: ") + GetContentTypeValue();
  65. header_string.push_back('\0');
  66. header_string += std::string("Foo: A");
  67. header_string.push_back('\0');
  68. header_string += std::string("Bar: B");
  69. header_string.push_back('\0');
  70. header_string += std::string("Baz: C");
  71. header_string.push_back('\0');
  72. header_string += std::string("Foo: D");
  73. header_string.push_back('\0');
  74. header_string += std::string("Foo: E");
  75. header_string.push_back('\0');
  76. header_string += std::string("Bar: F");
  77. header_string.push_back('\0');
  78. info->headers = new HttpResponseHeaders(header_string);
  79. }
  80. protected:
  81. std::string GetContentTypeValue() const {
  82. if (request()->url().path_piece() == "/badcontenttype")
  83. return "\xff";
  84. return kTextHtml;
  85. }
  86. };
  87. class NetURLRequestInterceptor : public URLRequestInterceptor {
  88. public:
  89. std::unique_ptr<URLRequestJob> MaybeInterceptRequest(
  90. URLRequest* request) const override {
  91. return std::make_unique<HeadersURLRequestJob>(request);
  92. }
  93. };
  94. class ProtocolHandlerUtilTest : public PlatformTest,
  95. public URLRequest::Delegate {
  96. public:
  97. ProtocolHandlerUtilTest()
  98. : task_environment_(base::test::TaskEnvironment::MainThreadType::IO),
  99. request_context_(net::CreateTestURLRequestContextBuilder()->Build()) {
  100. URLRequestFilter::GetInstance()->AddHostnameInterceptor(
  101. "http", "foo.test", std::make_unique<NetURLRequestInterceptor>());
  102. }
  103. ~ProtocolHandlerUtilTest() override {
  104. URLRequestFilter::GetInstance()->ClearHandlers();
  105. }
  106. void OnResponseStarted(URLRequest* request, int net_error) override {}
  107. void OnReadCompleted(URLRequest* request, int bytes_read) override {}
  108. protected:
  109. base::test::SingleThreadTaskEnvironment task_environment_;
  110. std::unique_ptr<URLRequestContext> request_context_;
  111. };
  112. } // namespace
  113. TEST_F(ProtocolHandlerUtilTest, GetResponseHttpTest) {
  114. // Create a request.
  115. GURL url("http://foo.test/");
  116. std::unique_ptr<URLRequest> request(
  117. request_context_->CreateRequest(url, DEFAULT_PRIORITY, this));
  118. request->Start();
  119. // Create a response from the request.
  120. NSURLResponse* response = GetNSURLResponseForRequest(request.get());
  121. EXPECT_NSEQ([NSString stringWithUTF8String:kTextHtml], [response MIMEType]);
  122. ASSERT_TRUE([response isKindOfClass:[NSHTTPURLResponse class]]);
  123. NSHTTPURLResponse* http_response = (NSHTTPURLResponse*)response;
  124. NSDictionary* headers = [http_response allHeaderFields];
  125. // Check the headers, duplicates must be appended.
  126. EXPECT_EQ(5u, [headers count]);
  127. NSString* foo_header = [headers objectForKey:@"Foo"];
  128. EXPECT_NSEQ(@"A,D,E", foo_header);
  129. NSString* bar_header = [headers objectForKey:@"Bar"];
  130. EXPECT_NSEQ(@"B,F", bar_header);
  131. NSString* baz_header = [headers objectForKey:@"Baz"];
  132. EXPECT_NSEQ(@"C", baz_header);
  133. NSString* cache_header = [headers objectForKey:@"Cache-Control"];
  134. EXPECT_NSEQ(@"no-store", cache_header); // Cache-Control is overridden.
  135. // Check the status.
  136. EXPECT_EQ(request->GetResponseCode(), [http_response statusCode]);
  137. }
  138. TEST_F(ProtocolHandlerUtilTest, BadHttpContentType) {
  139. // Create a request using the magic path that triggers a garbage
  140. // content-type in the test framework.
  141. GURL url("http://foo.test/badcontenttype");
  142. std::unique_ptr<URLRequest> request(
  143. request_context_->CreateRequest(url, DEFAULT_PRIORITY, this));
  144. request->Start();
  145. // Create a response from the request.
  146. @try {
  147. GetNSURLResponseForRequest(request.get());
  148. }
  149. @catch (id exception) {
  150. FAIL() << "Exception while creating response";
  151. }
  152. }
  153. TEST_F(ProtocolHandlerUtilTest, MultipleHttpContentType) {
  154. // Create a request using the magic path that triggers a garbage
  155. // content-type in the test framework.
  156. GURL url("http://foo.test/multiplecontenttype");
  157. std::unique_ptr<URLRequest> request(
  158. request_context_->CreateRequest(url, DEFAULT_PRIORITY, this));
  159. request->Start();
  160. // Create a response from the request.
  161. NSURLResponse* response = GetNSURLResponseForRequest(request.get());
  162. EXPECT_NSEQ(@"text/plain", [response MIMEType]);
  163. EXPECT_NSEQ(@"iso-8859-4", [response textEncodingName]);
  164. NSHTTPURLResponse* http_response = (NSHTTPURLResponse*)response;
  165. NSDictionary* headers = [http_response allHeaderFields];
  166. NSString* content_type_header = [headers objectForKey:@"Content-Type"];
  167. EXPECT_NSEQ(@"text/plain; charset=iso-8859-4", content_type_header);
  168. }
  169. TEST_F(ProtocolHandlerUtilTest, CopyHttpHeaders) {
  170. GURL url("http://foo.test/");
  171. NSMutableURLRequest* in_request =
  172. [[NSMutableURLRequest alloc] initWithURL:NSURLWithGURL(url)];
  173. [in_request setAllHTTPHeaderFields:@{
  174. @"Referer" : @"referrer",
  175. @"User-Agent" : @"secret",
  176. @"Accept" : @"money/cash",
  177. @"Foo" : @"bar",
  178. }];
  179. std::unique_ptr<URLRequest> out_request(
  180. request_context_->CreateRequest(url, DEFAULT_PRIORITY, nullptr));
  181. CopyHttpHeaders(in_request, out_request.get());
  182. EXPECT_EQ("referrer", out_request->referrer());
  183. const HttpRequestHeaders& headers = out_request->extra_request_headers();
  184. EXPECT_FALSE(headers.HasHeader("Content-Type")); // Only in POST requests.
  185. std::string header;
  186. EXPECT_TRUE(headers.GetHeader("Accept", &header));
  187. EXPECT_EQ("money/cash", header);
  188. EXPECT_TRUE(headers.GetHeader("Foo", &header));
  189. EXPECT_EQ("bar", header);
  190. }
  191. TEST_F(ProtocolHandlerUtilTest, AddMissingHeaders) {
  192. GURL url("http://foo.test/");
  193. NSMutableURLRequest* in_request =
  194. [[NSMutableURLRequest alloc] initWithURL:NSURLWithGURL(url)];
  195. std::unique_ptr<URLRequest> out_request(
  196. request_context_->CreateRequest(url, DEFAULT_PRIORITY, nullptr));
  197. out_request->set_method("POST");
  198. std::unique_ptr<UploadElementReader> reader(
  199. new UploadBytesElementReader(nullptr, 0));
  200. out_request->set_upload(
  201. ElementsUploadDataStream::CreateWithReader(std::move(reader), 0));
  202. CopyHttpHeaders(in_request, out_request.get());
  203. // Some headers are added by default if missing.
  204. const HttpRequestHeaders& headers = out_request->extra_request_headers();
  205. std::string header;
  206. EXPECT_TRUE(headers.GetHeader("Accept", &header));
  207. EXPECT_EQ("*/*", header);
  208. EXPECT_TRUE(headers.GetHeader("Content-Type", &header));
  209. EXPECT_EQ("application/x-www-form-urlencoded", header);
  210. }
  211. } // namespace net