cert_net_fetcher_url_request_unittest.cc 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674
  1. // Copyright 2015 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 "net/cert_net/cert_net_fetcher_url_request.h"
  5. #include <memory>
  6. #include <string>
  7. #include <utility>
  8. #include "base/bind.h"
  9. #include "base/memory/raw_ptr.h"
  10. #include "base/message_loop/message_pump_type.h"
  11. #include "base/run_loop.h"
  12. #include "base/synchronization/lock.h"
  13. #include "net/cert/cert_net_fetcher.h"
  14. #include "net/cert/ct_policy_enforcer.h"
  15. #include "net/cert/mock_cert_verifier.h"
  16. #include "net/cert/multi_log_ct_verifier.h"
  17. #include "net/dns/mock_host_resolver.h"
  18. #include "net/dns/public/secure_dns_policy.h"
  19. #include "net/http/http_server_properties.h"
  20. #include "net/http/transport_security_state.h"
  21. #include "net/proxy_resolution/configured_proxy_resolution_service.h"
  22. #include "net/quic/quic_context.h"
  23. #include "net/test/embedded_test_server/embedded_test_server.h"
  24. #include "net/test/gtest_util.h"
  25. #include "net/test/test_with_task_environment.h"
  26. #include "net/test/url_request/url_request_hanging_read_job.h"
  27. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  28. #include "net/url_request/url_request_context_builder.h"
  29. #include "net/url_request/url_request_filter.h"
  30. #include "net/url_request/url_request_interceptor.h"
  31. #include "net/url_request/url_request_job_factory.h"
  32. #include "net/url_request/url_request_test_util.h"
  33. #include "testing/gmock/include/gmock/gmock.h"
  34. #include "testing/gtest/include/gtest/gtest.h"
  35. #include "testing/platform_test.h"
  36. using net::test::IsOk;
  37. // TODO(eroman): Test that cookies aren't sent.
  38. namespace net {
  39. namespace {
  40. const base::FilePath::CharType kDocRoot[] =
  41. FILE_PATH_LITERAL("net/data/cert_net_fetcher_impl_unittest");
  42. const char kMockSecureDnsHostname[] = "mock.secure.dns.check";
  43. // Wait for the request to complete, and verify that it completed successfully
  44. // with the indicated bytes.
  45. void VerifySuccess(const std::string& expected_body,
  46. CertNetFetcher::Request* request) {
  47. Error actual_error;
  48. std::vector<uint8_t> actual_body;
  49. request->WaitForResult(&actual_error, &actual_body);
  50. EXPECT_THAT(actual_error, IsOk());
  51. EXPECT_EQ(expected_body, std::string(actual_body.begin(), actual_body.end()));
  52. }
  53. // Wait for the request to complete, and verify that it completed with the
  54. // indicated failure.
  55. void VerifyFailure(Error expected_error, CertNetFetcher::Request* request) {
  56. Error actual_error;
  57. std::vector<uint8_t> actual_body;
  58. request->WaitForResult(&actual_error, &actual_body);
  59. EXPECT_EQ(expected_error, actual_error);
  60. EXPECT_EQ(0u, actual_body.size());
  61. }
  62. struct NetworkThreadState {
  63. std::unique_ptr<URLRequestContext> context;
  64. // Owned by `context`.
  65. raw_ptr<TestNetworkDelegate> network_delegate;
  66. };
  67. class CertNetFetcherURLRequestTest : public PlatformTest {
  68. public:
  69. CertNetFetcherURLRequestTest() {
  70. test_server_.AddDefaultHandlers(base::FilePath(kDocRoot));
  71. StartNetworkThread();
  72. }
  73. ~CertNetFetcherURLRequestTest() override {
  74. if (!network_thread_)
  75. return;
  76. network_thread_->task_runner()->PostTask(
  77. FROM_HERE,
  78. base::BindOnce(&CertNetFetcherURLRequestTest::TeardownOnNetworkThread,
  79. base::Unretained(this)));
  80. network_thread_->Stop();
  81. }
  82. protected:
  83. CertNetFetcher* fetcher() const { return fetcher_.get(); }
  84. void CreateFetcherOnNetworkThread(base::WaitableEvent* done) {
  85. fetcher_ = base::MakeRefCounted<CertNetFetcherURLRequest>();
  86. fetcher_->SetURLRequestContext(state_->context.get());
  87. done->Signal();
  88. }
  89. void CreateFetcher() {
  90. base::WaitableEvent done(base::WaitableEvent::ResetPolicy::MANUAL,
  91. base::WaitableEvent::InitialState::NOT_SIGNALED);
  92. network_thread_->task_runner()->PostTask(
  93. FROM_HERE,
  94. base::BindOnce(
  95. &CertNetFetcherURLRequestTest::CreateFetcherOnNetworkThread,
  96. base::Unretained(this), &done));
  97. done.Wait();
  98. }
  99. void ShutDownFetcherOnNetworkThread(base::WaitableEvent* done) {
  100. fetcher_->Shutdown();
  101. done->Signal();
  102. }
  103. void ShutDownFetcher() {
  104. base::WaitableEvent done(base::WaitableEvent::ResetPolicy::MANUAL,
  105. base::WaitableEvent::InitialState::NOT_SIGNALED);
  106. network_thread_->task_runner()->PostTask(
  107. FROM_HERE,
  108. base::BindOnce(
  109. &CertNetFetcherURLRequestTest::ShutDownFetcherOnNetworkThread,
  110. base::Unretained(this), &done));
  111. done.Wait();
  112. }
  113. int NumCreatedRequests() {
  114. int count = 0;
  115. base::WaitableEvent done(base::WaitableEvent::ResetPolicy::MANUAL,
  116. base::WaitableEvent::InitialState::NOT_SIGNALED);
  117. network_thread_->task_runner()->PostTask(
  118. FROM_HERE,
  119. base::BindOnce(&CertNetFetcherURLRequestTest::CountCreatedRequests,
  120. base::Unretained(this), &count, &done));
  121. done.Wait();
  122. return count;
  123. }
  124. void StartNetworkThread() {
  125. // Start the network thread.
  126. network_thread_ = std::make_unique<base::Thread>("network thread");
  127. base::Thread::Options options(base::MessagePumpType::IO, 0);
  128. EXPECT_TRUE(network_thread_->StartWithOptions(std::move(options)));
  129. // Initialize the URLRequestContext (and wait till it has completed).
  130. base::WaitableEvent done(base::WaitableEvent::ResetPolicy::MANUAL,
  131. base::WaitableEvent::InitialState::NOT_SIGNALED);
  132. network_thread_->task_runner()->PostTask(
  133. FROM_HERE,
  134. base::BindOnce(&CertNetFetcherURLRequestTest::InitOnNetworkThread,
  135. base::Unretained(this), &done));
  136. done.Wait();
  137. }
  138. void InitOnNetworkThread(base::WaitableEvent* done) {
  139. state_ = std::make_unique<NetworkThreadState>();
  140. auto builder = CreateTestURLRequestContextBuilder();
  141. state_->network_delegate =
  142. builder->set_network_delegate(std::make_unique<TestNetworkDelegate>());
  143. state_->context = builder->Build();
  144. done->Signal();
  145. }
  146. void ResetStateOnNetworkThread(base::WaitableEvent* done) {
  147. state_.reset();
  148. done->Signal();
  149. }
  150. void ResetState() {
  151. base::WaitableEvent done(base::WaitableEvent::ResetPolicy::MANUAL,
  152. base::WaitableEvent::InitialState::NOT_SIGNALED);
  153. network_thread_->task_runner()->PostTask(
  154. FROM_HERE,
  155. base::BindOnce(&CertNetFetcherURLRequestTest::ResetStateOnNetworkThread,
  156. base::Unretained(this), &done));
  157. done.Wait();
  158. }
  159. void TeardownOnNetworkThread() {
  160. fetcher_->Shutdown();
  161. state_.reset();
  162. fetcher_ = nullptr;
  163. }
  164. void CountCreatedRequests(int* count, base::WaitableEvent* done) {
  165. *count = state_->network_delegate->created_requests();
  166. done->Signal();
  167. }
  168. EmbeddedTestServer test_server_;
  169. std::unique_ptr<base::Thread> network_thread_;
  170. scoped_refptr<CertNetFetcherURLRequest> fetcher_;
  171. std::unique_ptr<NetworkThreadState> state_;
  172. };
  173. // Installs URLRequestHangingReadJob handlers and clears them on teardown.
  174. class CertNetFetcherURLRequestTestWithHangingReadHandler
  175. : public CertNetFetcherURLRequestTest,
  176. public WithTaskEnvironment {
  177. protected:
  178. void SetUp() override { URLRequestHangingReadJob::AddUrlHandler(); }
  179. void TearDown() override { URLRequestFilter::GetInstance()->ClearHandlers(); }
  180. };
  181. // Interceptor to check that secure DNS has been disabled.
  182. class SecureDnsInterceptor : public net::URLRequestInterceptor {
  183. public:
  184. explicit SecureDnsInterceptor(bool* invoked_interceptor)
  185. : invoked_interceptor_(invoked_interceptor) {}
  186. ~SecureDnsInterceptor() override = default;
  187. private:
  188. // URLRequestInterceptor implementation:
  189. std::unique_ptr<net::URLRequestJob> MaybeInterceptRequest(
  190. net::URLRequest* request) const override {
  191. EXPECT_EQ(SecureDnsPolicy::kDisable, request->secure_dns_policy());
  192. *invoked_interceptor_ = true;
  193. return nullptr;
  194. }
  195. raw_ptr<bool> invoked_interceptor_;
  196. };
  197. class CertNetFetcherURLRequestTestWithSecureDnsInterceptor
  198. : public CertNetFetcherURLRequestTest,
  199. public WithTaskEnvironment {
  200. public:
  201. CertNetFetcherURLRequestTestWithSecureDnsInterceptor() = default;
  202. void SetUp() override {
  203. URLRequestFilter::GetInstance()->AddHostnameInterceptor(
  204. "http", kMockSecureDnsHostname,
  205. std::make_unique<SecureDnsInterceptor>(&invoked_interceptor_));
  206. }
  207. void TearDown() override { URLRequestFilter::GetInstance()->ClearHandlers(); }
  208. bool invoked_interceptor() { return invoked_interceptor_; }
  209. private:
  210. bool invoked_interceptor_ = false;
  211. };
  212. // Helper to start an AIA fetch using default parameters.
  213. [[nodiscard]] std::unique_ptr<CertNetFetcher::Request> StartRequest(
  214. CertNetFetcher* fetcher,
  215. const GURL& url) {
  216. return fetcher->FetchCaIssuers(url, CertNetFetcher::DEFAULT,
  217. CertNetFetcher::DEFAULT);
  218. }
  219. // Fetch a few unique URLs using GET in parallel. Each URL has a different body
  220. // and Content-Type.
  221. TEST_F(CertNetFetcherURLRequestTest, ParallelFetchNoDuplicates) {
  222. ASSERT_TRUE(test_server_.Start());
  223. CreateFetcher();
  224. // Request a URL with Content-Type "application/pkix-cert"
  225. GURL url1 = test_server_.GetURL("/cert.crt");
  226. std::unique_ptr<CertNetFetcher::Request> request1 =
  227. StartRequest(fetcher(), url1);
  228. // Request a URL with Content-Type "application/pkix-crl"
  229. GURL url2 = test_server_.GetURL("/root.crl");
  230. std::unique_ptr<CertNetFetcher::Request> request2 =
  231. StartRequest(fetcher(), url2);
  232. // Request a URL with Content-Type "application/pkcs7-mime"
  233. GURL url3 = test_server_.GetURL("/certs.p7c");
  234. std::unique_ptr<CertNetFetcher::Request> request3 =
  235. StartRequest(fetcher(), url3);
  236. // Wait for all of the requests to complete and verify the fetch results.
  237. VerifySuccess("-cert.crt-\n", request1.get());
  238. VerifySuccess("-root.crl-\n", request2.get());
  239. VerifySuccess("-certs.p7c-\n", request3.get());
  240. EXPECT_EQ(3, NumCreatedRequests());
  241. }
  242. // Fetch a caIssuers URL which has an unexpected extension and Content-Type.
  243. // The extension is .txt and the Content-Type is text/plain. Despite being
  244. // unusual this succeeds as the extension and Content-Type are not required to
  245. // be meaningful.
  246. TEST_F(CertNetFetcherURLRequestTest, ContentTypeDoesntMatter) {
  247. ASSERT_TRUE(test_server_.Start());
  248. CreateFetcher();
  249. GURL url = test_server_.GetURL("/foo.txt");
  250. std::unique_ptr<CertNetFetcher::Request> request =
  251. StartRequest(fetcher(), url);
  252. VerifySuccess("-foo.txt-\n", request.get());
  253. }
  254. // Fetch a URLs whose HTTP response code is not 200. These are considered
  255. // failures.
  256. TEST_F(CertNetFetcherURLRequestTest, HttpStatusCode) {
  257. ASSERT_TRUE(test_server_.Start());
  258. CreateFetcher();
  259. // Response was HTTP status 404.
  260. {
  261. GURL url = test_server_.GetURL("/404.html");
  262. std::unique_ptr<CertNetFetcher::Request> request =
  263. StartRequest(fetcher(), url);
  264. VerifyFailure(ERR_HTTP_RESPONSE_CODE_FAILURE, request.get());
  265. }
  266. // Response was HTTP status 500.
  267. {
  268. GURL url = test_server_.GetURL("/500.html");
  269. std::unique_ptr<CertNetFetcher::Request> request =
  270. StartRequest(fetcher(), url);
  271. VerifyFailure(ERR_HTTP_RESPONSE_CODE_FAILURE, request.get());
  272. }
  273. }
  274. // Fetching a URL with a Content-Disposition header should have no effect.
  275. TEST_F(CertNetFetcherURLRequestTest, ContentDisposition) {
  276. ASSERT_TRUE(test_server_.Start());
  277. CreateFetcher();
  278. GURL url = test_server_.GetURL("/downloadable.js");
  279. std::unique_ptr<CertNetFetcher::Request> request =
  280. StartRequest(fetcher(), url);
  281. VerifySuccess("-downloadable.js-\n", request.get());
  282. }
  283. // Verifies that a cacheable request will be served from the HTTP cache the
  284. // second time it is requested.
  285. TEST_F(CertNetFetcherURLRequestTest, Cache) {
  286. ASSERT_TRUE(test_server_.Start());
  287. CreateFetcher();
  288. // Fetch a URL whose HTTP headers make it cacheable for 1 hour.
  289. GURL url(test_server_.GetURL("/cacheable_1hr.crt"));
  290. {
  291. std::unique_ptr<CertNetFetcher::Request> request =
  292. StartRequest(fetcher(), url);
  293. VerifySuccess("-cacheable_1hr.crt-\n", request.get());
  294. }
  295. EXPECT_EQ(1, NumCreatedRequests());
  296. // Kill the HTTP server.
  297. ASSERT_TRUE(test_server_.ShutdownAndWaitUntilComplete());
  298. // Fetch again -- will fail unless served from cache.
  299. {
  300. std::unique_ptr<CertNetFetcher::Request> request =
  301. StartRequest(fetcher(), url);
  302. VerifySuccess("-cacheable_1hr.crt-\n", request.get());
  303. }
  304. EXPECT_EQ(2, NumCreatedRequests());
  305. }
  306. // Verify that the maximum response body constraints are enforced by fetching a
  307. // resource that is larger than the limit.
  308. TEST_F(CertNetFetcherURLRequestTest, TooLarge) {
  309. ASSERT_TRUE(test_server_.Start());
  310. CreateFetcher();
  311. // This file has a response body 12 bytes long. So setting the maximum to 11
  312. // bytes will cause it to fail.
  313. GURL url(test_server_.GetURL("/certs.p7c"));
  314. std::unique_ptr<CertNetFetcher::Request> request =
  315. fetcher()->FetchCaIssuers(url, CertNetFetcher::DEFAULT, 11);
  316. VerifyFailure(ERR_FILE_TOO_BIG, request.get());
  317. }
  318. // Set the timeout to 10 milliseconds, and try fetching a URL that takes 5
  319. // seconds to complete. It should fail due to a timeout.
  320. TEST_F(CertNetFetcherURLRequestTest, Hang) {
  321. ASSERT_TRUE(test_server_.Start());
  322. CreateFetcher();
  323. GURL url(test_server_.GetURL("/slow/certs.p7c?5"));
  324. std::unique_ptr<CertNetFetcher::Request> request =
  325. fetcher()->FetchCaIssuers(url, 10, CertNetFetcher::DEFAULT);
  326. VerifyFailure(ERR_TIMED_OUT, request.get());
  327. }
  328. // Verify that if a response is gzip-encoded it gets inflated before being
  329. // returned to the caller.
  330. TEST_F(CertNetFetcherURLRequestTest, Gzip) {
  331. ASSERT_TRUE(test_server_.Start());
  332. CreateFetcher();
  333. GURL url(test_server_.GetURL("/gzipped_crl"));
  334. std::unique_ptr<CertNetFetcher::Request> request =
  335. StartRequest(fetcher(), url);
  336. VerifySuccess("-gzipped_crl-\n", request.get());
  337. }
  338. // Try fetching an unsupported URL scheme (https).
  339. TEST_F(CertNetFetcherURLRequestTest, HttpsNotAllowed) {
  340. ASSERT_TRUE(test_server_.Start());
  341. CreateFetcher();
  342. GURL url("https://foopy/foo.crt");
  343. std::unique_ptr<CertNetFetcher::Request> request =
  344. StartRequest(fetcher(), url);
  345. VerifyFailure(ERR_DISALLOWED_URL_SCHEME, request.get());
  346. // No request was created because the URL scheme was unsupported.
  347. EXPECT_EQ(0, NumCreatedRequests());
  348. }
  349. // Try fetching a URL which redirects to https.
  350. TEST_F(CertNetFetcherURLRequestTest, RedirectToHttpsNotAllowed) {
  351. ASSERT_TRUE(test_server_.Start());
  352. CreateFetcher();
  353. GURL url(test_server_.GetURL("/redirect_https"));
  354. std::unique_ptr<CertNetFetcher::Request> request =
  355. StartRequest(fetcher(), url);
  356. VerifyFailure(ERR_DISALLOWED_URL_SCHEME, request.get());
  357. EXPECT_EQ(1, NumCreatedRequests());
  358. }
  359. // Try fetching an unsupported URL scheme (https) and then immediately
  360. // cancelling. This is a bit special because this codepath needs to post a task.
  361. TEST_F(CertNetFetcherURLRequestTest, CancelHttpsNotAllowed) {
  362. ASSERT_TRUE(test_server_.Start());
  363. CreateFetcher();
  364. GURL url("https://foopy/foo.crt");
  365. std::unique_ptr<CertNetFetcher::Request> request =
  366. StartRequest(fetcher(), url);
  367. // Cancel the request (May or may not have started yet, as the request is
  368. // running on another thread).
  369. request.reset();
  370. }
  371. // Start a few requests, and cancel one of them before running the message loop
  372. // again.
  373. TEST_F(CertNetFetcherURLRequestTest, CancelBeforeRunningMessageLoop) {
  374. ASSERT_TRUE(test_server_.Start());
  375. CreateFetcher();
  376. GURL url1 = test_server_.GetURL("/cert.crt");
  377. std::unique_ptr<CertNetFetcher::Request> request1 =
  378. StartRequest(fetcher(), url1);
  379. GURL url2 = test_server_.GetURL("/root.crl");
  380. std::unique_ptr<CertNetFetcher::Request> request2 =
  381. StartRequest(fetcher(), url2);
  382. GURL url3 = test_server_.GetURL("/certs.p7c");
  383. std::unique_ptr<CertNetFetcher::Request> request3 =
  384. StartRequest(fetcher(), url3);
  385. // Cancel the second request.
  386. request2.reset();
  387. // Wait for the non-cancelled requests to complete, and verify the fetch
  388. // results.
  389. VerifySuccess("-cert.crt-\n", request1.get());
  390. VerifySuccess("-certs.p7c-\n", request3.get());
  391. }
  392. // Start several requests, and cancel one of them after the first has completed.
  393. // NOTE: The python test server is single threaded and can only service one
  394. // request at a time. After a socket is opened by the server it waits for it to
  395. // be completed, and any subsequent request will hang until the first socket is
  396. // closed.
  397. // Cancelling the first request can therefore be problematic, since if
  398. // cancellation is done after the socket is opened but before reading/writing,
  399. // then the socket is re-cycled and things will be stalled until the cleanup
  400. // timer (10 seconds) closes it.
  401. // To work around this, the last request is cancelled, and hope that the
  402. // requests are given opened sockets in a FIFO order.
  403. // TODO(eroman): Make this more robust.
  404. // TODO(eroman): Rename this test.
  405. TEST_F(CertNetFetcherURLRequestTest, CancelAfterRunningMessageLoop) {
  406. ASSERT_TRUE(test_server_.Start());
  407. CreateFetcher();
  408. GURL url1 = test_server_.GetURL("/cert.crt");
  409. std::unique_ptr<CertNetFetcher::Request> request1 =
  410. StartRequest(fetcher(), url1);
  411. GURL url2 = test_server_.GetURL("/certs.p7c");
  412. std::unique_ptr<CertNetFetcher::Request> request2 =
  413. StartRequest(fetcher(), url2);
  414. GURL url3("ftp://www.not.supported.com/foo");
  415. std::unique_ptr<CertNetFetcher::Request> request3 =
  416. StartRequest(fetcher(), url3);
  417. // Wait for the ftp request to complete (it should complete right away since
  418. // it doesn't even try to connect to the server).
  419. VerifyFailure(ERR_DISALLOWED_URL_SCHEME, request3.get());
  420. // Cancel the second outstanding request.
  421. request2.reset();
  422. // Wait for the first request to complete and verify the fetch result.
  423. VerifySuccess("-cert.crt-\n", request1.get());
  424. }
  425. // Fetch the same URLs in parallel and verify that only 1 request is made per
  426. // URL.
  427. TEST_F(CertNetFetcherURLRequestTest, ParallelFetchDuplicates) {
  428. ASSERT_TRUE(test_server_.Start());
  429. CreateFetcher();
  430. GURL url1 = test_server_.GetURL("/cert.crt");
  431. GURL url2 = test_server_.GetURL("/root.crl");
  432. // Issue 3 requests for url1, and 3 requests for url2
  433. std::unique_ptr<CertNetFetcher::Request> request1 =
  434. StartRequest(fetcher(), url1);
  435. std::unique_ptr<CertNetFetcher::Request> request2 =
  436. StartRequest(fetcher(), url2);
  437. std::unique_ptr<CertNetFetcher::Request> request3 =
  438. StartRequest(fetcher(), url1);
  439. std::unique_ptr<CertNetFetcher::Request> request4 =
  440. StartRequest(fetcher(), url2);
  441. std::unique_ptr<CertNetFetcher::Request> request5 =
  442. StartRequest(fetcher(), url2);
  443. std::unique_ptr<CertNetFetcher::Request> request6 =
  444. StartRequest(fetcher(), url1);
  445. // Cancel all but one of the requests for url1.
  446. request1.reset();
  447. request3.reset();
  448. // Wait for the remaining requests to finish and verify the fetch results.
  449. VerifySuccess("-root.crl-\n", request2.get());
  450. VerifySuccess("-root.crl-\n", request4.get());
  451. VerifySuccess("-root.crl-\n", request5.get());
  452. VerifySuccess("-cert.crt-\n", request6.get());
  453. // Verify that only 2 URLRequests were started even though 6 requests were
  454. // issued.
  455. EXPECT_EQ(2, NumCreatedRequests());
  456. }
  457. // Cancel a request and then start another one for the same URL.
  458. TEST_F(CertNetFetcherURLRequestTest, CancelThenStart) {
  459. ASSERT_TRUE(test_server_.Start());
  460. CreateFetcher();
  461. GURL url = test_server_.GetURL("/cert.crt");
  462. std::unique_ptr<CertNetFetcher::Request> request1 =
  463. StartRequest(fetcher(), url);
  464. request1.reset();
  465. std::unique_ptr<CertNetFetcher::Request> request2 =
  466. StartRequest(fetcher(), url);
  467. std::unique_ptr<CertNetFetcher::Request> request3 =
  468. StartRequest(fetcher(), url);
  469. request3.reset();
  470. // All but |request2| were canceled.
  471. VerifySuccess("-cert.crt-\n", request2.get());
  472. }
  473. // Start duplicate requests and then cancel all of them.
  474. TEST_F(CertNetFetcherURLRequestTest, CancelAll) {
  475. ASSERT_TRUE(test_server_.Start());
  476. CreateFetcher();
  477. std::unique_ptr<CertNetFetcher::Request> requests[3];
  478. GURL url = test_server_.GetURL("/cert.crt");
  479. for (auto& request : requests) {
  480. request = StartRequest(fetcher(), url);
  481. }
  482. // Cancel all the requests.
  483. for (auto& request : requests) {
  484. request.reset();
  485. }
  486. EXPECT_EQ(1, NumCreatedRequests());
  487. }
  488. // Tests that Requests are signalled for completion even if they are
  489. // created after the CertNetFetcher has been shutdown.
  490. TEST_F(CertNetFetcherURLRequestTest, RequestsAfterShutdown) {
  491. ASSERT_TRUE(test_server_.Start());
  492. CreateFetcher();
  493. ShutDownFetcher();
  494. GURL url = test_server_.GetURL("/cert.crt");
  495. std::unique_ptr<CertNetFetcher::Request> request =
  496. StartRequest(fetcher(), url);
  497. VerifyFailure(ERR_ABORTED, request.get());
  498. EXPECT_EQ(0, NumCreatedRequests());
  499. }
  500. // Tests that Requests are signalled for completion if the fetcher is
  501. // shutdown and the network thread stopped before the request is
  502. // started.
  503. TEST_F(CertNetFetcherURLRequestTest,
  504. RequestAfterShutdownAndNetworkThreadStopped) {
  505. ASSERT_TRUE(test_server_.Start());
  506. CreateFetcher();
  507. ShutDownFetcher();
  508. ResetState();
  509. network_thread_.reset();
  510. GURL url = test_server_.GetURL("/cert.crt");
  511. std::unique_ptr<CertNetFetcher::Request> request =
  512. StartRequest(fetcher(), url);
  513. VerifyFailure(ERR_ABORTED, request.get());
  514. }
  515. // Tests that outstanding Requests are cancelled when Shutdown is called.
  516. TEST_F(CertNetFetcherURLRequestTestWithHangingReadHandler,
  517. ShutdownCancelsRequests) {
  518. CreateFetcher();
  519. GURL url = URLRequestHangingReadJob::GetMockHttpUrl();
  520. std::unique_ptr<CertNetFetcher::Request> request =
  521. StartRequest(fetcher(), url);
  522. ShutDownFetcher();
  523. VerifyFailure(ERR_ABORTED, request.get());
  524. }
  525. TEST_F(CertNetFetcherURLRequestTestWithSecureDnsInterceptor,
  526. SecureDnsDisabled) {
  527. CreateFetcher();
  528. std::unique_ptr<net::CertNetFetcher::Request> request = StartRequest(
  529. fetcher(),
  530. GURL("http://" + std::string(kMockSecureDnsHostname) + "/cert.crt"));
  531. Error actual_error;
  532. std::vector<uint8_t> actual_body;
  533. request->WaitForResult(&actual_error, &actual_body);
  534. EXPECT_TRUE(invoked_interceptor());
  535. }
  536. } // namespace
  537. } // namespace net