network_error_logging_service_unittest.cc 72 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821
  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 <memory>
  5. #include <string>
  6. #include <vector>
  7. #include "base/bind.h"
  8. #include "base/callback.h"
  9. #include "base/strings/stringprintf.h"
  10. #include "base/test/scoped_feature_list.h"
  11. #include "base/test/simple_test_clock.h"
  12. #include "base/test/values_test_util.h"
  13. #include "base/time/time.h"
  14. #include "base/values.h"
  15. #include "net/base/features.h"
  16. #include "net/base/ip_address.h"
  17. #include "net/base/net_errors.h"
  18. #include "net/base/schemeful_site.h"
  19. #include "net/network_error_logging/mock_persistent_nel_store.h"
  20. #include "net/network_error_logging/network_error_logging_service.h"
  21. #include "net/reporting/reporting_test_util.h"
  22. #include "testing/gtest/include/gtest/gtest.h"
  23. #include "url/gurl.h"
  24. #include "url/origin.h"
  25. namespace net {
  26. namespace {
  27. // The tests are parametrized on a boolean value which represents whether or not
  28. // to use a MockPersistentNelStore.
  29. // If a MockPersistentNelStore is used, then calls to
  30. // NetworkErrorLoggingService::OnHeader(), OnRequest(),
  31. // QueueSignedExchangeReport(), RemoveBrowsingData(), and
  32. // RemoveAllBrowsingData() will block until the store finishes loading.
  33. // Therefore, for tests that should run synchronously (i.e. tests that don't
  34. // specifically test the asynchronous/deferred task behavior), FinishLoading()
  35. // must be called after the first call to one of the above methods.
  36. class NetworkErrorLoggingServiceTest : public ::testing::TestWithParam<bool> {
  37. protected:
  38. using NelPolicyKey = NetworkErrorLoggingService::NelPolicyKey;
  39. NetworkErrorLoggingServiceTest() {
  40. feature_list_.InitAndEnableFeature(
  41. features::kPartitionNelAndReportingByNetworkIsolationKey);
  42. if (GetParam()) {
  43. store_ = std::make_unique<MockPersistentNelStore>();
  44. } else {
  45. store_.reset(nullptr);
  46. }
  47. service_ = NetworkErrorLoggingService::Create(store_.get());
  48. CreateReportingService();
  49. }
  50. void CreateReportingService() {
  51. DCHECK(!reporting_service_);
  52. reporting_service_ = std::make_unique<TestReportingService>();
  53. service_->SetReportingService(reporting_service_.get());
  54. }
  55. NetworkErrorLoggingService::RequestDetails MakeRequestDetails(
  56. const NetworkIsolationKey& network_isolation_key,
  57. const GURL& url,
  58. Error error_type,
  59. std::string method = "GET",
  60. int status_code = 0,
  61. IPAddress server_ip = IPAddress()) {
  62. NetworkErrorLoggingService::RequestDetails details;
  63. details.network_isolation_key = network_isolation_key;
  64. details.uri = url;
  65. details.referrer = kReferrer_;
  66. details.user_agent = kUserAgent_;
  67. details.server_ip = server_ip.IsValid() ? server_ip : kServerIP_;
  68. details.method = std::move(method);
  69. details.status_code = status_code;
  70. details.elapsed_time = base::Seconds(1);
  71. details.type = error_type;
  72. details.reporting_upload_depth = 0;
  73. return details;
  74. }
  75. NetworkErrorLoggingService::SignedExchangeReportDetails
  76. MakeSignedExchangeReportDetails(
  77. const NetworkIsolationKey& network_isolation_key,
  78. bool success,
  79. const std::string& type,
  80. const GURL& outer_url,
  81. const GURL& inner_url,
  82. const GURL& cert_url,
  83. const IPAddress& server_ip_address) {
  84. NetworkErrorLoggingService::SignedExchangeReportDetails details;
  85. details.network_isolation_key = network_isolation_key;
  86. details.success = success;
  87. details.type = type;
  88. details.outer_url = outer_url;
  89. details.inner_url = inner_url;
  90. details.cert_url = cert_url;
  91. details.referrer = kReferrer_.spec();
  92. details.server_ip_address = server_ip_address;
  93. details.protocol = "http/1.1";
  94. details.method = "GET";
  95. details.status_code = 200;
  96. details.elapsed_time = base::Milliseconds(1234);
  97. details.user_agent = kUserAgent_;
  98. return details;
  99. }
  100. NetworkErrorLoggingService* service() { return service_.get(); }
  101. MockPersistentNelStore* store() { return store_.get(); }
  102. const std::vector<TestReportingService::Report>& reports() {
  103. return reporting_service_->reports();
  104. }
  105. // These methods are design so that using them together will create unique
  106. // Origin, NetworkIsolationKey pairs, but they do return repeated values when
  107. // called separately, so they can be used to ensure that reports are keyed on
  108. // both NIK and Origin.
  109. url::Origin MakeOrigin(size_t index) {
  110. GURL url(base::StringPrintf("https://example%zd.com/", index / 2));
  111. return url::Origin::Create(url);
  112. }
  113. NetworkIsolationKey MakeNetworkIsolationKey(size_t index) {
  114. SchemefulSite site(
  115. GURL(base::StringPrintf("https://example%zd.com/", (index + 1) / 2)));
  116. return NetworkIsolationKey(site, site);
  117. }
  118. NetworkErrorLoggingService::NelPolicy MakePolicy(
  119. const NetworkIsolationKey& network_isolation_key,
  120. const url::Origin& origin,
  121. base::Time expires = base::Time(),
  122. base::Time last_used = base::Time()) {
  123. NetworkErrorLoggingService::NelPolicy policy;
  124. policy.key = NelPolicyKey(network_isolation_key, origin);
  125. policy.expires = expires;
  126. policy.last_used = last_used;
  127. return policy;
  128. }
  129. // Returns whether the NetworkErrorLoggingService has a policy corresponding
  130. // to |network_isolation_key| and |origin|. Returns true if so, even if the
  131. // policy is expired.
  132. bool HasPolicy(const NetworkIsolationKey& network_isolation_key,
  133. const url::Origin& origin) {
  134. std::set<NelPolicyKey> all_policy_keys =
  135. service_->GetPolicyKeysForTesting();
  136. return all_policy_keys.find(NelPolicyKey(network_isolation_key, origin)) !=
  137. all_policy_keys.end();
  138. }
  139. size_t PolicyCount() { return service_->GetPolicyKeysForTesting().size(); }
  140. // Makes the rest of the test run synchronously.
  141. void FinishLoading(bool load_success) {
  142. if (store())
  143. store()->FinishLoading(load_success);
  144. }
  145. base::test::ScopedFeatureList feature_list_;
  146. const GURL kUrl_ = GURL("https://example.com/path");
  147. const GURL kUrlDifferentPort_ = GURL("https://example.com:4433/path");
  148. const GURL kUrlSubdomain_ = GURL("https://subdomain.example.com/path");
  149. const GURL kUrlDifferentHost_ = GURL("https://somewhere-else.com/path");
  150. const GURL kUrlEtld_ = GURL("https://co.uk/foo.html");
  151. const GURL kInnerUrl_ = GURL("https://example.net/path");
  152. const GURL kCertUrl_ = GURL("https://example.com/cert_path");
  153. const IPAddress kServerIP_ = IPAddress(192, 168, 0, 1);
  154. const IPAddress kOtherServerIP_ = IPAddress(192, 168, 0, 2);
  155. const url::Origin kOrigin_ = url::Origin::Create(kUrl_);
  156. const url::Origin kOriginDifferentPort_ =
  157. url::Origin::Create(kUrlDifferentPort_);
  158. const url::Origin kOriginSubdomain_ = url::Origin::Create(kUrlSubdomain_);
  159. const url::Origin kOriginDifferentHost_ =
  160. url::Origin::Create(kUrlDifferentHost_);
  161. const url::Origin kOriginEtld_ = url::Origin::Create(kUrlEtld_);
  162. const NetworkIsolationKey kNik_ =
  163. NetworkIsolationKey(SchemefulSite(kOrigin_), SchemefulSite(kOrigin_));
  164. const NetworkIsolationKey kOtherNik_ =
  165. NetworkIsolationKey(SchemefulSite(kOriginDifferentHost_),
  166. SchemefulSite(kOriginDifferentHost_));
  167. const std::string kHeader_ = "{\"report_to\":\"group\",\"max_age\":86400}";
  168. const std::string kHeaderSuccessFraction0_ =
  169. "{\"report_to\":\"group\",\"max_age\":86400,\"success_fraction\":0.0}";
  170. const std::string kHeaderSuccessFraction1_ =
  171. "{\"report_to\":\"group\",\"max_age\":86400,\"success_fraction\":1.0}";
  172. const std::string kHeaderIncludeSubdomains_ =
  173. "{\"report_to\":\"group\",\"max_age\":86400,\"include_subdomains\":true}";
  174. const std::string kHeaderMaxAge0_ = "{\"max_age\":0}";
  175. const std::string kHeaderTooLong_ =
  176. "{\"report_to\":\"group\",\"max_age\":86400,\"junk\":\"" +
  177. std::string(32 * 1024, 'a') + "\"}";
  178. const std::string kHeaderTooDeep_ =
  179. "{\"report_to\":\"group\",\"max_age\":86400,\"junk\":[[[[[[[[[[]]]]]]]]]]"
  180. "}";
  181. const std::string kUserAgent_ = "Mozilla/1.0";
  182. const std::string kGroup_ = "group";
  183. const std::string kType_ = NetworkErrorLoggingService::kReportType;
  184. const GURL kReferrer_ = GURL("https://referrer.com/");
  185. // |store_| needs to outlive |service_|.
  186. std::unique_ptr<MockPersistentNelStore> store_;
  187. std::unique_ptr<NetworkErrorLoggingService> service_;
  188. std::unique_ptr<TestReportingService> reporting_service_;
  189. };
  190. void ExpectDictDoubleValue(double expected_value,
  191. const base::Value::Dict& value,
  192. const std::string& key) {
  193. absl::optional<double> double_value = value.FindDouble(key);
  194. ASSERT_TRUE(double_value) << key;
  195. EXPECT_DOUBLE_EQ(expected_value, *double_value) << key;
  196. }
  197. TEST_P(NetworkErrorLoggingServiceTest, CreateService) {
  198. // Service is created by default in the test fixture..
  199. EXPECT_TRUE(service());
  200. }
  201. TEST_P(NetworkErrorLoggingServiceTest, NoReportingService) {
  202. service_ = NetworkErrorLoggingService::Create(store_.get());
  203. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  204. // Make the rest of the test run synchronously.
  205. FinishLoading(true /* load_success */);
  206. // Should not crash.
  207. service()->OnRequest(
  208. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  209. }
  210. TEST_P(NetworkErrorLoggingServiceTest, NoPolicy) {
  211. service()->OnRequest(
  212. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  213. // Make the rest of the test run synchronously.
  214. FinishLoading(true /* load_success */);
  215. EXPECT_TRUE(reports().empty());
  216. }
  217. TEST_P(NetworkErrorLoggingServiceTest, PolicyKeyMatchesNikAndOrigin) {
  218. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  219. // Make the rest of the test run synchronously.
  220. FinishLoading(true /* load_success */);
  221. // Wrong NIK and origin.
  222. service()->OnRequest(MakeRequestDetails(kOtherNik_, kUrlDifferentHost_,
  223. ERR_CONNECTION_REFUSED));
  224. EXPECT_TRUE(reports().empty());
  225. // Wrong NIK.
  226. service()->OnRequest(
  227. MakeRequestDetails(kOtherNik_, kUrl_, ERR_CONNECTION_REFUSED));
  228. EXPECT_TRUE(reports().empty());
  229. // Wrong origin.
  230. service()->OnRequest(
  231. MakeRequestDetails(kNik_, kUrlDifferentHost_, ERR_CONNECTION_REFUSED));
  232. EXPECT_TRUE(reports().empty());
  233. // Correct key.
  234. service()->OnRequest(
  235. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  236. EXPECT_EQ(1u, reports().size());
  237. EXPECT_EQ(kUrl_, reports()[0].url);
  238. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  239. EXPECT_EQ(kUserAgent_, reports()[0].user_agent);
  240. EXPECT_EQ(kGroup_, reports()[0].group);
  241. EXPECT_EQ(kType_, reports()[0].type);
  242. }
  243. TEST_P(NetworkErrorLoggingServiceTest,
  244. PolicyKeyMatchesNikAndOriginIncludeSubdomains) {
  245. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderIncludeSubdomains_);
  246. // Make the rest of the test run synchronously.
  247. FinishLoading(true /* load_success */);
  248. // Wrong NIK and origin.
  249. service()->OnRequest(MakeRequestDetails(kOtherNik_, kUrlDifferentHost_,
  250. ERR_CONNECTION_REFUSED));
  251. EXPECT_TRUE(reports().empty());
  252. // Wrong NIK (same origin).
  253. service()->OnRequest(
  254. MakeRequestDetails(kOtherNik_, kUrl_, ERR_CONNECTION_REFUSED));
  255. EXPECT_TRUE(reports().empty());
  256. // Wrong NIK (subdomain).
  257. service()->OnRequest(
  258. MakeRequestDetails(kOtherNik_, kUrlSubdomain_, ERR_CONNECTION_REFUSED));
  259. EXPECT_TRUE(reports().empty());
  260. // Wrong origin.
  261. service()->OnRequest(
  262. MakeRequestDetails(kNik_, kUrlDifferentHost_, ERR_CONNECTION_REFUSED));
  263. EXPECT_TRUE(reports().empty());
  264. // Correct key (same origin).
  265. service()->OnRequest(
  266. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  267. EXPECT_EQ(1u, reports().size());
  268. EXPECT_EQ(kUrl_, reports()[0].url);
  269. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  270. EXPECT_EQ(kUserAgent_, reports()[0].user_agent);
  271. EXPECT_EQ(kGroup_, reports()[0].group);
  272. EXPECT_EQ(kType_, reports()[0].type);
  273. // Correct key (subdomain).
  274. service()->OnRequest(
  275. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  276. EXPECT_EQ(2u, reports().size());
  277. EXPECT_EQ(kUrl_, reports()[1].url);
  278. EXPECT_EQ(kNik_, reports()[1].network_isolation_key);
  279. EXPECT_EQ(kUserAgent_, reports()[1].user_agent);
  280. EXPECT_EQ(kGroup_, reports()[1].group);
  281. EXPECT_EQ(kType_, reports()[1].type);
  282. }
  283. TEST_P(NetworkErrorLoggingServiceTest, NetworkIsolationKeyDisabled) {
  284. base::test::ScopedFeatureList feature_list;
  285. feature_list.InitAndDisableFeature(
  286. features::kPartitionNelAndReportingByNetworkIsolationKey);
  287. // Need to re-create the service, since it caches the feature value on
  288. // creation.
  289. service_ = NetworkErrorLoggingService::Create(store_.get());
  290. reporting_service_ = std::make_unique<TestReportingService>();
  291. service_->SetReportingService(reporting_service_.get());
  292. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  293. // Make the rest of the test run synchronously.
  294. FinishLoading(true /* load_success */);
  295. // Wrong NIK, but a report should be generated anyways.
  296. service()->OnRequest(
  297. MakeRequestDetails(kOtherNik_, kUrl_, ERR_CONNECTION_REFUSED));
  298. EXPECT_EQ(1u, reports().size());
  299. EXPECT_EQ(kUrl_, reports()[0].url);
  300. EXPECT_EQ(NetworkIsolationKey(), reports()[0].network_isolation_key);
  301. EXPECT_EQ(kUserAgent_, reports()[0].user_agent);
  302. EXPECT_EQ(kGroup_, reports()[0].group);
  303. EXPECT_EQ(kType_, reports()[0].type);
  304. }
  305. TEST_P(NetworkErrorLoggingServiceTest, JsonTooLong) {
  306. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderTooLong_);
  307. // Make the rest of the test run synchronously.
  308. FinishLoading(true /* load_success */);
  309. service()->OnRequest(
  310. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  311. EXPECT_TRUE(reports().empty());
  312. }
  313. TEST_P(NetworkErrorLoggingServiceTest, JsonTooDeep) {
  314. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderTooDeep_);
  315. // Make the rest of the test run synchronously.
  316. FinishLoading(true /* load_success */);
  317. service()->OnRequest(
  318. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  319. EXPECT_TRUE(reports().empty());
  320. }
  321. TEST_P(NetworkErrorLoggingServiceTest, IncludeSubdomainsEtldRejected) {
  322. service()->OnHeader(kNik_, kOriginEtld_, kServerIP_,
  323. kHeaderIncludeSubdomains_);
  324. // Make the rest of the test run synchronously.
  325. FinishLoading(true /* load_success */);
  326. EXPECT_EQ(0u, PolicyCount());
  327. service()->OnRequest(
  328. MakeRequestDetails(kNik_, kUrlEtld_, ERR_CONNECTION_REFUSED));
  329. EXPECT_TRUE(reports().empty());
  330. }
  331. TEST_P(NetworkErrorLoggingServiceTest, NonIncludeSubdomainsEtldAccepted) {
  332. service()->OnHeader(kNik_, kOriginEtld_, kServerIP_, kHeader_);
  333. // Make the rest of the test run synchronously.
  334. FinishLoading(true /* load_success */);
  335. EXPECT_EQ(1u, PolicyCount());
  336. service()->OnRequest(
  337. MakeRequestDetails(kNik_, kUrlEtld_, ERR_CONNECTION_REFUSED));
  338. EXPECT_EQ(1u, reports().size());
  339. EXPECT_EQ(kUrlEtld_, reports()[0].url);
  340. }
  341. TEST_P(NetworkErrorLoggingServiceTest, SuccessReportQueued) {
  342. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFraction1_);
  343. // Make the rest of the test run synchronously.
  344. FinishLoading(true /* load_success */);
  345. service()->OnRequest(MakeRequestDetails(kNik_, kUrl_, OK));
  346. ASSERT_EQ(1u, reports().size());
  347. EXPECT_EQ(kUrl_, reports()[0].url);
  348. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  349. EXPECT_EQ(kUserAgent_, reports()[0].user_agent);
  350. EXPECT_EQ(kGroup_, reports()[0].group);
  351. EXPECT_EQ(kType_, reports()[0].type);
  352. EXPECT_EQ(0, reports()[0].depth);
  353. const base::Value* body = reports()[0].body.get();
  354. ASSERT_TRUE(body);
  355. ASSERT_TRUE(body->is_dict());
  356. const base::Value::Dict& body_dict = body->GetDict();
  357. base::ExpectDictStringValue(kReferrer_.spec(), body_dict,
  358. NetworkErrorLoggingService::kReferrerKey);
  359. // TODO(juliatuttle): Extract these constants.
  360. ExpectDictDoubleValue(1.0, body_dict,
  361. NetworkErrorLoggingService::kSamplingFractionKey);
  362. base::ExpectDictStringValue(kServerIP_.ToString(), body_dict,
  363. NetworkErrorLoggingService::kServerIpKey);
  364. base::ExpectDictStringValue("", body_dict,
  365. NetworkErrorLoggingService::kProtocolKey);
  366. base::ExpectDictStringValue("GET", body_dict,
  367. NetworkErrorLoggingService::kMethodKey);
  368. base::ExpectDictIntegerValue(0, body_dict,
  369. NetworkErrorLoggingService::kStatusCodeKey);
  370. base::ExpectDictIntegerValue(1000, body_dict,
  371. NetworkErrorLoggingService::kElapsedTimeKey);
  372. base::ExpectDictStringValue("application", body_dict,
  373. NetworkErrorLoggingService::kPhaseKey);
  374. base::ExpectDictStringValue("ok", body_dict,
  375. NetworkErrorLoggingService::kTypeKey);
  376. }
  377. TEST_P(NetworkErrorLoggingServiceTest, FailureReportQueued) {
  378. static const std::string kHeaderFailureFraction1 =
  379. "{\"report_to\":\"group\",\"max_age\":86400,\"failure_fraction\":1.0}";
  380. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderFailureFraction1);
  381. // Make the rest of the test run synchronously.
  382. FinishLoading(true /* load_success */);
  383. service()->OnRequest(
  384. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  385. ASSERT_EQ(1u, reports().size());
  386. EXPECT_EQ(kUrl_, reports()[0].url);
  387. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  388. EXPECT_EQ(kUserAgent_, reports()[0].user_agent);
  389. EXPECT_EQ(kGroup_, reports()[0].group);
  390. EXPECT_EQ(kType_, reports()[0].type);
  391. EXPECT_EQ(0, reports()[0].depth);
  392. const base::Value* body = reports()[0].body.get();
  393. ASSERT_TRUE(body);
  394. ASSERT_TRUE(body->is_dict());
  395. const base::Value::Dict& body_dict = body->GetDict();
  396. base::ExpectDictStringValue(kReferrer_.spec(), body_dict,
  397. NetworkErrorLoggingService::kReferrerKey);
  398. // TODO(juliatuttle): Extract these constants.
  399. ExpectDictDoubleValue(1.0, body_dict,
  400. NetworkErrorLoggingService::kSamplingFractionKey);
  401. base::ExpectDictStringValue(kServerIP_.ToString(), body_dict,
  402. NetworkErrorLoggingService::kServerIpKey);
  403. base::ExpectDictStringValue("", body_dict,
  404. NetworkErrorLoggingService::kProtocolKey);
  405. base::ExpectDictStringValue("GET", body_dict,
  406. NetworkErrorLoggingService::kMethodKey);
  407. base::ExpectDictIntegerValue(0, body_dict,
  408. NetworkErrorLoggingService::kStatusCodeKey);
  409. base::ExpectDictIntegerValue(1000, body_dict,
  410. NetworkErrorLoggingService::kElapsedTimeKey);
  411. base::ExpectDictStringValue("connection", body_dict,
  412. NetworkErrorLoggingService::kPhaseKey);
  413. base::ExpectDictStringValue("tcp.refused", body_dict,
  414. NetworkErrorLoggingService::kTypeKey);
  415. }
  416. TEST_P(NetworkErrorLoggingServiceTest, UnknownFailureReportQueued) {
  417. static const std::string kHeaderFailureFraction1 =
  418. "{\"report_to\":\"group\",\"max_age\":86400,\"failure_fraction\":1.0}";
  419. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderFailureFraction1);
  420. // Make the rest of the test run synchronously.
  421. FinishLoading(true /* load_success */);
  422. // This error code happens to not be mapped to a NEL report `type` field
  423. // value.
  424. service()->OnRequest(MakeRequestDetails(kNik_, kUrl_, ERR_FILE_NO_SPACE));
  425. ASSERT_EQ(1u, reports().size());
  426. const base::Value* body = reports()[0].body.get();
  427. ASSERT_TRUE(body);
  428. ASSERT_TRUE(body->is_dict());
  429. const base::Value::Dict& body_dict = body->GetDict();
  430. base::ExpectDictStringValue("application", body_dict,
  431. NetworkErrorLoggingService::kPhaseKey);
  432. base::ExpectDictStringValue("unknown", body_dict,
  433. NetworkErrorLoggingService::kTypeKey);
  434. }
  435. TEST_P(NetworkErrorLoggingServiceTest, UnknownCertFailureReportQueued) {
  436. static const std::string kHeaderFailureFraction1 =
  437. "{\"report_to\":\"group\",\"max_age\":86400,\"failure_fraction\":1.0}";
  438. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderFailureFraction1);
  439. // Make the rest of the test run synchronously.
  440. FinishLoading(true /* load_success */);
  441. // This error code happens to not be mapped to a NEL report `type` field
  442. // value. Because it's a certificate error, we'll set the `phase` to be
  443. // `connection`.
  444. service()->OnRequest(
  445. MakeRequestDetails(kNik_, kUrl_, ERR_CERT_NON_UNIQUE_NAME));
  446. ASSERT_EQ(1u, reports().size());
  447. const base::Value* body = reports()[0].body.get();
  448. ASSERT_TRUE(body);
  449. ASSERT_TRUE(body->is_dict());
  450. const base::Value::Dict& body_dict = body->GetDict();
  451. base::ExpectDictStringValue("connection", body_dict,
  452. NetworkErrorLoggingService::kPhaseKey);
  453. base::ExpectDictStringValue("unknown", body_dict,
  454. NetworkErrorLoggingService::kTypeKey);
  455. }
  456. TEST_P(NetworkErrorLoggingServiceTest, HttpErrorReportQueued) {
  457. static const std::string kHeaderFailureFraction1 =
  458. "{\"report_to\":\"group\",\"max_age\":86400,\"failure_fraction\":1.0}";
  459. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderFailureFraction1);
  460. // Make the rest of the test run synchronously.
  461. FinishLoading(true /* load_success */);
  462. service()->OnRequest(MakeRequestDetails(kNik_, kUrl_, OK, "GET", 504));
  463. ASSERT_EQ(1u, reports().size());
  464. EXPECT_EQ(kUrl_, reports()[0].url);
  465. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  466. EXPECT_EQ(kUserAgent_, reports()[0].user_agent);
  467. EXPECT_EQ(kGroup_, reports()[0].group);
  468. EXPECT_EQ(kType_, reports()[0].type);
  469. EXPECT_EQ(0, reports()[0].depth);
  470. const base::Value* body = reports()[0].body.get();
  471. ASSERT_TRUE(body);
  472. ASSERT_TRUE(body->is_dict());
  473. const base::Value::Dict& body_dict = body->GetDict();
  474. base::ExpectDictStringValue(kReferrer_.spec(), body_dict,
  475. NetworkErrorLoggingService::kReferrerKey);
  476. // TODO(juliatuttle): Extract these constants.
  477. ExpectDictDoubleValue(1.0, body_dict,
  478. NetworkErrorLoggingService::kSamplingFractionKey);
  479. base::ExpectDictStringValue(kServerIP_.ToString(), body_dict,
  480. NetworkErrorLoggingService::kServerIpKey);
  481. base::ExpectDictStringValue("", body_dict,
  482. NetworkErrorLoggingService::kProtocolKey);
  483. base::ExpectDictStringValue("GET", body_dict,
  484. NetworkErrorLoggingService::kMethodKey);
  485. base::ExpectDictIntegerValue(504, body_dict,
  486. NetworkErrorLoggingService::kStatusCodeKey);
  487. base::ExpectDictIntegerValue(1000, body_dict,
  488. NetworkErrorLoggingService::kElapsedTimeKey);
  489. base::ExpectDictStringValue("application", body_dict,
  490. NetworkErrorLoggingService::kPhaseKey);
  491. base::ExpectDictStringValue("http.error", body_dict,
  492. NetworkErrorLoggingService::kTypeKey);
  493. }
  494. TEST_P(NetworkErrorLoggingServiceTest, SuccessReportDowngraded) {
  495. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFraction1_);
  496. // Make the rest of the test run synchronously.
  497. FinishLoading(true /* load_success */);
  498. service()->OnRequest(
  499. MakeRequestDetails(kNik_, kUrl_, OK, "GET", 200, kOtherServerIP_));
  500. ASSERT_EQ(1u, reports().size());
  501. EXPECT_EQ(kUrl_, reports()[0].url);
  502. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  503. EXPECT_EQ(kGroup_, reports()[0].group);
  504. EXPECT_EQ(kType_, reports()[0].type);
  505. EXPECT_EQ(0, reports()[0].depth);
  506. const base::Value* body = reports()[0].body.get();
  507. ASSERT_TRUE(body);
  508. ASSERT_TRUE(body->is_dict());
  509. const base::Value::Dict& body_dict = body->GetDict();
  510. base::ExpectDictStringValue(kReferrer_.spec(), body_dict,
  511. NetworkErrorLoggingService::kReferrerKey);
  512. ExpectDictDoubleValue(1.0, body_dict,
  513. NetworkErrorLoggingService::kSamplingFractionKey);
  514. base::ExpectDictStringValue(kOtherServerIP_.ToString(), body_dict,
  515. NetworkErrorLoggingService::kServerIpKey);
  516. base::ExpectDictStringValue("", body_dict,
  517. NetworkErrorLoggingService::kProtocolKey);
  518. base::ExpectDictStringValue("GET", body_dict,
  519. NetworkErrorLoggingService::kMethodKey);
  520. base::ExpectDictIntegerValue(0, body_dict,
  521. NetworkErrorLoggingService::kStatusCodeKey);
  522. base::ExpectDictIntegerValue(0, body_dict,
  523. NetworkErrorLoggingService::kElapsedTimeKey);
  524. base::ExpectDictStringValue("dns", body_dict,
  525. NetworkErrorLoggingService::kPhaseKey);
  526. base::ExpectDictStringValue("dns.address_changed", body_dict,
  527. NetworkErrorLoggingService::kTypeKey);
  528. }
  529. TEST_P(NetworkErrorLoggingServiceTest, FailureReportDowngraded) {
  530. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFraction1_);
  531. // Make the rest of the test run synchronously.
  532. FinishLoading(true /* load_success */);
  533. service()->OnRequest(MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED,
  534. "GET", 200, kOtherServerIP_));
  535. ASSERT_EQ(1u, reports().size());
  536. EXPECT_EQ(kUrl_, reports()[0].url);
  537. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  538. EXPECT_EQ(kGroup_, reports()[0].group);
  539. EXPECT_EQ(kType_, reports()[0].type);
  540. EXPECT_EQ(0, reports()[0].depth);
  541. const base::Value* body = reports()[0].body.get();
  542. ASSERT_TRUE(body);
  543. ASSERT_TRUE(body->is_dict());
  544. const base::Value::Dict& body_dict = body->GetDict();
  545. base::ExpectDictStringValue(kReferrer_.spec(), body_dict,
  546. NetworkErrorLoggingService::kReferrerKey);
  547. ExpectDictDoubleValue(1.0, body_dict,
  548. NetworkErrorLoggingService::kSamplingFractionKey);
  549. base::ExpectDictStringValue(kOtherServerIP_.ToString(), body_dict,
  550. NetworkErrorLoggingService::kServerIpKey);
  551. base::ExpectDictStringValue("", body_dict,
  552. NetworkErrorLoggingService::kProtocolKey);
  553. base::ExpectDictStringValue("GET", body_dict,
  554. NetworkErrorLoggingService::kMethodKey);
  555. base::ExpectDictIntegerValue(0, body_dict,
  556. NetworkErrorLoggingService::kStatusCodeKey);
  557. base::ExpectDictIntegerValue(0, body_dict,
  558. NetworkErrorLoggingService::kElapsedTimeKey);
  559. base::ExpectDictStringValue("dns", body_dict,
  560. NetworkErrorLoggingService::kPhaseKey);
  561. base::ExpectDictStringValue("dns.address_changed", body_dict,
  562. NetworkErrorLoggingService::kTypeKey);
  563. }
  564. TEST_P(NetworkErrorLoggingServiceTest, HttpErrorReportDowngraded) {
  565. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFraction1_);
  566. // Make the rest of the test run synchronously.
  567. FinishLoading(true /* load_success */);
  568. service()->OnRequest(
  569. MakeRequestDetails(kNik_, kUrl_, OK, "GET", 504, kOtherServerIP_));
  570. ASSERT_EQ(1u, reports().size());
  571. EXPECT_EQ(kUrl_, reports()[0].url);
  572. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  573. EXPECT_EQ(kGroup_, reports()[0].group);
  574. EXPECT_EQ(kType_, reports()[0].type);
  575. EXPECT_EQ(0, reports()[0].depth);
  576. const base::Value* body = reports()[0].body.get();
  577. ASSERT_TRUE(body);
  578. ASSERT_TRUE(body->is_dict());
  579. const base::Value::Dict& body_dict = body->GetDict();
  580. base::ExpectDictStringValue(kReferrer_.spec(), body_dict,
  581. NetworkErrorLoggingService::kReferrerKey);
  582. ExpectDictDoubleValue(1.0, body_dict,
  583. NetworkErrorLoggingService::kSamplingFractionKey);
  584. base::ExpectDictStringValue(kOtherServerIP_.ToString(), body_dict,
  585. NetworkErrorLoggingService::kServerIpKey);
  586. base::ExpectDictStringValue("", body_dict,
  587. NetworkErrorLoggingService::kProtocolKey);
  588. base::ExpectDictStringValue("GET", body_dict,
  589. NetworkErrorLoggingService::kMethodKey);
  590. base::ExpectDictIntegerValue(0, body_dict,
  591. NetworkErrorLoggingService::kStatusCodeKey);
  592. base::ExpectDictIntegerValue(0, body_dict,
  593. NetworkErrorLoggingService::kElapsedTimeKey);
  594. base::ExpectDictStringValue("dns", body_dict,
  595. NetworkErrorLoggingService::kPhaseKey);
  596. base::ExpectDictStringValue("dns.address_changed", body_dict,
  597. NetworkErrorLoggingService::kTypeKey);
  598. }
  599. TEST_P(NetworkErrorLoggingServiceTest, DNSFailureReportNotDowngraded) {
  600. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFraction1_);
  601. // Make the rest of the test run synchronously.
  602. FinishLoading(true /* load_success */);
  603. service()->OnRequest(MakeRequestDetails(kNik_, kUrl_, ERR_NAME_NOT_RESOLVED,
  604. "GET", 0, kOtherServerIP_));
  605. ASSERT_EQ(1u, reports().size());
  606. EXPECT_EQ(kUrl_, reports()[0].url);
  607. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  608. EXPECT_EQ(kGroup_, reports()[0].group);
  609. EXPECT_EQ(kType_, reports()[0].type);
  610. EXPECT_EQ(0, reports()[0].depth);
  611. const base::Value* body = reports()[0].body.get();
  612. ASSERT_TRUE(body);
  613. ASSERT_TRUE(body->is_dict());
  614. const base::Value::Dict& body_dict = body->GetDict();
  615. base::ExpectDictStringValue(kReferrer_.spec(), body_dict,
  616. NetworkErrorLoggingService::kReferrerKey);
  617. ExpectDictDoubleValue(1.0, body_dict,
  618. NetworkErrorLoggingService::kSamplingFractionKey);
  619. base::ExpectDictStringValue(kOtherServerIP_.ToString(), body_dict,
  620. NetworkErrorLoggingService::kServerIpKey);
  621. base::ExpectDictStringValue("", body_dict,
  622. NetworkErrorLoggingService::kProtocolKey);
  623. base::ExpectDictStringValue("GET", body_dict,
  624. NetworkErrorLoggingService::kMethodKey);
  625. base::ExpectDictIntegerValue(0, body_dict,
  626. NetworkErrorLoggingService::kStatusCodeKey);
  627. base::ExpectDictIntegerValue(1000, body_dict,
  628. NetworkErrorLoggingService::kElapsedTimeKey);
  629. base::ExpectDictStringValue("dns", body_dict,
  630. NetworkErrorLoggingService::kPhaseKey);
  631. base::ExpectDictStringValue("dns.name_not_resolved", body_dict,
  632. NetworkErrorLoggingService::kTypeKey);
  633. }
  634. TEST_P(NetworkErrorLoggingServiceTest, SuccessPOSTReportQueued) {
  635. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFraction1_);
  636. // Make the rest of the test run synchronously.
  637. FinishLoading(true /* load_success */);
  638. service()->OnRequest(MakeRequestDetails(kNik_, kUrl_, OK, "POST"));
  639. ASSERT_EQ(1u, reports().size());
  640. EXPECT_EQ(kUrl_, reports()[0].url);
  641. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  642. EXPECT_EQ(kGroup_, reports()[0].group);
  643. EXPECT_EQ(kType_, reports()[0].type);
  644. EXPECT_EQ(0, reports()[0].depth);
  645. const base::Value* body = reports()[0].body.get();
  646. ASSERT_TRUE(body);
  647. ASSERT_TRUE(body->is_dict());
  648. const base::Value::Dict& body_dict = body->GetDict();
  649. base::ExpectDictStringValue(kReferrer_.spec(), body_dict,
  650. NetworkErrorLoggingService::kReferrerKey);
  651. ExpectDictDoubleValue(1.0, body_dict,
  652. NetworkErrorLoggingService::kSamplingFractionKey);
  653. base::ExpectDictStringValue(kServerIP_.ToString(), body_dict,
  654. NetworkErrorLoggingService::kServerIpKey);
  655. base::ExpectDictStringValue("", body_dict,
  656. NetworkErrorLoggingService::kProtocolKey);
  657. base::ExpectDictStringValue("POST", body_dict,
  658. NetworkErrorLoggingService::kMethodKey);
  659. base::ExpectDictStringValue("application", body_dict,
  660. NetworkErrorLoggingService::kPhaseKey);
  661. base::ExpectDictStringValue("ok", body_dict,
  662. NetworkErrorLoggingService::kTypeKey);
  663. }
  664. TEST_P(NetworkErrorLoggingServiceTest, MaxAge0) {
  665. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  666. // Make the rest of the test run synchronously.
  667. FinishLoading(true /* load_success */);
  668. EXPECT_EQ(1u, PolicyCount());
  669. // Max_age of 0 removes the policy.
  670. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderMaxAge0_);
  671. EXPECT_EQ(0u, PolicyCount());
  672. service()->OnRequest(
  673. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  674. EXPECT_TRUE(reports().empty());
  675. }
  676. TEST_P(NetworkErrorLoggingServiceTest, SuccessFraction0) {
  677. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFraction0_);
  678. // Make the rest of the test run synchronously.
  679. FinishLoading(true /* load_success */);
  680. // Each network error has a 0% chance of being reported. Fire off several and
  681. // verify that no reports are produced.
  682. constexpr size_t kReportCount = 100;
  683. for (size_t i = 0; i < kReportCount; ++i)
  684. service()->OnRequest(MakeRequestDetails(kNik_, kUrl_, OK));
  685. EXPECT_TRUE(reports().empty());
  686. }
  687. TEST_P(NetworkErrorLoggingServiceTest, SuccessFractionHalf) {
  688. // Include a different value for failure_fraction to ensure that we copy the
  689. // right value into sampling_fraction.
  690. static const std::string kHeaderSuccessFractionHalf =
  691. "{\"report_to\":\"group\",\"max_age\":86400,\"success_fraction\":0.5,"
  692. "\"failure_fraction\":0.25}";
  693. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFractionHalf);
  694. // Make the rest of the test run synchronously.
  695. FinishLoading(true /* load_success */);
  696. // Each network error has a 50% chance of being reported. Fire off several
  697. // and verify that some requests were reported and some weren't. (We can't
  698. // verify exact counts because each decision is made randomly.)
  699. constexpr size_t kReportCount = 100;
  700. for (size_t i = 0; i < kReportCount; ++i)
  701. service()->OnRequest(MakeRequestDetails(kNik_, kUrl_, OK));
  702. // If our random selection logic is correct, there is a 2^-100 chance that
  703. // every single report above was skipped. If this check fails, it's much more
  704. // likely that our code is wrong.
  705. EXPECT_FALSE(reports().empty());
  706. // There's also a 2^-100 chance that every single report was logged. Same as
  707. // above, that's much more likely to be a code error.
  708. EXPECT_GT(kReportCount, reports().size());
  709. for (const auto& report : reports()) {
  710. const base::Value::Dict* body_dict = report.body->GetIfDict();
  711. ASSERT_TRUE(body_dict);
  712. // Our header includes a different value for failure_fraction, so that this
  713. // check verifies that we copy the correct fraction into sampling_fraction.
  714. ExpectDictDoubleValue(0.5, *body_dict,
  715. NetworkErrorLoggingService::kSamplingFractionKey);
  716. }
  717. }
  718. TEST_P(NetworkErrorLoggingServiceTest, FailureFraction0) {
  719. static const std::string kHeaderFailureFraction0 =
  720. "{\"report_to\":\"group\",\"max_age\":86400,\"failure_fraction\":0.0}";
  721. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderFailureFraction0);
  722. // Make the rest of the test run synchronously.
  723. FinishLoading(true /* load_success */);
  724. // Each network error has a 0% chance of being reported. Fire off several and
  725. // verify that no reports are produced.
  726. constexpr size_t kReportCount = 100;
  727. for (size_t i = 0; i < kReportCount; ++i)
  728. service()->OnRequest(
  729. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  730. EXPECT_TRUE(reports().empty());
  731. }
  732. TEST_P(NetworkErrorLoggingServiceTest, FailureFractionHalf) {
  733. // Include a different value for success_fraction to ensure that we copy the
  734. // right value into sampling_fraction.
  735. static const std::string kHeaderFailureFractionHalf =
  736. "{\"report_to\":\"group\",\"max_age\":86400,\"failure_fraction\":0.5,"
  737. "\"success_fraction\":0.25}";
  738. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderFailureFractionHalf);
  739. // Make the rest of the test run synchronously.
  740. FinishLoading(true /* load_success */);
  741. // Each network error has a 50% chance of being reported. Fire off several
  742. // and verify that some requests were reported and some weren't. (We can't
  743. // verify exact counts because each decision is made randomly.)
  744. constexpr size_t kReportCount = 100;
  745. for (size_t i = 0; i < kReportCount; ++i)
  746. service()->OnRequest(
  747. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  748. // If our random selection logic is correct, there is a 2^-100 chance that
  749. // every single report above was skipped. If this check fails, it's much more
  750. // likely that our code is wrong.
  751. EXPECT_FALSE(reports().empty());
  752. // There's also a 2^-100 chance that every single report was logged. Same as
  753. // above, that's much more likely to be a code error.
  754. EXPECT_GT(kReportCount, reports().size());
  755. for (const auto& report : reports()) {
  756. const base::Value::Dict* body_dict = report.body->GetIfDict();
  757. ASSERT_TRUE(body_dict);
  758. ExpectDictDoubleValue(0.5, *body_dict,
  759. NetworkErrorLoggingService::kSamplingFractionKey);
  760. }
  761. }
  762. TEST_P(NetworkErrorLoggingServiceTest,
  763. ExcludeSubdomainsDoesntMatchDifferentPort) {
  764. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  765. // Make the rest of the test run synchronously.
  766. FinishLoading(true /* load_success */);
  767. service()->OnRequest(
  768. MakeRequestDetails(kNik_, kUrlDifferentPort_, ERR_CONNECTION_REFUSED));
  769. EXPECT_TRUE(reports().empty());
  770. }
  771. TEST_P(NetworkErrorLoggingServiceTest, ExcludeSubdomainsDoesntMatchSubdomain) {
  772. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  773. // Make the rest of the test run synchronously.
  774. FinishLoading(true /* load_success */);
  775. service()->OnRequest(
  776. MakeRequestDetails(kNik_, kUrlSubdomain_, ERR_CONNECTION_REFUSED));
  777. EXPECT_TRUE(reports().empty());
  778. }
  779. TEST_P(NetworkErrorLoggingServiceTest, IncludeSubdomainsMatchesDifferentPort) {
  780. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderIncludeSubdomains_);
  781. // Make the rest of the test run synchronously.
  782. FinishLoading(true /* load_success */);
  783. service()->OnRequest(
  784. MakeRequestDetails(kNik_, kUrlDifferentPort_, ERR_NAME_NOT_RESOLVED));
  785. ASSERT_EQ(1u, reports().size());
  786. EXPECT_EQ(kUrlDifferentPort_, reports()[0].url);
  787. }
  788. TEST_P(NetworkErrorLoggingServiceTest, IncludeSubdomainsMatchesSubdomain) {
  789. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderIncludeSubdomains_);
  790. // Make the rest of the test run synchronously.
  791. FinishLoading(true /* load_success */);
  792. service()->OnRequest(
  793. MakeRequestDetails(kNik_, kUrlSubdomain_, ERR_NAME_NOT_RESOLVED));
  794. ASSERT_EQ(1u, reports().size());
  795. }
  796. TEST_P(NetworkErrorLoggingServiceTest,
  797. IncludeSubdomainsDoesntMatchSuperdomain) {
  798. service()->OnHeader(kNik_, kOriginSubdomain_, kServerIP_,
  799. kHeaderIncludeSubdomains_);
  800. // Make the rest of the test run synchronously.
  801. FinishLoading(true /* load_success */);
  802. service()->OnRequest(MakeRequestDetails(kNik_, kUrl_, ERR_NAME_NOT_RESOLVED));
  803. EXPECT_TRUE(reports().empty());
  804. }
  805. TEST_P(NetworkErrorLoggingServiceTest,
  806. IncludeSubdomainsDoesntReportConnectionError) {
  807. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderIncludeSubdomains_);
  808. // Make the rest of the test run synchronously.
  809. FinishLoading(true /* load_success */);
  810. service()->OnRequest(
  811. MakeRequestDetails(kNik_, kUrlSubdomain_, ERR_CONNECTION_REFUSED));
  812. EXPECT_TRUE(reports().empty());
  813. }
  814. TEST_P(NetworkErrorLoggingServiceTest,
  815. IncludeSubdomainsDoesntReportApplicationError) {
  816. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderIncludeSubdomains_);
  817. // Make the rest of the test run synchronously.
  818. FinishLoading(true /* load_success */);
  819. service()->OnRequest(
  820. MakeRequestDetails(kNik_, kUrlSubdomain_, ERR_INVALID_HTTP_RESPONSE));
  821. EXPECT_TRUE(reports().empty());
  822. }
  823. TEST_P(NetworkErrorLoggingServiceTest, IncludeSubdomainsDoesntReportSuccess) {
  824. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderIncludeSubdomains_);
  825. // Make the rest of the test run synchronously.
  826. FinishLoading(true /* load_success */);
  827. service()->OnRequest(MakeRequestDetails(kNik_, kUrlSubdomain_, OK));
  828. EXPECT_TRUE(reports().empty());
  829. }
  830. TEST_P(NetworkErrorLoggingServiceTest,
  831. IncludeSubdomainsReportsSameOriginSuccess) {
  832. static const std::string kHeaderIncludeSubdomainsSuccess1 =
  833. "{\"report_to\":\"group\",\"max_age\":86400,"
  834. "\"include_subdomains\":true,\"success_fraction\":1.0}";
  835. service()->OnHeader(kNik_, kOrigin_, kServerIP_,
  836. kHeaderIncludeSubdomainsSuccess1);
  837. // Make the rest of the test run synchronously.
  838. FinishLoading(true /* load_success */);
  839. service()->OnRequest(MakeRequestDetails(kNik_, kUrl_, OK));
  840. ASSERT_EQ(1u, reports().size());
  841. EXPECT_EQ(kUrl_, reports()[0].url);
  842. }
  843. TEST_P(NetworkErrorLoggingServiceTest, RemoveAllBrowsingData) {
  844. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  845. // Make the rest of the test run synchronously.
  846. FinishLoading(true /* load_success */);
  847. EXPECT_EQ(1u, PolicyCount());
  848. EXPECT_TRUE(HasPolicy(kNik_, kOrigin_));
  849. service()->RemoveAllBrowsingData();
  850. service()->OnRequest(
  851. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  852. EXPECT_EQ(0u, PolicyCount());
  853. EXPECT_FALSE(HasPolicy(kNik_, kOrigin_));
  854. EXPECT_TRUE(reports().empty());
  855. }
  856. TEST_P(NetworkErrorLoggingServiceTest, RemoveSomeBrowsingData) {
  857. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  858. // Make the rest of the test run synchronously.
  859. FinishLoading(true /* load_success */);
  860. service()->OnHeader(kNik_, kOriginDifferentHost_, kServerIP_, kHeader_);
  861. EXPECT_EQ(2u, PolicyCount());
  862. // Remove policy for kOrigin_ but not kOriginDifferentHost_
  863. service()->RemoveBrowsingData(
  864. base::BindRepeating([](const url::Origin& origin) -> bool {
  865. return origin.host() == "example.com";
  866. }));
  867. EXPECT_EQ(1u, PolicyCount());
  868. EXPECT_TRUE(HasPolicy(kNik_, kOriginDifferentHost_));
  869. EXPECT_FALSE(HasPolicy(kNik_, kOrigin_));
  870. service()->OnRequest(
  871. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED));
  872. EXPECT_TRUE(reports().empty());
  873. service()->OnRequest(
  874. MakeRequestDetails(kNik_, kUrlDifferentHost_, ERR_CONNECTION_REFUSED));
  875. ASSERT_EQ(1u, reports().size());
  876. }
  877. TEST_P(NetworkErrorLoggingServiceTest, Nested) {
  878. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  879. // Make the rest of the test run synchronously.
  880. FinishLoading(true /* load_success */);
  881. NetworkErrorLoggingService::RequestDetails details =
  882. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED);
  883. details.reporting_upload_depth =
  884. NetworkErrorLoggingService::kMaxNestedReportDepth;
  885. service()->OnRequest(details);
  886. ASSERT_EQ(1u, reports().size());
  887. EXPECT_EQ(NetworkErrorLoggingService::kMaxNestedReportDepth,
  888. reports()[0].depth);
  889. }
  890. TEST_P(NetworkErrorLoggingServiceTest, NestedTooDeep) {
  891. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  892. // Make the rest of the test run synchronously.
  893. FinishLoading(true /* load_success */);
  894. NetworkErrorLoggingService::RequestDetails details =
  895. MakeRequestDetails(kNik_, kUrl_, ERR_CONNECTION_REFUSED);
  896. details.reporting_upload_depth =
  897. NetworkErrorLoggingService::kMaxNestedReportDepth + 1;
  898. service()->OnRequest(details);
  899. EXPECT_TRUE(reports().empty());
  900. }
  901. TEST_P(NetworkErrorLoggingServiceTest, StatusAsValue) {
  902. // The expiration times will be bogus, but we need a reproducible value for
  903. // this test.
  904. base::SimpleTestClock clock;
  905. service()->SetClockForTesting(&clock);
  906. // The clock is initialized to the "zero" or origin point of the Time class.
  907. // This sets the clock's Time to the equivalent of the "zero" or origin point
  908. // of the TimeTicks class, so that the serialized value produced by
  909. // NetLog::TimeToString is consistent across restarts.
  910. base::TimeDelta delta_from_origin =
  911. base::Time::UnixEpoch().since_origin() -
  912. base::TimeTicks::UnixEpoch().since_origin();
  913. clock.Advance(delta_from_origin);
  914. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFraction1_);
  915. // Make the rest of the test run synchronously.
  916. FinishLoading(true /* load_success */);
  917. service()->OnHeader(kNik_, kOriginDifferentHost_, kServerIP_, kHeader_);
  918. service()->OnHeader(kOtherNik_, kOriginSubdomain_, kServerIP_,
  919. kHeaderIncludeSubdomains_);
  920. const std::string kHeaderWrongTypes =
  921. ("{\"report_to\":\"group\","
  922. "\"max_age\":86400,"
  923. // We'll ignore each of these fields because they're the wrong type.
  924. // We'll use a default value instead.
  925. "\"include_subdomains\":\"true\","
  926. "\"success_fraction\": \"1.0\","
  927. "\"failure_fraction\": \"0.0\"}");
  928. service()->OnHeader(
  929. kNik_, url::Origin::Create(GURL("https://invalid-types.example.com")),
  930. kServerIP_, kHeaderWrongTypes);
  931. base::Value actual = service()->StatusAsValue();
  932. base::Value expected = base::test::ParseJson(R"json(
  933. {
  934. "originPolicies": [
  935. {
  936. "networkIsolationKey": "https://example.com https://example.com",
  937. "origin": "https://example.com",
  938. "includeSubdomains": false,
  939. "expires": "86400000",
  940. "reportTo": "group",
  941. "successFraction": 1.0,
  942. "failureFraction": 1.0,
  943. },
  944. {
  945. "networkIsolationKey": "https://example.com https://example.com",
  946. "origin": "https://invalid-types.example.com",
  947. "includeSubdomains": false,
  948. "expires": "86400000",
  949. "reportTo": "group",
  950. "successFraction": 0.0,
  951. "failureFraction": 1.0,
  952. },
  953. {
  954. "networkIsolationKey": "https://example.com https://example.com",
  955. "origin": "https://somewhere-else.com",
  956. "includeSubdomains": false,
  957. "expires": "86400000",
  958. "reportTo": "group",
  959. "successFraction": 0.0,
  960. "failureFraction": 1.0,
  961. },
  962. {
  963. "networkIsolationKey": "https://somewhere-else.com https://somewhere-else.com",
  964. "origin": "https://subdomain.example.com",
  965. "includeSubdomains": true,
  966. "expires": "86400000",
  967. "reportTo": "group",
  968. "successFraction": 0.0,
  969. "failureFraction": 1.0,
  970. },
  971. ]
  972. }
  973. )json");
  974. EXPECT_EQ(expected, actual);
  975. }
  976. TEST_P(NetworkErrorLoggingServiceTest, NoReportingService_SignedExchange) {
  977. service_ = NetworkErrorLoggingService::Create(store_.get());
  978. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  979. // Make the rest of the test run synchronously.
  980. FinishLoading(true /* load_success */);
  981. // Should not crash
  982. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  983. kNik_, false, "sxg.failed", kUrl_, kInnerUrl_, kCertUrl_, kServerIP_));
  984. }
  985. TEST_P(NetworkErrorLoggingServiceTest, NoPolicyForOrigin_SignedExchange) {
  986. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  987. kNik_, false, "sxg.failed", kUrl_, kInnerUrl_, kCertUrl_, kServerIP_));
  988. // Make the rest of the test run synchronously.
  989. FinishLoading(true /* load_success */);
  990. EXPECT_TRUE(reports().empty());
  991. }
  992. TEST_P(NetworkErrorLoggingServiceTest, SuccessFraction0_SignedExchange) {
  993. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFraction0_);
  994. // Make the rest of the test run synchronously.
  995. FinishLoading(true /* load_success */);
  996. // Each network error has a 0% chance of being reported. Fire off several and
  997. // verify that no reports are produced.
  998. constexpr size_t kReportCount = 100;
  999. for (size_t i = 0; i < kReportCount; ++i) {
  1000. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  1001. kNik_, true, "ok", kUrl_, kInnerUrl_, kCertUrl_, kServerIP_));
  1002. }
  1003. EXPECT_TRUE(reports().empty());
  1004. }
  1005. TEST_P(NetworkErrorLoggingServiceTest, SuccessReportQueued_SignedExchange) {
  1006. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFraction1_);
  1007. // Make the rest of the test run synchronously.
  1008. FinishLoading(true /* load_success */);
  1009. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  1010. kNik_, true, "ok", kUrl_, kInnerUrl_, kCertUrl_, kServerIP_));
  1011. ASSERT_EQ(1u, reports().size());
  1012. EXPECT_EQ(kUrl_, reports()[0].url);
  1013. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  1014. EXPECT_EQ(kUserAgent_, reports()[0].user_agent);
  1015. EXPECT_EQ(kGroup_, reports()[0].group);
  1016. EXPECT_EQ(kType_, reports()[0].type);
  1017. EXPECT_EQ(0, reports()[0].depth);
  1018. const base::Value* body = reports()[0].body.get();
  1019. ASSERT_TRUE(body);
  1020. ASSERT_TRUE(body->is_dict());
  1021. const base::Value::Dict& body_dict = body->GetDict();
  1022. base::ExpectDictStringValue(kReferrer_.spec(), body_dict,
  1023. NetworkErrorLoggingService::kReferrerKey);
  1024. ExpectDictDoubleValue(1.0, body_dict,
  1025. NetworkErrorLoggingService::kSamplingFractionKey);
  1026. base::ExpectDictStringValue(kServerIP_.ToString(), body_dict,
  1027. NetworkErrorLoggingService::kServerIpKey);
  1028. base::ExpectDictStringValue("http/1.1", body_dict,
  1029. NetworkErrorLoggingService::kProtocolKey);
  1030. base::ExpectDictStringValue("GET", body_dict,
  1031. NetworkErrorLoggingService::kMethodKey);
  1032. base::ExpectDictIntegerValue(200, body_dict,
  1033. NetworkErrorLoggingService::kStatusCodeKey);
  1034. base::ExpectDictIntegerValue(1234, body_dict,
  1035. NetworkErrorLoggingService::kElapsedTimeKey);
  1036. base::ExpectDictStringValue(
  1037. NetworkErrorLoggingService::kSignedExchangePhaseValue, body_dict,
  1038. NetworkErrorLoggingService::kPhaseKey);
  1039. base::ExpectDictStringValue("ok", body_dict,
  1040. NetworkErrorLoggingService::kTypeKey);
  1041. const base::Value::Dict* sxg_body =
  1042. body_dict.FindDict(NetworkErrorLoggingService::kSignedExchangeBodyKey);
  1043. ASSERT_TRUE(sxg_body);
  1044. base::ExpectDictStringValue(kUrl_.spec(), *sxg_body,
  1045. NetworkErrorLoggingService::kOuterUrlKey);
  1046. base::ExpectDictStringValue(kInnerUrl_.spec(), *sxg_body,
  1047. NetworkErrorLoggingService::kInnerUrlKey);
  1048. base::ExpectStringValue(
  1049. kCertUrl_.spec(),
  1050. sxg_body->Find(NetworkErrorLoggingService::kCertUrlKey)->GetList()[0]);
  1051. }
  1052. TEST_P(NetworkErrorLoggingServiceTest, FailureReportQueued_SignedExchange) {
  1053. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  1054. // Make the rest of the test run synchronously.
  1055. FinishLoading(true /* load_success */);
  1056. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  1057. kNik_, false, "sxg.failed", kUrl_, kInnerUrl_, kCertUrl_, kServerIP_));
  1058. ASSERT_EQ(1u, reports().size());
  1059. EXPECT_EQ(kUrl_, reports()[0].url);
  1060. EXPECT_EQ(kNik_, reports()[0].network_isolation_key);
  1061. EXPECT_EQ(kUserAgent_, reports()[0].user_agent);
  1062. EXPECT_EQ(kGroup_, reports()[0].group);
  1063. EXPECT_EQ(kType_, reports()[0].type);
  1064. EXPECT_EQ(0, reports()[0].depth);
  1065. const base::Value* body = reports()[0].body.get();
  1066. ASSERT_TRUE(body);
  1067. ASSERT_TRUE(body->is_dict());
  1068. const base::Value::Dict& body_dict = body->GetDict();
  1069. base::ExpectDictStringValue(kReferrer_.spec(), body_dict,
  1070. NetworkErrorLoggingService::kReferrerKey);
  1071. ExpectDictDoubleValue(1.0, body_dict,
  1072. NetworkErrorLoggingService::kSamplingFractionKey);
  1073. base::ExpectDictStringValue(kServerIP_.ToString(), body_dict,
  1074. NetworkErrorLoggingService::kServerIpKey);
  1075. base::ExpectDictStringValue("http/1.1", body_dict,
  1076. NetworkErrorLoggingService::kProtocolKey);
  1077. base::ExpectDictStringValue("GET", body_dict,
  1078. NetworkErrorLoggingService::kMethodKey);
  1079. base::ExpectDictIntegerValue(200, body_dict,
  1080. NetworkErrorLoggingService::kStatusCodeKey);
  1081. base::ExpectDictIntegerValue(1234, body_dict,
  1082. NetworkErrorLoggingService::kElapsedTimeKey);
  1083. base::ExpectDictStringValue(
  1084. NetworkErrorLoggingService::kSignedExchangePhaseValue, body_dict,
  1085. NetworkErrorLoggingService::kPhaseKey);
  1086. base::ExpectDictStringValue("sxg.failed", body_dict,
  1087. NetworkErrorLoggingService::kTypeKey);
  1088. const base::Value::Dict* sxg_body =
  1089. body_dict.FindDict(NetworkErrorLoggingService::kSignedExchangeBodyKey);
  1090. ASSERT_TRUE(sxg_body);
  1091. base::ExpectDictStringValue(kUrl_.spec(), *sxg_body,
  1092. NetworkErrorLoggingService::kOuterUrlKey);
  1093. base::ExpectDictStringValue(kInnerUrl_.spec(), *sxg_body,
  1094. NetworkErrorLoggingService::kInnerUrlKey);
  1095. base::ExpectStringValue(
  1096. kCertUrl_.spec(),
  1097. sxg_body->Find(NetworkErrorLoggingService::kCertUrlKey)->GetList()[0]);
  1098. }
  1099. TEST_P(NetworkErrorLoggingServiceTest, MismatchingSubdomain_SignedExchange) {
  1100. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderIncludeSubdomains_);
  1101. // Make the rest of the test run synchronously.
  1102. FinishLoading(true /* load_success */);
  1103. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  1104. kNik_, false, "sxg.failed", kUrlSubdomain_, kInnerUrl_, kCertUrl_,
  1105. kServerIP_));
  1106. EXPECT_TRUE(reports().empty());
  1107. }
  1108. TEST_P(NetworkErrorLoggingServiceTest, MismatchingIPAddress_SignedExchange) {
  1109. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  1110. // Make the rest of the test run synchronously.
  1111. FinishLoading(true /* load_success */);
  1112. service()->QueueSignedExchangeReport(
  1113. MakeSignedExchangeReportDetails(kNik_, false, "sxg.failed", kUrl_,
  1114. kInnerUrl_, kCertUrl_, kOtherServerIP_));
  1115. EXPECT_TRUE(reports().empty());
  1116. }
  1117. TEST_P(NetworkErrorLoggingServiceTest,
  1118. SignedExchangeNetworkIsolationKeyDisabled) {
  1119. base::test::ScopedFeatureList feature_list;
  1120. feature_list.InitAndDisableFeature(
  1121. features::kPartitionNelAndReportingByNetworkIsolationKey);
  1122. // Need to re-create the service, since it caches the feature value on
  1123. // creation.
  1124. service_ = NetworkErrorLoggingService::Create(store_.get());
  1125. reporting_service_ = std::make_unique<TestReportingService>();
  1126. service_->SetReportingService(reporting_service_.get());
  1127. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeaderSuccessFraction1_);
  1128. // Make the rest of the test run synchronously.
  1129. FinishLoading(true /* load_success */);
  1130. // Wrong NIK, but a report should be generated anyways.
  1131. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  1132. kOtherNik_, true, "ok", kUrl_, kInnerUrl_, kCertUrl_, kServerIP_));
  1133. ASSERT_EQ(1u, reports().size());
  1134. EXPECT_EQ(kUrl_, reports()[0].url);
  1135. EXPECT_EQ(NetworkIsolationKey(), reports()[0].network_isolation_key);
  1136. EXPECT_EQ(kUserAgent_, reports()[0].user_agent);
  1137. EXPECT_EQ(kGroup_, reports()[0].group);
  1138. EXPECT_EQ(kType_, reports()[0].type);
  1139. EXPECT_EQ(0, reports()[0].depth);
  1140. }
  1141. // When the max number of policies is exceeded, first try to remove expired
  1142. // policies before evicting the least recently used unexpired policy.
  1143. TEST_P(NetworkErrorLoggingServiceTest, EvictAllExpiredPoliciesFirst) {
  1144. base::SimpleTestClock clock;
  1145. service()->SetClockForTesting(&clock);
  1146. // Add 100 policies then make them expired.
  1147. for (size_t i = 0; i < 100; ++i) {
  1148. service()->OnHeader(MakeNetworkIsolationKey(i), MakeOrigin(i), kServerIP_,
  1149. kHeader_);
  1150. }
  1151. // Make the rest of the test run synchronously.
  1152. FinishLoading(true /* load_success */);
  1153. EXPECT_EQ(100u, PolicyCount());
  1154. clock.Advance(base::Seconds(86401)); // max_age is 86400 sec
  1155. // Expired policies are allowed to linger before hitting the policy limit.
  1156. EXPECT_EQ(100u, PolicyCount());
  1157. // Reach the max policy limit.
  1158. for (size_t i = 100; i < NetworkErrorLoggingService::kMaxPolicies; ++i) {
  1159. service()->OnHeader(MakeNetworkIsolationKey(i), MakeOrigin(i), kServerIP_,
  1160. kHeader_);
  1161. }
  1162. EXPECT_EQ(NetworkErrorLoggingService::kMaxPolicies, PolicyCount());
  1163. // Add one more policy to trigger eviction of only the expired policies.
  1164. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  1165. EXPECT_EQ(NetworkErrorLoggingService::kMaxPolicies - 100 + 1, PolicyCount());
  1166. }
  1167. TEST_P(NetworkErrorLoggingServiceTest, EvictLeastRecentlyUsedPolicy) {
  1168. base::SimpleTestClock clock;
  1169. service()->SetClockForTesting(&clock);
  1170. // A policy's |last_used| is updated when it is added
  1171. for (size_t i = 0; i < NetworkErrorLoggingService::kMaxPolicies; ++i) {
  1172. service()->OnHeader(MakeNetworkIsolationKey(i), MakeOrigin(i), kServerIP_,
  1173. kHeader_);
  1174. clock.Advance(base::Seconds(1));
  1175. }
  1176. // Make the rest of the test run synchronously.
  1177. FinishLoading(true /* load_success */);
  1178. EXPECT_EQ(PolicyCount(), NetworkErrorLoggingService::kMaxPolicies);
  1179. // Set another policy which triggers eviction. None of the policies have
  1180. // expired, so the least recently used (i.e. least recently added) policy
  1181. // should be evicted.
  1182. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  1183. clock.Advance(base::Seconds(1));
  1184. EXPECT_EQ(PolicyCount(), NetworkErrorLoggingService::kMaxPolicies);
  1185. EXPECT_FALSE(
  1186. HasPolicy(MakeNetworkIsolationKey(0), MakeOrigin(0))); // evicted
  1187. std::set<NelPolicyKey> all_policy_keys = service()->GetPolicyKeysForTesting();
  1188. for (size_t i = 1; i < NetworkErrorLoggingService::kMaxPolicies; ++i) {
  1189. // Avoid n calls to HasPolicy(), which would be O(n^2).
  1190. NelPolicyKey key(MakeNetworkIsolationKey(i), MakeOrigin(i));
  1191. EXPECT_EQ(1u, all_policy_keys.count(key));
  1192. }
  1193. EXPECT_TRUE(HasPolicy(kNik_, kOrigin_));
  1194. // Now use the policies in reverse order starting with kOrigin_, then add
  1195. // another policy to trigger eviction, to check that the stalest policy is
  1196. // identified correctly.
  1197. service()->OnRequest(
  1198. MakeRequestDetails(kNik_, kOrigin_.GetURL(), ERR_CONNECTION_REFUSED));
  1199. clock.Advance(base::Seconds(1));
  1200. for (size_t i = NetworkErrorLoggingService::kMaxPolicies - 1; i >= 1; --i) {
  1201. service()->OnRequest(MakeRequestDetails(MakeNetworkIsolationKey(i),
  1202. MakeOrigin(i).GetURL(),
  1203. ERR_CONNECTION_REFUSED));
  1204. clock.Advance(base::Seconds(1));
  1205. }
  1206. service()->OnHeader(kNik_, kOriginSubdomain_, kServerIP_, kHeader_);
  1207. EXPECT_EQ(PolicyCount(), NetworkErrorLoggingService::kMaxPolicies);
  1208. EXPECT_FALSE(HasPolicy(kNik_, kOrigin_)); // evicted
  1209. all_policy_keys = service()->GetPolicyKeysForTesting();
  1210. for (size_t i = NetworkErrorLoggingService::kMaxPolicies - 1; i >= 1; --i) {
  1211. // Avoid n calls to HasPolicy(), which would be O(n^2).
  1212. NelPolicyKey key(MakeNetworkIsolationKey(i), MakeOrigin(i));
  1213. EXPECT_EQ(1u, all_policy_keys.count(key));
  1214. }
  1215. EXPECT_TRUE(HasPolicy(kNik_, kOriginSubdomain_)); // most recently added
  1216. // Note: This test advances the clock by ~2000 seconds, which is below the
  1217. // specified max_age of 86400 seconds, so none of the policies expire during
  1218. // this test.
  1219. }
  1220. TEST_P(NetworkErrorLoggingServiceTest, SendsCommandsToStoreSynchronous) {
  1221. if (!store())
  1222. return;
  1223. MockPersistentNelStore::CommandList expected_commands;
  1224. NetworkErrorLoggingService::NelPolicy policy1 = MakePolicy(kNik_, kOrigin_);
  1225. NetworkErrorLoggingService::NelPolicy policy2 =
  1226. MakePolicy(kNik_, kOriginDifferentHost_);
  1227. std::vector<NetworkErrorLoggingService::NelPolicy> prestored_policies = {
  1228. policy1, policy2};
  1229. store()->SetPrestoredPolicies(std::move(prestored_policies));
  1230. // The first call to any of the public methods triggers a load.
  1231. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  1232. expected_commands.emplace_back(
  1233. MockPersistentNelStore::Command::Type::LOAD_NEL_POLICIES);
  1234. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1235. // Make the rest of the test run synchronously.
  1236. FinishLoading(true /* load_success */);
  1237. // DoOnHeader() should now execute.
  1238. expected_commands.emplace_back(
  1239. MockPersistentNelStore::Command::Type::DELETE_NEL_POLICY, policy1);
  1240. expected_commands.emplace_back(
  1241. MockPersistentNelStore::Command::Type::ADD_NEL_POLICY, policy1);
  1242. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1243. service()->OnRequest(
  1244. MakeRequestDetails(kNik_, kOrigin_.GetURL(), ERR_CONNECTION_REFUSED));
  1245. expected_commands.emplace_back(
  1246. MockPersistentNelStore::Command::Type::UPDATE_NEL_POLICY, policy1);
  1247. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1248. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  1249. kNik_, false, "sxg.failed", kUrl_, kInnerUrl_, kCertUrl_, kServerIP_));
  1250. expected_commands.emplace_back(
  1251. MockPersistentNelStore::Command::Type::UPDATE_NEL_POLICY, policy1);
  1252. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1253. // Removes policy1 but not policy2.
  1254. EXPECT_EQ(2, store()->StoredPoliciesCount());
  1255. service()->RemoveBrowsingData(
  1256. base::BindRepeating([](const url::Origin& origin) -> bool {
  1257. return origin.host() == "example.com";
  1258. }));
  1259. expected_commands.emplace_back(
  1260. MockPersistentNelStore::Command::Type::DELETE_NEL_POLICY, policy1);
  1261. expected_commands.emplace_back(MockPersistentNelStore::Command::Type::FLUSH);
  1262. EXPECT_EQ(1, store()->StoredPoliciesCount());
  1263. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1264. service()->RemoveAllBrowsingData();
  1265. expected_commands.emplace_back(
  1266. MockPersistentNelStore::Command::Type::DELETE_NEL_POLICY, policy2);
  1267. expected_commands.emplace_back(MockPersistentNelStore::Command::Type::FLUSH);
  1268. EXPECT_EQ(0, store()->StoredPoliciesCount());
  1269. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1270. }
  1271. TEST_P(NetworkErrorLoggingServiceTest, DuplicateEntriesInStore) {
  1272. if (!store())
  1273. return;
  1274. NetworkErrorLoggingService::NelPolicy policy1 = MakePolicy(kNik_, kOrigin_);
  1275. NetworkErrorLoggingService::NelPolicy policy2 = policy1;
  1276. std::vector<NetworkErrorLoggingService::NelPolicy> prestored_policies = {
  1277. policy1, policy2};
  1278. store()->SetPrestoredPolicies(std::move(prestored_policies));
  1279. // The first call to any of the public methods triggers a load.
  1280. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  1281. EXPECT_TRUE(store()->VerifyCommands({MockPersistentNelStore::Command(
  1282. MockPersistentNelStore::Command::Type::LOAD_NEL_POLICIES)}));
  1283. FinishLoading(/*load_success=*/true);
  1284. EXPECT_EQ(service()->GetPolicyKeysForTesting().size(), 1u);
  1285. }
  1286. // Same as the above test, except that all the tasks are queued until loading
  1287. // is complete.
  1288. TEST_P(NetworkErrorLoggingServiceTest, SendsCommandsToStoreDeferred) {
  1289. if (!store())
  1290. return;
  1291. MockPersistentNelStore::CommandList expected_commands;
  1292. NetworkErrorLoggingService::NelPolicy policy1 = MakePolicy(kNik_, kOrigin_);
  1293. NetworkErrorLoggingService::NelPolicy policy2 =
  1294. MakePolicy(kNik_, kOriginDifferentHost_);
  1295. std::vector<NetworkErrorLoggingService::NelPolicy> prestored_policies = {
  1296. policy1, policy2};
  1297. store()->SetPrestoredPolicies(std::move(prestored_policies));
  1298. // The first call to any of the public methods triggers a load.
  1299. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  1300. expected_commands.emplace_back(
  1301. MockPersistentNelStore::Command::Type::LOAD_NEL_POLICIES);
  1302. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1303. service()->OnRequest(
  1304. MakeRequestDetails(kNik_, kOrigin_.GetURL(), ERR_CONNECTION_REFUSED));
  1305. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1306. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  1307. kNik_, false, "sxg.failed", kUrl_, kInnerUrl_, kCertUrl_, kServerIP_));
  1308. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1309. // Removes policy1 but not policy2.
  1310. service()->RemoveBrowsingData(
  1311. base::BindRepeating([](const url::Origin& origin) -> bool {
  1312. return origin.host() == "example.com";
  1313. }));
  1314. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1315. service()->RemoveAllBrowsingData();
  1316. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1317. // The store has not yet been told to remove the policies because the tasks
  1318. // to remove browsing data were queued pending initialization.
  1319. EXPECT_EQ(2, store()->StoredPoliciesCount());
  1320. FinishLoading(true /* load_success */);
  1321. // DoOnHeader()
  1322. expected_commands.emplace_back(
  1323. MockPersistentNelStore::Command::Type::DELETE_NEL_POLICY, policy1);
  1324. expected_commands.emplace_back(
  1325. MockPersistentNelStore::Command::Type::ADD_NEL_POLICY, policy1);
  1326. // DoOnRequest()
  1327. expected_commands.emplace_back(
  1328. MockPersistentNelStore::Command::Type::UPDATE_NEL_POLICY, policy1);
  1329. // DoQueueSignedExchangeReport()
  1330. expected_commands.emplace_back(
  1331. MockPersistentNelStore::Command::Type::UPDATE_NEL_POLICY, policy1);
  1332. // DoRemoveBrowsingData()
  1333. expected_commands.emplace_back(
  1334. MockPersistentNelStore::Command::Type::DELETE_NEL_POLICY, policy1);
  1335. expected_commands.emplace_back(MockPersistentNelStore::Command::Type::FLUSH);
  1336. // DoRemoveAllBrowsingData()
  1337. expected_commands.emplace_back(
  1338. MockPersistentNelStore::Command::Type::DELETE_NEL_POLICY, policy2);
  1339. expected_commands.emplace_back(MockPersistentNelStore::Command::Type::FLUSH);
  1340. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1341. }
  1342. // These two tests check that if loading fails, the commands should still
  1343. // be sent to the store; the actual store impl will just ignore them.
  1344. TEST_P(NetworkErrorLoggingServiceTest,
  1345. SendsCommandsToStoreSynchronousLoadFailed) {
  1346. if (!store())
  1347. return;
  1348. MockPersistentNelStore::CommandList expected_commands;
  1349. NetworkErrorLoggingService::NelPolicy policy1 = MakePolicy(kNik_, kOrigin_);
  1350. NetworkErrorLoggingService::NelPolicy policy2 =
  1351. MakePolicy(kNik_, kOriginDifferentHost_);
  1352. std::vector<NetworkErrorLoggingService::NelPolicy> prestored_policies = {
  1353. policy1, policy2};
  1354. store()->SetPrestoredPolicies(std::move(prestored_policies));
  1355. // The first call to any of the public methods triggers a load.
  1356. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  1357. expected_commands.emplace_back(
  1358. MockPersistentNelStore::Command::Type::LOAD_NEL_POLICIES);
  1359. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1360. // Make the rest of the test run synchronously.
  1361. FinishLoading(false /* load_success */);
  1362. // DoOnHeader() should now execute.
  1363. // Because the load failed, there will be no policies in memory, so the store
  1364. // is not told to delete anything.
  1365. expected_commands.emplace_back(
  1366. MockPersistentNelStore::Command::Type::ADD_NEL_POLICY, policy1);
  1367. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1368. service()->OnRequest(
  1369. MakeRequestDetails(kNik_, kOrigin_.GetURL(), ERR_CONNECTION_REFUSED));
  1370. expected_commands.emplace_back(
  1371. MockPersistentNelStore::Command::Type::UPDATE_NEL_POLICY, policy1);
  1372. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1373. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  1374. kNik_, false, "sxg.failed", kUrl_, kInnerUrl_, kCertUrl_, kServerIP_));
  1375. expected_commands.emplace_back(
  1376. MockPersistentNelStore::Command::Type::UPDATE_NEL_POLICY, policy1);
  1377. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1378. // Removes policy1 but not policy2.
  1379. service()->RemoveBrowsingData(
  1380. base::BindRepeating([](const url::Origin& origin) -> bool {
  1381. return origin.host() == "example.com";
  1382. }));
  1383. expected_commands.emplace_back(
  1384. MockPersistentNelStore::Command::Type::DELETE_NEL_POLICY, policy1);
  1385. expected_commands.emplace_back(MockPersistentNelStore::Command::Type::FLUSH);
  1386. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1387. service()->RemoveAllBrowsingData();
  1388. // We failed to load policy2 from the store, so there is nothing to remove
  1389. // here.
  1390. expected_commands.emplace_back(MockPersistentNelStore::Command::Type::FLUSH);
  1391. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1392. }
  1393. TEST_P(NetworkErrorLoggingServiceTest, SendsCommandsToStoreDeferredLoadFailed) {
  1394. if (!store())
  1395. return;
  1396. MockPersistentNelStore::CommandList expected_commands;
  1397. NetworkErrorLoggingService::NelPolicy policy1 = MakePolicy(kNik_, kOrigin_);
  1398. NetworkErrorLoggingService::NelPolicy policy2 =
  1399. MakePolicy(kNik_, kOriginDifferentHost_);
  1400. std::vector<NetworkErrorLoggingService::NelPolicy> prestored_policies = {
  1401. policy1, policy2};
  1402. store()->SetPrestoredPolicies(std::move(prestored_policies));
  1403. // The first call to any of the public methods triggers a load.
  1404. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  1405. expected_commands.emplace_back(
  1406. MockPersistentNelStore::Command::Type::LOAD_NEL_POLICIES);
  1407. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1408. service()->OnRequest(
  1409. MakeRequestDetails(kNik_, kOrigin_.GetURL(), ERR_CONNECTION_REFUSED));
  1410. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1411. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  1412. kNik_, false, "sxg.failed", kUrl_, kInnerUrl_, kCertUrl_, kServerIP_));
  1413. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1414. // Removes policy1 but not policy2.
  1415. service()->RemoveBrowsingData(
  1416. base::BindRepeating([](const url::Origin& origin) -> bool {
  1417. return origin.host() == "example.com";
  1418. }));
  1419. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1420. service()->RemoveAllBrowsingData();
  1421. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1422. FinishLoading(false /* load_success */);
  1423. // DoOnHeader()
  1424. // Because the load failed, there will be no policies in memory, so the store
  1425. // is not told to delete anything.
  1426. expected_commands.emplace_back(
  1427. MockPersistentNelStore::Command::Type::ADD_NEL_POLICY, policy1);
  1428. // DoOnRequest()
  1429. expected_commands.emplace_back(
  1430. MockPersistentNelStore::Command::Type::UPDATE_NEL_POLICY, policy1);
  1431. // DoQueueSignedExchangeReport()
  1432. expected_commands.emplace_back(
  1433. MockPersistentNelStore::Command::Type::UPDATE_NEL_POLICY, policy1);
  1434. // DoRemoveBrowsingData()
  1435. expected_commands.emplace_back(
  1436. MockPersistentNelStore::Command::Type::DELETE_NEL_POLICY, policy1);
  1437. expected_commands.emplace_back(MockPersistentNelStore::Command::Type::FLUSH);
  1438. // DoRemoveAllBrowsingData()
  1439. // We failed to load policy2 from the store, so there is nothing to remove
  1440. // here.
  1441. expected_commands.emplace_back(MockPersistentNelStore::Command::Type::FLUSH);
  1442. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1443. }
  1444. TEST_P(NetworkErrorLoggingServiceTest, FlushesStoreOnDestruction) {
  1445. auto store = std::make_unique<MockPersistentNelStore>();
  1446. std::unique_ptr<NetworkErrorLoggingService> service =
  1447. NetworkErrorLoggingService::Create(store.get());
  1448. MockPersistentNelStore::CommandList expected_commands;
  1449. service->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  1450. expected_commands.emplace_back(
  1451. MockPersistentNelStore::Command::Type::LOAD_NEL_POLICIES);
  1452. EXPECT_TRUE(store->VerifyCommands(expected_commands));
  1453. store->FinishLoading(false /* load_success */);
  1454. expected_commands.emplace_back(
  1455. MockPersistentNelStore::Command::Type::ADD_NEL_POLICY,
  1456. MakePolicy(kNik_, kOrigin_));
  1457. EXPECT_TRUE(store->VerifyCommands(expected_commands));
  1458. // Store should be flushed on destruction of service.
  1459. service.reset();
  1460. expected_commands.emplace_back(MockPersistentNelStore::Command::Type::FLUSH);
  1461. EXPECT_TRUE(store->VerifyCommands(expected_commands));
  1462. }
  1463. TEST_P(NetworkErrorLoggingServiceTest,
  1464. DoesntFlushStoreOnDestructionBeforeLoad) {
  1465. auto store = std::make_unique<MockPersistentNelStore>();
  1466. std::unique_ptr<NetworkErrorLoggingService> service =
  1467. NetworkErrorLoggingService::Create(store.get());
  1468. service.reset();
  1469. EXPECT_EQ(0u, store->GetAllCommands().size());
  1470. }
  1471. TEST_P(NetworkErrorLoggingServiceTest, DoNothingIfShutDown) {
  1472. if (!store())
  1473. return;
  1474. MockPersistentNelStore::CommandList expected_commands;
  1475. // The first call to any of the public methods triggers a load.
  1476. service()->OnHeader(kNik_, kOrigin_, kServerIP_, kHeader_);
  1477. expected_commands.emplace_back(
  1478. MockPersistentNelStore::Command::Type::LOAD_NEL_POLICIES);
  1479. EXPECT_TRUE(store()->VerifyCommands(expected_commands));
  1480. service()->OnRequest(
  1481. MakeRequestDetails(kNik_, kOrigin_.GetURL(), ERR_CONNECTION_REFUSED));
  1482. service()->QueueSignedExchangeReport(MakeSignedExchangeReportDetails(
  1483. kNik_, false, "sxg.failed", kUrl_, kInnerUrl_, kCertUrl_, kServerIP_));
  1484. service()->RemoveBrowsingData(
  1485. base::BindRepeating([](const url::Origin& origin) -> bool {
  1486. return origin.host() == "example.com";
  1487. }));
  1488. service()->RemoveAllBrowsingData();
  1489. // Finish loading after the service has been shut down.
  1490. service()->OnShutdown();
  1491. FinishLoading(true /* load_success */);
  1492. // Only the LOAD command should have been sent to the store.
  1493. EXPECT_EQ(1u, store()->GetAllCommands().size());
  1494. EXPECT_EQ(0u, PolicyCount());
  1495. EXPECT_EQ(0u, reports().size());
  1496. }
  1497. INSTANTIATE_TEST_SUITE_P(NetworkErrorLoggingServiceStoreTest,
  1498. NetworkErrorLoggingServiceTest,
  1499. testing::Bool());
  1500. } // namespace
  1501. } // namespace net