quic_end_to_end_unittest.cc 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322
  1. // Copyright 2013 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. #include <memory>
  5. #include <ostream>
  6. #include <utility>
  7. #include <vector>
  8. #include "base/compiler_specific.h"
  9. #include "base/memory/ptr_util.h"
  10. #include "base/run_loop.h"
  11. #include "base/strings/string_number_conversions.h"
  12. #include "net/base/completion_once_callback.h"
  13. #include "net/base/elements_upload_data_stream.h"
  14. #include "net/base/ip_address.h"
  15. #include "net/base/test_completion_callback.h"
  16. #include "net/base/upload_bytes_element_reader.h"
  17. #include "net/base/upload_data_stream.h"
  18. #include "net/cert/ct_policy_enforcer.h"
  19. #include "net/cert/mock_cert_verifier.h"
  20. #include "net/cert/multi_log_ct_verifier.h"
  21. #include "net/dns/mapped_host_resolver.h"
  22. #include "net/dns/mock_host_resolver.h"
  23. #include "net/http/http_auth_handler_factory.h"
  24. #include "net/http/http_network_session.h"
  25. #include "net/http/http_network_transaction.h"
  26. #include "net/http/http_server_properties.h"
  27. #include "net/http/http_transaction_test_util.h"
  28. #include "net/http/transport_security_state.h"
  29. #include "net/log/net_log_with_source.h"
  30. #include "net/proxy_resolution/configured_proxy_resolution_service.h"
  31. #include "net/quic/crypto_test_utils_chromium.h"
  32. #include "net/quic/quic_context.h"
  33. #include "net/socket/client_socket_factory.h"
  34. #include "net/ssl/ssl_config_service_defaults.h"
  35. #include "net/test/cert_test_util.h"
  36. #include "net/test/gtest_util.h"
  37. #include "net/test/test_data_directory.h"
  38. #include "net/test/test_with_task_environment.h"
  39. #include "net/third_party/quiche/src/quiche/quic/test_tools/crypto_test_utils.h"
  40. #include "net/third_party/quiche/src/quiche/quic/test_tools/quic_test_utils.h"
  41. #include "net/third_party/quiche/src/quiche/quic/tools/quic_memory_cache_backend.h"
  42. #include "net/tools/quic/quic_simple_server.h"
  43. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  44. #include "testing/gmock/include/gmock/gmock.h"
  45. #include "testing/gtest/include/gtest/gtest.h"
  46. #include "testing/platform_test.h"
  47. namespace net {
  48. using test::IsOk;
  49. namespace test {
  50. namespace {
  51. const char kResponseBody[] = "some arbitrary response body";
  52. // Factory for creating HttpTransactions, used by TestTransactionConsumer.
  53. class TestTransactionFactory : public HttpTransactionFactory {
  54. public:
  55. explicit TestTransactionFactory(
  56. const HttpNetworkSessionParams& session_params,
  57. const HttpNetworkSessionContext& session_context)
  58. : session_(std::make_unique<HttpNetworkSession>(session_params,
  59. session_context)) {}
  60. ~TestTransactionFactory() override = default;
  61. // HttpTransactionFactory methods
  62. int CreateTransaction(RequestPriority priority,
  63. std::unique_ptr<HttpTransaction>* trans) override {
  64. *trans = std::make_unique<HttpNetworkTransaction>(priority, session_.get());
  65. return OK;
  66. }
  67. HttpCache* GetCache() override { return nullptr; }
  68. HttpNetworkSession* GetSession() override { return session_.get(); }
  69. private:
  70. std::unique_ptr<HttpNetworkSession> session_;
  71. };
  72. } // namespace
  73. class QuicEndToEndTest : public ::testing::Test, public WithTaskEnvironment {
  74. protected:
  75. QuicEndToEndTest()
  76. : host_resolver_(CreateResolverImpl()),
  77. ssl_config_service_(std::make_unique<SSLConfigServiceDefaults>()),
  78. proxy_resolution_service_(
  79. ConfiguredProxyResolutionService::CreateDirect()),
  80. auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault()) {
  81. request_.method = "GET";
  82. request_.url = GURL("https://test.example.com/");
  83. request_.load_flags = 0;
  84. request_.traffic_annotation =
  85. net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS);
  86. session_params_.enable_quic = true;
  87. session_context_.client_socket_factory =
  88. ClientSocketFactory::GetDefaultFactory();
  89. session_context_.quic_context = &quic_context_;
  90. session_context_.host_resolver = &host_resolver_;
  91. session_context_.cert_verifier = &cert_verifier_;
  92. session_context_.transport_security_state = &transport_security_state_;
  93. session_context_.ct_policy_enforcer = &ct_policy_enforcer_;
  94. session_context_.proxy_resolution_service = proxy_resolution_service_.get();
  95. session_context_.ssl_config_service = ssl_config_service_.get();
  96. session_context_.http_auth_handler_factory = auth_handler_factory_.get();
  97. session_context_.http_server_properties = &http_server_properties_;
  98. CertVerifyResult verify_result;
  99. verify_result.verified_cert =
  100. ImportCertFromFile(GetTestCertsDirectory(), "quic-chain.pem");
  101. cert_verifier_.AddResultForCertAndHost(verify_result.verified_cert.get(),
  102. "test.example.com", verify_result,
  103. OK);
  104. }
  105. // Creates a mock host resolver in which test.example.com
  106. // resolves to localhost.
  107. static std::unique_ptr<MockHostResolver> CreateResolverImpl() {
  108. auto resolver = std::make_unique<MockHostResolver>();
  109. resolver->rules()->AddRule("test.example.com", "127.0.0.1");
  110. return resolver;
  111. }
  112. void SetUp() override {
  113. StartServer();
  114. // Use a mapped host resolver so that request for test.example.com (port 80)
  115. // reach the server running on localhost.
  116. std::string map_rule =
  117. "MAP test.example.com test.example.com:" +
  118. base::NumberToString(server_->server_address().port());
  119. EXPECT_TRUE(host_resolver_.AddRuleFromString(map_rule));
  120. // To simplify the test, and avoid the race with the HTTP request, we force
  121. // QUIC for these requests.
  122. quic_context_.params()->origins_to_force_quic_on.insert(
  123. HostPortPair::FromString("test.example.com:443"));
  124. transaction_factory_ = std::make_unique<TestTransactionFactory>(
  125. session_params_, session_context_);
  126. }
  127. void TearDown() override {}
  128. // Starts the QUIC server listening on a random port.
  129. void StartServer() {
  130. server_address_ = IPEndPoint(IPAddress(127, 0, 0, 1), 0);
  131. server_config_.SetInitialStreamFlowControlWindowToSend(
  132. quic::test::kInitialStreamFlowControlWindowForTest);
  133. server_config_.SetInitialSessionFlowControlWindowToSend(
  134. quic::test::kInitialSessionFlowControlWindowForTest);
  135. server_ = std::make_unique<QuicSimpleServer>(
  136. net::test::ProofSourceForTestingChromium(), server_config_,
  137. server_config_options_, quic::AllSupportedVersions(),
  138. &memory_cache_backend_);
  139. server_->Listen(server_address_);
  140. server_address_ = server_->server_address();
  141. server_->StartReading();
  142. server_started_ = true;
  143. }
  144. // Adds an entry to the cache used by the QUIC server to serve
  145. // responses.
  146. void AddToCache(absl::string_view path,
  147. int response_code,
  148. absl::string_view response_detail,
  149. absl::string_view body) {
  150. memory_cache_backend_.AddSimpleResponse("test.example.com", path,
  151. response_code, body);
  152. }
  153. // Populates |request_body_| with |length_| ASCII bytes.
  154. void GenerateBody(size_t length) {
  155. request_body_.clear();
  156. request_body_.reserve(length);
  157. for (size_t i = 0; i < length; ++i) {
  158. request_body_.append(1, static_cast<char>(32 + i % (126 - 32)));
  159. }
  160. }
  161. // Initializes |request_| for a post of |length| bytes.
  162. void InitializePostRequest(size_t length) {
  163. GenerateBody(length);
  164. std::vector<std::unique_ptr<UploadElementReader>> element_readers;
  165. element_readers.push_back(std::make_unique<UploadBytesElementReader>(
  166. request_body_.data(), request_body_.length()));
  167. upload_data_stream_ = std::make_unique<ElementsUploadDataStream>(
  168. std::move(element_readers), 0);
  169. request_.method = "POST";
  170. request_.url = GURL("https://test.example.com/");
  171. request_.upload_data_stream = upload_data_stream_.get();
  172. ASSERT_THAT(request_.upload_data_stream->Init(CompletionOnceCallback(),
  173. NetLogWithSource()),
  174. IsOk());
  175. }
  176. // Checks that |consumer| completed and received |status_line| and |body|.
  177. void CheckResponse(const TestTransactionConsumer& consumer,
  178. const std::string& status_line,
  179. const std::string& body) {
  180. ASSERT_TRUE(consumer.is_done());
  181. ASSERT_THAT(consumer.error(), IsOk());
  182. EXPECT_EQ(status_line, consumer.response_info()->headers->GetStatusLine());
  183. EXPECT_EQ(body, consumer.content());
  184. }
  185. QuicContext quic_context_;
  186. MappedHostResolver host_resolver_;
  187. MockCertVerifier cert_verifier_;
  188. TransportSecurityState transport_security_state_;
  189. DefaultCTPolicyEnforcer ct_policy_enforcer_;
  190. std::unique_ptr<SSLConfigServiceDefaults> ssl_config_service_;
  191. std::unique_ptr<ProxyResolutionService> proxy_resolution_service_;
  192. std::unique_ptr<HttpAuthHandlerFactory> auth_handler_factory_;
  193. HttpServerProperties http_server_properties_;
  194. HttpNetworkSessionParams session_params_;
  195. HttpNetworkSessionContext session_context_;
  196. std::unique_ptr<TestTransactionFactory> transaction_factory_;
  197. HttpRequestInfo request_;
  198. std::string request_body_;
  199. std::unique_ptr<UploadDataStream> upload_data_stream_;
  200. std::unique_ptr<QuicSimpleServer> server_;
  201. quic::QuicMemoryCacheBackend memory_cache_backend_;
  202. IPEndPoint server_address_;
  203. std::string server_hostname_;
  204. quic::QuicConfig server_config_;
  205. quic::QuicCryptoServerConfig::ConfigOptions server_config_options_;
  206. bool server_started_;
  207. bool strike_register_no_startup_period_ = false;
  208. };
  209. TEST_F(QuicEndToEndTest, LargeGetWithNoPacketLoss) {
  210. std::string response(10 * 1024, 'x');
  211. AddToCache(request_.url.PathForRequest(), 200, "OK", response);
  212. TestTransactionConsumer consumer(DEFAULT_PRIORITY,
  213. transaction_factory_.get());
  214. consumer.Start(&request_, NetLogWithSource());
  215. // Will terminate when the last consumer completes.
  216. base::RunLoop().Run();
  217. CheckResponse(consumer, "HTTP/1.1 200", response);
  218. }
  219. // crbug.com/559173
  220. #if defined(THREAD_SANITIZER)
  221. TEST_F(QuicEndToEndTest, DISABLED_LargePostWithNoPacketLoss) {
  222. #else
  223. TEST_F(QuicEndToEndTest, LargePostWithNoPacketLoss) {
  224. #endif
  225. InitializePostRequest(1024 * 1024);
  226. AddToCache(request_.url.PathForRequest(), 200, "OK", kResponseBody);
  227. TestTransactionConsumer consumer(DEFAULT_PRIORITY,
  228. transaction_factory_.get());
  229. consumer.Start(&request_, NetLogWithSource());
  230. // Will terminate when the last consumer completes.
  231. base::RunLoop().Run();
  232. CheckResponse(consumer, "HTTP/1.1 200", kResponseBody);
  233. }
  234. // crbug.com/559173
  235. #if defined(THREAD_SANITIZER)
  236. TEST_F(QuicEndToEndTest, DISABLED_LargePostWithPacketLoss) {
  237. #else
  238. TEST_F(QuicEndToEndTest, LargePostWithPacketLoss) {
  239. #endif
  240. // FLAGS_fake_packet_loss_percentage = 30;
  241. InitializePostRequest(1024 * 1024);
  242. AddToCache(request_.url.PathForRequest(), 200, "OK", kResponseBody);
  243. TestTransactionConsumer consumer(DEFAULT_PRIORITY,
  244. transaction_factory_.get());
  245. consumer.Start(&request_, NetLogWithSource());
  246. // Will terminate when the last consumer completes.
  247. base::RunLoop().Run();
  248. CheckResponse(consumer, "HTTP/1.1 200", kResponseBody);
  249. }
  250. // crbug.com/536845
  251. #if defined(THREAD_SANITIZER)
  252. TEST_F(QuicEndToEndTest, DISABLED_UberTest) {
  253. #else
  254. TEST_F(QuicEndToEndTest, UberTest) {
  255. #endif
  256. // FLAGS_fake_packet_loss_percentage = 30;
  257. AddToCache(request_.url.PathForRequest(), 200, "OK", kResponseBody);
  258. std::vector<std::unique_ptr<TestTransactionConsumer>> consumers;
  259. for (size_t i = 0; i < 100; ++i) {
  260. TestTransactionConsumer* consumer = new TestTransactionConsumer(
  261. DEFAULT_PRIORITY, transaction_factory_.get());
  262. consumers.push_back(base::WrapUnique(consumer));
  263. consumer->Start(&request_, NetLogWithSource());
  264. }
  265. // Will terminate when the last consumer completes.
  266. base::RunLoop().Run();
  267. for (const auto& consumer : consumers)
  268. CheckResponse(*consumer.get(), "HTTP/1.1 200", kResponseBody);
  269. }
  270. } // namespace test
  271. } // namespace net