uploader_unittest.cc 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341
  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 "components/domain_reliability/uploader.h"
  5. #include <stddef.h>
  6. #include <memory>
  7. #include <string>
  8. #include "base/bind.h"
  9. #include "base/memory/ptr_util.h"
  10. #include "base/memory/raw_ptr.h"
  11. #include "base/run_loop.h"
  12. #include "base/test/task_environment.h"
  13. #include "base/test/test_simple_task_runner.h"
  14. #include "base/threading/thread_task_runner_handle.h"
  15. #include "components/domain_reliability/test_util.h"
  16. #include "net/base/isolation_info.h"
  17. #include "net/base/load_flags.h"
  18. #include "net/base/network_isolation_key.h"
  19. #include "net/http/http_response_headers.h"
  20. #include "net/http/http_response_info.h"
  21. #include "net/http/http_util.h"
  22. #include "net/log/net_log_with_source.h"
  23. #include "net/url_request/url_request.h"
  24. #include "net/url_request/url_request_context.h"
  25. #include "net/url_request/url_request_context_builder.h"
  26. #include "net/url_request/url_request_filter.h"
  27. #include "net/url_request/url_request_interceptor.h"
  28. #include "net/url_request/url_request_job.h"
  29. #include "net/url_request/url_request_test_util.h"
  30. #include "testing/gtest/include/gtest/gtest.h"
  31. namespace domain_reliability {
  32. namespace {
  33. const char kUploadURL[] = "https://example/upload";
  34. struct MockUploadResult {
  35. int net_error;
  36. scoped_refptr<net::HttpResponseHeaders> response_headers;
  37. };
  38. class UploadMockURLRequestJob : public net::URLRequestJob {
  39. public:
  40. UploadMockURLRequestJob(net::URLRequest* request, MockUploadResult result)
  41. : net::URLRequestJob(request), upload_stream_(nullptr), result_(result) {
  42. EXPECT_FALSE(request->allow_credentials());
  43. EXPECT_TRUE(request->load_flags() & net::LOAD_DO_NOT_SAVE_COOKIES);
  44. }
  45. ~UploadMockURLRequestJob() override = default;
  46. protected:
  47. void Start() override {
  48. int rv = upload_stream_->Init(
  49. base::BindOnce(&UploadMockURLRequestJob::OnStreamInitialized,
  50. base::Unretained(this)),
  51. net::NetLogWithSource());
  52. if (rv == net::ERR_IO_PENDING)
  53. return;
  54. OnStreamInitialized(rv);
  55. }
  56. void SetUpload(net::UploadDataStream* upload_stream) override {
  57. upload_stream_ = upload_stream;
  58. }
  59. private:
  60. void OnStreamInitialized(int rv) {
  61. EXPECT_EQ(net::OK, rv);
  62. size_t upload_size = upload_stream_->size();
  63. upload_buffer_ = base::MakeRefCounted<net::IOBufferWithSize>(upload_size);
  64. rv = upload_stream_->Read(
  65. upload_buffer_.get(), upload_size,
  66. base::BindOnce(&UploadMockURLRequestJob::OnStreamRead,
  67. base::Unretained(this)));
  68. if (rv == net::ERR_IO_PENDING)
  69. return;
  70. OnStreamRead(rv);
  71. }
  72. void OnStreamRead(int rv) {
  73. EXPECT_EQ(upload_buffer_->size(), rv);
  74. upload_data_ = std::string(upload_buffer_->data(), upload_buffer_->size());
  75. upload_buffer_ = nullptr;
  76. if (result_.net_error == net::OK)
  77. NotifyHeadersComplete();
  78. else if (result_.net_error != net::ERR_IO_PENDING)
  79. NotifyStartError(result_.net_error);
  80. }
  81. void GetResponseInfo(net::HttpResponseInfo* info) override {
  82. info->headers = result_.response_headers;
  83. }
  84. raw_ptr<net::UploadDataStream> upload_stream_;
  85. scoped_refptr<net::IOBufferWithSize> upload_buffer_;
  86. std::string upload_data_;
  87. MockUploadResult result_;
  88. };
  89. class UploadInterceptor : public net::URLRequestInterceptor {
  90. public:
  91. explicit UploadInterceptor(
  92. const net::IsolationInfo& expected_network_isolation_info)
  93. : expected_network_isolation_info_(expected_network_isolation_info),
  94. request_count_(0),
  95. last_upload_depth_(-1) {}
  96. ~UploadInterceptor() override { EXPECT_TRUE(results_.empty()); }
  97. std::unique_ptr<net::URLRequestJob> MaybeInterceptRequest(
  98. net::URLRequest* request) const override {
  99. EXPECT_TRUE(expected_network_isolation_info_.IsEqualForTesting(
  100. request->isolation_info()));
  101. EXPECT_FALSE(results_.empty());
  102. MockUploadResult result = results_.front();
  103. results_.pop_front();
  104. last_upload_depth_ =
  105. DomainReliabilityUploader::GetURLRequestUploadDepth(*request);
  106. ++request_count_;
  107. return std::make_unique<UploadMockURLRequestJob>(request, result);
  108. }
  109. void ExpectRequestAndReturnError(int net_error) {
  110. MockUploadResult result;
  111. result.net_error = net_error;
  112. results_.push_back(result);
  113. }
  114. void ExpectRequestAndReturnResponseHeaders(const char* headers) {
  115. MockUploadResult result;
  116. result.net_error = net::OK;
  117. result.response_headers = base::MakeRefCounted<net::HttpResponseHeaders>(
  118. net::HttpUtil::AssembleRawHeaders(headers));
  119. results_.push_back(result);
  120. }
  121. int request_count() const { return request_count_; }
  122. int last_upload_depth() const { return last_upload_depth_; }
  123. private:
  124. const net::IsolationInfo expected_network_isolation_info_;
  125. mutable std::list<MockUploadResult> results_;
  126. mutable int request_count_;
  127. mutable int last_upload_depth_;
  128. };
  129. class TestUploadCallback {
  130. public:
  131. TestUploadCallback() : called_count_(0u) {}
  132. DomainReliabilityUploader::UploadCallback callback() {
  133. return base::BindOnce(&TestUploadCallback::OnCalled,
  134. base::Unretained(this));
  135. }
  136. unsigned called_count() const { return called_count_; }
  137. DomainReliabilityUploader::UploadResult last_result() const {
  138. return last_result_;
  139. }
  140. private:
  141. void OnCalled(const DomainReliabilityUploader::UploadResult& result) {
  142. called_count_++;
  143. last_result_ = result;
  144. }
  145. unsigned called_count_;
  146. DomainReliabilityUploader::UploadResult last_result_;
  147. };
  148. class DomainReliabilityUploaderTest : public testing::Test {
  149. protected:
  150. DomainReliabilityUploaderTest()
  151. : url_request_context_(
  152. net::CreateTestURLRequestContextBuilder()->Build()),
  153. uploader_(
  154. DomainReliabilityUploader::Create(&time_,
  155. url_request_context_.get())) {
  156. auto interceptor =
  157. std::make_unique<UploadInterceptor>(expected_isolation_info_);
  158. interceptor_ = interceptor.get();
  159. net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
  160. GURL(kUploadURL), std::move(interceptor));
  161. uploader_->SetDiscardUploads(false);
  162. }
  163. ~DomainReliabilityUploaderTest() override {
  164. net::URLRequestFilter::GetInstance()->ClearHandlers();
  165. }
  166. DomainReliabilityUploader* uploader() const { return uploader_.get(); }
  167. UploadInterceptor* interceptor() const { return interceptor_; }
  168. net::URLRequestContext* url_request_context() {
  169. return url_request_context_.get();
  170. }
  171. const net::NetworkIsolationKey& network_isolation_key() const {
  172. return expected_isolation_info_.network_isolation_key();
  173. }
  174. private:
  175. base::test::SingleThreadTaskEnvironment task_environment_{
  176. base::test::SingleThreadTaskEnvironment::MainThreadType::IO};
  177. const net::IsolationInfo expected_isolation_info_ =
  178. net::IsolationInfo::CreateTransient();
  179. std::unique_ptr<net::URLRequestContext> url_request_context_;
  180. raw_ptr<UploadInterceptor> interceptor_;
  181. MockTime time_;
  182. std::unique_ptr<DomainReliabilityUploader> uploader_;
  183. };
  184. TEST_F(DomainReliabilityUploaderTest, Null) {
  185. uploader()->Shutdown();
  186. }
  187. TEST_F(DomainReliabilityUploaderTest, SuccessfulUpload) {
  188. interceptor()->ExpectRequestAndReturnResponseHeaders("HTTP/1.1 200\r\n\r\n");
  189. TestUploadCallback c;
  190. uploader()->UploadReport("{}", 0, GURL(kUploadURL), network_isolation_key(),
  191. c.callback());
  192. base::RunLoop().RunUntilIdle();
  193. EXPECT_EQ(1u, c.called_count());
  194. EXPECT_TRUE(c.last_result().is_success());
  195. uploader()->Shutdown();
  196. }
  197. TEST_F(DomainReliabilityUploaderTest, NetworkErrorUpload) {
  198. interceptor()->ExpectRequestAndReturnError(net::ERR_CONNECTION_REFUSED);
  199. TestUploadCallback c;
  200. uploader()->UploadReport("{}", 0, GURL(kUploadURL), network_isolation_key(),
  201. c.callback());
  202. base::RunLoop().RunUntilIdle();
  203. EXPECT_EQ(1u, c.called_count());
  204. EXPECT_TRUE(c.last_result().is_failure());
  205. uploader()->Shutdown();
  206. }
  207. TEST_F(DomainReliabilityUploaderTest, ServerErrorUpload) {
  208. interceptor()->ExpectRequestAndReturnResponseHeaders("HTTP/1.1 500\r\n\r\n");
  209. TestUploadCallback c;
  210. uploader()->UploadReport("{}", 0, GURL(kUploadURL), network_isolation_key(),
  211. c.callback());
  212. base::RunLoop().RunUntilIdle();
  213. EXPECT_EQ(1u, c.called_count());
  214. EXPECT_TRUE(c.last_result().is_failure());
  215. uploader()->Shutdown();
  216. }
  217. TEST_F(DomainReliabilityUploaderTest, RetryAfterUpload) {
  218. interceptor()->ExpectRequestAndReturnResponseHeaders(
  219. "HTTP/1.1 503 Ugh\nRetry-After: 3600\n\n");
  220. TestUploadCallback c;
  221. uploader()->UploadReport("{}", 0, GURL(kUploadURL), network_isolation_key(),
  222. c.callback());
  223. base::RunLoop().RunUntilIdle();
  224. EXPECT_EQ(1u, c.called_count());
  225. EXPECT_TRUE(c.last_result().is_retry_after());
  226. uploader()->Shutdown();
  227. }
  228. TEST_F(DomainReliabilityUploaderTest, UploadDepth1) {
  229. interceptor()->ExpectRequestAndReturnResponseHeaders("HTTP/1.1 200\r\n\r\n");
  230. TestUploadCallback c;
  231. uploader()->UploadReport("{}", 0, GURL(kUploadURL), network_isolation_key(),
  232. c.callback());
  233. base::RunLoop().RunUntilIdle();
  234. EXPECT_EQ(1u, c.called_count());
  235. EXPECT_EQ(1, interceptor()->last_upload_depth());
  236. uploader()->Shutdown();
  237. }
  238. TEST_F(DomainReliabilityUploaderTest, UploadDepth2) {
  239. interceptor()->ExpectRequestAndReturnResponseHeaders("HTTP/1.1 200\r\n\r\n");
  240. TestUploadCallback c;
  241. uploader()->UploadReport("{}", 1, GURL(kUploadURL), network_isolation_key(),
  242. c.callback());
  243. base::RunLoop().RunUntilIdle();
  244. EXPECT_EQ(1u, c.called_count());
  245. EXPECT_EQ(2, interceptor()->last_upload_depth());
  246. uploader()->Shutdown();
  247. }
  248. TEST_F(DomainReliabilityUploaderTest, UploadCanceledAtShutdown) {
  249. interceptor()->ExpectRequestAndReturnError(net::ERR_IO_PENDING);
  250. TestUploadCallback c;
  251. uploader()->UploadReport("{}", 1, GURL(kUploadURL), network_isolation_key(),
  252. c.callback());
  253. base::RunLoop().RunUntilIdle();
  254. EXPECT_EQ(1, interceptor()->request_count());
  255. EXPECT_EQ(0u, c.called_count());
  256. uploader()->Shutdown();
  257. EXPECT_EQ(0u, c.called_count());
  258. url_request_context()->AssertNoURLRequests();
  259. }
  260. TEST_F(DomainReliabilityUploaderTest, NoUploadAfterShutdown) {
  261. uploader()->Shutdown();
  262. TestUploadCallback c;
  263. uploader()->UploadReport("{}", 1, GURL(kUploadURL), network_isolation_key(),
  264. c.callback());
  265. base::RunLoop().RunUntilIdle();
  266. EXPECT_EQ(1u, c.called_count());
  267. EXPECT_EQ(0, interceptor()->request_count());
  268. }
  269. } // namespace
  270. } // namespace domain_reliability