| // Copyright 2022 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/test/interaction/interactive_browser_test.h" |
| |
| #include <list> |
| #include <sstream> |
| #include <tuple> |
| |
| #include "base/command_line.h" |
| #include "base/files/file_util.h" |
| #include "base/files/scoped_temp_dir.h" |
| #include "base/functional/bind.h" |
| #include "base/functional/callback_helpers.h" |
| #include "base/test/bind.h" |
| #include "base/time/time.h" |
| #include "base/timer/timer.h" |
| #include "build/build_config.h" |
| #include "chrome/browser/ui/browser_element_identifiers.h" |
| #include "chrome/browser/ui/interaction/browser_elements.h" |
| #include "chrome/test/base/test_switches.h" |
| #include "components/constrained_window/constrained_window_views.h" |
| #include "content/public/test/browser_test.h" |
| #include "ui/base/interaction/element_identifier.h" |
| #include "ui/base/interaction/element_tracker.h" |
| #include "ui/base/interaction/expect_call_in_scope.h" |
| #include "ui/base/interaction/interaction_sequence.h" |
| #include "ui/base/mojom/ui_base_types.mojom-shared.h" |
| #include "ui/base/test/ui_controls.h" |
| #include "ui/base/ui_base_types.h" |
| #include "ui/gfx/geometry/size.h" |
| #include "ui/gfx/native_ui_types.h" |
| #include "ui/views/view_class_properties.h" |
| #include "ui/views/window/dialog_delegate.h" |
| #include "url/gurl.h" |
| |
| namespace { |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kWebContentsId); |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kWebContents2Id); |
| constexpr char kDocumentWithNamedElement[] = "/select.html"; |
| constexpr char kDocumentWithLinks[] = "/links.html"; |
| constexpr char kDocumentWithClickDetection[] = "/click.html"; |
| constexpr char kScrollableDocument[] = |
| "/scroll/scrollable_page_with_content.html"; |
| } // namespace |
| |
| class InteractiveBrowserTestBrowsertest : public InteractiveBrowserTest { |
| public: |
| InteractiveBrowserTestBrowsertest() = default; |
| ~InteractiveBrowserTestBrowsertest() override = default; |
| |
| void SetUp() override { |
| set_open_about_blank_on_browser_launch(true); |
| ASSERT_TRUE(embedded_test_server()->InitializeAndListen()); |
| InteractiveBrowserTest::SetUp(); |
| } |
| |
| void SetUpOnMainThread() override { |
| InteractiveBrowserTest::SetUpOnMainThread(); |
| embedded_test_server()->StartAcceptingConnections(); |
| } |
| |
| void TearDownOnMainThread() override { |
| EXPECT_TRUE(embedded_test_server()->ShutdownAndWaitUntilComplete()); |
| InteractiveBrowserTest::TearDownOnMainThread(); |
| } |
| |
| static constexpr base::TimeDelta kDelayedActionDelay = |
| base::Milliseconds(500); |
| |
| void PostDelayedAction(base::OnceClosure action) { |
| delayed_actions_.push_back(std::move(action)); |
| if (!delayed_action_timer_.IsRunning()) { |
| delayed_action_timer_.Start( |
| FROM_HERE, kDelayedActionDelay, |
| base::BindRepeating( |
| &InteractiveBrowserTestBrowsertest::OnDelayedActionTimer, |
| base::Unretained(this))); |
| } |
| } |
| |
| private: |
| void OnDelayedActionTimer() { |
| std::move(delayed_actions_.front()).Run(); |
| delayed_actions_.pop_front(); |
| if (delayed_actions_.empty()) { |
| delayed_action_timer_.Stop(); |
| } |
| } |
| |
| std::list<base::OnceClosure> delayed_actions_; |
| base::RepeatingTimer delayed_action_timer_; |
| }; |
| |
| // This test checks that all of the UI elements in the browser can be dumped. |
| // The output must be manually verified. |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, DumpElements) { |
| auto* const incog = CreateIncognitoBrowser(); |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| InContext(BrowserElements::From(incog)->GetContext(), |
| PressButton(kToolbarAppMenuButtonElementId)), |
| DumpElements()); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| EnsurePresentNotPresent) { |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| EnsurePresent(kWebContentsId, DeepQuery({"#select"})), |
| EnsureNotPresent(kWebContentsId, DeepQuery{"#doesNotExist"})); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| EnsureNotPresent_Fails) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| EnsureNotPresent(kWebContentsId, DeepQuery{"#select"}))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, EnsureNotVisible) { |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url), |
| // Element that is set to display: none. |
| ExecuteJsAt(kWebContentsId, DeepQuery{"#select"}, |
| "el => el.style.display = 'none'"), |
| EnsureNotVisible(kWebContentsId, DeepQuery({"#select"})), |
| // Element that has zero size. |
| ExecuteJsAt(kWebContentsId, DeepQuery{"p"}, |
| "el => { el.style.width = '0'; el.style.height = '0'; }"), |
| EnsureNotVisible(kWebContentsId, DeepQuery({"p"})), |
| // Element that is not present at all. |
| EnsureNotVisible(kWebContentsId, DeepQuery{"#doesNotExist"})); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| EnsureNotVisible_Fails) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| EnsureNotVisible(kWebContentsId, DeepQuery{"#select"}))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, EnsurePresent_Fails) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| EnsurePresent(kWebContentsId, DeepQuery{"#doesNotExist"}))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, ExecuteJs) { |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url), |
| ExecuteJs(kWebContentsId, "() => { window.value = 1; }"), |
| WithElement(kWebContentsId, base::BindOnce([](ui::TrackedElement* el) { |
| const auto result = AsInstrumentedWebContents(el)->Evaluate( |
| "() => window.value"); |
| EXPECT_EQ(1, result.GetInt()); |
| }))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| ExecuteJsFireAndForget) { |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url), |
| ExecuteJs(kWebContentsId, "() => { window.value = 1; }", |
| ExecuteJsMode::kFireAndForget), |
| WithElement(kWebContentsId, base::BindOnce([](ui::TrackedElement* el) { |
| const auto result = AsInstrumentedWebContents(el)->Evaluate( |
| "() => window.value"); |
| EXPECT_EQ(1, result.GetInt()); |
| }))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| ExecuteJsFailsOnThrow) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| ExecuteJs(kWebContentsId, "() => { throw new Error('an error'); }"))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, CheckJsResult) { |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| const std::string str("a string"); |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url), |
| ExecuteJs(kWebContentsId, |
| R"(() => { |
| window.intValue = 1; |
| window.boolValue = true; |
| window.doubleValue = 2.0; |
| window.stringValue = 'a string'; |
| })"), |
| CheckJsResult(kWebContentsId, "() => window.intValue"), |
| CheckJsResult(kWebContentsId, "() => window.intValue", 1), |
| CheckJsResult(kWebContentsId, "() => window.intValue", testing::Lt(2)), |
| CheckJsResult(kWebContentsId, "() => window.boolValue"), |
| CheckJsResult(kWebContentsId, "() => window.boolValue", true), |
| CheckJsResult(kWebContentsId, "() => window.boolValue", |
| testing::Ne(false)), |
| CheckJsResult(kWebContentsId, "() => window.doubleValue"), |
| CheckJsResult(kWebContentsId, "() => window.doubleValue", 2.0), |
| CheckJsResult(kWebContentsId, "() => window.doubleValue", |
| testing::Gt(1.5)), |
| CheckJsResult(kWebContentsId, "() => window.stringValue"), |
| CheckJsResult(kWebContentsId, "() => window.stringValue", "a string"), |
| CheckJsResult(kWebContentsId, "() => window.stringValue", str), |
| CheckJsResult(kWebContentsId, "() => window.stringValue", |
| std::string("a string")), |
| CheckJsResult(kWebContentsId, "() => window.stringValue", |
| testing::Ne(std::string("another string")))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| CheckJsResultWithPromise) { |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| CheckJsResult(kWebContentsId, |
| "() => new Promise((resolve, reject) => " |
| "setTimeout(() => resolve(true), 100))"), |
| CheckJsResult(kWebContentsId, |
| "() => new Promise((resolve, reject) => " |
| "setTimeout(() => resolve(1), 100))", |
| 1)); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| CheckJsResultWithPromiseFailsOnReject) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| CheckJsResult(kWebContentsId, |
| "() => new Promise((resolve, reject) => " |
| "setTimeout(() => reject('rejected'), 100))"))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, CheckJsResult_Fails) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| ExecuteJs(kWebContentsId, "() => { window.value = 1; }"), |
| CheckJsResult(kWebContentsId, "() => window.value", 2))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| CheckJsResult_ThrowError_Fails) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| CheckJsResult(kWebContentsId, |
| "() => { throw new Error('an error'); }", 2))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| CheckJsResult_NoArgument_Fails) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| ExecuteJs(kWebContentsId, "() => { window.value = 0; }"), |
| CheckJsResult(kWebContentsId, "() => window.value"))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, ExecuteJsAt) { |
| const DeepQuery kWhere{"#select"}; |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url), |
| ExecuteJsAt(kWebContentsId, kWhere, "(el) => { el.intValue = 1; }"), |
| WithElement(kWebContentsId, |
| base::BindLambdaForTesting([&kWhere](ui::TrackedElement* el) { |
| const auto result = |
| AsInstrumentedWebContents(el)->EvaluateAt( |
| kWhere, "(el) => el.intValue"); |
| EXPECT_EQ(1, result.GetInt()); |
| }))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| ExecuteJsAtFireAndForget) { |
| const DeepQuery kWhere{"#select"}; |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url), |
| ExecuteJsAt(kWebContentsId, kWhere, "(el) => { el.intValue = 1; }", |
| ExecuteJsMode::kFireAndForget), |
| WithElement(kWebContentsId, |
| base::BindLambdaForTesting([&kWhere](ui::TrackedElement* el) { |
| const auto result = |
| AsInstrumentedWebContents(el)->EvaluateAt( |
| kWhere, "(el) => el.intValue"); |
| EXPECT_EQ(1, result.GetInt()); |
| }))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| ExecuteJsAtFailsIfElementNotPresent) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const DeepQuery kWhere{"#aaaaa"}; |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| ExecuteJsAt(kWebContentsId, kWhere, "(el) => { el.intValue = 1; }"))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| ExecuteJsAtFailsOnThrow) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const DeepQuery kWhere{"#select"}; |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| ExecuteJsAt(kWebContentsId, kWhere, |
| "(el) => { throw new Error('an error'); }"))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, CheckJsResultAt) { |
| const DeepQuery kWhere{"#select"}; |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| const std::string str("a string"); |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url), |
| ExecuteJsAt(kWebContentsId, kWhere, |
| R"((el) => { |
| el.intValue = 1; |
| el.boolValue = true; |
| el.doubleValue = 2.0; |
| el.stringValue = 'a string'; |
| })"), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.intValue"), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.intValue", 1), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.intValue", |
| testing::Lt(2)), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.boolValue"), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.boolValue", true), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.boolValue", |
| testing::Ne(false)), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.doubleValue"), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.doubleValue", 2.0), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.doubleValue", |
| testing::Gt(1.5)), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.stringValue"), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.stringValue", |
| "a string"), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.stringValue", str), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.stringValue", |
| std::string("a string")), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.stringValue", |
| testing::Ne(std::string("another string")))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| CheckJsResultAtWithPromise) { |
| const DeepQuery kWhere{"#select"}; |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url), |
| ExecuteJsAt(kWebContentsId, kWhere, |
| R"((el) => { |
| el.intValue = 1; |
| el.stringValue = 'a string'; |
| })"), |
| CheckJsResultAt( |
| kWebContentsId, kWhere, |
| "(el) => new Promise((resolve, reject) => resolve(el.intValue))"), |
| CheckJsResultAt( |
| kWebContentsId, kWhere, |
| "(el) => new Promise((resolve, reject) => resolve(el.intValue))", 1), |
| CheckJsResultAt( |
| kWebContentsId, kWhere, |
| "(el) => new Promise((resolve, reject) => resolve(el.stringValue))"), |
| CheckJsResultAt( |
| kWebContentsId, kWhere, |
| "(el) => new Promise((resolve, reject) => resolve(el.stringValue))", |
| "a string")); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| CheckJsResultAtWithPromiseFailsOnReject) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const DeepQuery kWhere{"#select"}; |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| CheckJsResultAt(kWebContentsId, kWhere, |
| "(el) => new Promise((resolve, reject) " |
| "=> reject('rejected!'))"))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| CheckJsResultAt_Fails) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const DeepQuery kWhere{"#select"}; |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| ExecuteJsAt(kWebContentsId, kWhere, "(el) => { el.intValue = 1; }"), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.intValue", 2))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| CheckJsResultAt_ThrowsError_Fails) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const DeepQuery kWhere{"#select"}; |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| CheckJsResultAt(kWebContentsId, kWhere, |
| "(el) => { throw new Error('an error'); }", 2))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| CheckJsResultAt_BadPath_Fails) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const DeepQuery kWhere{"#aaaaa"}; |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.intValue", 2))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| CheckJsResultAt_NoArgument_Fails) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| const DeepQuery kWhere{"#select"}; |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| ExecuteJsAt(kWebContentsId, kWhere, |
| "(el) => { el.stringValue = ''; }"), |
| CheckJsResultAt(kWebContentsId, kWhere, "(el) => el.stringValue"))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| InstrumentTabsAsTestSteps) { |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kTab1Id); |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kTab2Id); |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kTab3Id); |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kIncognito1Id); |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kIncognito2Id); |
| const char kIncognitoNtbName[] = "Incognito NTB"; |
| |
| auto verify_is_at_tab_index = [](Browser* where, ui::ElementIdentifier id, |
| int expected_index) { |
| return CheckElement( |
| id, base::BindLambdaForTesting([where](ui::TrackedElement* el) { |
| return where->tab_strip_model()->GetIndexOfWebContents( |
| AsInstrumentedWebContents(el)->web_contents()); |
| }), |
| expected_index); |
| }; |
| |
| const GURL url1 = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| const GURL url2 = embedded_test_server()->GetURL(kDocumentWithLinks); |
| |
| Browser* incognito_browser = CreateIncognitoBrowser(); |
| |
| RunTestSequence( |
| // Instrument an existing tab. |
| InstrumentTab(kTab1Id), verify_is_at_tab_index(browser(), kTab1Id, 0), |
| |
| // Instrument the next tab, then insert a tab and verify it's there. |
| InstrumentNextTab(kTab2Id), PressButton(kNewTabButtonElementId), |
| NavigateWebContents(kTab2Id, url1), |
| verify_is_at_tab_index(browser(), kTab2Id, 1), |
| |
| // Add and instrument tab all in one fell swoop. |
| AddInstrumentedTab(kTab3Id, url2), |
| verify_is_at_tab_index(browser(), kTab3Id, 2), |
| |
| // Instrument the next tab in any browser, then insert the tab and verify |
| // it's there. |
| InstrumentNextTab(kIncognito1Id, AnyBrowser()), |
| NameView( |
| kIncognitoNtbName, base::BindLambdaForTesting([incognito_browser]() { |
| return AsView( |
| ui::ElementTracker::GetElementTracker()->GetUniqueElement( |
| kNewTabButtonElementId, |
| BrowserElements::From(incognito_browser)->GetContext())); |
| })), |
| PressButton(kIncognitoNtbName), |
| InAnyContext(verify_is_at_tab_index(incognito_browser, kIncognito1Id, 1)), |
| |
| Do(base::BindOnce([]() { LOG(WARNING) << 1; })), |
| |
| // Instrument a final tab by inserting it. Specify an index so the other |
| // tabs are re-ordered. |
| AddInstrumentedTab(kIncognito2Id, url2, 1, incognito_browser), |
| InAnyContext(verify_is_at_tab_index(incognito_browser, kIncognito2Id, 1)), |
| InAnyContext( |
| verify_is_at_tab_index(incognito_browser, kIncognito1Id, 2))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, ScrollIntoView) { |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kTabId); |
| const GURL url = embedded_test_server()->GetURL(kScrollableDocument); |
| const DeepQuery kLink{"#link"}; |
| const DeepQuery kText{"#text"}; |
| |
| constexpr char kElementIsInViewport[] = R"( |
| (el) => { |
| const bounds = el.getBoundingClientRect(); |
| return bounds.right >= 0 && bounds.bottom >= 0 && |
| bounds.x < window.innerWidth && bounds.y < window.innerHeight; |
| } |
| )"; |
| |
| RunTestSequence(InstrumentTab(kTabId), NavigateWebContents(kTabId, url), |
| CheckJsResultAt(kTabId, kLink, kElementIsInViewport, true), |
| CheckJsResultAt(kTabId, kText, kElementIsInViewport, false), |
| ScrollIntoView(kTabId, kText), |
| CheckJsResultAt(kTabId, kLink, kElementIsInViewport, false), |
| CheckJsResultAt(kTabId, kText, kElementIsInViewport, true)); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| WaitForJsResultTrueAtStart) { |
| const GURL url1 = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url1), |
| ExecuteJs(kWebContentsId, |
| R"(() => { |
| window.intValue = 1; |
| window.boolValue = true; |
| window.doubleValue = 2.0; |
| window.stringValue = 'a string'; |
| })"), |
| WaitForJsResult(kWebContentsId, "() => window.intValue", 1), |
| WaitForJsResult(kWebContentsId, "() => window.boolValue", true), |
| WaitForJsResult(kWebContentsId, "() => window.doubleValue", |
| testing::Ge(1.0)), |
| WaitForJsResult(kWebContentsId, "() => window.stringValue", "a string"), |
| WaitForJsResult(kWebContentsId, "() => window.stringValue", |
| testing::HasSubstr("stri")), |
| WaitForJsResult(kWebContentsId, "() => window.intValue", |
| testing::AnyOf(4, 3, 1, 0))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| WaitForJsResultTrueAfterDelay) { |
| const GURL url1 = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url1), |
| ExecuteJs(kWebContentsId, |
| R"(() => { |
| window.intValue = 0; |
| window.boolValue = false; |
| window.doubleValue = 0.0; |
| window.stringValue = 'nothing'; |
| })"), |
| WithElement(kWebContentsId, |
| [this](ui::TrackedElement* el) { |
| auto* const util = AsInstrumentedWebContents(el); |
| PostDelayedAction(base::BindLambdaForTesting([util]() { |
| util->Execute("() => window.intValue = 1"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util]() { |
| util->Execute("() => window.boolValue = true"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util]() { |
| util->Execute("() => window.doubleValue = 2.0"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util]() { |
| util->Execute("() => window.stringValue = 'a string'"); |
| })); |
| }), |
| WaitForJsResult(kWebContentsId, "() => window.intValue", 1), |
| WaitForJsResult(kWebContentsId, "() => window.boolValue", true), |
| WaitForJsResult(kWebContentsId, "() => window.doubleValue", |
| testing::Ge(1.0)), |
| WaitForJsResult(kWebContentsId, "() => window.stringValue", |
| testing::HasSubstr("stri"))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| WaitForJsResultTargetChangesAfterDelay) { |
| const GURL url1 = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| int target = 0; |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url1), |
| ExecuteJs(kWebContentsId, |
| R"(() => { |
| window.intValue = 1; |
| window.boolValue = true; |
| window.doubleValue = 2.0; |
| window.stringValue = 'a string'; |
| })"), |
| Do([this, &target]() { |
| PostDelayedAction( |
| base::BindLambdaForTesting([&target]() { target = 1; })); |
| }), |
| WaitForJsResult(kWebContentsId, "() => window.intValue", |
| std::ref(target))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| WaitForJsResultIsTruthyAfterDelay) { |
| const GURL url1 = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url1), |
| ExecuteJs(kWebContentsId, |
| R"(() => { |
| window.intValue = 0; |
| window.boolValue = false; |
| window.doubleValue = 0.0; |
| window.stringValue = null; |
| })"), |
| CheckJsResult(kWebContentsId, "() => window.intValue", |
| testing::Not(IsTruthy())), |
| CheckJsResult(kWebContentsId, "() => window.boolValue", |
| testing::Not(IsTruthy())), |
| CheckJsResult(kWebContentsId, "() => window.doubleValue", |
| testing::Not(IsTruthy())), |
| CheckJsResult(kWebContentsId, "() => window.stringValue", |
| testing::Not(IsTruthy())), |
| WithElement(kWebContentsId, |
| [this](ui::TrackedElement* el) { |
| auto* const util = AsInstrumentedWebContents(el); |
| PostDelayedAction(base::BindLambdaForTesting([util]() { |
| util->Execute("() => window.intValue = 1"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util]() { |
| util->Execute("() => window.boolValue = true"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util]() { |
| util->Execute("() => window.doubleValue = 2.0"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util]() { |
| util->Execute("() => window.stringValue = 'a string'"); |
| })); |
| }), |
| WaitForJsResult(kWebContentsId, "() => window.intValue"), |
| WaitForJsResult(kWebContentsId, "() => window.boolValue"), |
| WaitForJsResult(kWebContentsId, "() => window.doubleValue"), |
| WaitForJsResult(kWebContentsId, "() => window.stringValue")); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| WaitForJsResultAtTrueAtStart) { |
| const GURL url1 = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| const DeepQuery kWhere{"#select"}; |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url1), |
| ExecuteJsAt(kWebContentsId, kWhere, |
| R"(el => { |
| el.intValue = 1; |
| el.boolValue = true; |
| el.doubleValue = 2.0; |
| el.stringValue = 'a string'; |
| })"), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.intValue", 1), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.boolValue", true), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.doubleValue", |
| testing::Ge(1.0)), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.stringValue", |
| "a string"), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.stringValue", |
| testing::HasSubstr("stri")), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.intValue", |
| testing::AnyOf(4, 3, 1, 0))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| WaitForJsResultAtTrueAfterDelay) { |
| const GURL url1 = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| const DeepQuery kWhere{"#select"}; |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url1), |
| ExecuteJsAt(kWebContentsId, kWhere, |
| R"(el => { |
| el.intValue = 0; |
| el.boolValue = false; |
| el.doubleValue = 0.0; |
| el.stringValue = 'nothing'; |
| })"), |
| WithElement( |
| kWebContentsId, |
| [this, kWhere](ui::TrackedElement* el) { |
| auto* const util = AsInstrumentedWebContents(el); |
| PostDelayedAction(base::BindLambdaForTesting([util, kWhere]() { |
| util->ExecuteAt(kWhere, "el => el.intValue = 1"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util, kWhere]() { |
| util->ExecuteAt(kWhere, "el => el.boolValue = true"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util, kWhere]() { |
| util->ExecuteAt(kWhere, "el => el.doubleValue = 2.0"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util, kWhere]() { |
| util->ExecuteAt(kWhere, "el => el.stringValue = 'a string'"); |
| })); |
| }), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.intValue", 1), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.boolValue", true), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.doubleValue", |
| testing::Ge(1.0)), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.stringValue", |
| testing::HasSubstr("stri"))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| WaitForJsResultAtTargetChangesAfterDelay) { |
| const GURL url1 = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| const DeepQuery kWhere{"#select"}; |
| int target = 0; |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url1), |
| ExecuteJsAt(kWebContentsId, kWhere, |
| R"(el => { |
| el.intValue = 1; |
| el.boolValue = true; |
| el.doubleValue = 2.0; |
| el.stringValue = 'a string'; |
| })"), |
| Do([this, &target]() { |
| PostDelayedAction( |
| base::BindLambdaForTesting([&target]() { target = 1; })); |
| }), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.intValue", |
| std::ref(target))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| WaitForJsResultAtIsTruthyAfterDelay) { |
| const GURL url1 = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| const DeepQuery kWhere{"#select"}; |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url1), |
| ExecuteJsAt(kWebContentsId, kWhere, |
| R"(el => { |
| el.intValue = 0; |
| el.boolValue = false; |
| el.doubleValue = 0.0; |
| el.stringValue = ''; |
| })"), |
| CheckJsResultAt(kWebContentsId, kWhere, "el => el.intValue", |
| testing::Not(IsTruthy())), |
| CheckJsResultAt(kWebContentsId, kWhere, "el => el.boolValue", |
| testing::Not(IsTruthy())), |
| CheckJsResultAt(kWebContentsId, kWhere, "el => el.doubleValue", |
| testing::Not(IsTruthy())), |
| CheckJsResultAt(kWebContentsId, kWhere, "el => el.stringValue", |
| testing::Not(IsTruthy())), |
| WithElement( |
| kWebContentsId, |
| [this, kWhere](ui::TrackedElement* el) { |
| auto* const util = AsInstrumentedWebContents(el); |
| PostDelayedAction(base::BindLambdaForTesting([util, kWhere]() { |
| util->ExecuteAt(kWhere, "el => el.intValue = 1"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util, kWhere]() { |
| util->ExecuteAt(kWhere, "el => el.boolValue = true"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util, kWhere]() { |
| util->ExecuteAt(kWhere, "el => el.doubleValue = 2.0"); |
| })); |
| PostDelayedAction(base::BindLambdaForTesting([util, kWhere]() { |
| util->ExecuteAt(kWhere, "el => el.stringValue = 'a string'"); |
| })); |
| }), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.intValue"), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.boolValue"), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.doubleValue"), |
| WaitForJsResultAt(kWebContentsId, kWhere, "el => el.stringValue")); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| WaitForStateChangeAcrossNavigation) { |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kTabId); |
| DEFINE_LOCAL_CUSTOM_ELEMENT_EVENT_TYPE(kFoundElementEvent); |
| const GURL url1 = embedded_test_server()->GetURL(kDocumentWithLinks); |
| const GURL url2 = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| |
| StateChange state_change; |
| state_change.type = StateChange::Type::kExists; |
| state_change.where = {"#select"}; |
| state_change.continue_across_navigation = true; |
| state_change.event = kFoundElementEvent; |
| |
| RunTestSequence( |
| InstrumentTab(kTabId), |
| InParallel(RunSubsequence(NavigateWebContents(kTabId, url1), |
| NavigateWebContents(kTabId, url2)), |
| RunSubsequence(WaitForStateChange(kTabId, state_change)))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| WaitForStateChangeWithConditionAcrossNavigation) { |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kTabId); |
| DEFINE_LOCAL_CUSTOM_ELEMENT_EVENT_TYPE(kFoundElementEvent); |
| const GURL url1 = embedded_test_server()->GetURL(kDocumentWithLinks); |
| const GURL url2 = embedded_test_server()->GetURL(kDocumentWithNamedElement); |
| |
| StateChange state_change; |
| state_change.type = StateChange::Type::kExistsAndConditionTrue; |
| state_change.where = {"#select option[selected]"}; |
| state_change.test_function = "(el) => (el.innerText === 'Apple')"; |
| state_change.continue_across_navigation = true; |
| state_change.event = kFoundElementEvent; |
| |
| RunTestSequence( |
| InstrumentTab(kTabId), |
| InParallel(RunSubsequence(NavigateWebContents(kTabId, url1), |
| NavigateWebContents(kTabId, url2)), |
| RunSubsequence(WaitForStateChange(kTabId, state_change)))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| UninstrumentWebContents_CanReinstrument) { |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| UninstrumentWebContents(kWebContentsId), |
| // This should remove the element. |
| WaitForHide(kWebContentsId), InstrumentTab(kWebContentsId)); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| UninstrumentWebContents_DoesNotFail) { |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| UninstrumentWebContents(kWebContents2Id, |
| /*fail_if_not_instrumented=*/false)); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestBrowsertest, |
| UninstrumentWebContents_Fails) { |
| UNCALLED_MOCK_CALLBACK(ui::InteractionSequence::AbortedCallback, aborted); |
| private_test_impl().set_aborted_callback_for_testing(aborted.Get()); |
| |
| EXPECT_CALL_IN_SCOPE( |
| aborted, Run, |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| UninstrumentWebContents(kWebContents2Id))); |
| } |
| |
| using ClickElementParams = |
| std::tuple<ui_controls::MouseButton, ui_controls::AcceleratorState>; |
| |
| class InteractiveBrowserTestClickElementTest |
| : public InteractiveBrowserTestBrowsertest, |
| public testing::WithParamInterface<ClickElementParams> { |
| public: |
| InteractiveBrowserTestClickElementTest() = default; |
| ~InteractiveBrowserTestClickElementTest() override = default; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P( |
| , |
| InteractiveBrowserTestClickElementTest, |
| testing::Combine( |
| testing::Values(ui_controls::LEFT, |
| ui_controls::MIDDLE, |
| ui_controls::RIGHT), |
| testing::Values(ui_controls::kNoAccelerator, |
| ui_controls::kShift, |
| ui_controls::kControl, |
| ui_controls::kAlt, |
| ui_controls::kCommand, |
| static_cast<ui_controls::AcceleratorState>( |
| ui_controls::kAlt | ui_controls::kShift), |
| static_cast<ui_controls::AcceleratorState>( |
| ui_controls::kControl | ui_controls::kCommand | |
| ui_controls::kAlt | ui_controls::kShift))), |
| [](const testing::TestParamInfo<ClickElementParams>& params) { |
| std::ostringstream oss; |
| switch (std::get<0>(params.param)) { |
| case ui_controls::LEFT: |
| oss << "Left"; |
| break; |
| case ui_controls::MIDDLE: |
| oss << "Middle"; |
| break; |
| case ui_controls::RIGHT: |
| oss << "Right"; |
| break; |
| } |
| const auto accel = std::get<1>(params.param); |
| if (accel & ui_controls::kControl) { |
| oss << "_Control"; |
| } |
| if (accel & ui_controls::kAlt) { |
| oss << "_Alt"; |
| } |
| if (accel & ui_controls::kShift) { |
| oss << "_Shift"; |
| } |
| if (accel & ui_controls::kCommand) { |
| oss << "_Meta"; |
| } |
| return oss.str(); |
| }); |
| |
| IN_PROC_BROWSER_TEST_P(InteractiveBrowserTestClickElementTest, ClickElement) { |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithClickDetection); |
| const auto mouse_button = std::get<0>(GetParam()); |
| const auto modifier = std::get<1>(GetParam()); |
| const DeepQuery kButton = {"#button"}; |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url), |
| ClickElement(kWebContentsId, kButton, mouse_button, modifier), |
| CheckJsResultAt(kWebContentsId, kButton, "el => el.lastClickEvent.button", |
| static_cast<int>(mouse_button)), |
| CheckJsResultAt(kWebContentsId, kButton, "el => el.lastClickEvent.altKey", |
| (modifier & ui_controls::kAlt) != 0), |
| CheckJsResultAt(kWebContentsId, kButton, |
| "el => el.lastClickEvent.shiftKey", |
| (modifier & ui_controls::AcceleratorState::kShift) != 0), |
| CheckJsResultAt( |
| kWebContentsId, kButton, "el => el.lastClickEvent.ctrlKey", |
| (modifier & ui_controls::AcceleratorState::kControl) != 0), |
| CheckJsResultAt( |
| kWebContentsId, kButton, "el => el.lastClickEvent.metaKey", |
| (modifier & ui_controls::AcceleratorState::kCommand) != 0), |
| CheckJsResultAt(kWebContentsId, kButton, |
| R"( |
| function(el) { |
| const x = el.lastClickEvent.x; |
| const y = el.lastClickEvent.y; |
| const rect = el.getBoundingClientRect(); |
| return x >= rect.left && x < rect.right && |
| y >= rect.top && y < rect.bottom; |
| } |
| )")); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestClickElementTest, |
| ClickElementOpensLink) { |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithClickDetection); |
| const GURL url2 = embedded_test_server()->GetURL(kDocumentWithLinks); |
| const DeepQuery kLink = {"#link"}; |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| ClickElement(kWebContentsId, kLink), |
| WaitForWebContentsNavigation(kWebContentsId, url2)); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestClickElementTest, |
| MiddleClickElementOpensLink) { |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithClickDetection); |
| const GURL url2 = embedded_test_server()->GetURL(kDocumentWithLinks); |
| const DeepQuery kLink = {"#link"}; |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| InstrumentNextTab(kWebContents2Id), |
| ClickElement(kWebContentsId, kLink, ui_controls::MIDDLE), |
| WaitForWebContentsReady(kWebContents2Id, url2)); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestClickElementTest, |
| ControlClickElementOpensLink) { |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithClickDetection); |
| const GURL url2 = embedded_test_server()->GetURL(kDocumentWithLinks); |
| const DeepQuery kLink = {"#link"}; |
| RunTestSequence(InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, url), |
| InstrumentNextTab(kWebContents2Id), |
| ClickElement(kWebContentsId, kLink, ui_controls::LEFT, |
| #if BUILDFLAG(IS_MAC) |
| ui_controls::kCommand |
| #else |
| ui_controls::kControl |
| #endif |
| ), |
| WaitForWebContentsReady(kWebContents2Id, url2)); |
| } |
| |
| // TODO(crbug.com/370724585): Re-enable this test. |
| #if BUILDFLAG(IS_MAC) |
| #define MAYBE_ShiftClickElementOpensLink DISABLED_ShiftClickElementOpensLink |
| #else |
| #define MAYBE_ShiftClickElementOpensLink ShiftClickElementOpensLink |
| #endif |
| IN_PROC_BROWSER_TEST_F(InteractiveBrowserTestClickElementTest, |
| MAYBE_ShiftClickElementOpensLink) { |
| const GURL url = embedded_test_server()->GetURL(kDocumentWithClickDetection); |
| const GURL url2 = embedded_test_server()->GetURL(kDocumentWithLinks); |
| const DeepQuery kLink = {"#link"}; |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), NavigateWebContents(kWebContentsId, url), |
| InstrumentNextTab(kWebContents2Id, AnyBrowser()), |
| ClickElement(kWebContentsId, kLink, ui_controls::LEFT, |
| #if BUILDFLAG(IS_MAC) |
| static_cast<ui_controls::AcceleratorState>( |
| ui_controls::kCommand | ui_controls::kAlt) |
| #else |
| ui_controls::kShift |
| #endif |
| ), |
| InAnyContext(WaitForWebContentsReady(kWebContents2Id, url2)), |
| InSameContext(CheckView( |
| kBrowserViewElementId, |
| [](BrowserView* browser_view) { return browser_view->browser(); }, |
| testing::Ne(browser())))); |
| } |
| |
| // Parameter for WebUI coverage tests. |
| struct CoverageConfig { |
| // Whether to set the --devtools-code-coverage flag. If it's not set, nothing |
| // should be captured, and the test is simply verifying that no errors are |
| // generated as a result. |
| bool command_line_flag = false; |
| |
| // Whether coverage is actively enabled. If the command line flag is also set, |
| // the test will check whether data got written to the code coverage folder. |
| bool enable_coverage = false; |
| }; |
| |
| // Test fixture to verify that when EnableWebUICodeCoverage() is called with the |
| // correct command-line arguments, coverage data actually gets written out. It |
| // also verifies that |
| class InteractiveBrowserTestCodeCoverageBrowsertest |
| : public InteractiveBrowserTestBrowsertest, |
| public testing::WithParamInterface<CoverageConfig> { |
| public: |
| void SetUp() override { |
| { |
| // This is required for file IO. |
| base::ScopedAllowBlockingForTesting allow_blocking; |
| CHECK(tmp_dir_.CreateUniqueTempDir()); |
| ASSERT_TRUE(base::IsDirectoryEmpty(tmp_dir_.GetPath())); |
| } |
| InteractiveBrowserTestBrowsertest::SetUp(); |
| } |
| |
| void SetUpCommandLine(base::CommandLine* command_line) override { |
| if (GetParam().command_line_flag) { |
| command_line->AppendSwitchPath(switches::kDevtoolsCodeCoverage, |
| tmp_dir_.GetPath()); |
| } else { |
| command_line->RemoveSwitch(switches::kDevtoolsCodeCoverage); |
| } |
| InteractiveBrowserTestBrowsertest::SetUpCommandLine(command_line); |
| } |
| |
| void SetUpOnMainThread() override { |
| InteractiveBrowserTestBrowsertest::SetUpOnMainThread(); |
| if (GetParam().enable_coverage) { |
| EnableWebUICodeCoverage(); |
| } |
| } |
| |
| // This is where we actually verify that the data has been written out, since |
| // coverage output doesn't happen until teardown. |
| void TearDownOnMainThread() override { |
| InteractiveBrowserTestBrowsertest::TearDownOnMainThread(); |
| |
| if (GetParam().command_line_flag) { |
| // This is required for file IO. |
| base::ScopedAllowBlockingForTesting allow_blocking; |
| if (GetParam().enable_coverage) { |
| // Scripts and tests are special directories under the WebUI specific |
| // directory, ensure they have been created and are not empty. |
| base::FilePath coverage_dir = |
| tmp_dir_.GetPath().AppendASCII("webui_javascript_code_coverage"); |
| EXPECT_FALSE( |
| base::IsDirectoryEmpty(coverage_dir.AppendASCII("scripts"))); |
| EXPECT_FALSE(base::IsDirectoryEmpty(coverage_dir.AppendASCII("tests"))); |
| } else { |
| EXPECT_TRUE(base::IsDirectoryEmpty(tmp_dir_.GetPath())); |
| } |
| } |
| } |
| |
| protected: |
| base::ScopedTempDir tmp_dir_; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(, |
| InteractiveBrowserTestCodeCoverageBrowsertest, |
| testing::Values(CoverageConfig{false, false}, |
| CoverageConfig{false, true}, |
| CoverageConfig{true, false}, |
| CoverageConfig{true, true})); |
| |
| // TODO(crbug.com/390224186) Re-enable the test after fixing the flakiness. |
| // TODO(crbug.com/430147700) Re-enable after fixing flakiness on ChromeOS. |
| #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| #define MAYBE_TestCoverageEmits DISABLED_TestCoverageEmits |
| #else |
| #define MAYBE_TestCoverageEmits TestCoverageEmits |
| #endif |
| IN_PROC_BROWSER_TEST_P(InteractiveBrowserTestCodeCoverageBrowsertest, |
| MAYBE_TestCoverageEmits) { |
| // Navigate and load the New Tab Page, which we know works with code coverage. |
| RunTestSequence( |
| InstrumentTab(kWebContentsId), |
| NavigateWebContents(kWebContentsId, GURL("chrome://history"))); |
| } |
| |
| class InteractiveBrowserTestDialog : public views::DialogDelegateView { |
| public: |
| DECLARE_CLASS_ELEMENT_IDENTIFIER_VALUE(kElementId); |
| |
| InteractiveBrowserTestDialog() { |
| SetProperty(views::kElementIdentifierKey, kElementId); |
| } |
| ~InteractiveBrowserTestDialog() override = default; |
| |
| gfx::Size CalculatePreferredSize( |
| const views::SizeBounds& available_size) const override { |
| return gfx::Size(200, 200); |
| } |
| |
| static views::Widget* Show(Browser* parent, ui::mojom::ModalType modal_type) { |
| auto dialog = std::make_unique<InteractiveBrowserTestDialog>(); |
| dialog->SetModalType(modal_type); |
| views::Widget* widget = nullptr; |
| switch (modal_type) { |
| case ui::mojom::ModalType::kWindow: |
| widget = constrained_window::CreateBrowserModalDialogViews( |
| std::move(dialog), parent->window()->GetNativeWindow()); |
| break; |
| case ui::mojom::ModalType::kChild: |
| widget = constrained_window::CreateWebModalDialogViews( |
| dialog.release(), |
| parent->tab_strip_model()->GetActiveWebContents()); |
| break; |
| case ui::mojom::ModalType::kSystem: |
| case ui::mojom::ModalType::kNone: |
| widget = views::DialogDelegate::CreateDialogWidget( |
| std::move(dialog), gfx::NativeWindow(), |
| BrowserView::GetBrowserViewForBrowser(parent) |
| ->GetWidget() |
| ->GetNativeView()); |
| break; |
| } |
| widget->Show(); |
| return widget; |
| } |
| }; |
| |
| DEFINE_CLASS_ELEMENT_IDENTIFIER_VALUE(InteractiveBrowserTestDialog, kElementId); |
| |
| namespace { |
| |
| // Scoped object that closes a widget it does not own. |
| class SafeWidgetRef { |
| public: |
| SafeWidgetRef() = default; |
| SafeWidgetRef(const SafeWidgetRef&) = delete; |
| SafeWidgetRef& operator=(views::Widget* widget) { |
| if (widget != widget_) { |
| Close(); |
| widget_ = widget; |
| } |
| return *this; |
| } |
| ~SafeWidgetRef() { Close(); } |
| |
| void Close() { |
| if (views::Widget* widget = widget_.get()) { |
| widget_ = nullptr; |
| if (!widget->IsClosed()) { |
| widget->CloseNow(); |
| } |
| } |
| } |
| |
| views::Widget* operator->() { return widget_.get(); } |
| |
| private: |
| raw_ptr<views::Widget> widget_ = nullptr; |
| }; |
| |
| } // namespace |
| |
| class InteractiveBrowserTestDialogBrowsertest |
| : public InteractiveBrowserTest, |
| public testing::WithParamInterface<ui::mojom::ModalType> { |
| public: |
| InteractiveBrowserTestDialogBrowsertest() = default; |
| ~InteractiveBrowserTestDialogBrowsertest() override = default; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P( |
| , |
| InteractiveBrowserTestDialogBrowsertest, |
| ::testing::Values( |
| ui::mojom::ModalType::kNone, |
| ui::mojom::ModalType::kChild, |
| ui::mojom::ModalType::kWindow |
| #if !BUILDFLAG(IS_MAC) |
| // System modals not supported on mac; see crbug.com/335864910 |
| , |
| ui::mojom::ModalType::kSystem |
| #endif |
| ), |
| [](const testing::TestParamInfo<ui::mojom::ModalType>& param) { |
| switch (param.param) { |
| case ui::mojom::ModalType::kNone: |
| return "None"; |
| case ui::mojom::ModalType::kChild: |
| return "Child"; |
| case ui::mojom::ModalType::kWindow: |
| return "Window"; |
| case ui::mojom::ModalType::kSystem: |
| return "System"; |
| } |
| }); |
| |
| IN_PROC_BROWSER_TEST_P(InteractiveBrowserTestDialogBrowsertest, |
| BrowserModalDialogContext) { |
| SafeWidgetRef widget; |
| RunTestSequence( |
| Do([this, &widget]() { |
| widget = InteractiveBrowserTestDialog::Show(browser(), GetParam()); |
| }), |
| InAnyContext(WaitForShow(InteractiveBrowserTestDialog::kElementId)), |
| InSameContext( |
| CheckView( |
| InteractiveBrowserTestDialog::kElementId, |
| [](views::View* view) { return view->GetWidget()->parent(); }, |
| BrowserView::GetBrowserViewForBrowser(browser())->GetWidget()), |
| CheckElement( |
| InteractiveBrowserTestDialog::kElementId, |
| [](ui::TrackedElement* el) { return el->context(); }, |
| private_test_impl().default_context()))); |
| } |
