reporting_test_util.cc 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400
  1. // Copyright 2017 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/reporting/reporting_test_util.h"
  5. #include <memory>
  6. #include <string>
  7. #include <vector>
  8. #include "base/bind.h"
  9. #include "base/check_op.h"
  10. #include "base/json/json_reader.h"
  11. #include "base/memory/ptr_util.h"
  12. #include "base/notreached.h"
  13. #include "base/strings/stringprintf.h"
  14. #include "base/test/simple_test_clock.h"
  15. #include "base/test/simple_test_tick_clock.h"
  16. #include "base/timer/mock_timer.h"
  17. #include "net/base/isolation_info.h"
  18. #include "net/base/network_isolation_key.h"
  19. #include "net/reporting/reporting_cache.h"
  20. #include "net/reporting/reporting_context.h"
  21. #include "net/reporting/reporting_delegate.h"
  22. #include "net/reporting/reporting_delivery_agent.h"
  23. #include "net/reporting/reporting_endpoint.h"
  24. #include "net/reporting/reporting_garbage_collector.h"
  25. #include "net/reporting/reporting_policy.h"
  26. #include "net/reporting/reporting_uploader.h"
  27. #include "testing/gtest/include/gtest/gtest.h"
  28. #include "third_party/abseil-cpp/absl/types/optional.h"
  29. #include "url/gurl.h"
  30. #include "url/origin.h"
  31. namespace net {
  32. namespace {
  33. class PendingUploadImpl : public TestReportingUploader::PendingUpload {
  34. public:
  35. PendingUploadImpl(const url::Origin& report_origin,
  36. const GURL& url,
  37. const IsolationInfo& isolation_info,
  38. const std::string& json,
  39. ReportingUploader::UploadCallback callback,
  40. base::OnceCallback<void(PendingUpload*)> complete_callback)
  41. : report_origin_(report_origin),
  42. url_(url),
  43. isolation_info_(isolation_info),
  44. json_(json),
  45. callback_(std::move(callback)),
  46. complete_callback_(std::move(complete_callback)) {}
  47. ~PendingUploadImpl() override = default;
  48. // PendingUpload implementation:
  49. const url::Origin& report_origin() const override { return report_origin_; }
  50. const GURL& url() const override { return url_; }
  51. const std::string& json() const override { return json_; }
  52. absl::optional<base::Value> GetValue() const override {
  53. return base::JSONReader::Read(json_);
  54. }
  55. void Complete(ReportingUploader::Outcome outcome) override {
  56. std::move(callback_).Run(outcome);
  57. // Deletes |this|.
  58. std::move(complete_callback_).Run(this);
  59. }
  60. private:
  61. url::Origin report_origin_;
  62. GURL url_;
  63. IsolationInfo isolation_info_;
  64. std::string json_;
  65. ReportingUploader::UploadCallback callback_;
  66. base::OnceCallback<void(PendingUpload*)> complete_callback_;
  67. };
  68. void ErasePendingUpload(
  69. std::vector<std::unique_ptr<TestReportingUploader::PendingUpload>>* uploads,
  70. TestReportingUploader::PendingUpload* upload) {
  71. for (auto it = uploads->begin(); it != uploads->end(); ++it) {
  72. if (it->get() == upload) {
  73. uploads->erase(it);
  74. return;
  75. }
  76. }
  77. NOTREACHED();
  78. }
  79. } // namespace
  80. RandIntCallback TestReportingRandIntCallback() {
  81. return base::BindRepeating(
  82. [](int* rand_counter, int min, int max) {
  83. DCHECK_LE(min, max);
  84. return min + ((*rand_counter)++ % (max - min + 1));
  85. },
  86. base::Owned(std::make_unique<int>(0)));
  87. }
  88. TestReportingUploader::PendingUpload::~PendingUpload() = default;
  89. TestReportingUploader::PendingUpload::PendingUpload() = default;
  90. TestReportingUploader::TestReportingUploader() = default;
  91. TestReportingUploader::~TestReportingUploader() = default;
  92. void TestReportingUploader::StartUpload(const url::Origin& report_origin,
  93. const GURL& url,
  94. const IsolationInfo& isolation_info,
  95. const std::string& json,
  96. int max_depth,
  97. bool eligible_for_credentials,
  98. UploadCallback callback) {
  99. pending_uploads_.push_back(std::make_unique<PendingUploadImpl>(
  100. report_origin, url, isolation_info, json, std::move(callback),
  101. base::BindOnce(&ErasePendingUpload, &pending_uploads_)));
  102. }
  103. void TestReportingUploader::OnShutdown() {
  104. pending_uploads_.clear();
  105. }
  106. int TestReportingUploader::GetPendingUploadCountForTesting() const {
  107. return pending_uploads_.size();
  108. }
  109. TestReportingDelegate::TestReportingDelegate() = default;
  110. TestReportingDelegate::~TestReportingDelegate() = default;
  111. bool TestReportingDelegate::CanQueueReport(const url::Origin& origin) const {
  112. return true;
  113. }
  114. void TestReportingDelegate::CanSendReports(
  115. std::set<url::Origin> origins,
  116. base::OnceCallback<void(std::set<url::Origin>)> result_callback) const {
  117. if (pause_permissions_check_) {
  118. saved_origins_ = std::move(origins);
  119. permissions_check_callback_ = std::move(result_callback);
  120. return;
  121. }
  122. if (disallow_report_uploads_)
  123. origins.clear();
  124. std::move(result_callback).Run(std::move(origins));
  125. }
  126. bool TestReportingDelegate::PermissionsCheckPaused() const {
  127. return !permissions_check_callback_.is_null();
  128. }
  129. void TestReportingDelegate::ResumePermissionsCheck() {
  130. if (disallow_report_uploads_)
  131. saved_origins_.clear();
  132. std::move(permissions_check_callback_).Run(std::move(saved_origins_));
  133. }
  134. bool TestReportingDelegate::CanSetClient(const url::Origin& origin,
  135. const GURL& endpoint) const {
  136. return true;
  137. }
  138. bool TestReportingDelegate::CanUseClient(const url::Origin& origin,
  139. const GURL& endpoint) const {
  140. return true;
  141. }
  142. TestReportingContext::TestReportingContext(
  143. base::Clock* clock,
  144. const base::TickClock* tick_clock,
  145. const ReportingPolicy& policy,
  146. ReportingCache::PersistentReportingStore* store)
  147. : ReportingContext(policy,
  148. clock,
  149. tick_clock,
  150. TestReportingRandIntCallback(),
  151. std::make_unique<TestReportingUploader>(),
  152. std::make_unique<TestReportingDelegate>(),
  153. store) {
  154. auto delivery_timer = std::make_unique<base::MockOneShotTimer>();
  155. delivery_timer_ = delivery_timer.get();
  156. auto garbage_collection_timer = std::make_unique<base::MockOneShotTimer>();
  157. garbage_collection_timer_ = garbage_collection_timer.get();
  158. garbage_collector()->SetTimerForTesting(std::move(garbage_collection_timer));
  159. delivery_agent()->SetTimerForTesting(std::move(delivery_timer));
  160. }
  161. TestReportingContext::~TestReportingContext() {
  162. delivery_timer_ = nullptr;
  163. garbage_collection_timer_ = nullptr;
  164. }
  165. ReportingTestBase::ReportingTestBase() {
  166. // For tests, disable jitter.
  167. ReportingPolicy policy;
  168. policy.endpoint_backoff_policy.jitter_factor = 0.0;
  169. CreateContext(policy, base::Time::Now(), base::TimeTicks::Now());
  170. }
  171. ReportingTestBase::~ReportingTestBase() = default;
  172. void ReportingTestBase::UsePolicy(const ReportingPolicy& new_policy) {
  173. CreateContext(new_policy, clock()->Now(), tick_clock()->NowTicks());
  174. }
  175. void ReportingTestBase::UseStore(
  176. ReportingCache::PersistentReportingStore* store) {
  177. store_ = store;
  178. CreateContext(policy(), clock()->Now(), tick_clock()->NowTicks());
  179. }
  180. const ReportingEndpoint ReportingTestBase::FindEndpointInCache(
  181. const ReportingEndpointGroupKey& group_key,
  182. const GURL& url) {
  183. return cache()->GetEndpointForTesting(group_key, url);
  184. }
  185. bool ReportingTestBase::SetEndpointInCache(
  186. const ReportingEndpointGroupKey& group_key,
  187. const GURL& url,
  188. base::Time expires,
  189. OriginSubdomains include_subdomains,
  190. int priority,
  191. int weight) {
  192. cache()->SetEndpointForTesting(group_key, url, include_subdomains, expires,
  193. priority, weight);
  194. const ReportingEndpoint endpoint = FindEndpointInCache(group_key, url);
  195. return endpoint.is_valid();
  196. }
  197. void ReportingTestBase::SetV1EndpointInCache(
  198. const ReportingEndpointGroupKey& group_key,
  199. const base::UnguessableToken& reporting_source,
  200. const IsolationInfo& isolation_info,
  201. const GURL& url) {
  202. cache()->SetV1EndpointForTesting(group_key, reporting_source, isolation_info,
  203. url);
  204. }
  205. bool ReportingTestBase::EndpointExistsInCache(
  206. const ReportingEndpointGroupKey& group_key,
  207. const GURL& url) {
  208. ReportingEndpoint endpoint = cache()->GetEndpointForTesting(group_key, url);
  209. return endpoint.is_valid();
  210. }
  211. ReportingEndpoint::Statistics ReportingTestBase::GetEndpointStatistics(
  212. const ReportingEndpointGroupKey& group_key,
  213. const GURL& url) {
  214. ReportingEndpoint endpoint;
  215. if (group_key.IsDocumentEndpoint()) {
  216. endpoint = cache()->GetV1EndpointForTesting(
  217. group_key.reporting_source.value(), group_key.group_name);
  218. } else {
  219. endpoint = cache()->GetEndpointForTesting(group_key, url);
  220. }
  221. if (endpoint)
  222. return endpoint.stats;
  223. return ReportingEndpoint::Statistics();
  224. }
  225. bool ReportingTestBase::EndpointGroupExistsInCache(
  226. const ReportingEndpointGroupKey& group_key,
  227. OriginSubdomains include_subdomains,
  228. base::Time expires) {
  229. return cache()->EndpointGroupExistsForTesting(group_key, include_subdomains,
  230. expires);
  231. }
  232. bool ReportingTestBase::ClientExistsInCacheForOrigin(
  233. const url::Origin& origin) {
  234. std::set<url::Origin> all_origins = cache()->GetAllOrigins();
  235. return all_origins.find(origin) != all_origins.end();
  236. }
  237. GURL ReportingTestBase::MakeURL(size_t index) {
  238. return GURL(base::StringPrintf("https://example%zd.test", index));
  239. }
  240. void ReportingTestBase::SimulateRestart(base::TimeDelta delta,
  241. base::TimeDelta delta_ticks) {
  242. CreateContext(policy(), clock()->Now() + delta,
  243. tick_clock()->NowTicks() + delta_ticks);
  244. }
  245. void ReportingTestBase::CreateContext(const ReportingPolicy& policy,
  246. base::Time now,
  247. base::TimeTicks now_ticks) {
  248. context_ = std::make_unique<TestReportingContext>(&clock_, &tick_clock_,
  249. policy, store_);
  250. clock()->SetNow(now);
  251. tick_clock()->SetNowTicks(now_ticks);
  252. }
  253. base::TimeTicks ReportingTestBase::yesterday() {
  254. return tick_clock()->NowTicks() - base::Days(1);
  255. }
  256. base::TimeTicks ReportingTestBase::now() {
  257. return tick_clock()->NowTicks();
  258. }
  259. base::TimeTicks ReportingTestBase::tomorrow() {
  260. return tick_clock()->NowTicks() + base::Days(1);
  261. }
  262. TestReportingService::Report::Report() = default;
  263. TestReportingService::Report::Report(Report&& other) = default;
  264. TestReportingService::Report::Report(
  265. const GURL& url,
  266. const NetworkIsolationKey& network_isolation_key,
  267. const std::string& user_agent,
  268. const std::string& group,
  269. const std::string& type,
  270. std::unique_ptr<const base::Value> body,
  271. int depth)
  272. : url(url),
  273. network_isolation_key(network_isolation_key),
  274. user_agent(user_agent),
  275. group(group),
  276. type(type),
  277. body(std::move(body)),
  278. depth(depth) {}
  279. TestReportingService::Report::~Report() = default;
  280. TestReportingService::TestReportingService() = default;
  281. TestReportingService::~TestReportingService() = default;
  282. void TestReportingService::QueueReport(
  283. const GURL& url,
  284. const absl::optional<base::UnguessableToken>& reporting_source,
  285. const NetworkIsolationKey& network_isolation_key,
  286. const std::string& user_agent,
  287. const std::string& group,
  288. const std::string& type,
  289. base::Value::Dict body,
  290. int depth) {
  291. reports_.emplace_back(
  292. Report(url, network_isolation_key, user_agent, group, type,
  293. std::make_unique<base::Value>(std::move(body)), depth));
  294. }
  295. void TestReportingService::ProcessReportToHeader(
  296. const url::Origin& origin,
  297. const NetworkIsolationKey& network_isolation_key,
  298. const std::string& header_value) {
  299. NOTREACHED();
  300. }
  301. void TestReportingService::RemoveBrowsingData(
  302. uint64_t data_type_mask,
  303. const base::RepeatingCallback<bool(const url::Origin&)>& origin_filter) {
  304. NOTREACHED();
  305. }
  306. void TestReportingService::RemoveAllBrowsingData(uint64_t data_type_mask) {
  307. NOTREACHED();
  308. }
  309. void TestReportingService::OnShutdown() {}
  310. const ReportingPolicy& TestReportingService::GetPolicy() const {
  311. NOTREACHED();
  312. return dummy_policy_;
  313. }
  314. ReportingContext* TestReportingService::GetContextForTesting() const {
  315. NOTREACHED();
  316. return nullptr;
  317. }
  318. std::vector<const ReportingReport*> TestReportingService::GetReports() const {
  319. NOTREACHED();
  320. return std::vector<const ReportingReport*>();
  321. }
  322. base::flat_map<url::Origin, std::vector<ReportingEndpoint>>
  323. TestReportingService::GetV1ReportingEndpointsByOrigin() const {
  324. NOTREACHED();
  325. return base::flat_map<url::Origin, std::vector<ReportingEndpoint>>();
  326. }
  327. void TestReportingService::AddReportingCacheObserver(
  328. ReportingCacheObserver* observer) {
  329. NOTREACHED();
  330. }
  331. void TestReportingService::RemoveReportingCacheObserver(
  332. ReportingCacheObserver* observer) {
  333. NOTREACHED();
  334. }
  335. } // namespace net