| // Copyright 2021 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/task/sequenced_task_runner.h" |
| #include "content/public/test/browser_test.h" |
| #include "fuchsia_web/common/string_util.h" |
| #include "fuchsia_web/common/test/frame_for_test.h" |
| #include "fuchsia_web/common/test/frame_test_util.h" |
| #include "fuchsia_web/common/test/test_navigation_listener.h" |
| #include "fuchsia_web/common/test/url_request_rewrite_test_util.h" |
| #include "fuchsia_web/webengine/browser/frame_impl_browser_test_base.h" |
| #include "fuchsia_web/webengine/switches.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| |
| namespace { |
| |
| constexpr char kPage1Path[] = "/title1.html"; |
| constexpr char kPage2Path[] = "/title2.html"; |
| constexpr char kPage3Path[] = "/image.html"; |
| constexpr char kPage1Title[] = "title 1"; |
| constexpr char kPage3ImgPath[] = "/img.png"; |
| constexpr char kSetHeaderRequestPath[] = "/set_header_request.html"; |
| |
| class RequestMonitoringTest : public FrameImplTestBase { |
| public: |
| RequestMonitoringTest() = default; |
| ~RequestMonitoringTest() override = default; |
| |
| RequestMonitoringTest(const RequestMonitoringTest&) = delete; |
| RequestMonitoringTest& operator=(const RequestMonitoringTest&) = delete; |
| |
| protected: |
| void SetUpOnMainThread() override { |
| // Accumulate all http requests made to |embedded_test_server| into |
| // |accumulated_requests_| container. |
| embedded_test_server()->RegisterRequestMonitor( |
| base::BindRepeating(&RequestMonitoringTest::MonitorRequestOnIoThread, |
| base::Unretained(this), |
| base::SequencedTaskRunner::GetCurrentDefault())); |
| |
| ASSERT_TRUE(test_server_handle_ = |
| embedded_test_server()->StartAndReturnHandle()); |
| } |
| |
| void SetUpCommandLine(base::CommandLine* command_line) override { |
| // Needed for UrlRequestRewriteAddHeaders. |
| command_line->AppendSwitchNative(switches::kCorsExemptHeaders, "Test"); |
| } |
| |
| std::map<GURL, net::test_server::HttpRequest> accumulated_requests_; |
| |
| private: |
| void MonitorRequestOnIoThread( |
| const scoped_refptr<base::SequencedTaskRunner>& main_thread_task_runner, |
| const net::test_server::HttpRequest& request) { |
| main_thread_task_runner->PostTask( |
| FROM_HERE, |
| base::BindOnce(&RequestMonitoringTest::MonitorRequestOnMainThread, |
| base::Unretained(this), request)); |
| } |
| |
| void MonitorRequestOnMainThread( |
| const net::test_server::HttpRequest& request) { |
| accumulated_requests_[request.GetURL()] = request; |
| } |
| |
| net::test_server::EmbeddedTestServerHandle test_server_handle_; |
| }; |
| |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, ExtraHeaders) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| const GURL page_url(embedded_test_server()->GetURL(kPage1Path)); |
| fuchsia::web::LoadUrlParams load_url_params; |
| fuchsia::net::http::Header header1; |
| header1.name = StringToBytes("X-ExtraHeaders"); |
| header1.value = StringToBytes("1"); |
| fuchsia::net::http::Header header2; |
| header2.name = StringToBytes("X-2ExtraHeaders"); |
| header2.value = StringToBytes("2"); |
| load_url_params.set_headers({header1, header2}); |
| |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| std::move(load_url_params), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlAndTitleEquals(page_url, kPage1Title); |
| |
| // At this point, the page should be loaded, the server should have received |
| // the request and the request should be in the map. |
| const auto iter = accumulated_requests_.find(page_url); |
| ASSERT_NE(iter, accumulated_requests_.end()); |
| EXPECT_THAT(iter->second.headers, |
| testing::Contains(testing::Key("X-ExtraHeaders"))); |
| EXPECT_THAT(iter->second.headers, |
| testing::Contains(testing::Key("X-2ExtraHeaders"))); |
| } |
| |
| // Tests that UrlRequestActions can be set up to deny requests to specific |
| // hosts. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteDeny) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_hosts_filter({"127.0.0.1"}); |
| rule.set_action(fuchsia::web::UrlRequestAction::DENY); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // 127.0.0.1 should be blocked. |
| const GURL page_url(embedded_test_server()->GetURL(kPage3Path)); |
| { |
| fuchsia::web::NavigationState error_state; |
| error_state.set_page_type(fuchsia::web::PageType::ERROR); |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilNavigationStateMatches(error_state); |
| } |
| |
| // However, "localhost" is not blocked, so this request should be allowed. |
| { |
| GURL::Replacements replacements; |
| replacements.SetHostStr("localhost"); |
| GURL page_url_localhost = page_url.ReplaceComponents(replacements); |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url_localhost.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(page_url_localhost); |
| } |
| } |
| |
| // Tests that a UrlRequestAction with no filter criteria will apply to all |
| // requests. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteDenyAll) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| // No filter criteria are set, so everything is denied. |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_action(fuchsia::web::UrlRequestAction::DENY); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // 127.0.0.1 should be blocked. |
| const GURL page_url(embedded_test_server()->GetURL(kPage3Path)); |
| { |
| fuchsia::web::NavigationState error_state; |
| error_state.set_page_type(fuchsia::web::PageType::ERROR); |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilNavigationStateMatches(error_state); |
| } |
| |
| // "localhost" should be blocked. |
| { |
| GURL::Replacements replacements; |
| replacements.SetHostStr("localhost"); |
| GURL page_url_localhost = page_url.ReplaceComponents(replacements); |
| fuchsia::web::NavigationState error_state; |
| error_state.set_page_type(fuchsia::web::PageType::ERROR); |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilNavigationStateMatches(error_state); |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url_localhost.spec())); |
| frame.navigation_listener().RunUntilNavigationStateMatches(error_state); |
| } |
| } |
| |
| // Tests that UrlRequestActions can be set up to only allow requests for a |
| // single host, while denying everything else. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteSelectiveAllow) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| // Allow 127.0.0.1. |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_hosts_filter({"127.0.0.1"}); |
| rule.set_action(fuchsia::web::UrlRequestAction::ALLOW); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| |
| // Deny everything else. |
| rule = {}; |
| rule.set_action(fuchsia::web::UrlRequestAction::DENY); |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // 127.0.0.1 should be allowed. |
| const GURL page_url(embedded_test_server()->GetURL(kPage3Path)); |
| { |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(page_url); |
| } |
| |
| // "localhost" should be blocked. |
| { |
| GURL::Replacements replacements; |
| replacements.SetHostStr("localhost"); |
| GURL page_url_localhost = page_url.ReplaceComponents(replacements); |
| fuchsia::web::NavigationState error_state; |
| error_state.set_page_type(fuchsia::web::PageType::ERROR); |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url_localhost.spec())); |
| frame.navigation_listener().RunUntilNavigationStateMatches(error_state); |
| } |
| } |
| |
| // Tests the URLRequestRewrite API properly adds headers on every requests. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteAddHeaders) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites; |
| rewrites.push_back(CreateRewriteAddHeaders("Test", "Value")); |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_rewrites(std::move(rewrites)); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // Navigate, we should get the additional header on the main request and the |
| // image request. |
| const GURL page_url(embedded_test_server()->GetURL(kPage3Path)); |
| const GURL img_url(embedded_test_server()->GetURL(kPage3ImgPath)); |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(page_url); |
| |
| { |
| const auto iter = accumulated_requests_.find(page_url); |
| ASSERT_NE(iter, accumulated_requests_.end()); |
| EXPECT_THAT(iter->second.headers, testing::Contains(testing::Key("Test"))); |
| } |
| { |
| const auto iter = accumulated_requests_.find(img_url); |
| ASSERT_NE(iter, accumulated_requests_.end()); |
| EXPECT_THAT(iter->second.headers, testing::Contains(testing::Key("Test"))); |
| } |
| } |
| |
| // Tests the URLRequestRewrite API properly adds headers on every requests. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, |
| UrlRequestRewriteAddExistingHeader) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites; |
| rewrites.push_back(CreateRewriteAddHeaders("Test", "Value")); |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_rewrites(std::move(rewrites)); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // Navigate. The first page request should have the "Test" header set to |
| // "Value". The second one should have the "Test" header set to "SetByJS" via |
| // JavaScript and not be overridden by the rewrite rule. |
| const GURL page_url(embedded_test_server()->GetURL(kSetHeaderRequestPath)); |
| const GURL img_url(embedded_test_server()->GetURL(kPage3Path)); |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilTitleEquals("loaded"); |
| |
| { |
| const auto iter = accumulated_requests_.find(page_url); |
| ASSERT_NE(iter, accumulated_requests_.end()); |
| ASSERT_THAT(iter->second.headers, testing::Contains(testing::Key("Test"))); |
| EXPECT_EQ(iter->second.headers["Test"], "Value"); |
| } |
| { |
| const auto iter = accumulated_requests_.find(img_url); |
| ASSERT_NE(iter, accumulated_requests_.end()); |
| ASSERT_THAT(iter->second.headers, testing::Contains(testing::Key("Test"))); |
| EXPECT_EQ(iter->second.headers["Test"], "SetByJS"); |
| } |
| } |
| |
| // Tests the URLRequestRewrite API properly removes headers on every requests. |
| // Also tests that rewrites are applied properly in succession. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteRemoveHeader) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites; |
| rewrites.push_back(CreateRewriteAddHeaders("Test", "Value")); |
| rewrites.push_back(CreateRewriteRemoveHeader(absl::nullopt, "Test")); |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_rewrites(std::move(rewrites)); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // Navigate, we should get no "Test" header. |
| const GURL page_url(embedded_test_server()->GetURL(kPage3Path)); |
| const GURL img_url(embedded_test_server()->GetURL(kPage3ImgPath)); |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(page_url); |
| |
| { |
| const auto iter = accumulated_requests_.find(page_url); |
| ASSERT_NE(iter, accumulated_requests_.end()); |
| EXPECT_THAT(iter->second.headers, |
| testing::Not(testing::Contains(testing::Key("Test")))); |
| } |
| { |
| const auto iter = accumulated_requests_.find(img_url); |
| ASSERT_NE(iter, accumulated_requests_.end()); |
| EXPECT_THAT(iter->second.headers, |
| testing::Not(testing::Contains(testing::Key("Test")))); |
| } |
| } |
| |
| // Tests the URLRequestRewrite API properly removes headers, based on the |
| // presence of a string in the query. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, |
| UrlRequestRewriteRemoveHeaderWithQuery) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| const GURL page_url(embedded_test_server()->GetURL("/page?stuff=[pattern]")); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites; |
| rewrites.push_back(CreateRewriteAddHeaders("Test", "Value")); |
| rewrites.push_back( |
| CreateRewriteRemoveHeader(absl::make_optional("[pattern]"), "Test")); |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_rewrites(std::move(rewrites)); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // Navigate, we should get no "Test" header. |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(page_url); |
| |
| const auto iter = accumulated_requests_.find(page_url); |
| ASSERT_NE(iter, accumulated_requests_.end()); |
| EXPECT_THAT(iter->second.headers, |
| testing::Not(testing::Contains(testing::Key("Test")))); |
| } |
| |
| // Tests the URLRequestRewrite API properly handles query substitution. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, |
| UrlRequestRewriteSubstituteQueryPattern) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites; |
| rewrites.push_back( |
| CreateRewriteSubstituteQueryPattern("[pattern]", "substitution")); |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_rewrites(std::move(rewrites)); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // Navigate, we should get to the URL with the modified request. |
| const GURL page_url(embedded_test_server()->GetURL("/page?[pattern]")); |
| const GURL final_url(embedded_test_server()->GetURL("/page?substitution")); |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(final_url); |
| |
| EXPECT_THAT(accumulated_requests_, |
| testing::Contains(testing::Key(final_url))); |
| } |
| |
| // Tests the URLRequestRewrite API properly handles URL replacement. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteReplaceUrl) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| const GURL page_url(embedded_test_server()->GetURL(kPage1Path)); |
| const GURL final_url(embedded_test_server()->GetURL(kPage2Path)); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites; |
| rewrites.push_back(CreateRewriteReplaceUrl(kPage1Path, final_url.spec())); |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_rewrites(std::move(rewrites)); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // Navigate, we should get to the replaced URL. |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(final_url); |
| |
| EXPECT_THAT(accumulated_requests_, |
| testing::Contains(testing::Key(final_url))); |
| } |
| |
| // Tests the URLRequestRewrite API properly handles URL replacement when the |
| // original request URL contains a query and a fragment string. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, |
| UrlRequestRewriteReplaceUrlQueryRef) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| const GURL page_url( |
| embedded_test_server()->GetURL(std::string(kPage1Path) + "?query#ref")); |
| const GURL replacement_url(embedded_test_server()->GetURL(kPage2Path)); |
| const GURL final_url_with_ref( |
| embedded_test_server()->GetURL(std::string(kPage2Path) + "?query#ref")); |
| const GURL final_url( |
| embedded_test_server()->GetURL(std::string(kPage2Path) + "?query")); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites; |
| rewrites.push_back( |
| CreateRewriteReplaceUrl(kPage1Path, replacement_url.spec())); |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_rewrites(std::move(rewrites)); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // Navigate, we should get to the replaced URL. |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(final_url_with_ref); |
| |
| EXPECT_THAT(accumulated_requests_, |
| testing::Contains(testing::Key(final_url))); |
| } |
| |
| // Tests the URLRequestRewrite API properly handles adding a query. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, UrlRequestRewriteAddQuery) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites; |
| rewrites.push_back(CreateRewriteAppendToQuery("query")); |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_rewrites(std::move(rewrites)); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| { |
| // Add a query to a URL with no query. |
| const GURL page_url(embedded_test_server()->GetURL(kPage1Path)); |
| const GURL expected_url( |
| embedded_test_server()->GetURL(std::string(kPage1Path) + "?query")); |
| |
| // Navigate, we should get to the URL with the query. |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(expected_url); |
| |
| EXPECT_THAT(accumulated_requests_, |
| testing::Contains(testing::Key(expected_url))); |
| } |
| |
| { |
| // Add a quest to a URL that has an empty query. |
| const std::string original_path = std::string(kPage1Path) + "?"; |
| const GURL page_url(embedded_test_server()->GetURL(original_path)); |
| const GURL expected_url( |
| embedded_test_server()->GetURL(original_path + "query")); |
| |
| // Navigate, we should get to the URL with the query, but no "&". |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(expected_url); |
| |
| EXPECT_THAT(accumulated_requests_, |
| testing::Contains(testing::Key(expected_url))); |
| } |
| |
| { |
| // Add a query to a URL that already has a query. |
| const std::string original_path = |
| std::string(kPage1Path) + "?original_query=value"; |
| const GURL page_url(embedded_test_server()->GetURL(original_path)); |
| const GURL expected_url( |
| embedded_test_server()->GetURL(original_path + "&query")); |
| |
| // Navigate, we should get to the URL with the appended query. |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(expected_url); |
| |
| EXPECT_THAT(accumulated_requests_, |
| testing::Contains(testing::Key(expected_url))); |
| } |
| |
| { |
| // Add a query to a URL that has a ref. |
| const GURL page_url( |
| embedded_test_server()->GetURL(std::string(kPage1Path) + "#ref")); |
| const GURL expected_url( |
| embedded_test_server()->GetURL(std::string(kPage1Path) + "?query#ref")); |
| |
| // Navigate, we should get to the URL with the query. |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(expected_url); |
| } |
| } |
| |
| // Tests the URLRequestRewrite API properly handles adding a query with a |
| // question mark. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, |
| UrlRequestRewriteAppendToQueryQuestionMark) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| const GURL page_url(embedded_test_server()->GetURL(kPage1Path)); |
| const GURL expected_url( |
| embedded_test_server()->GetURL(std::string(kPage1Path) + "?qu?ery")); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites; |
| rewrites.push_back(CreateRewriteAppendToQuery("qu?ery")); |
| fuchsia::web::UrlRequestRewriteRule rule; |
| rule.set_rewrites(std::move(rewrites)); |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule)); |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // Navigate, we should get to the URL with the query. |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(expected_url); |
| |
| EXPECT_THAT(accumulated_requests_, |
| testing::Contains(testing::Key(expected_url))); |
| } |
| |
| // Tests the URLRequestRewrite API properly handles scheme and host filtering in |
| // rules. |
| IN_PROC_BROWSER_TEST_F(RequestMonitoringTest, |
| UrlRequestRewriteSchemeHostFilter) { |
| auto frame = FrameForTest::Create(context(), {}); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites1; |
| rewrites1.push_back(CreateRewriteAddHeaders("Test1", "Value")); |
| fuchsia::web::UrlRequestRewriteRule rule1; |
| rule1.set_rewrites(std::move(rewrites1)); |
| rule1.set_hosts_filter({"127.0.0.1"}); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites2; |
| rewrites2.push_back(CreateRewriteAddHeaders("Test2", "Value")); |
| fuchsia::web::UrlRequestRewriteRule rule2; |
| rule2.set_rewrites(std::move(rewrites2)); |
| rule2.set_hosts_filter({"test.xyz"}); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites3; |
| rewrites3.push_back(CreateRewriteAddHeaders("Test3", "Value")); |
| fuchsia::web::UrlRequestRewriteRule rule3; |
| rule3.set_rewrites(std::move(rewrites3)); |
| rule3.set_schemes_filter({"http"}); |
| |
| std::vector<fuchsia::web::UrlRequestRewrite> rewrites4; |
| rewrites4.push_back(CreateRewriteAddHeaders("Test4", "Value")); |
| fuchsia::web::UrlRequestRewriteRule rule4; |
| rule4.set_rewrites(std::move(rewrites4)); |
| rule4.set_schemes_filter({"https"}); |
| |
| std::vector<fuchsia::web::UrlRequestRewriteRule> rules; |
| rules.push_back(std::move(rule1)); |
| rules.push_back(std::move(rule2)); |
| rules.push_back(std::move(rule3)); |
| rules.push_back(std::move(rule4)); |
| |
| frame->SetUrlRequestRewriteRules(std::move(rules), []() {}); |
| |
| // Navigate, we should get the "Test1" and "Test3" headers, but not "Test2" |
| // and "Test4". |
| const GURL page_url(embedded_test_server()->GetURL("/default")); |
| EXPECT_TRUE(LoadUrlAndExpectResponse(frame.GetNavigationController(), |
| fuchsia::web::LoadUrlParams(), |
| page_url.spec())); |
| frame.navigation_listener().RunUntilUrlEquals(page_url); |
| |
| const auto iter = accumulated_requests_.find(page_url); |
| ASSERT_NE(iter, accumulated_requests_.end()); |
| EXPECT_THAT(iter->second.headers, testing::Contains(testing::Key("Test1"))); |
| EXPECT_THAT(iter->second.headers, testing::Contains(testing::Key("Test3"))); |
| EXPECT_THAT(iter->second.headers, |
| testing::Not(testing::Contains(testing::Key("Test2")))); |
| EXPECT_THAT(iter->second.headers, |
| testing::Not(testing::Contains(testing::Key("Test4")))); |
| } |
| |
| } // namespace |