request_monitoring_browsertest.cc 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596
  1. // Copyright 2021 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 "content/public/test/browser_test.h"
  5. #include "fuchsia_web/common/string_util.h"
  6. #include "fuchsia_web/common/test/frame_test_util.h"
  7. #include "fuchsia_web/common/test/test_navigation_listener.h"
  8. #include "fuchsia_web/common/test/url_request_rewrite_test_util.h"
  9. #include "fuchsia_web/webengine/browser/frame_impl_browser_test_base.h"
  10. #include "fuchsia_web/webengine/switches.h"
  11. #include "fuchsia_web/webengine/test/frame_for_test.h"
  12. #include "testing/gmock/include/gmock/gmock.h"
  13. namespace {
  14. constexpr char kPage1Path[] = "/title1.html";
  15. constexpr char kPage2Path[] = "/title2.html";
  16. constexpr char kPage3Path[] = "/image.html";
  17. constexpr char kPage1Title[] = "title 1";
  18. constexpr char kPage3ImgPath[] = "/img.png";
  19. constexpr char kSetHeaderRequestPath[] = "/set_header_request.html";
  20. class RequestMonitoringTest : public FrameImplTestBase {
  21. public:
  22. RequestMonitoringTest() = default;
  23. ~RequestMonitoringTest() override = default;
  24. RequestMonitoringTest(const RequestMonitoringTest&) = delete;
  25. RequestMonitoringTest& operator=(const RequestMonitoringTest&) = delete;
  26. protected:
  27. void SetUpOnMainThread() override {
  28. // Accumulate all http requests made to |embedded_test_server| into
  29. // |accumulated_requests_| container.
  30. embedded_test_server()->RegisterRequestMonitor(base::BindRepeating(
  31. &RequestMonitoringTest::MonitorRequestOnIoThread,
  32. base::Unretained(this), base::SequencedTaskRunnerHandle::Get()));
  33. ASSERT_TRUE(test_server_handle_ =
  34. embedded_test_server()->StartAndReturnHandle());
  35. }
  36. void SetUpCommandLine(base::CommandLine* command_line) override {
  37. // Needed for UrlRequestRewriteAddHeaders.
  38. command_line->AppendSwitchNative(switches::kCorsExemptHeaders, "Test");
  39. }
  40. std::map<GURL, net::test_server::HttpRequest> accumulated_requests_;
  41. private:
  42. void MonitorRequestOnIoThread(
  43. const scoped_refptr<base::SequencedTaskRunner>& main_thread_task_runner,
  44. const net::test_server::HttpRequest& request) {
  45. main_thread_task_runner->PostTask(
  46. FROM_HERE,
  47. base::BindOnce(&RequestMonitoringTest::MonitorRequestOnMainThread,
  48. base::Unretained(this), request));
  49. }
  50. void MonitorRequestOnMainThread(
  51. const net::test_server::HttpRequest& request) {
  52. accumulated_requests_[request.GetURL()] = request;
  53. }
  54. net::test_server::EmbeddedTestServerHandle test_server_handle_;
  55. };
  56. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, ExtraHeaders) {
  57. auto frame = FrameForTest::Create(context(), {});
  58. const GURL page_url(embedded_test_server()->GetURL(kPage1Path));
  59. fuchsia::web::LoadUrlParams load_url_params;
  60. fuchsia::net::http::Header header1;
  61. header1.name = StringToBytes("X-ExtraHeaders");
  62. header1.value = StringToBytes("1");
  63. fuchsia::net::http::Header header2;
  64. header2.name = StringToBytes("X-2ExtraHeaders");
  65. header2.value = StringToBytes("2");
  66. load_url_params.set_headers({header1, header2});
  67. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  68. std::move(load_url_params),
  69. page_url.spec()));
  70. frame.navigation_listener().RunUntilUrlAndTitleEquals(page_url, kPage1Title);
  71. // At this point, the page should be loaded, the server should have received
  72. // the request and the request should be in the map.
  73. const auto iter = accumulated_requests_.find(page_url);
  74. ASSERT_NE(iter, accumulated_requests_.end());
  75. EXPECT_THAT(iter->second.headers,
  76. testing::Contains(testing::Key("X-ExtraHeaders")));
  77. EXPECT_THAT(iter->second.headers,
  78. testing::Contains(testing::Key("X-2ExtraHeaders")));
  79. }
  80. // Tests that UrlRequestActions can be set up to deny requests to specific
  81. // hosts.
  82. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteDeny) {
  83. auto frame = FrameForTest::Create(context(), {});
  84. fuchsia::web::UrlRequestRewriteRule rule;
  85. rule.set_hosts_filter({"127.0.0.1"});
  86. rule.set_action(fuchsia::web::UrlRequestAction::DENY);
  87. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  88. rules.push_back(std::move(rule));
  89. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  90. // 127.0.0.1 should be blocked.
  91. const GURL page_url(embedded_test_server()->GetURL(kPage3Path));
  92. {
  93. fuchsia::web::NavigationState error_state;
  94. error_state.set_page_type(fuchsia::web::PageType::ERROR);
  95. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  96. fuchsia::web::LoadUrlParams(),
  97. page_url.spec()));
  98. frame.navigation_listener().RunUntilNavigationStateMatches(error_state);
  99. }
  100. // However, "localhost" is not blocked, so this request should be allowed.
  101. {
  102. GURL::Replacements replacements;
  103. replacements.SetHostStr("localhost");
  104. GURL page_url_localhost = page_url.ReplaceComponents(replacements);
  105. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  106. fuchsia::web::LoadUrlParams(),
  107. page_url_localhost.spec()));
  108. frame.navigation_listener().RunUntilUrlEquals(page_url_localhost);
  109. }
  110. }
  111. // Tests that a UrlRequestAction with no filter criteria will apply to all
  112. // requests.
  113. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteDenyAll) {
  114. auto frame = FrameForTest::Create(context(), {});
  115. // No filter criteria are set, so everything is denied.
  116. fuchsia::web::UrlRequestRewriteRule rule;
  117. rule.set_action(fuchsia::web::UrlRequestAction::DENY);
  118. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  119. rules.push_back(std::move(rule));
  120. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  121. // 127.0.0.1 should be blocked.
  122. const GURL page_url(embedded_test_server()->GetURL(kPage3Path));
  123. {
  124. fuchsia::web::NavigationState error_state;
  125. error_state.set_page_type(fuchsia::web::PageType::ERROR);
  126. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  127. fuchsia::web::LoadUrlParams(),
  128. page_url.spec()));
  129. frame.navigation_listener().RunUntilNavigationStateMatches(error_state);
  130. }
  131. // "localhost" should be blocked.
  132. {
  133. GURL::Replacements replacements;
  134. replacements.SetHostStr("localhost");
  135. GURL page_url_localhost = page_url.ReplaceComponents(replacements);
  136. fuchsia::web::NavigationState error_state;
  137. error_state.set_page_type(fuchsia::web::PageType::ERROR);
  138. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  139. fuchsia::web::LoadUrlParams(),
  140. page_url.spec()));
  141. frame.navigation_listener().RunUntilNavigationStateMatches(error_state);
  142. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  143. fuchsia::web::LoadUrlParams(),
  144. page_url_localhost.spec()));
  145. frame.navigation_listener().RunUntilNavigationStateMatches(error_state);
  146. }
  147. }
  148. // Tests that UrlRequestActions can be set up to only allow requests for a
  149. // single host, while denying everything else.
  150. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteSelectiveAllow) {
  151. auto frame = FrameForTest::Create(context(), {});
  152. // Allow 127.0.0.1.
  153. fuchsia::web::UrlRequestRewriteRule rule;
  154. rule.set_hosts_filter({"127.0.0.1"});
  155. rule.set_action(fuchsia::web::UrlRequestAction::ALLOW);
  156. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  157. rules.push_back(std::move(rule));
  158. // Deny everything else.
  159. rule = {};
  160. rule.set_action(fuchsia::web::UrlRequestAction::DENY);
  161. rules.push_back(std::move(rule));
  162. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  163. // 127.0.0.1 should be allowed.
  164. const GURL page_url(embedded_test_server()->GetURL(kPage3Path));
  165. {
  166. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  167. fuchsia::web::LoadUrlParams(),
  168. page_url.spec()));
  169. frame.navigation_listener().RunUntilUrlEquals(page_url);
  170. }
  171. // "localhost" should be blocked.
  172. {
  173. GURL::Replacements replacements;
  174. replacements.SetHostStr("localhost");
  175. GURL page_url_localhost = page_url.ReplaceComponents(replacements);
  176. fuchsia::web::NavigationState error_state;
  177. error_state.set_page_type(fuchsia::web::PageType::ERROR);
  178. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  179. fuchsia::web::LoadUrlParams(),
  180. page_url_localhost.spec()));
  181. frame.navigation_listener().RunUntilNavigationStateMatches(error_state);
  182. }
  183. }
  184. // Tests the URLRequestRewrite API properly adds headers on every requests.
  185. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteAddHeaders) {
  186. auto frame = FrameForTest::Create(context(), {});
  187. std::vector<fuchsia::web::UrlRequestRewrite> rewrites;
  188. rewrites.push_back(CreateRewriteAddHeaders("Test", "Value"));
  189. fuchsia::web::UrlRequestRewriteRule rule;
  190. rule.set_rewrites(std::move(rewrites));
  191. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  192. rules.push_back(std::move(rule));
  193. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  194. // Navigate, we should get the additional header on the main request and the
  195. // image request.
  196. const GURL page_url(embedded_test_server()->GetURL(kPage3Path));
  197. const GURL img_url(embedded_test_server()->GetURL(kPage3ImgPath));
  198. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  199. fuchsia::web::LoadUrlParams(),
  200. page_url.spec()));
  201. frame.navigation_listener().RunUntilUrlEquals(page_url);
  202. {
  203. const auto iter = accumulated_requests_.find(page_url);
  204. ASSERT_NE(iter, accumulated_requests_.end());
  205. EXPECT_THAT(iter->second.headers, testing::Contains(testing::Key("Test")));
  206. }
  207. {
  208. const auto iter = accumulated_requests_.find(img_url);
  209. ASSERT_NE(iter, accumulated_requests_.end());
  210. EXPECT_THAT(iter->second.headers, testing::Contains(testing::Key("Test")));
  211. }
  212. }
  213. // Tests the URLRequestRewrite API properly adds headers on every requests.
  214. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest,
  215. UrlRequestRewriteAddExistingHeader) {
  216. auto frame = FrameForTest::Create(context(), {});
  217. std::vector<fuchsia::web::UrlRequestRewrite> rewrites;
  218. rewrites.push_back(CreateRewriteAddHeaders("Test", "Value"));
  219. fuchsia::web::UrlRequestRewriteRule rule;
  220. rule.set_rewrites(std::move(rewrites));
  221. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  222. rules.push_back(std::move(rule));
  223. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  224. // Navigate. The first page request should have the "Test" header set to
  225. // "Value". The second one should have the "Test" header set to "SetByJS" via
  226. // JavaScript and not be overridden by the rewrite rule.
  227. const GURL page_url(embedded_test_server()->GetURL(kSetHeaderRequestPath));
  228. const GURL img_url(embedded_test_server()->GetURL(kPage3Path));
  229. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  230. fuchsia::web::LoadUrlParams(),
  231. page_url.spec()));
  232. frame.navigation_listener().RunUntilTitleEquals("loaded");
  233. {
  234. const auto iter = accumulated_requests_.find(page_url);
  235. ASSERT_NE(iter, accumulated_requests_.end());
  236. ASSERT_THAT(iter->second.headers, testing::Contains(testing::Key("Test")));
  237. EXPECT_EQ(iter->second.headers["Test"], "Value");
  238. }
  239. {
  240. const auto iter = accumulated_requests_.find(img_url);
  241. ASSERT_NE(iter, accumulated_requests_.end());
  242. ASSERT_THAT(iter->second.headers, testing::Contains(testing::Key("Test")));
  243. EXPECT_EQ(iter->second.headers["Test"], "SetByJS");
  244. }
  245. }
  246. // Tests the URLRequestRewrite API properly removes headers on every requests.
  247. // Also tests that rewrites are applied properly in succession.
  248. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteRemoveHeader) {
  249. auto frame = FrameForTest::Create(context(), {});
  250. std::vector<fuchsia::web::UrlRequestRewrite> rewrites;
  251. rewrites.push_back(CreateRewriteAddHeaders("Test", "Value"));
  252. rewrites.push_back(CreateRewriteRemoveHeader(absl::nullopt, "Test"));
  253. fuchsia::web::UrlRequestRewriteRule rule;
  254. rule.set_rewrites(std::move(rewrites));
  255. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  256. rules.push_back(std::move(rule));
  257. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  258. // Navigate, we should get no "Test" header.
  259. const GURL page_url(embedded_test_server()->GetURL(kPage3Path));
  260. const GURL img_url(embedded_test_server()->GetURL(kPage3ImgPath));
  261. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  262. fuchsia::web::LoadUrlParams(),
  263. page_url.spec()));
  264. frame.navigation_listener().RunUntilUrlEquals(page_url);
  265. {
  266. const auto iter = accumulated_requests_.find(page_url);
  267. ASSERT_NE(iter, accumulated_requests_.end());
  268. EXPECT_THAT(iter->second.headers,
  269. testing::Not(testing::Contains(testing::Key("Test"))));
  270. }
  271. {
  272. const auto iter = accumulated_requests_.find(img_url);
  273. ASSERT_NE(iter, accumulated_requests_.end());
  274. EXPECT_THAT(iter->second.headers,
  275. testing::Not(testing::Contains(testing::Key("Test"))));
  276. }
  277. }
  278. // Tests the URLRequestRewrite API properly removes headers, based on the
  279. // presence of a string in the query.
  280. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest,
  281. UrlRequestRewriteRemoveHeaderWithQuery) {
  282. auto frame = FrameForTest::Create(context(), {});
  283. const GURL page_url(embedded_test_server()->GetURL("/page?stuff=[pattern]"));
  284. std::vector<fuchsia::web::UrlRequestRewrite> rewrites;
  285. rewrites.push_back(CreateRewriteAddHeaders("Test", "Value"));
  286. rewrites.push_back(
  287. CreateRewriteRemoveHeader(absl::make_optional("[pattern]"), "Test"));
  288. fuchsia::web::UrlRequestRewriteRule rule;
  289. rule.set_rewrites(std::move(rewrites));
  290. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  291. rules.push_back(std::move(rule));
  292. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  293. // Navigate, we should get no "Test" header.
  294. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  295. fuchsia::web::LoadUrlParams(),
  296. page_url.spec()));
  297. frame.navigation_listener().RunUntilUrlEquals(page_url);
  298. const auto iter = accumulated_requests_.find(page_url);
  299. ASSERT_NE(iter, accumulated_requests_.end());
  300. EXPECT_THAT(iter->second.headers,
  301. testing::Not(testing::Contains(testing::Key("Test"))));
  302. }
  303. // Tests the URLRequestRewrite API properly handles query substitution.
  304. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest,
  305. UrlRequestRewriteSubstituteQueryPattern) {
  306. auto frame = FrameForTest::Create(context(), {});
  307. std::vector<fuchsia::web::UrlRequestRewrite> rewrites;
  308. rewrites.push_back(
  309. CreateRewriteSubstituteQueryPattern("[pattern]", "substitution"));
  310. fuchsia::web::UrlRequestRewriteRule rule;
  311. rule.set_rewrites(std::move(rewrites));
  312. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  313. rules.push_back(std::move(rule));
  314. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  315. // Navigate, we should get to the URL with the modified request.
  316. const GURL page_url(embedded_test_server()->GetURL("/page?[pattern]"));
  317. const GURL final_url(embedded_test_server()->GetURL("/page?substitution"));
  318. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  319. fuchsia::web::LoadUrlParams(),
  320. page_url.spec()));
  321. frame.navigation_listener().RunUntilUrlEquals(final_url);
  322. EXPECT_THAT(accumulated_requests_,
  323. testing::Contains(testing::Key(final_url)));
  324. }
  325. // Tests the URLRequestRewrite API properly handles URL replacement.
  326. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteReplaceUrl) {
  327. auto frame = FrameForTest::Create(context(), {});
  328. const GURL page_url(embedded_test_server()->GetURL(kPage1Path));
  329. const GURL final_url(embedded_test_server()->GetURL(kPage2Path));
  330. std::vector<fuchsia::web::UrlRequestRewrite> rewrites;
  331. rewrites.push_back(CreateRewriteReplaceUrl(kPage1Path, final_url.spec()));
  332. fuchsia::web::UrlRequestRewriteRule rule;
  333. rule.set_rewrites(std::move(rewrites));
  334. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  335. rules.push_back(std::move(rule));
  336. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  337. // Navigate, we should get to the replaced URL.
  338. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  339. fuchsia::web::LoadUrlParams(),
  340. page_url.spec()));
  341. frame.navigation_listener().RunUntilUrlEquals(final_url);
  342. EXPECT_THAT(accumulated_requests_,
  343. testing::Contains(testing::Key(final_url)));
  344. }
  345. // Tests the URLRequestRewrite API properly handles URL replacement when the
  346. // original request URL contains a query and a fragment string.
  347. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest,
  348. UrlRequestRewriteReplaceUrlQueryRef) {
  349. auto frame = FrameForTest::Create(context(), {});
  350. const GURL page_url(
  351. embedded_test_server()->GetURL(std::string(kPage1Path) + "?query#ref"));
  352. const GURL replacement_url(embedded_test_server()->GetURL(kPage2Path));
  353. const GURL final_url_with_ref(
  354. embedded_test_server()->GetURL(std::string(kPage2Path) + "?query#ref"));
  355. const GURL final_url(
  356. embedded_test_server()->GetURL(std::string(kPage2Path) + "?query"));
  357. std::vector<fuchsia::web::UrlRequestRewrite> rewrites;
  358. rewrites.push_back(
  359. CreateRewriteReplaceUrl(kPage1Path, replacement_url.spec()));
  360. fuchsia::web::UrlRequestRewriteRule rule;
  361. rule.set_rewrites(std::move(rewrites));
  362. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  363. rules.push_back(std::move(rule));
  364. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  365. // Navigate, we should get to the replaced URL.
  366. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  367. fuchsia::web::LoadUrlParams(),
  368. page_url.spec()));
  369. frame.navigation_listener().RunUntilUrlEquals(final_url_with_ref);
  370. EXPECT_THAT(accumulated_requests_,
  371. testing::Contains(testing::Key(final_url)));
  372. }
  373. // Tests the URLRequestRewrite API properly handles adding a query.
  374. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteAddQuery) {
  375. auto frame = FrameForTest::Create(context(), {});
  376. std::vector<fuchsia::web::UrlRequestRewrite> rewrites;
  377. rewrites.push_back(CreateRewriteAppendToQuery("query"));
  378. fuchsia::web::UrlRequestRewriteRule rule;
  379. rule.set_rewrites(std::move(rewrites));
  380. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  381. rules.push_back(std::move(rule));
  382. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  383. {
  384. // Add a query to a URL with no query.
  385. const GURL page_url(embedded_test_server()->GetURL(kPage1Path));
  386. const GURL expected_url(
  387. embedded_test_server()->GetURL(std::string(kPage1Path) + "?query"));
  388. // Navigate, we should get to the URL with the query.
  389. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  390. fuchsia::web::LoadUrlParams(),
  391. page_url.spec()));
  392. frame.navigation_listener().RunUntilUrlEquals(expected_url);
  393. EXPECT_THAT(accumulated_requests_,
  394. testing::Contains(testing::Key(expected_url)));
  395. }
  396. {
  397. // Add a quest to a URL that has an empty query.
  398. const std::string original_path = std::string(kPage1Path) + "?";
  399. const GURL page_url(embedded_test_server()->GetURL(original_path));
  400. const GURL expected_url(
  401. embedded_test_server()->GetURL(original_path + "query"));
  402. // Navigate, we should get to the URL with the query, but no "&".
  403. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  404. fuchsia::web::LoadUrlParams(),
  405. page_url.spec()));
  406. frame.navigation_listener().RunUntilUrlEquals(expected_url);
  407. EXPECT_THAT(accumulated_requests_,
  408. testing::Contains(testing::Key(expected_url)));
  409. }
  410. {
  411. // Add a query to a URL that already has a query.
  412. const std::string original_path =
  413. std::string(kPage1Path) + "?original_query=value";
  414. const GURL page_url(embedded_test_server()->GetURL(original_path));
  415. const GURL expected_url(
  416. embedded_test_server()->GetURL(original_path + "&query"));
  417. // Navigate, we should get to the URL with the appended query.
  418. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  419. fuchsia::web::LoadUrlParams(),
  420. page_url.spec()));
  421. frame.navigation_listener().RunUntilUrlEquals(expected_url);
  422. EXPECT_THAT(accumulated_requests_,
  423. testing::Contains(testing::Key(expected_url)));
  424. }
  425. {
  426. // Add a query to a URL that has a ref.
  427. const GURL page_url(
  428. embedded_test_server()->GetURL(std::string(kPage1Path) + "#ref"));
  429. const GURL expected_url(
  430. embedded_test_server()->GetURL(std::string(kPage1Path) + "?query#ref"));
  431. // Navigate, we should get to the URL with the query.
  432. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  433. fuchsia::web::LoadUrlParams(),
  434. page_url.spec()));
  435. frame.navigation_listener().RunUntilUrlEquals(expected_url);
  436. }
  437. }
  438. // Tests the URLRequestRewrite API properly handles adding a query with a
  439. // question mark.
  440. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest,
  441. UrlRequestRewriteAppendToQueryQuestionMark) {
  442. auto frame = FrameForTest::Create(context(), {});
  443. const GURL page_url(embedded_test_server()->GetURL(kPage1Path));
  444. const GURL expected_url(
  445. embedded_test_server()->GetURL(std::string(kPage1Path) + "?qu?ery"));
  446. std::vector<fuchsia::web::UrlRequestRewrite> rewrites;
  447. rewrites.push_back(CreateRewriteAppendToQuery("qu?ery"));
  448. fuchsia::web::UrlRequestRewriteRule rule;
  449. rule.set_rewrites(std::move(rewrites));
  450. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  451. rules.push_back(std::move(rule));
  452. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  453. // Navigate, we should get to the URL with the query.
  454. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  455. fuchsia::web::LoadUrlParams(),
  456. page_url.spec()));
  457. frame.navigation_listener().RunUntilUrlEquals(expected_url);
  458. EXPECT_THAT(accumulated_requests_,
  459. testing::Contains(testing::Key(expected_url)));
  460. }
  461. // Tests the URLRequestRewrite API properly handles scheme and host filtering in
  462. // rules.
  463. IN_PROC_BROWSER_TEST_F(RequestMonitoringTest,
  464. UrlRequestRewriteSchemeHostFilter) {
  465. auto frame = FrameForTest::Create(context(), {});
  466. std::vector<fuchsia::web::UrlRequestRewrite> rewrites1;
  467. rewrites1.push_back(CreateRewriteAddHeaders("Test1", "Value"));
  468. fuchsia::web::UrlRequestRewriteRule rule1;
  469. rule1.set_rewrites(std::move(rewrites1));
  470. rule1.set_hosts_filter({"127.0.0.1"});
  471. std::vector<fuchsia::web::UrlRequestRewrite> rewrites2;
  472. rewrites2.push_back(CreateRewriteAddHeaders("Test2", "Value"));
  473. fuchsia::web::UrlRequestRewriteRule rule2;
  474. rule2.set_rewrites(std::move(rewrites2));
  475. rule2.set_hosts_filter({"test.xyz"});
  476. std::vector<fuchsia::web::UrlRequestRewrite> rewrites3;
  477. rewrites3.push_back(CreateRewriteAddHeaders("Test3", "Value"));
  478. fuchsia::web::UrlRequestRewriteRule rule3;
  479. rule3.set_rewrites(std::move(rewrites3));
  480. rule3.set_schemes_filter({"http"});
  481. std::vector<fuchsia::web::UrlRequestRewrite> rewrites4;
  482. rewrites4.push_back(CreateRewriteAddHeaders("Test4", "Value"));
  483. fuchsia::web::UrlRequestRewriteRule rule4;
  484. rule4.set_rewrites(std::move(rewrites4));
  485. rule4.set_schemes_filter({"https"});
  486. std::vector<fuchsia::web::UrlRequestRewriteRule> rules;
  487. rules.push_back(std::move(rule1));
  488. rules.push_back(std::move(rule2));
  489. rules.push_back(std::move(rule3));
  490. rules.push_back(std::move(rule4));
  491. frame->SetUrlRequestRewriteRules(std::move(rules), []() {});
  492. // Navigate, we should get the "Test1" and "Test3" headers, but not "Test2"
  493. // and "Test4".
  494. const GURL page_url(embedded_test_server()->GetURL("/default"));
  495. EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(),
  496. fuchsia::web::LoadUrlParams(),
  497. page_url.spec()));
  498. frame.navigation_listener().RunUntilUrlEquals(page_url);
  499. const auto iter = accumulated_requests_.find(page_url);
  500. ASSERT_NE(iter, accumulated_requests_.end());
  501. EXPECT_THAT(iter->second.headers, testing::Contains(testing::Key("Test1")));
  502. EXPECT_THAT(iter->second.headers, testing::Contains(testing::Key("Test3")));
  503. EXPECT_THAT(iter->second.headers,
  504. testing::Not(testing::Contains(testing::Key("Test2"))));
  505. EXPECT_THAT(iter->second.headers,
  506. testing::Not(testing::Contains(testing::Key("Test4"))));
  507. }
  508. } // namespace