\n"
"window.pageYOffset&&t+o>window.pageXOffset"
)
return driver.execute_script(script, element)
selenium-selenium-4.18.1/test/selenium/webdriver/common/executing_async_javascript_tests.py 0000644 0001750 0001750 00000020776 14564764517 032457 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import TimeoutException
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.common.by import By
from selenium.webdriver.remote.webelement import WebElement
@pytest.fixture(autouse=True)
def reset_timeouts(driver):
driver.set_script_timeout(5)
yield
driver.set_script_timeout(30)
def test_should_not_timeout_if_callback_invoked_immediately(driver, pages):
pages.load("ajaxy_page.html")
result = driver.execute_async_script("arguments[arguments.length - 1](123);")
assert isinstance(result, int)
assert 123 == result
def test_should_be_able_to_return_javascript_primitives_from_async_scripts_neither_none_nor_undefined(driver, pages):
pages.load("ajaxy_page.html")
assert 123 == driver.execute_async_script("arguments[arguments.length - 1](123);")
assert "abc" == driver.execute_async_script("arguments[arguments.length - 1]('abc');")
assert not bool(driver.execute_async_script("arguments[arguments.length - 1](false);"))
assert bool(driver.execute_async_script("arguments[arguments.length - 1](true);"))
def test_should_be_able_to_return_javascript_primitives_from_async_scripts_null_and_undefined(driver, pages):
pages.load("ajaxy_page.html")
assert driver.execute_async_script("arguments[arguments.length - 1](null)") is None
assert driver.execute_async_script("arguments[arguments.length - 1]()") is None
def test_should_be_able_to_return_an_array_literal_from_an_async_script(driver, pages):
pages.load("ajaxy_page.html")
result = driver.execute_async_script("arguments[arguments.length - 1]([]);")
assert "Expected not to be null!", result is not None
assert isinstance(result, list)
assert len(result) == 0
def test_should_be_able_to_return_an_array_object_from_an_async_script(driver, pages):
pages.load("ajaxy_page.html")
result = driver.execute_async_script("arguments[arguments.length - 1](new Array());")
assert "Expected not to be null!", result is not None
assert isinstance(result, list)
assert len(result) == 0
def test_should_be_able_to_return_arrays_of_primitives_from_async_scripts(driver, pages):
pages.load("ajaxy_page.html")
result = driver.execute_async_script("arguments[arguments.length - 1]([null, 123, 'abc', true, false]);")
assert result is not None
assert isinstance(result, list)
assert not bool(result.pop())
assert bool(result.pop())
assert "abc" == result.pop()
assert 123 == result.pop()
assert result.pop() is None
assert len(result) == 0
def test_should_be_able_to_return_web_elements_from_async_scripts(driver, pages):
pages.load("ajaxy_page.html")
result = driver.execute_async_script("arguments[arguments.length - 1](document.body);")
assert isinstance(result, WebElement)
assert "body" == result.tag_name.lower()
@pytest.mark.xfail_safari
@pytest.mark.xfail_chrome(reason="https://bugs.chromium.org/p/chromedriver/issues/detail?id=4525")
def test_should_be_able_to_return_arrays_of_web_elements_from_async_scripts(driver, pages):
pages.load("ajaxy_page.html")
result = driver.execute_async_script("arguments[arguments.length - 1]([document.body, document.body]);")
assert result is not None
assert isinstance(result, list)
list_ = result
assert 2 == len(list_)
assert isinstance(list_[0], WebElement)
assert isinstance(list_[1], WebElement)
assert "body" == list_[0].tag_name
# assert list_[0] == list_[1]
def test_should_timeout_if_script_does_not_invoke_callback(driver, pages):
pages.load("ajaxy_page.html")
with pytest.raises(TimeoutException):
# Script is expected to be async and explicitly callback, so this should timeout.
driver.execute_async_script("return 1 + 2;")
def test_should_timeout_if_script_does_not_invoke_callback_with_azero_timeout(driver, pages):
pages.load("ajaxy_page.html")
with pytest.raises(TimeoutException):
driver.execute_async_script("window.setTimeout(function() {}, 0);")
def test_should_not_timeout_if_script_callsback_inside_azero_timeout(driver, pages):
pages.load("ajaxy_page.html")
driver.execute_async_script(
"""var callback = arguments[arguments.length - 1];
window.setTimeout(function() { callback(123); }, 0)"""
)
def test_should_timeout_if_script_does_not_invoke_callback_with_long_timeout(driver, pages):
driver.set_script_timeout(0.5)
pages.load("ajaxy_page.html")
with pytest.raises(TimeoutException):
driver.execute_async_script(
"""var callback = arguments[arguments.length - 1];
window.setTimeout(callback, 1500);"""
)
def test_should_detect_page_loads_while_waiting_on_an_async_script_and_return_an_error(driver, pages):
pages.load("ajaxy_page.html")
driver.set_script_timeout(0.1)
with pytest.raises(WebDriverException):
url = pages.url("dynamic.html")
driver.execute_async_script(f"window.location = '{url}';")
def test_should_catch_errors_when_executing_initial_script(driver, pages):
pages.load("ajaxy_page.html")
with pytest.raises(WebDriverException):
driver.execute_async_script("throw Error('you should catch this!');")
def test_should_be_able_to_execute_asynchronous_scripts(driver, pages):
pages.load("ajaxy_page.html")
typer = driver.find_element(by=By.NAME, value="typer")
typer.send_keys("bob")
assert "bob" == typer.get_attribute("value")
driver.find_element(by=By.ID, value="red").click()
driver.find_element(by=By.NAME, value="submit").click()
assert 1 == len(
driver.find_elements(by=By.TAG_NAME, value="div")
), "There should only be 1 DIV at this point, which is used for the butter message"
driver.set_script_timeout(10)
text = driver.execute_async_script(
"""var callback = arguments[arguments.length - 1];
window.registerListener(arguments[arguments.length - 1]);"""
)
assert "bob" == text
assert "" == typer.get_attribute("value")
assert 2 == len(
driver.find_elements(by=By.TAG_NAME, value="div")
), "There should be 1 DIV (for the butter message) + 1 DIV (for the new label)"
def test_should_be_able_to_pass_multiple_arguments_to_async_scripts(driver, pages):
pages.load("ajaxy_page.html")
result = driver.execute_async_script(
"""
arguments[arguments.length - 1](arguments[0] + arguments[1]);""",
1,
2,
)
assert 3 == result
# TODO DavidBurns Disabled till Java WebServer is used
# def test_should_be_able_to_make_xmlhttp_requests_and_wait_for_the_response(driver, pages):
# script = """
# var url = arguments[0];
# var callback = arguments[arguments.length - 1];
# // Adapted from http://www.quirksmode.org/js/xmlhttp.html
# var XMLHttpFactories = [
# function () return new XMLHttpRequest(),
# function () return new ActiveXObject('Msxml2.XMLHTTP'),
# function () return new ActiveXObject('Msxml3.XMLHTTP'),
# function () return new ActiveXObject('Microsoft.XMLHTTP')
# ];
# var xhr = false;
# while (!xhr && XMLHttpFactories.length)
# try{
# xhr = XMLHttpFactories.shift().call();
# }catch (e)
#
# if (!xhr) throw Error('unable to create XHR object');
# xhr.open('GET', url, true);
# xhr.onreadystatechange = function()
# if (xhr.readyState == 4) callback(xhr.responseText);
#
# xhr.send('');""" # empty string to stop firefox 3 from choking
#
# pages.load("ajaxy_page.html")
# driver.set_script_timeout(3)
# response = driver.execute_async_script(script, pages.sleepingPage + "?time=2")
# htm = "DoneSlept for 2s"
# assert response.strip() == htm
selenium-selenium-4.18.1/test/selenium/webdriver/common/window_switching_tests.py 0000644 0001750 0001750 00000016476 14564764517 030431 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import NoSuchWindowException
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.common.by import By
from selenium.webdriver.common.window import WindowTypes
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
@pytest.fixture(autouse=True)
def close_windows(driver):
main_windows_handle = driver.current_window_handle
yield
from urllib import request as url_request
URLError = url_request.URLError
try:
window_handles = driver.window_handles
except URLError:
return
for handle in window_handles:
if handle != main_windows_handle:
driver.switch_to.window(handle)
driver.close()
driver.switch_to.window(main_windows_handle)
def test_should_switch_focus_to_anew_window_when_it_is_opened_and_not_stop_future_operations(driver, pages):
pages.load("xhtmlTest.html")
current = driver.current_window_handle
driver.find_element(By.LINK_TEXT, "Open new window").click()
assert driver.title == "XHTML Test Page"
handles = driver.window_handles
handles.remove(current)
driver.switch_to.window(handles[0])
assert driver.title == "We Arrive Here"
pages.load("iframes.html")
handle = driver.current_window_handle
driver.find_element(By.ID, "iframe_page_heading")
driver.switch_to.frame(driver.find_element(By.ID, "iframe1"))
assert driver.current_window_handle == handle
def test_can_switch_to_window_by_name(driver, pages):
pages.load("xhtmlTest.html")
handles = driver.window_handles
driver.find_element(By.LINK_TEXT, "Open new window").click()
WebDriverWait(driver, 3).until(EC.new_window_is_opened(handles))
driver.switch_to.window("result")
assert driver.title == "We Arrive Here"
def test_should_throw_no_such_window_exception(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(NoSuchWindowException):
driver.switch_to.window("invalid name")
@pytest.mark.xfail_safari
def test_should_throw_no_such_window_exception_on_an_attempt_to_get_its_handle(driver, pages):
pages.load("xhtmlTest.html")
current = driver.current_window_handle
handles = driver.window_handles
driver.find_element(By.LINK_TEXT, "Open new window").click()
WebDriverWait(driver, 3).until(EC.new_window_is_opened(handles))
handles = driver.window_handles
handles.remove(current)
driver.switch_to.window(handles[0])
driver.close()
with pytest.raises(NoSuchWindowException):
driver.current_window_handle
@pytest.mark.xfail_ie
def test_should_throw_no_such_window_exception_on_any_operation_if_awindow_is_closed(driver, pages):
pages.load("xhtmlTest.html")
current = driver.current_window_handle
handles = driver.window_handles
driver.find_element(By.LINK_TEXT, "Open new window").click()
WebDriverWait(driver, 3).until(EC.new_window_is_opened(handles))
handles = driver.window_handles
handles.remove(current)
driver.switch_to.window(handles[0])
driver.close()
with pytest.raises(NoSuchWindowException):
driver.title
with pytest.raises(NoSuchWindowException):
driver.find_element(By.TAG_NAME, "body")
@pytest.mark.xfail_ie
@pytest.mark.xfail_safari
def test_should_throw_no_such_window_exception_on_any_element_operation_if_awindow_is_closed(driver, pages):
pages.load("xhtmlTest.html")
current = driver.current_window_handle
handles = driver.window_handles
driver.find_element(By.LINK_TEXT, "Open new window").click()
WebDriverWait(driver, 3).until(EC.new_window_is_opened(handles))
handles = driver.window_handles
handles.remove(current)
driver.switch_to.window(handles[0])
element = driver.find_element(By.TAG_NAME, "body")
driver.close()
with pytest.raises(NoSuchWindowException):
element.text
def test_clicking_on_abutton_that_closes_an_open_window_does_not_cause_the_browser_to_hang(driver, pages):
pages.load("xhtmlTest.html")
current = driver.current_window_handle
handles = driver.window_handles
driver.find_element(By.NAME, "windowThree").click()
WebDriverWait(driver, 3).until(EC.new_window_is_opened(handles))
handles = driver.window_handles
handles.remove(current)
driver.switch_to.window(handles[0])
driver.find_element(By.ID, "close").click()
driver.switch_to.window(current)
driver.find_element(By.ID, "linkId")
@pytest.mark.xfail_safari
def test_can_call_get_window_handles_after_closing_awindow(driver, pages):
pages.load("xhtmlTest.html")
current = driver.current_window_handle
handles = driver.window_handles
driver.find_element(By.NAME, "windowThree").click()
WebDriverWait(driver, 3).until(EC.new_window_is_opened(handles))
handles = driver.window_handles
handles.remove(current)
driver.switch_to.window(handles[0])
driver.find_element(By.ID, "close").click()
WebDriverWait(driver, 3).until(EC.number_of_windows_to_be(1))
def test_can_obtain_awindow_handle(driver, pages):
pages.load("xhtmlTest.html")
currentHandle = driver.current_window_handle
assert currentHandle is not None
def test_failing_to_switch_to_awindow_leaves_the_current_window_as_is(driver, pages):
pages.load("xhtmlTest.html")
current = driver.current_window_handle
with pytest.raises(NoSuchWindowException):
driver.switch_to.window("I will never exist")
new_handle = driver.current_window_handle
assert current == new_handle
@pytest.mark.xfail_safari
def test_that_accessing_finding_an_element_after_window_is_closed_and_haventswitched_doesnt_crash(driver, pages):
pages.load("xhtmlTest.html")
current = driver.current_window_handle
handles = driver.window_handles
driver.find_element(By.NAME, "windowThree").click()
WebDriverWait(driver, 3).until(EC.new_window_is_opened(handles))
handles = driver.window_handles
handles.remove(current)
driver.switch_to.window(handles[0])
with pytest.raises(WebDriverException):
driver.find_element(By.ID, "close").click()
all_handles = driver.window_handles
assert 1 == len(all_handles)
driver.find_element(By.ID, "close")
driver.switch_to.window(current)
@pytest.mark.xfail_ie
def test_should_be_able_to_create_anew_window(driver, pages):
original_handle = driver.current_window_handle
driver.switch_to.new_window(WindowTypes.TAB)
new_handle = driver.current_window_handle
driver.close()
driver.switch_to.window(original_handle)
assert new_handle != original_handle
selenium-selenium-4.18.1/test/selenium/webdriver/common/selenium_manager_tests.py 0000644 0001750 0001750 00000006643 14564764517 030351 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
from unittest.mock import Mock
import pytest
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.proxy import Proxy
from selenium.webdriver.common.selenium_manager import SeleniumManager
def test_browser_version_is_used_for_sm(mocker):
import subprocess
mock_run = mocker.patch("subprocess.run")
mocked_result = Mock()
mocked_result.configure_mock(
**{
"stdout.decode.return_value": '{"result": {"driver_path": "driver", "browser_path": "browser"}, "logs": []}',
"returncode": 0,
}
)
mock_run.return_value = mocked_result
options = Options()
options.capabilities["browserName"] = "chrome"
options.browser_version = "110"
_ = SeleniumManager().driver_location(options)
args, kwargs = subprocess.run.call_args
assert "--browser-version" in args[0]
assert "110" in args[0]
def test_browser_path_is_used_for_sm(mocker):
import subprocess
mock_run = mocker.patch("subprocess.run")
mocked_result = Mock()
mocked_result.configure_mock(
**{
"stdout.decode.return_value": '{"result": {"driver_path": "driver", "browser_path": "browser"}, "logs": []}',
"returncode": 0,
}
)
mock_run.return_value = mocked_result
options = Options()
options.capabilities["browserName"] = "chrome"
options.binary_location = "/opt/bin/browser-bin"
_ = SeleniumManager().driver_location(options)
args, kwargs = subprocess.run.call_args
assert "--browser-path" in args[0]
assert "/opt/bin/browser-bin" in args[0]
def test_proxy_is_used_for_sm(mocker):
import subprocess
mock_run = mocker.patch("subprocess.run")
mocked_result = Mock()
mocked_result.configure_mock(
**{
"stdout.decode.return_value": '{"result": {"driver_path": "driver", "browser_path": "browser"}, "logs": []}',
"returncode": 0,
}
)
mock_run.return_value = mocked_result
options = Options()
options.capabilities["browserName"] = "chrome"
proxy = Proxy()
proxy.http_proxy = "http-proxy"
options.proxy = proxy
_ = SeleniumManager().driver_location(options)
args, kwargs = subprocess.run.call_args
assert "--proxy" in args[0]
assert "http-proxy" in args[0]
def test_stderr_is_propagated_to_exception_messages():
msg = r"Unsuccessful command executed:.*\n.* 'Invalid browser name: foo'.*"
with pytest.raises(WebDriverException, match=msg):
manager = SeleniumManager()
binary = manager.get_binary()
_ = manager.run([str(binary), "--browser", "foo"])
selenium-selenium-4.18.1/test/selenium/webdriver/common/page_load_timeout_tests.py 0000644 0001750 0001750 00000002652 14564764517 030513 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import TimeoutException
from selenium.webdriver.common.by import By
@pytest.fixture(autouse=True)
def reset_timeouts(driver):
yield
driver.set_page_load_timeout(300)
def test_should_timeout_on_page_load_taking_too_long(driver, pages):
driver.set_page_load_timeout(0.01)
with pytest.raises(TimeoutException):
pages.load("simpleTest.html")
@pytest.mark.xfail_safari
def test_click_should_timeout(driver, pages):
pages.load("simpleTest.html")
driver.set_page_load_timeout(0.01)
with pytest.raises(TimeoutException):
driver.find_element(By.ID, "multilinelink").click()
selenium-selenium-4.18.1/test/selenium/webdriver/common/script_pinning_tests.py 0000644 0001750 0001750 00000005123 14564764517 030054 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import re
import pytest
from selenium.common.exceptions import JavascriptException
from selenium.webdriver.remote.script_key import ScriptKey
def test_should_allow_script_pinning(driver, pages):
pages.load("simpleTest.html")
driver.pinned_scripts = {}
script_key = driver.pin_script("return 'i like cheese';")
result = driver.execute_script(script_key)
assert result == "i like cheese"
def test_should_allow_pinned_scripts_to_take_arguments(driver, pages):
pages.load("simpleTest.html")
driver.pinned_scripts = {}
hello = driver.pin_script("return arguments[0]")
result = driver.execute_script(hello, "cheese")
assert result == "cheese"
def test_should_list_all_pinned_scripts(driver, pages):
pages.load("simpleTest.html")
driver.pinned_scripts = {}
expected = []
expected.append(driver.pin_script("return arguments[0];").id)
expected.append(driver.pin_script("return 'cheese';").id)
expected.append(driver.pin_script("return 42;").id)
result = driver.get_pinned_scripts()
assert expected == result
def test_should_allow_scripts_to_be_unpinned(driver, pages):
pages.load("simpleTest.html")
driver.pinned_scripts = {}
cheese = driver.pin_script("return 'cheese';")
driver.unpin(cheese)
results = driver.get_pinned_scripts()
assert cheese not in results
def test_calling_unpinned_script_causes_error(driver, pages):
pages.load("simpleTest.html")
cheese = driver.pin_script("return 'brie';")
driver.unpin(cheese)
with pytest.raises(JavascriptException):
driver.execute_script(cheese)
def test_unpinning_non_existing_script_raises(driver, pages):
pages.load("simpleTest.html")
with pytest.raises(KeyError, match=re.escape(r"No script with key: ScriptKey(id=1) existed in {}")):
driver.unpin(ScriptKey(1))
selenium-selenium-4.18.1/test/selenium/webdriver/common/__init__.py 0000644 0001750 0001750 00000001423 14564764517 025342 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
selenium-selenium-4.18.1/test/selenium/webdriver/common/conftest.py 0000644 0001750 0001750 00000001735 14564764517 025436 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
def pytest_generate_tests(metafunc):
if "driver" in metafunc.fixturenames and metafunc.config.option.drivers:
metafunc.parametrize("driver", metafunc.config.option.drivers, indirect=True)
selenium-selenium-4.18.1/test/selenium/webdriver/common/takes_screenshots_tests.py 0000644 0001750 0001750 00000003001 14564764517 030546 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import base64
import imghdr
import pytest
from selenium.webdriver.common.by import By
def test_get_screenshot_as_base64(driver, pages):
pages.load("simpleTest.html")
result = base64.b64decode(driver.get_screenshot_as_base64())
assert imghdr.what("", result) == "png"
def test_get_screenshot_as_png(driver, pages):
pages.load("simpleTest.html")
result = driver.get_screenshot_as_png()
assert imghdr.what("", result) == "png"
@pytest.mark.xfail_firefox
@pytest.mark.xfail_remote
def test_get_element_screenshot(driver, pages):
pages.load("simpleTest.html")
element = driver.find_element(By.ID, "multiline")
result = base64.b64decode(element.screenshot_as_base64)
assert imghdr.what("", result) == "png"
selenium-selenium-4.18.1/test/selenium/webdriver/common/proxy_tests.py 0000644 0001750 0001750 00000011124 14564764517 026205 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.webdriver.common.options import ArgOptions
from selenium.webdriver.common.proxy import Proxy
from selenium.webdriver.common.proxy import ProxyType
MANUAL_PROXY = {
"httpProxy": "some.url:1234",
"ftpProxy": "ftp.proxy",
"noProxy": "localhost, foo.localhost",
"sslProxy": "ssl.proxy:1234",
"socksProxy": "socks.proxy:65555",
"socksUsername": "test",
"socksPassword": "test",
"socksVersion": 5,
}
PAC_PROXY = {
"proxyAutoconfigUrl": "http://pac.url:1234",
}
AUTODETECT_PROXY = {
"autodetect": True,
}
def test_can_add_manual_proxy_to_options():
proxy = Proxy()
proxy.http_proxy = MANUAL_PROXY["httpProxy"]
proxy.ftp_proxy = MANUAL_PROXY["ftpProxy"]
proxy.no_proxy = MANUAL_PROXY["noProxy"]
proxy.sslProxy = MANUAL_PROXY["sslProxy"]
proxy.socksProxy = MANUAL_PROXY["socksProxy"]
proxy.socksUsername = MANUAL_PROXY["socksUsername"]
proxy.socksPassword = MANUAL_PROXY["socksPassword"]
proxy.socksVersion = MANUAL_PROXY["socksVersion"]
options = ArgOptions()
options.proxy = proxy
proxy_capabilities = MANUAL_PROXY.copy()
proxy_capabilities["proxyType"] = "manual"
assert proxy_capabilities == options.to_capabilities().get("proxy")
def test_can_add_autodetect_proxy_to_options():
proxy = Proxy()
proxy.auto_detect = AUTODETECT_PROXY["autodetect"]
options = ArgOptions()
options.proxy = proxy
proxy_capabilities = AUTODETECT_PROXY.copy()
proxy_capabilities["proxyType"] = "autodetect"
assert proxy_capabilities == options.to_capabilities().get("proxy")
def test_can_add_pacproxy_to_options():
proxy = Proxy()
proxy.proxy_autoconfig_url = PAC_PROXY["proxyAutoconfigUrl"]
options = ArgOptions()
options.proxy = proxy
proxy_capabilities = PAC_PROXY.copy()
proxy_capabilities["proxyType"] = "pac"
assert proxy_capabilities == options.to_capabilities().get("proxy")
def test_can_not_change_initialized_proxy_type():
proxy = Proxy(raw={"proxyType": "direct"})
with pytest.raises(Exception):
proxy.proxy_type = ProxyType.SYSTEM
proxy = Proxy(raw={"proxyType": ProxyType.DIRECT})
with pytest.raises(Exception):
proxy.proxy_type = ProxyType.SYSTEM
def test_can_init_manual_proxy():
proxy = Proxy(raw=MANUAL_PROXY)
assert ProxyType.MANUAL == proxy.proxy_type
assert MANUAL_PROXY["httpProxy"] == proxy.http_proxy
assert MANUAL_PROXY["ftpProxy"] == proxy.ftp_proxy
assert MANUAL_PROXY["noProxy"] == proxy.no_proxy
assert MANUAL_PROXY["sslProxy"] == proxy.sslProxy
assert MANUAL_PROXY["socksProxy"] == proxy.socksProxy
assert MANUAL_PROXY["socksUsername"] == proxy.socksUsername
assert MANUAL_PROXY["socksPassword"] == proxy.socksPassword
assert MANUAL_PROXY["socksVersion"] == proxy.socksVersion
def test_can_init_autodetect_proxy():
proxy = Proxy(raw=AUTODETECT_PROXY)
assert ProxyType.AUTODETECT == proxy.proxy_type
assert AUTODETECT_PROXY["autodetect"] == proxy.auto_detect
def test_can_init_pacproxy():
proxy = Proxy(raw=PAC_PROXY)
assert ProxyType.PAC == proxy.proxy_type
assert PAC_PROXY["proxyAutoconfigUrl"] == proxy.proxy_autoconfig_url
def test_can_init_empty_proxy():
proxy = Proxy()
assert ProxyType.UNSPECIFIED == proxy.proxy_type
assert "" == proxy.http_proxy
assert "" == proxy.ftp_proxy
assert "" == proxy.no_proxy
assert "" == proxy.sslProxy
assert "" == proxy.socksProxy
assert "" == proxy.socksUsername
assert "" == proxy.socksPassword
assert proxy.auto_detect is False
assert "" == proxy.proxy_autoconfig_url
assert proxy.socks_version is None
options = ArgOptions()
options.proxy = proxy
proxy_capabilities = {}
proxy_capabilities["proxyType"] = "unspecified"
assert proxy_capabilities == options.to_capabilities().get("proxy")
selenium-selenium-4.18.1/test/selenium/webdriver/common/click_tests.py 0000644 0001750 0001750 00000002641 14564764517 026115 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait
@pytest.fixture(autouse=True)
def loadPage(pages):
pages.load("clicks.html")
def test_can_click_on_alink_that_overflows_and_follow_it(driver):
driver.find_element(By.ID, "overflowLink").click()
WebDriverWait(driver, 3).until(EC.title_is("XHTML Test Page"))
def test_clicking_alink_made_up_of_numbers_is_handled_correctly(driver):
driver.find_element(By.LINK_TEXT, "333333").click()
WebDriverWait(driver, 3).until(EC.title_is("XHTML Test Page"))
selenium-selenium-4.18.1/test/selenium/webdriver/common/implicit_waits_tests.py 0000644 0001750 0001750 00000005144 14564764517 030052 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.by import By
def test_should_implicitly_wait_for_asingle_element(driver, pages):
pages.load("dynamic.html")
add = driver.find_element(By.ID, "adder")
driver.implicitly_wait(3)
add.click()
driver.find_element(By.ID, "box0") # All is well if this doesn't throw.
def test_should_still_fail_to_find_an_element_when_implicit_waits_are_enabled(driver, pages):
pages.load("dynamic.html")
driver.implicitly_wait(0.5)
with pytest.raises(NoSuchElementException):
driver.find_element(By.ID, "box0")
def test_should_return_after_first_attempt_to_find_one_after_disabling_implicit_waits(driver, pages):
pages.load("dynamic.html")
driver.implicitly_wait(3)
driver.implicitly_wait(0)
with pytest.raises(NoSuchElementException):
driver.find_element(By.ID, "box0")
def test_should_implicitly_wait_until_at_least_one_element_is_found_when_searching_for_many(driver, pages):
pages.load("dynamic.html")
add = driver.find_element(By.ID, "adder")
driver.implicitly_wait(2)
add.click()
add.click()
elements = driver.find_elements(By.CLASS_NAME, "redbox")
assert len(elements) >= 1
def test_should_still_fail_to_find_an_elemenst_when_implicit_waits_are_enabled(driver, pages):
pages.load("dynamic.html")
driver.implicitly_wait(0.5)
elements = driver.find_elements(By.CLASS_NAME, "redbox")
assert 0 == len(elements)
def test_should_return_after_first_attempt_to_find_many_after_disabling_implicit_waits(driver, pages):
pages.load("dynamic.html")
add = driver.find_element(By.ID, "adder")
driver.implicitly_wait(1.1)
driver.implicitly_wait(0)
add.click()
elements = driver.find_elements(By.CLASS_NAME, "redbox")
assert 0 == len(elements)
selenium-selenium-4.18.1/test/selenium/webdriver/common/api_example_tests.py 0000644 0001750 0001750 00000022566 14564764517 027324 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait
def test_get_title(driver, pages):
pages.load("simpleTest.html")
title = driver.title
assert "Hello WebDriver" == title
def test_get_current_url(driver, pages, webserver):
pages.load("simpleTest.html")
url = driver.current_url
assert webserver.where_is("simpleTest.html") == url
def test_find_element_by_xpath(driver, pages):
pages.load("simpleTest.html")
elem = driver.find_element(By.XPATH, "//h1")
assert "Heading" == elem.text
def test_find_element_by_xpath_throw_no_such_element_exception(driver, pages):
pages.load("simpleTest.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.XPATH, "//h4")
def test_find_elements_by_xpath(driver, pages):
pages.load("nestedElements.html")
elems = driver.find_elements(By.XPATH, "//option")
assert 48 == len(elems)
assert "One" == elems[0].get_attribute("value")
def test_find_elements_by_name(driver, pages):
pages.load("xhtmlTest.html")
elem = driver.find_element(By.NAME, "windowOne")
assert "Open new window" == elem.text
def test_find_elements_by_name_in_element_context(driver, pages):
pages.load("nestedElements.html")
elem = driver.find_element(By.NAME, "form2")
sub_elem = elem.find_element(By.NAME, "selectomatic")
assert "2" == sub_elem.get_attribute("id")
def test_find_elements_by_link_text_in_element_context(driver, pages):
pages.load("nestedElements.html")
elem = driver.find_element(By.NAME, "div1")
sub_elem = elem.find_element(By.LINK_TEXT, "hello world")
assert "link1" == sub_elem.get_attribute("name")
def test_find_element_by_id_in_element_context(driver, pages):
pages.load("nestedElements.html")
elem = driver.find_element(By.NAME, "form2")
sub_elem = elem.find_element(By.ID, "2")
assert "selectomatic" == sub_elem.get_attribute("name")
def test_find_element_by_xpath_in_element_context(driver, pages):
pages.load("nestedElements.html")
elem = driver.find_element(By.NAME, "form2")
sub_elem = elem.find_element(By.XPATH, "select")
assert "2" == sub_elem.get_attribute("id")
def test_find_element_by_xpath_in_element_context_not_found(driver, pages):
pages.load("nestedElements.html")
elem = driver.find_element(By.NAME, "form2")
with pytest.raises(NoSuchElementException):
elem.find_element(By.XPATH, "div")
def test_should_be_able_to_enter_data_into_form_fields(driver, pages):
pages.load("xhtmlTest.html")
elem = driver.find_element(By.XPATH, "//form[@name='someForm']/input[@id='username']")
elem.clear()
elem.send_keys("some text")
elem = driver.find_element(By.XPATH, "//form[@name='someForm']/input[@id='username']")
assert "some text" == elem.get_attribute("value")
def test_find_element_by_tag_name(driver, pages):
pages.load("simpleTest.html")
elems = driver.find_elements(By.TAG_NAME, "div")
num_by_xpath = len(driver.find_elements(By.XPATH, "//div"))
assert num_by_xpath == len(elems)
elems = driver.find_elements(By.TAG_NAME, "iframe")
assert 0 == len(elems)
def test_find_element_by_tag_name_within_element(driver, pages):
pages.load("simpleTest.html")
div = driver.find_element(By.ID, "multiline")
elems = div.find_elements(By.TAG_NAME, "p")
assert len(elems) == 1
def test_switch_frame_by_name(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame(driver.find_element(By.NAME, "third"))
checkbox = driver.find_element(By.ID, "checky")
checkbox.click()
checkbox.submit()
def test_is_enabled(driver, pages):
pages.load("formPage.html")
elem = driver.find_element(By.XPATH, "//input[@id='working']")
assert elem.is_enabled()
elem = driver.find_element(By.XPATH, "//input[@id='notWorking']")
assert not elem.is_enabled()
def test_is_selected_and_toggle(driver, pages):
pages.load("formPage.html")
elem = driver.find_element(By.ID, "multi")
option_elems = elem.find_elements(By.XPATH, "option")
assert option_elems[0].is_selected()
option_elems[0].click()
assert not option_elems[0].is_selected()
option_elems[0].click()
assert option_elems[0].is_selected()
assert option_elems[2].is_selected()
def test_navigate(driver, pages):
pages.load("formPage.html")
driver.find_element(By.ID, "imageButton").submit()
WebDriverWait(driver, 3).until(EC.title_is("We Arrive Here"))
driver.back()
assert "We Leave From Here" == driver.title
driver.forward()
assert "We Arrive Here" == driver.title
def test_get_attribute(driver, pages):
url = pages.url("xhtmlTest.html")
driver.get(url)
elem = driver.find_element(By.ID, "id1")
attr = elem.get_attribute("href")
assert f"{url}#" == attr
def test_get_implicit_attribute(driver, pages):
pages.load("nestedElements.html")
elems = driver.find_elements(By.XPATH, "//option")
assert len(elems) >= 3
for i, elem in enumerate(elems[:3]):
assert i == int(elem.get_attribute("index"))
def test_get_dom_attribute(driver, pages):
url = pages.url("formPage.html")
driver.get(url)
elem = driver.find_element(By.ID, "vsearchGadget")
attr = elem.get_dom_attribute("accesskey")
assert "4" == attr
def test_get_property(driver, pages):
url = pages.url("formPage.html")
driver.get(url)
elem = driver.find_element(By.ID, "withText")
prop = elem.get_property("value")
assert "Example text" == prop
def test_execute_simple_script(driver, pages):
pages.load("xhtmlTest.html")
title = driver.execute_script("return document.title;")
assert "XHTML Test Page" == title
def test_execute_script_and_return_element(driver, pages):
pages.load("xhtmlTest.html")
elem = driver.execute_script("return document.getElementById('id1');")
assert "WebElement" in str(type(elem))
def test_execute_script_with_args(driver, pages):
pages.load("xhtmlTest.html")
result = driver.execute_script("return arguments[0] == 'fish' ? 'fish' : 'not fish';", "fish")
assert "fish" == result
def test_execute_script_with_multiple_args(driver, pages):
pages.load("xhtmlTest.html")
result = driver.execute_script("return arguments[0] + arguments[1]", 1, 2)
assert 3 == result
def test_execute_script_with_element_args(driver, pages):
pages.load("javascriptPage.html")
button = driver.find_element(By.ID, "plainButton")
result = driver.execute_script(
"arguments[0]['flibble'] = arguments[0].getAttribute('id'); return arguments[0]['flibble'];", button
)
assert "plainButton" == result
def test_find_elements_by_partial_link_text(driver, pages):
pages.load("xhtmlTest.html")
elem = driver.find_element(By.PARTIAL_LINK_TEXT, "new window")
elem.click()
def test_is_element_displayed(driver, pages):
pages.load("javascriptPage.html")
visible = driver.find_element(By.ID, "displayed").is_displayed()
not_visible = driver.find_element(By.ID, "hidden").is_displayed()
assert visible
assert not not_visible
@pytest.mark.xfail_chrome
def test_move_window_position(driver, pages):
pages.load("blank.html")
loc = driver.get_window_position()
# note can't test 0,0 since some OS's dont allow that location
# because of system toolbars
new_x = 50
new_y = 50
if loc["x"] == new_x:
new_x += 10
if loc["y"] == new_y:
new_y += 10
driver.set_window_position(new_x, new_y)
loc = driver.get_window_position()
assert loc["x"] == new_x
assert loc["y"] == new_y
def test_change_window_size(driver, pages):
pages.load("blank.html")
size = driver.get_window_size()
newSize = [600, 600]
if size["width"] == 600:
newSize[0] = 500
if size["height"] == 600:
newSize[1] = 500
driver.set_window_size(newSize[0], newSize[1])
size = driver.get_window_size()
assert size["width"] == newSize[0]
assert size["height"] == newSize[1]
@pytest.mark.xfail_firefox(raises=WebDriverException)
@pytest.mark.xfail_remote
@pytest.mark.xfail_safari
def test_get_log_types(driver, pages):
pages.load("blank.html")
assert isinstance(driver.log_types, list)
@pytest.mark.xfail_firefox(raises=WebDriverException)
@pytest.mark.xfail_remote
@pytest.mark.xfail_safari
def test_get_log(driver, pages):
pages.load("blank.html")
for log_type in driver.log_types:
log = driver.get_log(log_type)
assert isinstance(log, list)
selenium-selenium-4.18.1/test/selenium/webdriver/common/clear_tests.py 0000644 0001750 0001750 00000005040 14564764517 026112 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import InvalidElementStateException
from selenium.webdriver.common.by import By
def test_writable_text_input_should_clear(driver, pages):
pages.load("readOnlyPage.html")
element = driver.find_element(By.ID, "writableTextInput")
element.clear()
assert "" == element.get_attribute("value")
def test_text_input_should_not_clear_when_disabled(driver, pages):
pages.load("readOnlyPage.html")
element = driver.find_element(By.ID, "textInputNotEnabled")
assert not element.is_enabled()
with pytest.raises(InvalidElementStateException):
element.clear()
def test_text_input_should_not_clear_when_read_only(driver, pages):
pages.load("readOnlyPage.html")
element = driver.find_element(By.ID, "readOnlyTextInput")
with pytest.raises(InvalidElementStateException):
element.clear()
def test_writable_text_area_should_clear(driver, pages):
pages.load("readOnlyPage.html")
element = driver.find_element(By.ID, "writableTextArea")
element.clear()
assert "" == element.get_attribute("value")
def test_text_area_should_not_clear_when_disabled(driver, pages):
pages.load("readOnlyPage.html")
element = driver.find_element(By.ID, "textAreaNotEnabled")
with pytest.raises(InvalidElementStateException):
element.clear()
def test_text_area_should_not_clear_when_read_only(driver, pages):
pages.load("readOnlyPage.html")
element = driver.find_element(By.ID, "textAreaReadOnly")
with pytest.raises(InvalidElementStateException):
element.clear()
def test_content_editable_area_should_clear(driver, pages):
pages.load("readOnlyPage.html")
element = driver.find_element(By.ID, "content-editable")
element.clear()
assert "" == element.text
selenium-selenium-4.18.1/test/selenium/webdriver/common/driver_element_finding_tests.py 0000644 0001750 0001750 00000062013 14564764517 031531 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import InvalidSelectorException
from selenium.common.exceptions import NoSuchElementException
from selenium.webdriver.common.by import By
# By.id positive
def test_should_be_able_to_find_asingle_element_by_id(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.ID, "linkId")
assert element.get_attribute("id") == "linkId"
def test_should_be_able_to_find_asingle_element_by_numeric_id(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.ID, "2")
assert element.get_attribute("id") == "2"
def test_should_be_able_to_find_an_element_with_css_escape(driver, pages):
pages.load("idElements.html")
element = driver.find_element(By.ID, "with.dots")
assert element.get_attribute("id") == "with.dots"
def test_should_be_able_to_find_multiple_elements_by_id(driver, pages):
pages.load("nestedElements.html")
elements = driver.find_elements(By.ID, "test_id")
assert len(elements) == 2
def test_should_be_able_to_find_multiple_elements_by_numeric_id(driver, pages):
pages.load("nestedElements.html")
elements = driver.find_elements(By.ID, "2")
assert len(elements) == 8
# By.id negative
def test_should_not_be_able_to_locate_by_id_asingle_element_that_does_not_exist(driver, pages):
pages.load("formPage.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.ID, "non_Existent_Button")
def test_should_not_be_able_to_locate_by_id_multiple_elements_that_do_not_exist(driver, pages):
pages.load("formPage.html")
elements = driver.find_elements(By.ID, "non_Existent_Button")
assert len(elements) == 0
def test_finding_asingle_element_by_empty_id_should_throw(driver, pages):
pages.load("formPage.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.ID, "")
def test_finding_multiple_elements_by_empty_id_should_return_empty_list(driver, pages):
pages.load("formPage.html")
elements = driver.find_elements(By.ID, "")
assert len(elements) == 0
def test_finding_asingle_element_by_id_with_space_should_throw(driver, pages):
pages.load("formPage.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.ID, "nonexistent button")
def test_finding_multiple_elements_by_id_with_space_should_return_empty_list(driver, pages):
pages.load("formPage.html")
elements = driver.find_elements(By.ID, "nonexistent button")
assert len(elements) == 0
def test_no_such_element_error(driver, pages):
pages.load("formPage.html")
msg = r"\/errors#no-such-element-exception"
with pytest.raises(NoSuchElementException, match=msg):
driver.find_element(By.ID, "non_Existent_Button")
# By.name positive
def test_should_be_able_to_find_asingle_element_by_name(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.NAME, "checky")
assert element.get_attribute("value") == "furrfu"
def test_should_be_able_to_find_multiple_elements_by_name(driver, pages):
pages.load("nestedElements.html")
elements = driver.find_elements(By.NAME, "checky")
assert len(elements) > 1
def test_should_be_able_to_find_an_element_that_does_not_support_the_name_property(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "div1")
assert element.get_attribute("name") == "div1"
# By.name negative
def test_should_not_be_able_to_locate_by_name_asingle_element_that_does_not_exist(driver, pages):
pages.load("formPage.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.NAME, "non_Existent_Button")
def test_should_not_be_able_to_locate_by_name_multiple_elements_that_do_not_exist(driver, pages):
pages.load("formPage.html")
elements = driver.find_elements(By.NAME, "non_Existent_Button")
assert len(elements) == 0
def test_finding_asingle_element_by_empty_name_should_throw(driver, pages):
pages.load("formPage.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.NAME, "")
def test_finding_multiple_elements_by_empty_name_should_return_empty_list(driver, pages):
pages.load("formPage.html")
elements = driver.find_elements(By.NAME, "")
assert len(elements) == 0
def test_finding_asingle_element_by_name_with_space_should_throw(driver, pages):
pages.load("formPage.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.NAME, "nonexistent button")
def test_finding_multiple_elements_by_name_with_space_should_return_empty_list(driver, pages):
pages.load("formPage.html")
elements = driver.find_elements(By.NAME, "nonexistent button")
assert len(elements) == 0
# By.tag_Name positive
def test_should_be_able_to_find_asingle_element_by_tag_name(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.TAG_NAME, "input")
assert element.tag_name.lower() == "input"
def test_should_be_able_to_find_multiple_elements_by_tag_name(driver, pages):
pages.load("formPage.html")
elements = driver.find_elements(By.TAG_NAME, "input")
assert len(elements) > 1
# By.tag_Name negative
def test_should_not_be_able_to_locate_by_tag_name_asingle_element_that_does_not_exist(driver, pages):
pages.load("formPage.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.TAG_NAME, "non_Existent_Button")
def test_should_not_be_able_to_locate_by_tag_name_multiple_elements_that_do_not_exist(driver, pages):
pages.load("formPage.html")
elements = driver.find_elements(By.TAG_NAME, "non_Existent_Button")
assert len(elements) == 0
@pytest.mark.xfail_firefox(reason="https://github.com/mozilla/geckodriver/issues/2007")
@pytest.mark.xfail_remote(reason="https://github.com/mozilla/geckodriver/issues/2007")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises NoSuchElementException")
def test_finding_asingle_element_by_empty_tag_name_should_throw(driver, pages):
pages.load("formPage.html")
with pytest.raises(InvalidSelectorException):
driver.find_element(By.TAG_NAME, "")
@pytest.mark.xfail_firefox(reason="https://github.com/mozilla/geckodriver/issues/2007")
@pytest.mark.xfail_remote(reason="https://github.com/mozilla/geckodriver/issues/2007")
@pytest.mark.xfail_safari(reason="unlike chrome, safari returns an empty list")
def test_finding_multiple_elements_by_empty_tag_name_should_throw(driver, pages):
pages.load("formPage.html")
with pytest.raises(InvalidSelectorException):
driver.find_elements(By.TAG_NAME, "")
def test_finding_asingle_element_by_tag_name_with_space_should_throw(driver, pages):
pages.load("formPage.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.TAG_NAME, "nonexistent button")
def test_finding_multiple_elements_by_tag_name_with_space_should_return_empty_list(driver, pages):
pages.load("formPage.html")
elements = driver.find_elements(By.TAG_NAME, "nonexistent button")
assert len(elements) == 0
# By.class_Name positive
def test_should_be_able_to_find_asingle_element_by_class(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.CLASS_NAME, "extraDiv")
assert "Another div starts here." in element.text
def test_should_be_able_to_find_multiple_elements_by_class_name(driver, pages):
pages.load("xhtmlTest.html")
elements = driver.find_elements(By.CLASS_NAME, "nameC")
assert len(elements) > 1
def test_should_find_element_by_class_when_it_is_the_first_name_among_many(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.CLASS_NAME, "nameA")
assert element.text == "An H2 title"
def test_should_find_element_by_class_when_it_is_the_last_name_among_many(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.CLASS_NAME, "nameC")
assert element.text == "An H2 title"
def test_should_find_element_by_class_when_it_is_in_the_middle_among_many(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.CLASS_NAME, "nameBnoise")
assert element.text == "An H2 title"
def test_should_find_element_by_class_when_its_name_is_surrounded_by_whitespace(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.CLASS_NAME, "spaceAround")
assert element.text == "Spaced out"
def test_should_find_elements_by_class_when_its_name_is_surrounded_by_whitespace(driver, pages):
pages.load("xhtmlTest.html")
elements = driver.find_elements(By.CLASS_NAME, "spaceAround")
assert len(elements) == 1
assert elements[0].text == "Spaced out"
# By.class_Name negative
def test_should_not_find_element_by_class_when_the_name_queried_is_shorter_than_candidate_name(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.CLASS_NAME, "name_B")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_finding_asingle_element_by_empty_class_name_should_throw(driver, pages):
pages.load("xhtmlTest.html")
msg = r"\/errors#invalid-selector-exception"
with pytest.raises(InvalidSelectorException, match=msg):
driver.find_element(By.CLASS_NAME, "")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_finding_multiple_elements_by_empty_class_name_should_throw(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(InvalidSelectorException):
driver.find_elements(By.CLASS_NAME, "")
def test_finding_asingle_element_by_compound_class_name_should_throw(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.CLASS_NAME, "a b")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_finding_asingle_element_by_invalid_class_name_should_throw(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(InvalidSelectorException):
driver.find_element(By.CLASS_NAME, "!@#$%^&*")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_finding_multiple_elements_by_invalid_class_name_should_throw(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(InvalidSelectorException):
driver.find_elements(By.CLASS_NAME, "!@#$%^&*")
# By.xpath positive
def test_should_be_able_to_find_asingle_element_by_xpath(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.XPATH, "//h1")
assert element.text == "XHTML Might Be The Future"
def test_should_be_able_to_find_multiple_elements_by_xpath(driver, pages):
pages.load("xhtmlTest.html")
elements = driver.find_elements(By.XPATH, "//div")
assert len(elements) == 13
def test_should_be_able_to_find_many_elements_repeatedly_by_xpath(driver, pages):
pages.load("xhtmlTest.html")
xpath = "//node()[contains(@id,'id')]"
assert len(driver.find_elements(By.XPATH, xpath)) == 3
xpath = "//node()[contains(@id,'nope')]"
assert len(driver.find_elements(By.XPATH, xpath)) == 0
def test_should_be_able_to_identify_elements_by_class(driver, pages):
pages.load("xhtmlTest.html")
header = driver.find_element(By.XPATH, "//h1[@class='header']")
assert header.text == "XHTML Might Be The Future"
def test_should_be_able_to_find_an_element_by_xpath_with_multiple_attributes(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.XPATH, "//form[@name='optional']/input[@type='submit' and @value='Click!']")
assert element.tag_name.lower() == "input"
assert element.get_attribute("value") == "Click!"
def test_finding_alink_by_xpath_should_locate_an_element_with_the_given_text(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.XPATH, "//a[text()='click me']")
assert element.text == "click me"
def test_finding_alink_by_xpath_using_contains_keyword_should_work(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.XPATH, "//a[contains(.,'hello world')]")
assert "hello world" in element.text
# @pytest.mark.xfail_chrome(raises=InvalidSelectorException)
# @pytest.mark.xfail_chromiumedge(raises=InvalidSelectorException)
# @pytest.mark.xfail_firefox(raises=InvalidSelectorException)
# @pytest.mark.xfail_remote(raises=InvalidSelectorException)
# @pytest.mark.xfail_safari(raises=NoSuchElementException)
# @pytest.mark.xfail_webkitgtk(raises=InvalidSelectorException)
# def test_Should_Be_Able_To_Find_Element_By_XPath_With_Namespace(driver, pages):
# pages.load("svgPage.html")
# element = driver.find_element(By.XPATH, "//svg:svg//svg:text")
# assert element.text == "Test Chart"
def test_should_be_able_to_find_element_by_xpath_in_xml_document(driver, pages):
pages.load("simple.xml")
element = driver.find_element(By.XPATH, "//foo")
assert "baz" in element.text
# By.xpath negative
def test_should_throw_an_exception_when_there_is_no_link_to_click(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.XPATH, "//a[@id='Not here']")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_should_throw_invalid_selector_exception_when_xpath_is_syntactically_invalid_in_driver_find_element(
driver, pages
):
pages.load("formPage.html")
with pytest.raises(InvalidSelectorException):
driver.find_element(By.XPATH, "this][isnot][valid")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_should_throw_invalid_selector_exception_when_xpath_is_syntactically_invalid_in_driver_find_elements(
driver, pages
):
pages.load("formPage.html")
with pytest.raises(InvalidSelectorException):
driver.find_elements(By.XPATH, "this][isnot][valid")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_should_throw_invalid_selector_exception_when_xpath_is_syntactically_invalid_in_element_find_element(
driver, pages
):
pages.load("formPage.html")
body = driver.find_element(By.TAG_NAME, "body")
with pytest.raises(InvalidSelectorException):
body.find_element(By.XPATH, "this][isnot][valid")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_should_throw_invalid_selector_exception_when_xpath_is_syntactically_invalid_in_element_find_elements(
driver, pages
):
pages.load("formPage.html")
body = driver.find_element(By.TAG_NAME, "body")
with pytest.raises(InvalidSelectorException):
body.find_elements(By.XPATH, "this][isnot][valid")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_should_throw_invalid_selector_exception_when_xpath_returns_wrong_type_in_driver_find_element(driver, pages):
pages.load("formPage.html")
with pytest.raises(InvalidSelectorException):
driver.find_element(By.XPATH, "count(//input)")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_should_throw_invalid_selector_exception_when_xpath_returns_wrong_type_in_driver_find_elements(driver, pages):
pages.load("formPage.html")
with pytest.raises(InvalidSelectorException):
driver.find_elements(By.XPATH, "count(//input)")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_should_throw_invalid_selector_exception_when_xpath_returns_wrong_type_in_element_find_element(driver, pages):
pages.load("formPage.html")
body = driver.find_element(By.TAG_NAME, "body")
with pytest.raises(InvalidSelectorException):
body.find_element(By.XPATH, "count(//input)")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_should_throw_invalid_selector_exception_when_xpath_returns_wrong_type_in_element_find_elements(driver, pages):
pages.load("formPage.html")
body = driver.find_element(By.TAG_NAME, "body")
with pytest.raises(InvalidSelectorException):
body.find_elements(By.XPATH, "count(//input)")
# By.css_Selector positive
def test_should_be_able_to_find_asingle_element_by_css_selector(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.CSS_SELECTOR, "div.content")
assert element.tag_name.lower() == "div"
assert element.get_attribute("class") == "content"
def test_should_be_able_to_find_multiple_elements_by_css_selector(driver, pages):
pages.load("xhtmlTest.html")
elements = driver.find_elements(By.CSS_SELECTOR, "p")
assert len(elements) > 1
def test_should_be_able_to_find_asingle_element_by_compound_css_selector(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.CSS_SELECTOR, "div.extraDiv, div.content")
assert element.tag_name.lower() == "div"
assert element.get_attribute("class") == "content"
def test_should_be_able_to_find_multiple_elements_by_compound_css_selector(driver, pages):
pages.load("xhtmlTest.html")
elements = driver.find_elements(By.CSS_SELECTOR, "div.extraDiv, div.content")
assert len(elements) > 1
assert elements[0].get_attribute("class") == "content"
assert elements[1].get_attribute("class") == "extraDiv"
def test_should_be_able_to_find_an_element_by_boolean_attribute_using_css_selector(driver, pages):
pages.load("locators_tests/boolean_attribute_selected.html")
element = driver.find_element(By.CSS_SELECTOR, "option[selected='selected']")
assert element.get_attribute("value") == "two"
def test_should_be_able_to_find_an_element_by_boolean_attribute_using_short_css_selector(driver, pages):
pages.load("locators_tests/boolean_attribute_selected.html")
element = driver.find_element(By.CSS_SELECTOR, "option[selected]")
assert element.get_attribute("value") == "two"
def test_should_be_able_to_find_an_element_by_boolean_attribute_using_short_css_selector_on_html_4_page(driver, pages):
pages.load("locators_tests/boolean_attribute_selected_html4.html")
element = driver.find_element(By.CSS_SELECTOR, "option[selected]")
assert element.get_attribute("value") == "two"
# By.css_Selector negative
def test_should_not_find_element_by_css_selector_when_there_is_no_such_element(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.CSS_SELECTOR, ".there-is-no-such-class")
def test_should_not_find_elements_by_css_selector_when_there_is_no_such_element(driver, pages):
pages.load("xhtmlTest.html")
elements = driver.find_elements(By.CSS_SELECTOR, ".there-is-no-such-class")
assert len(elements) == 0
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_finding_asingle_element_by_empty_css_selector_should_throw(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(InvalidSelectorException):
driver.find_element(By.CSS_SELECTOR, "")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_finding_multiple_elements_by_empty_css_selector_should_throw(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(InvalidSelectorException):
driver.find_elements(By.CSS_SELECTOR, "")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_finding_asingle_element_by_invalid_css_selector_should_throw(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(InvalidSelectorException):
driver.find_element(By.CSS_SELECTOR, "//a/b/c[@id='1']")
@pytest.mark.xfail_safari(reason="unlike chrome, safari raises TimeoutException")
def test_finding_multiple_elements_by_invalid_css_selector_should_throw(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(InvalidSelectorException):
driver.find_elements(By.CSS_SELECTOR, "//a/b/c[@id='1']")
# By.link_Text positive
def test_should_be_able_to_find_alink_by_text(driver, pages):
pages.load("xhtmlTest.html")
link = driver.find_element(By.LINK_TEXT, "click me")
assert link.text == "click me"
def test_should_be_able_to_find_multiple_links_by_text(driver, pages):
pages.load("xhtmlTest.html")
elements = driver.find_elements(By.LINK_TEXT, "click me")
assert len(elements) == 2
def test_should_find_element_by_link_text_containing_equals_sign(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.LINK_TEXT, "Link=equalssign")
assert element.get_attribute("id") == "linkWithEqualsSign"
def test_should_find_multiple_elements_by_link_text_containing_equals_sign(driver, pages):
pages.load("xhtmlTest.html")
elements = driver.find_elements(By.LINK_TEXT, "Link=equalssign")
assert 1 == len(elements)
assert elements[0].get_attribute("id") == "linkWithEqualsSign"
def test_finds_by_link_text_on_xhtml_page(driver, pages):
pages.load("actualXhtmlPage.xhtml")
link_Text = "Foo"
element = driver.find_element(By.LINK_TEXT, link_Text)
assert element.text == link_Text
def test_link_with_formatting_tags(driver, pages):
pages.load("simpleTest.html")
elem = driver.find_element(By.ID, "links")
res = elem.find_element(By.PARTIAL_LINK_TEXT, "link with formatting tags")
assert res.text == "link with formatting tags"
@pytest.mark.xfail_safari
def test_driver_can_get_link_by_link_test_ignoring_trailing_whitespace(driver, pages):
pages.load("simpleTest.html")
link = driver.find_element(By.LINK_TEXT, "link with trailing space")
assert link.get_attribute("id") == "linkWithTrailingSpace"
assert link.text == "link with trailing space"
# By.link_Text negative
def test_should_not_be_able_to_locate_by_link_text_asingle_element_that_does_not_exist(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(NoSuchElementException):
driver.find_element(By.LINK_TEXT, "Not here either")
def test_should_not_be_able_to_locate_by_link_text_multiple_elements_that_do_not_exist(driver, pages):
pages.load("xhtmlTest.html")
elements = driver.find_elements(By.LINK_TEXT, "Not here either")
assert len(elements) == 0
# By.partial_Link_Text positive
def test_should_be_able_to_find_multiple_elements_by_partial_link_text(driver, pages):
pages.load("xhtmlTest.html")
elements = driver.find_elements(By.PARTIAL_LINK_TEXT, "ick me")
assert len(elements) == 2
def test_should_be_able_to_find_asingle_element_by_partial_link_text(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.PARTIAL_LINK_TEXT, "anon")
assert "anon" in element.text
def test_should_find_element_by_partial_link_text_containing_equals_sign(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.PARTIAL_LINK_TEXT, "Link=")
assert element.get_attribute("id") == "linkWithEqualsSign"
def test_should_find_multiple_elements_by_partial_link_text_containing_equals_sign(driver, pages):
pages.load("xhtmlTest.html")
elements = driver.find_elements(By.PARTIAL_LINK_TEXT, "Link=")
assert len(elements) == 1
assert elements[0].get_attribute("id") == "linkWithEqualsSign"
# Misc tests
def test_driver_should_be_able_to_find_elements_after_loading_more_than_one_page_at_atime(driver, pages):
pages.load("formPage.html")
pages.load("xhtmlTest.html")
link = driver.find_element(By.LINK_TEXT, "click me")
assert link.text == "click me"
# You don't want to ask why this is here
def test_when_finding_by_name_should_not_return_by_id(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.NAME, "id-name1")
assert element.get_attribute("value") == "name"
element = driver.find_element(By.ID, "id-name1")
assert element.get_attribute("value") == "id"
element = driver.find_element(By.NAME, "id-name2")
assert element.get_attribute("value") == "name"
element = driver.find_element(By.ID, "id-name2")
assert element.get_attribute("value") == "id"
def test_should_be_able_to_find_ahidden_elements_by_name(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.NAME, "hidden")
assert element.get_attribute("name") == "hidden"
def test_should_not_be_able_to_find_an_element_on_a_blank_page(driver, pages):
driver.get("about:blank")
with pytest.raises(NoSuchElementException):
driver.find_element(By.TAG_NAME, "a")
selenium-selenium-4.18.1/test/selenium/webdriver/common/rendered_webelement_tests.py 0000644 0001750 0001750 00000004701 14564764517 031026 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.common.by import By
from selenium.webdriver.support.color import Color
def test_should_pick_up_style_of_an_element(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="green-parent")
backgroundColour = Color.from_string(element.value_of_css_property("background-color"))
assert Color.from_string("rgba(0, 128, 0, 1)") == backgroundColour
element = driver.find_element(by=By.ID, value="red-item")
backgroundColour = Color.from_string(element.value_of_css_property("background-color"))
assert Color.from_string("rgba(255, 0, 0, 1)") == backgroundColour
def test_should_allow_inherited_styles_to_be_used(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="green-item")
backgroundColour = Color.from_string(element.value_of_css_property("background-color"))
assert backgroundColour == Color.from_string("transparent")
def test_should_correctly_identify_that_an_element_has_width(driver, pages):
pages.load("xhtmlTest.html")
shrinko = driver.find_element(by=By.ID, value="linkId")
size = shrinko.size
assert size["width"] > 0
assert size["height"] > 0
@pytest.mark.xfail_safari(reason="Get Element Rect command not implemented", raises=WebDriverException)
def test_should_be_able_to_determine_the_rect_of_an_element(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.ID, "username")
rect = element.rect
assert rect["x"] > 0
assert rect["y"] > 0
assert rect["width"] > 0
assert rect["height"] > 0
selenium-selenium-4.18.1/test/selenium/webdriver/common/upload_tests.py 0000644 0001750 0001750 00000005505 14564764517 026316 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import os
import pytest
from selenium.webdriver.common.by import By
from selenium.webdriver.remote.webelement import WebElement
@pytest.fixture
def get_local_path():
current_dir = os.path.dirname(os.path.realpath(__file__))
def wrapped(filename):
return os.path.join(current_dir, filename)
return wrapped
def test_can_upload_file(driver, pages, get_local_path):
pages.load("upload.html")
driver.find_element(By.ID, "upload").send_keys(get_local_path("test_file.txt"))
driver.find_element(By.ID, "go").click()
driver.switch_to.frame(driver.find_element(By.ID, "upload_target"))
body = driver.find_element(By.CSS_SELECTOR, "body").text
assert "test_file.txt" in body
def test_can_upload_two_files(driver, pages, get_local_path):
pages.load("upload.html")
two_file_paths = get_local_path("test_file.txt") + "\n" + get_local_path("test_file2.txt")
driver.find_element(By.ID, "upload").send_keys(two_file_paths)
driver.find_element(By.ID, "go").click()
driver.switch_to.frame(driver.find_element(By.ID, "upload_target"))
body = driver.find_element(By.CSS_SELECTOR, "body").text
assert "test_file.txt" in body
assert "test_file2.txt" in body
@pytest.mark.xfail_firefox
@pytest.mark.xfail_chrome
@pytest.mark.xfail_safari
def test_file_is_uploaded_to_remote_machine_on_select(driver, pages, get_local_path):
uploaded_files = []
original_upload_func = WebElement._upload
def mocked_upload_func(self, filename):
uploaded_files.append(filename)
return original_upload_func(self, filename)
WebElement._upload = mocked_upload_func
try:
pages.load("upload.html")
two_file_paths = get_local_path("test_file.txt") + "\n" + get_local_path("test_file2.txt")
driver.find_element(By.ID, "upload").send_keys(two_file_paths)
assert len(uploaded_files) == 2
assert uploaded_files[0] == get_local_path("test_file.txt")
assert uploaded_files[1] == get_local_path("test_file2.txt")
finally:
WebElement._upload = original_upload_func
selenium-selenium-4.18.1/test/selenium/webdriver/common/frame_switching_tests.py 0000644 0001750 0001750 00000044224 14564764517 030204 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import NoSuchFrameException
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
# ----------------------------------------------------------------------------------------------
#
# Tests that WebDriver doesn't do anything fishy when it navigates to a page with frames.
#
# ----------------------------------------------------------------------------------------------
@pytest.fixture(autouse=True)
def restore_default_context(driver):
yield
driver.switch_to.default_content()
def test_should_always_focus_on_the_top_most_frame_after_anavigation_event(driver, pages):
pages.load("frameset.html")
driver.find_element(By.TAG_NAME, "frameset") # Test passes if this does not throw.
def test_should_not_automatically_switch_focus_to_an_iframe_when_apage_containing_them_is_loaded(driver, pages):
pages.load("iframes.html")
driver.find_element(By.ID, "iframe_page_heading")
def test_should_open_page_with_broken_frameset(driver, pages):
pages.load("framesetPage3.html")
frame1 = driver.find_element(By.ID, "first")
driver.switch_to.frame(frame1)
driver.switch_to.default_content()
frame2 = driver.find_element(By.ID, "second")
driver.switch_to.frame(frame2) # IE9 can not switch to this broken frame - it has no window.
# ----------------------------------------------------------------------------------------------
#
# Tests that WebDriver can switch to frames as expected.
#
# ----------------------------------------------------------------------------------------------
def test_should_be_able_to_switch_to_aframe_by_its_index(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame(1)
assert driver.find_element(By.ID, "pageNumber").text == "2"
def test_should_be_able_to_switch_to_an_iframe_by_its_index(driver, pages):
pages.load("iframes.html")
driver.switch_to.frame(0)
assert driver.find_element(By.NAME, "id-name1").get_attribute("value") == "name"
def test_should_be_able_to_switch_to_aframe_by_its_name(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame("fourth")
assert driver.find_element(By.TAG_NAME, "frame").get_attribute("name") == "child1"
def test_should_be_able_to_switch_to_an_iframe_by_its_name(driver, pages):
pages.load("iframes.html")
driver.switch_to.frame("iframe1-name")
assert driver.find_element(By.NAME, "id-name1").get_attribute("value") == "name"
def test_should_be_able_to_switch_to_aframe_by_its_id(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame("fifth")
assert driver.find_element(By.NAME, "windowOne").text == "Open new window"
def test_should_be_able_to_switch_to_an_iframe_by_its_id(driver, pages):
pages.load("iframes.html")
driver.switch_to.frame("iframe1")
assert driver.find_element(By.NAME, "id-name1").get_attribute("value") == "name"
def test_should_be_able_to_switch_to_frame_with_name_containing_dot(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame("sixth.iframe1")
assert "Page number 3" in driver.find_element(By.TAG_NAME, "body").text
def test_should_be_able_to_switch_to_aframe_using_apreviously_located_web_element(driver, pages):
pages.load("frameset.html")
frame = driver.find_element(By.TAG_NAME, "frame")
driver.switch_to.frame(frame)
assert driver.find_element(By.ID, "pageNumber").text == "1"
def test_should_be_able_to_switch_to_an_iframe_using_apreviously_located_web_element(driver, pages):
pages.load("iframes.html")
frame = driver.find_element(By.TAG_NAME, "iframe")
driver.switch_to.frame(frame)
element = driver.find_element(By.NAME, "id-name1")
assert element.get_attribute("value") == "name"
def test_should_ensure_element_is_aframe_before_switching(driver, pages):
pages.load("frameset.html")
frame = driver.find_element(By.TAG_NAME, "frameset")
with pytest.raises(NoSuchFrameException):
driver.switch_to.frame(frame)
def test_frame_searches_should_be_relative_to_the_currently_selected_frame(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame("second")
assert driver.find_element(By.ID, "pageNumber").text == "2"
with pytest.raises(NoSuchElementException):
driver.switch_to.frame(driver.find_element(By.NAME, "third"))
driver.switch_to.default_content()
driver.switch_to.frame(driver.find_element(By.NAME, "third"))
with pytest.raises(NoSuchFrameException):
driver.switch_to.frame("second")
driver.switch_to.default_content()
driver.switch_to.frame(driver.find_element(By.NAME, "second"))
assert driver.find_element(By.ID, "pageNumber").text == "2"
def test_should_select_child_frames_by_chained_calls(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame(driver.find_element(By.NAME, "fourth"))
driver.switch_to.frame(driver.find_element(By.NAME, "child2"))
assert driver.find_element(By.ID, "pageNumber").text == "11"
def test_should_throw_frame_not_found_exception_looking_up_sub_frames_with_super_frame_names(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame(driver.find_element(By.NAME, "fourth"))
with pytest.raises(NoSuchElementException):
driver.switch_to.frame(driver.find_element(By.NAME, "second"))
def test_should_throw_an_exception_when_aframe_cannot_be_found(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(NoSuchElementException):
driver.switch_to.frame(driver.find_element(By.NAME, "Nothing here"))
def test_should_throw_an_exception_when_aframe_cannot_be_found_by_index(driver, pages):
pages.load("xhtmlTest.html")
with pytest.raises(NoSuchFrameException):
driver.switch_to.frame(27)
def test_should_be_able_to_switch_to_parent_frame(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame(driver.find_element(By.NAME, "fourth"))
driver.switch_to.parent_frame()
driver.switch_to.frame(driver.find_element(By.NAME, "first"))
assert driver.find_element(By.ID, "pageNumber").text == "1"
@pytest.mark.xfail_safari
def test_should_be_able_to_switch_to_parent_frame_from_asecond_level_frame(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame(driver.find_element(By.NAME, "fourth"))
driver.switch_to.frame(driver.find_element(By.NAME, "child1"))
driver.switch_to.parent_frame()
driver.switch_to.frame(driver.find_element(By.NAME, "child2"))
assert driver.find_element(By.ID, "pageNumber").text == "11"
def test_switching_to_parent_frame_from_default_context_is_no_op(driver, pages):
pages.load("xhtmlTest.html")
driver.switch_to.parent_frame()
assert driver.title == "XHTML Test Page"
def test_should_be_able_to_switch_to_parent_from_an_iframe(driver, pages):
pages.load("iframes.html")
driver.switch_to.frame(0)
driver.switch_to.parent_frame()
driver.find_element(By.ID, "iframe_page_heading")
# ----------------------------------------------------------------------------------------------
#
# General frame handling behavior tests
#
# ----------------------------------------------------------------------------------------------
def test_should_continue_to_refer_to_the_same_frame_once_it_has_been_selected(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame(2)
checkbox = driver.find_element(By.XPATH, "//input[@name='checky']")
checkbox.click()
checkbox.submit()
# TODO(simon): this should not be needed, and is only here because IE's submit returns too
# soon.
WebDriverWait(driver, 3).until(EC.text_to_be_present_in_element((By.XPATH, "//p"), "Success!"))
@pytest.mark.xfail_firefox(raises=WebDriverException, reason="https://github.com/mozilla/geckodriver/issues/610")
@pytest.mark.xfail_remote(raises=WebDriverException, reason="https://github.com/mozilla/geckodriver/issues/610")
@pytest.mark.xfail_safari
@pytest.mark.xfail_chrome
def test_should_focus_on_the_replacement_when_aframe_follows_alink_to_a_top_targeted_page(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame(0)
driver.find_element(By.LINK_TEXT, "top").click()
expectedTitle = "XHTML Test Page"
WebDriverWait(driver, 3).until(EC.title_is(expectedTitle))
WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.ID, "only-exists-on-xhtmltest")))
def test_should_allow_auser_to_switch_from_an_iframe_back_to_the_main_content_of_the_page(driver, pages):
pages.load("iframes.html")
driver.switch_to.frame(0)
driver.switch_to.default_content()
driver.find_element(By.ID, "iframe_page_heading")
def test_should_allow_the_user_to_switch_to_an_iframe_and_remain_focused_on_it(driver, pages):
pages.load("iframes.html")
driver.switch_to.frame(0)
driver.find_element(By.ID, "submitButton").click()
assert get_text_of_greeting_element(driver) == "Success!"
def get_text_of_greeting_element(driver):
return WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.ID, "greeting"))).text
def test_should_be_able_to_click_in_aframe(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame("third")
# This should replace frame "third" ...
driver.find_element(By.ID, "submitButton").click()
# driver should still be focused on frame "third" ...
assert get_text_of_greeting_element(driver) == "Success!"
# Make sure it was really frame "third" which was replaced ...
driver.switch_to.default_content()
driver.switch_to.frame("third")
assert get_text_of_greeting_element(driver) == "Success!"
def test_should_be_able_to_click_in_aframe_that_rewrites_top_window_location(driver, pages):
pages.load("click_tests/issue5237.html")
driver.switch_to.frame(driver.find_element(By.ID, "search"))
driver.find_element(By.ID, "submit").click()
driver.switch_to.default_content()
WebDriverWait(driver, 3).until(EC.title_is("Target page for issue 5237"))
def test_should_be_able_to_click_in_asub_frame(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame(driver.find_element(By.ID, "sixth"))
driver.switch_to.frame(driver.find_element(By.ID, "iframe1"))
# This should replace frame "iframe1" inside frame "sixth" ...
driver.find_element(By.ID, "submitButton").click()
# driver should still be focused on frame "iframe1" inside frame "sixth" ...
assert get_text_of_greeting_element(driver), "Success!"
# Make sure it was really frame "iframe1" inside frame "sixth" which was replaced ...
driver.switch_to.default_content()
driver.switch_to.frame(driver.find_element(By.ID, "sixth"))
driver.switch_to.frame(driver.find_element(By.ID, "iframe1"))
assert driver.find_element(By.ID, "greeting").text == "Success!"
def test_should_be_able_to_find_elements_in_iframes_by_xpath(driver, pages):
pages.load("iframes.html")
driver.switch_to.frame(driver.find_element(By.ID, "iframe1"))
element = driver.find_element(By.XPATH, "//*[@id = 'changeme']")
assert element is not None
def test_get_current_url_returns_top_level_browsing_context_url(driver, pages):
pages.load("frameset.html")
assert "frameset.html" in driver.current_url
driver.switch_to.frame(driver.find_element(By.NAME, "second"))
assert "frameset.html" in driver.current_url
def test_get_current_url_returns_top_level_browsing_context_url_for_iframes(driver, pages):
pages.load("iframes.html")
assert "iframes.html" in driver.current_url
driver.switch_to.frame(driver.find_element(By.ID, "iframe1"))
assert "iframes.html" in driver.current_url
def test_should_be_able_to_switch_to_the_top_if_the_frame_is_deleted_from_under_us(driver, pages):
pages.load("frame_switching_tests/deletingFrame.html")
driver.switch_to.frame(driver.find_element(By.ID, "iframe1"))
killIframe = driver.find_element(By.ID, "killIframe")
killIframe.click()
driver.switch_to.default_content()
WebDriverWait(driver, 3).until_not(EC.presence_of_element_located((By.ID, "iframe1")))
addIFrame = driver.find_element(By.ID, "addBackFrame")
addIFrame.click()
WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.ID, "iframe1")))
driver.switch_to.frame(driver.find_element(By.ID, "iframe1"))
WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.ID, "success")))
def test_should_be_able_to_switch_to_the_top_if_the_frame_is_deleted_from_under_us_with_frame_index(driver, pages):
pages.load("frame_switching_tests/deletingFrame.html")
iframe = 0
WebDriverWait(driver, 3).until(EC.frame_to_be_available_and_switch_to_it(iframe))
# we should be in the frame now
killIframe = driver.find_element(By.ID, "killIframe")
killIframe.click()
driver.switch_to.default_content()
addIFrame = driver.find_element(By.ID, "addBackFrame")
addIFrame.click()
WebDriverWait(driver, 3).until(EC.frame_to_be_available_and_switch_to_it(iframe))
WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.ID, "success")))
def test_frame_to_be_available_and_switch_to_it_using_string_inputs(driver, pages):
# Similar to above test, but using `iframe = "iframe1"` instead of `iframe = 0`
pages.load("frame_switching_tests/deletingFrame.html")
iframe = "iframe1"
WebDriverWait(driver, 3).until(EC.frame_to_be_available_and_switch_to_it(iframe))
# we should be in the frame now
killIframe = driver.find_element(By.ID, "killIframe")
killIframe.click()
driver.switch_to.default_content()
addIFrame = driver.find_element(By.ID, "addBackFrame")
addIFrame.click()
WebDriverWait(driver, 3).until(EC.frame_to_be_available_and_switch_to_it(iframe))
WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.ID, "success")))
def test_should_be_able_to_switch_to_the_top_if_the_frame_is_deleted_from_under_us_with_webelement(driver, pages):
pages.load("frame_switching_tests/deletingFrame.html")
iframe = driver.find_element(By.ID, "iframe1")
WebDriverWait(driver, 3).until(EC.frame_to_be_available_and_switch_to_it(iframe))
# we should be in the frame now
killIframe = driver.find_element(By.ID, "killIframe")
killIframe.click()
driver.switch_to.default_content()
addIFrame = driver.find_element(By.ID, "addBackFrame")
addIFrame.click()
iframe = driver.find_element(By.ID, "iframe1")
WebDriverWait(driver, 3).until(EC.frame_to_be_available_and_switch_to_it(iframe))
WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.ID, "success")))
# @pytest.mark.xfail_chrome(raises=NoSuchElementException)
# @pytest.mark.xfail_chromiumedge(raises=NoSuchElementException)
# @pytest.mark.xfail_firefox(raises=WebDriverException,
# reason='https://github.com/mozilla/geckodriver/issues/614')
# @pytest.mark.xfail_remote(raises=WebDriverException,
# reason='https://github.com/mozilla/geckodriver/issues/614')
# @pytest.mark.xfail_webkitgtk(raises=NoSuchElementException)
# @pytest.mark.xfail_safari
# def test_should_not_be_able_to_do_anything_the_frame_is_deleted_from_under_us(driver, pages):
# pages.load("frame_switching_tests/deletingFrame.html")
# driver.switch_to.frame(driver.find_element(By.ID, "iframe1"))
# killIframe = driver.find_element(By.ID, "killIframe")
# killIframe.click()
# with pytest.raises(NoSuchFrameException):
# driver.find_element(By.ID, "killIframe").click()
def test_should_return_window_title_in_aframeset(driver, pages):
pages.load("frameset.html")
driver.switch_to.frame(driver.find_element(By.NAME, "third"))
assert "Unique title" == driver.title
def test_java_script_should_execute_in_the_context_of_the_current_frame(driver, pages):
pages.load("frameset.html")
assert driver.execute_script("return window == window.top")
driver.switch_to.frame(driver.find_element(By.NAME, "third"))
assert driver.execute_script("return window != window.top")
@pytest.mark.xfail_chrome(reason="Fails on Travis")
@pytest.mark.xfail_safari
def test_should_not_switch_magically_to_the_top_window(driver, pages):
pages.load("frame_switching_tests/bug4876.html")
driver.switch_to.frame(0)
WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.ID, "inputText")))
for i in range(20):
try:
input = WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.ID, "inputText")))
submit = WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.ID, "submitButton")))
input.clear()
import random
input.send_keys("rand%s" % int(random.random()))
submit.click()
finally:
url = driver.execute_script("return window.location.href")
# IE6 and Chrome add "?"-symbol to the end of the URL
if url.endswith("?"):
url = url[: len(url) - 1]
assert pages.url("frame_switching_tests/bug4876_iframe.html") == url
def test_get_should_switch_to_default_context(driver, pages):
pages.load("iframes.html")
driver.find_element(By.ID, "iframe1")
driver.switch_to.frame(driver.find_element(By.ID, "iframe1"))
driver.find_element(By.ID, "cheese") # Found on formPage.html but not on iframes.html.
pages.load("iframes.html") # This must effectively switch_to.default_content(), too.
driver.find_element(By.ID, "iframe1")
selenium-selenium-4.18.1/test/selenium/webdriver/common/form_handling_tests.py 0000644 0001750 0001750 00000017543 14564764517 027646 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
def test_should_click_on_submit_input_elements(driver, pages):
pages.load("formPage.html")
driver.find_element(By.ID, "submitButton").click()
WebDriverWait(driver, 3).until(EC.title_is("We Arrive Here"))
def test_clicking_on_unclickable_elements_does_nothing(driver, pages):
pages.load("formPage.html")
driver.find_element(By.XPATH, "//body").click()
def test_should_be_able_to_click_image_buttons(driver, pages):
pages.load("formPage.html")
driver.find_element(By.ID, "imageButton").click()
WebDriverWait(driver, 3).until(EC.title_is("We Arrive Here"))
def test_should_submit_input_in_form(driver, pages):
pages.load("formPage.html")
driver.find_element(By.NAME, "login").submit()
WebDriverWait(driver, 3).until(EC.title_is("We Arrive Here"))
def test_should_submit_any_input_element_within_form(driver, pages):
pages.load("formPage.html")
driver.find_element(By.ID, "checky").submit()
WebDriverWait(driver, 3).until(EC.title_is("We Arrive Here"))
def test_should_submit_any_element_within_form(driver, pages):
pages.load("formPage.html")
driver.find_element(By.XPATH, "//form/p").submit()
WebDriverWait(driver, 5).until(EC.title_is("We Arrive Here"))
def test_should_submit_element_with_id_submit(driver, pages):
pages.load("formPage.html")
driver.find_element(By.ID, "submit").submit()
WebDriverWait(driver, 5).until(EC.title_is("We Arrive Here"))
def test_should_submit_element_with_name_submit(driver, pages):
pages.load("formPage.html")
driver.find_element(By.NAME, "submit").submit()
WebDriverWait(driver, 5).until(EC.title_is("We Arrive Here"))
def test_should_not_submit_button_outside_form(driver, pages):
pages.load("formPage.html")
with pytest.raises(WebDriverException):
driver.find_element(By.NAME, "SearchableText").submit()
def test_should_be_able_to_enter_text_into_atext_area_by_setting_its_value(driver, pages):
pages.load("javascriptPage.html")
textarea = driver.find_element(By.ID, "keyUpArea")
cheesey = "Brie and cheddar"
textarea.send_keys(cheesey)
assert textarea.get_attribute("value") == cheesey
def test_should_enter_data_into_form_fields(driver, pages):
pages.load("xhtmlTest.html")
element = driver.find_element(By.XPATH, "//form[@name='someForm']/input[@id='username']")
originalValue = element.get_attribute("value")
assert originalValue == "change"
element.clear()
element.send_keys("some text")
element = driver.find_element(By.XPATH, "//form[@name='someForm']/input[@id='username']")
newFormValue = element.get_attribute("value")
assert newFormValue == "some text"
def test_should_be_able_to_select_acheck_box(driver, pages):
pages.load("formPage.html")
checkbox = driver.find_element(By.ID, "checky")
assert checkbox.is_selected() is False
checkbox.click()
assert checkbox.is_selected() is True
checkbox.click()
assert checkbox.is_selected() is False
def test_should_toggle_the_checked_state_of_acheckbox(driver, pages):
pages.load("formPage.html")
checkbox = driver.find_element(By.ID, "checky")
assert checkbox.is_selected() is False
checkbox.click()
assert checkbox.is_selected() is True
checkbox.click()
assert checkbox.is_selected() is False
def test_toggling_acheckbox_should_return_its_current_state(driver, pages):
pages.load("formPage.html")
checkbox = driver.find_element(By.ID, "checky")
assert checkbox.is_selected() is False
checkbox.click()
assert checkbox.is_selected() is True
checkbox.click()
assert checkbox.is_selected() is False
def test_should_be_able_to_select_aradio_button(driver, pages):
pages.load("formPage.html")
radioButton = driver.find_element(By.ID, "peas")
assert radioButton.is_selected() is False
radioButton.click()
assert radioButton.is_selected() is True
def test_should_be_able_to_select_aradio_button_by_clicking_on_it(driver, pages):
pages.load("formPage.html")
radioButton = driver.find_element(By.ID, "peas")
assert radioButton.is_selected() is False
radioButton.click()
assert radioButton.is_selected() is True
def test_should_return_state_of_radio_buttons_before_interaction(driver, pages):
pages.load("formPage.html")
radioButton = driver.find_element(By.ID, "cheese_and_peas")
assert radioButton.is_selected() is True
radioButton = driver.find_element(By.ID, "cheese")
assert radioButton.is_selected() is False
def test_toggling_an_option_should_toggle_options_in_amulti_select(driver, pages):
pages.load("formPage.html")
select = driver.find_element(By.NAME, "multi")
option = select.find_elements(By.TAG_NAME, "option")[0]
selected = option.is_selected()
option.click()
assert not selected == option.is_selected()
option.click()
assert selected == option.is_selected()
def test_should_throw_an_exception_when_selecting_an_unselectable_element(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.XPATH, "//title")
with pytest.raises(WebDriverException):
element.click()
def test_sending_keyboard_events_should_append_text_in_inputs(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.ID, "working")
element.send_keys("Some")
value = element.get_attribute("value")
assert value == "Some"
element.send_keys(" text")
value = element.get_attribute("value")
assert value == "Some text"
def test_should_be_able_to_clear_text_from_input_elements(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.ID, "working")
element.send_keys("Some text")
value = element.get_attribute("value")
assert len(value) > 0
element.clear()
value = element.get_attribute("value")
assert len(value) == 0
def test_empty_text_boxes_should_return_an_empty_string_not_null(driver, pages):
pages.load("formPage.html")
emptyTextBox = driver.find_element(By.ID, "working")
assert emptyTextBox.get_attribute("value") == ""
emptyTextArea = driver.find_element(By.ID, "emptyTextArea")
assert emptyTextArea.get_attribute("value") == ""
def test_should_be_able_to_clear_text_from_text_areas(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.ID, "withText")
element.send_keys("Some text")
value = element.get_attribute("value")
assert len(value) > 0
element.clear()
value = element.get_attribute("value")
assert len(value) == 0
def test_radio_should_not_be_selected_after_selecting_sibling(driver, pages):
pages.load("formPage.html")
cheese = driver.find_element(By.ID, "cheese")
peas = driver.find_element(By.ID, "peas")
cheese.click()
assert cheese.is_selected() is True
assert peas.is_selected() is False
peas.click()
assert cheese.is_selected() is False
assert peas.is_selected() is True
selenium-selenium-4.18.1/test/selenium/webdriver/common/cookie_tests.py 0000644 0001750 0001750 00000011775 14564764517 026311 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import calendar
import random
import time
import pytest
@pytest.fixture
def cookie(webserver):
cookie = {"name": "foo", "value": "bar", "domain": webserver.host, "path": "/", "secure": False}
return cookie
@pytest.fixture
def same_site_cookie_strict(webserver):
same_site_cookie_strict = {
"name": "foo",
"value": "bar",
"path": "/",
"domain": webserver.host,
"sameSite": "Strict",
"secure": False,
}
return same_site_cookie_strict
@pytest.fixture
def same_site_cookie_lax(webserver):
same_site_cookie_lax = {
"name": "foo",
"value": "bar",
"path": "/",
"domain": webserver.host,
"sameSite": "Lax",
"secure": False,
}
return same_site_cookie_lax
@pytest.fixture
def same_site_cookie_none(webserver):
same_site_cookie_none = {
"name": "foo",
"value": "bar",
"path": "/",
"domain": webserver.host,
"sameSite": "None",
"secure": True,
}
return same_site_cookie_none
@pytest.fixture(autouse=True)
def pages(request, driver, pages):
pages.load("simpleTest.html")
yield pages
driver.delete_all_cookies()
def test_add_cookie(cookie, driver):
driver.add_cookie(cookie)
returned = driver.execute_script("return document.cookie")
assert cookie["name"] in returned
@pytest.mark.xfail_firefox(reason="sameSite cookie attribute not implemented")
@pytest.mark.xfail_remote(reason="sameSite cookie attribute not implemented")
@pytest.mark.xfail_safari
def test_add_cookie_same_site_strict(same_site_cookie_strict, driver):
driver.add_cookie(same_site_cookie_strict)
returned = driver.get_cookie("foo")
assert "sameSite" in returned and returned["sameSite"] == "Strict"
@pytest.mark.xfail_firefox(reason="sameSite cookie attribute not implemented")
@pytest.mark.xfail_remote(reason="sameSite cookie attribute not implemented")
@pytest.mark.xfail_safari
def test_add_cookie_same_site_lax(same_site_cookie_lax, driver):
driver.add_cookie(same_site_cookie_lax)
returned = driver.get_cookie("foo")
assert "sameSite" in returned and returned["sameSite"] == "Lax"
@pytest.mark.xfail_firefox(reason="sameSite cookie attribute not implemented")
@pytest.mark.xfail_remote(reason="sameSite cookie attribute not implemented")
@pytest.mark.xfail_safari
def test_add_cookie_same_site_none(same_site_cookie_none, driver):
driver.add_cookie(same_site_cookie_none)
# Note that insecure sites (http:) can't set cookies with the Secure directive.
# driver.get_cookie would return None
@pytest.mark.xfail_ie
@pytest.mark.xfail_safari
def test_adding_acookie_that_expired_in_the_past(cookie, driver):
expired = cookie.copy()
expired["expiry"] = calendar.timegm(time.gmtime()) - 1
driver.add_cookie(expired)
assert 0 == len(driver.get_cookies())
def test_delete_all_cookie(cookie, driver):
driver.add_cookie(cookie)
driver.delete_all_cookies()
assert not driver.get_cookies()
def test_delete_cookie(cookie, driver):
driver.add_cookie(cookie)
driver.delete_cookie("foo")
assert not driver.get_cookies()
def test_should_get_cookie_by_name(driver):
key = f"key_{int(random.random() * 10000000)}"
driver.execute_script("document.cookie = arguments[0] + '=set';", key)
cookie = driver.get_cookie(key)
assert "set" == cookie["value"]
def test_should_return_none_when_cookie_does_not_exist(driver):
key = f"key_{int(random.random() * 10000000)}"
cookie = driver.get_cookie(key)
assert cookie is None
def test_get_all_cookies(cookie, driver, pages, webserver):
cookies = driver.get_cookies()
count = len(cookies)
for i in range(2):
cookie["name"] = f"key_{int(random.random() * 10000000)}"
driver.add_cookie(cookie)
pages.load("simpleTest.html")
assert count + 2 == len(driver.get_cookies())
def test_should_not_delete_cookies_with_asimilar_name(cookie, driver, webserver):
cookie2 = cookie.copy()
cookie2["name"] = "{}x".format(cookie["name"])
driver.add_cookie(cookie)
driver.add_cookie(cookie2)
driver.delete_cookie(cookie["name"])
cookies = driver.get_cookies()
assert cookie["name"] != cookies[0]["name"]
assert cookie2["name"] == cookies[0]["name"]
selenium-selenium-4.18.1/test/selenium/webdriver/common/page_loader.py 0000644 0001750 0001750 00000002574 14564764517 026055 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
"""This module contains some decorators that can be used to support
the page models. For example for an action that needs a page to be fully
loaded, the @require_loaded decorator will make sure the page is loaded
before the call is invoked.
This pattern is also useful for waiting for certain asynchronous events
to happen before executing certain actions."""
def require_loaded(func):
def load_page(page, *params, **kwds):
if not page.is_loaded():
page.load()
assert page.is_loaded(), "page should be loaded by now"
return func(page, *params, **kwds)
return load_page
selenium-selenium-4.18.1/test/selenium/webdriver/common/page_loading_tests.py 0000644 0001750 0001750 00000011577 14564764517 027451 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# import pytest
#
# from selenium.common.exceptions import WebDriverException
# from selenium.webdriver.common.by import By
# from selenium.webdriver.support.wait import WebDriverWait
# from selenium.webdriver.support import expected_conditions as EC
def test_should_wait_for_document_to_be_loaded(driver, pages):
pages.load("simpleTest.html")
assert driver.title == "Hello WebDriver"
# Disabled till Java WebServer is used
# def test_should_follow_redirects_sent_in_the_http_response_headers(driver, pages):
# pages.load("redirect.html")
# assert driver.title == "We Arrive Here"
# Disabled till the Java WebServer is used
# def test_should_follow_meta_redirects(driver, pages):
# pages.load("metaRedirect.html")
# assert driver.title == "We Arrive Here"
# def test_should_be_able_to_get_afragment_on_the_current_page(driver, pages):
# pages.load("xhtmlTest.html")
# location = driver.current_url
# driver.get(location + "#text")
# driver.find_element(by=By.ID, value="id1")
# @pytest.mark.xfail_firefox(raises=WebDriverException)
# @pytest.mark.xfail_remote(raises=WebDriverException)
# def test_should_return_when_getting_aurl_that_does_not_resolve(driver):
# # Of course, we're up the creek if this ever does get registered
# driver.get("http://www.thisurldoesnotexist.comx/")
# @pytest.mark.xfail_firefox(raises=WebDriverException)
# @pytest.mark.xfail_remote(raises=WebDriverException)
# def test_should_return_when_getting_aurl_that_does_not_connect(driver):
# # Here's hoping that there's nothing here. There shouldn't be
# driver.get("http://localhost:3001")
# def test_should_be_able_to_load_apage_with_framesets_and_wait_until_all_frames_are_loaded() {
# driver.get(pages.framesetPage)
#
# driver.switchTo().frame(0)
# WebElement pageNumber = driver.findElement(By.xpath("#span[@id='pageNumber']"))
# self.assertEqual((pageNumber.getText().trim(), equalTo("1"))
#
# driver.switchTo().defaultContent().switchTo().frame(1)
# pageNumber = driver.findElement(By.xpath("#span[@id='pageNumber']"))
# self.assertEqual((pageNumber.getText().trim(), equalTo("2"))
# Need to implement this decorator
# @NeedsFreshDriver
# def test_sould_do_nothing_if_there_is_nothing_to_go_back_to() {
# originalTitle = driver.getTitle();
# driver.get(pages.formPage);
# driver.back();
# # We may have returned to the browser's home page
# self.assertEqual(driver.title, anyOf(equalTo(originalTitle), equalTo("We Leave From Here")));
# @pytest.mark.xfail_safari
# def test_should_be_able_to_navigate_back_in_the_browser_history(driver, pages):
# pages.load("formPage.html")
# driver.find_element(by=By.ID, value="imageButton").submit()
# WebDriverWait(driver, 3).until(EC.title_is("We Arrive Here"))
# driver.back()
# assert driver.title == "We Leave From Here"
# @pytest.mark.xfail_safari
# def test_should_be_able_to_navigate_back_in_the_browser_history_in_presence_of_iframes(driver, pages):
# pages.load("xhtmlTest.html")
# driver.find_element(by=By.NAME, value="sameWindow").click()
# assert driver.title == "This page has iframes"
# driver.back()
# assert driver.title == "XHTML Test Page"
# def test_should_be_able_to_navigate_forwards_in_the_browser_history(driver, pages):
# pages.load("formPage.html")
# driver.find_element(by=By.ID, value="imageButton").submit()
# WebDriverWait(driver, 3).until(EC.title_is("We Arrive Here"))
# driver.back()
# assert driver.title == "We Leave From Here"
# driver.forward()
# assert driver.title == "We Arrive Here"
# @pytest.mark.xfail_ie
# @pytest.mark.xfail_firefox(run=False)
# @pytest.mark.xfail_remote(run=False)
# @pytest.mark.xfail_chrome(run=False)
# @pytest.mark.xfail_chromiumedge(run=False)
# def test_should_not_hang_if_document_open_call_is_never_followed_by_document_close_call(driver, pages):
# pages.load("document_write_in_onload.html")
# driver.find_element(By.XPATH, "//body")
# def test_should_be_able_to_refresh_apage(driver, pages):
# pages.load("xhtmlTest.html")
# driver.refresh()
# assert driver.title == "XHTML Test Page"
selenium-selenium-4.18.1/test/selenium/webdriver/common/children_finding_tests.py 0000644 0001750 0001750 00000015312 14564764517 030315 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.common.by import By
def test_should_find_element_by_xpath(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "form2")
child = element.find_element(By.XPATH, "select")
assert child.get_attribute("id") == "2"
def test_should_not_find_element_by_xpath(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "form2")
with pytest.raises(NoSuchElementException):
element.find_element(By.XPATH, "select/x")
def test_finding_dot_slash_elements_on_element_by_xpath_should_find_not_top_level_elements(driver, pages):
pages.load("simpleTest.html")
parent = driver.find_element(By.ID, "multiline")
children = parent.find_elements(By.XPATH, "./p")
assert 1 == len(children)
assert "A div containing" == children[0].text
def test_should_find_elements_by_xpath(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "form2")
children = element.find_elements(By.XPATH, "select/option")
assert len(children) == 8
assert children[0].text == "One"
assert children[1].text == "Two"
def test_should_not_find_elements_by_xpath(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "form2")
children = element.find_elements(By.XPATH, "select/x")
assert len(children) == 0
def test_finding_elements_on_element_by_xpath_should_find_top_level_elements(driver, pages):
pages.load("simpleTest.html")
parent = driver.find_element(By.ID, "multiline")
all_para_elements = driver.find_elements(By.XPATH, "//p")
children = parent.find_elements(By.XPATH, "//p")
assert len(all_para_elements) == len(children)
def test_should_find_element_by_name(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "form2")
child = element.find_element(By.NAME, "selectomatic")
assert child.get_attribute("id") == "2"
def test_should_find_elements_by_name(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "form2")
children = element.find_elements(By.NAME, "selectomatic")
assert len(children) == 2
def test_should_find_element_by_id(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "form2")
child = element.find_element(By.ID, "2")
assert child.get_attribute("name") == "selectomatic"
def test_should_find_elements_by_id(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "form2")
child = element.find_elements(By.ID, "2")
assert len(child) == 2
def test_should_find_element_by_id_when_multiple_matches_exist(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.ID, "test_id_div")
child = element.find_element(By.ID, "test_id")
assert child.text == "inside"
def test_should_find_element_by_id_when_no_match_in_context(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.ID, "test_id_div")
with pytest.raises(NoSuchElementException):
element.find_element(By.ID, "test_id_out")
def test_should_find_element_by_link_text(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "div1")
child = element.find_element(By.LINK_TEXT, "hello world")
assert child.get_attribute("name") == "link1"
def test_should_find_elements_by_link_text(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "div1")
children = element.find_elements(By.LINK_TEXT, "hello world")
assert len(children) == 2
assert "link1" == children[0].get_attribute("name")
assert "link2" == children[1].get_attribute("name")
def test_should_find_element_by_class_name(driver, pages):
pages.load("nestedElements.html")
parent = driver.find_element(By.NAME, "classes")
element = parent.find_element(By.CLASS_NAME, "one")
assert "Find me" == element.text
def test_should_find_elements_by_class_name(driver, pages):
pages.load("nestedElements.html")
parent = driver.find_element(By.NAME, "classes")
elements = parent.find_elements(By.CLASS_NAME, "one")
assert 2 == len(elements)
def test_should_find_element_by_tag_name(driver, pages):
pages.load("nestedElements.html")
parent = driver.find_element(By.NAME, "div1")
element = parent.find_element(By.TAG_NAME, "a")
assert "link1" == element.get_attribute("name")
def test_should_find_elements_by_tag_name(driver, pages):
pages.load("nestedElements.html")
parent = driver.find_element(By.NAME, "div1")
elements = parent.find_elements(By.TAG_NAME, "a")
assert 2 == len(elements)
def test_should_be_able_to_find_an_element_by_css_selector(driver, pages):
pages.load("nestedElements.html")
parent = driver.find_element(By.NAME, "form2")
element = parent.find_element(By.CSS_SELECTOR, '*[name="selectomatic"]')
assert "2" == element.get_attribute("id")
def test_should_be_able_to_find_multiple_elements_by_css_selector(driver, pages):
pages.load("nestedElements.html")
parent = driver.find_element(By.NAME, "form2")
elements = parent.find_elements(By.CSS_SELECTOR, '*[name="selectomatic"]')
assert 2 == len(elements)
def test_should_throw_an_error_if_user_passes_in_invalid_by(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "form2")
with pytest.raises(WebDriverException):
element.find_element("foo", "bar")
def test_should_throw_an_error_if_user_passes_in_invalid_by_when_find_elements(driver, pages):
pages.load("nestedElements.html")
element = driver.find_element(By.NAME, "form2")
with pytest.raises(WebDriverException):
element.find_elements("foo", "bar")
selenium-selenium-4.18.1/test/selenium/webdriver/common/correct_event_firing_tests.py 0000644 0001750 0001750 00000011511 14564764517 031224 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.webdriver.common.by import By
@pytest.mark.xfail_safari
def test_should_fire_click_event_when_clicking(driver, pages):
pages.load("javascriptPage.html")
_click_on_element_which_records_events(driver)
_assert_event_fired(driver, "click")
@pytest.mark.xfail_safari
def test_should_fire_mouse_down_event_when_clicking(driver, pages):
pages.load("javascriptPage.html")
_click_on_element_which_records_events(driver)
_assert_event_fired(driver, "mousedown")
@pytest.mark.xfail_safari
def test_should_fire_mouse_up_event_when_clicking(driver, pages):
pages.load("javascriptPage.html")
_click_on_element_which_records_events(driver)
_assert_event_fired(driver, "mouseup")
@pytest.mark.xfail_safari
def test_should_issue_mouse_down_events(driver, pages):
pages.load("javascriptPage.html")
driver.find_element(By.ID, "mousedown").click()
result = driver.find_element(By.ID, "result").text
assert result == "mouse down"
@pytest.mark.xfail_safari
def test_should_issue_click_events(driver, pages):
pages.load("javascriptPage.html")
driver.find_element(By.ID, "mouseclick").click()
result = driver.find_element(By.ID, "result").text
assert result == "mouse click"
@pytest.mark.xfail_safari
def test_should_issue_mouse_up_events(driver, pages):
pages.load("javascriptPage.html")
driver.find_element(By.ID, "mouseup").click()
result = driver.find_element(By.ID, "result").text
assert result == "mouse up"
@pytest.mark.xfail_safari
def test_mouse_events_should_bubble_up_to_containing_elements(driver, pages):
pages.load("javascriptPage.html")
driver.find_element(By.ID, "child").click()
result = driver.find_element(By.ID, "result").text
assert result == "mouse down"
@pytest.mark.xfail_safari
def test_should_emit_on_change_events_when_selecting_elements(driver, pages):
pages.load("javascriptPage.html")
select = driver.find_element(By.ID, "selector")
options = select.find_elements(By.TAG_NAME, "option")
initialTextValue = driver.find_element(By.ID, "result").text
select.click()
assert driver.find_element(By.ID, "result").text == initialTextValue
options[1].click()
assert driver.find_element(By.ID, "result").text == "bar"
@pytest.mark.xfail_safari
def test_should_emit_on_change_events_when_changing_the_state_of_acheckbox(driver, pages):
pages.load("javascriptPage.html")
checkbox = driver.find_element(By.ID, "checkbox")
checkbox.click()
assert driver.find_element(By.ID, "result").text == "checkbox thing"
def test_should_emit_click_event_when_clicking_on_atext_input_element(driver, pages):
pages.load("javascriptPage.html")
clicker = driver.find_element(By.ID, "clickField")
clicker.click()
assert clicker.get_attribute("value") == "Clicked"
@pytest.mark.xfail_safari
def test_clearing_an_element_should_cause_the_on_change_handler_to_fire(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(By.ID, "clearMe")
element.clear()
result = driver.find_element(By.ID, "result")
assert result.text == "Cleared"
# TODO Currently Failing and needs fixing
# def test_sending_keys_to_another_element_should_cause_the_blur_event_to_fire(driver, pages):
# pages.load("javascriptPage.html")
# element = driver.find_element(By.ID, "theworks")
# element.send_keys("foo")
# element2 = driver.find_element(By.ID, "changeable")
# element2.send_keys("bar")
# _assertEventFired(driver, "blur")
# TODO Currently Failing and needs fixing
# def test_sending_keys_to_an_element_should_cause_the_focus_event_to_fire(driver, pages):
# pages.load("javascriptPage.html")
# element = driver.find_element(By.ID, "theworks")
# element.send_keys("foo")
# _assertEventFired(driver, "focus")
def _click_on_element_which_records_events(driver):
driver.find_element(By.ID, "plainButton").click()
def _assert_event_fired(driver, eventName):
result = driver.find_element(By.ID, "result")
text = result.text
assert eventName in text, "No " + eventName + " fired: " + text
selenium-selenium-4.18.1/test/selenium/webdriver/common/select_class_tests.py 0000644 0001750 0001750 00000031445 14564764517 027500 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import NoSuchElementException
from selenium.common.exceptions import UnexpectedTagNameException
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import Select
disabledSelect = {"name": "no-select", "values": ["Foo"]}
disabledSingleSelect = {"name": "single_disabled", "values": ["Enabled", "Disabled"]}
disabledMultiSelect = {"name": "multi_disabled", "values": ["Enabled", "Disabled"]}
singleSelectValues1 = {
"name": "selectomatic",
"values": ["One", "Two", "Four", "Still learning how to count, apparently"],
}
singleSelectValues2 = {"name": "redirect", "values": ["One", "Two"]}
singleSelectValuesWithSpaces = {
"name": "select_with_spaces",
"values": ["One", "Two", "Four", "Still learning how to count, apparently"],
}
multiSelectValues1 = {"name": "multi", "values": ["Eggs", "Ham", "Sausages", "Onion gravy"]}
multiSelectValues2 = {"name": "select_empty_multiple", "values": ["select_1", "select_2", "select_3", "select_4"]}
def test_select_by_index_single(driver, pages):
pages.load("formPage.html")
for select in [singleSelectValues1]:
sel = Select(driver.find_element(By.NAME, select["name"]))
for x in range(len(select["values"])):
sel.select_by_index(x)
assert sel.first_selected_option.text == select["values"][x]
@pytest.mark.xfail_safari(reason="options incorrectly reported as enabled")
def test_raises_exception_select_by_index_single_disabled(driver, pages):
pages.load("formPage.html")
sel = Select(driver.find_element(By.NAME, disabledSingleSelect["name"]))
with pytest.raises(NotImplementedError):
sel.select_by_index(1)
def test_select_by_value_single(driver, pages):
pages.load("formPage.html")
for select in [singleSelectValues1]:
sel = Select(driver.find_element(By.NAME, select["name"]))
for x in range(len(select["values"])):
sel.select_by_value(select["values"][x].lower())
assert sel.first_selected_option.text == select["values"][x]
@pytest.mark.xfail_safari(reason="options incorrectly reported as enabled")
def test_raises_exception_select_by_value_single_disabled(driver, pages):
pages.load("formPage.html")
sel = Select(driver.find_element(By.NAME, disabledSingleSelect["name"]))
with pytest.raises(NotImplementedError):
sel.select_by_value(disabledSingleSelect["values"][1].lower())
def test_select_by_visible_text_single(driver, pages):
pages.load("formPage.html")
for select in [singleSelectValues1]:
sel = Select(driver.find_element(By.NAME, select["name"]))
for x in range(len(select["values"])):
print(select["values"][x])
sel.select_by_visible_text(select["values"][x])
assert sel.first_selected_option.text == select["values"][x]
@pytest.mark.xfail_safari(reason="options incorrectly reported as enabled")
def test_raises_exception_select_by_text_single_disabled(driver, pages):
pages.load("formPage.html")
sel = Select(driver.find_element(By.NAME, disabledSingleSelect["name"]))
with pytest.raises(NotImplementedError):
sel.select_by_visible_text(disabledSingleSelect["values"][1])
def test_select_by_index_multiple(driver, pages):
pages.load("formPage.html")
for select in [multiSelectValues1, multiSelectValues2]:
sel = Select(driver.find_element(By.NAME, select["name"]))
sel.deselect_all()
for x in range(len(select["values"])):
sel.select_by_index(x)
selected = sel.all_selected_options
assert len(selected) == x + 1
for j in range(len(selected)):
assert selected[j].text == select["values"][j]
@pytest.mark.xfail_safari(reason="options incorrectly reported as enabled")
def test_raises_exception_select_by_index_multiple_disabled(driver, pages):
pages.load("formPage.html")
sel = Select(driver.find_element(By.NAME, disabledMultiSelect["name"]))
with pytest.raises(NotImplementedError):
sel.select_by_index(1)
def test_select_by_value_multiple(driver, pages):
pages.load("formPage.html")
for select in [multiSelectValues1, multiSelectValues2]:
sel = Select(driver.find_element(By.NAME, select["name"]))
sel.deselect_all()
for x in range(len(select["values"])):
sel.select_by_value(select["values"][x].lower())
selected = sel.all_selected_options
assert len(selected) == x + 1
for j in range(len(selected)):
assert selected[j].text == select["values"][j]
@pytest.mark.xfail_safari(reason="options incorrectly reported as enabled")
def test_raises_exception_select_by_value_multiple_disabled(driver, pages):
pages.load("formPage.html")
sel = Select(driver.find_element(By.NAME, disabledMultiSelect["name"]))
with pytest.raises(NotImplementedError):
sel.select_by_value(disabledMultiSelect["values"][1].lower())
def test_select_by_visible_text_multiple(driver, pages):
pages.load("formPage.html")
for select in [multiSelectValues1, multiSelectValues2]:
sel = Select(driver.find_element(By.NAME, select["name"]))
sel.deselect_all()
for x in range(len(select["values"])):
sel.select_by_visible_text(select["values"][x])
selected = sel.all_selected_options
assert len(selected) == x + 1
for j in range(len(selected)):
assert selected[j].text == select["values"][j]
@pytest.mark.xfail_safari(reason="options incorrectly reported as enabled")
def test_raises_exception_select_by_text_multiple_disabled(driver, pages):
pages.load("formPage.html")
sel = Select(driver.find_element(By.NAME, disabledMultiSelect["name"]))
with pytest.raises(NotImplementedError):
sel.select_by_visible_text(disabledMultiSelect["values"][1])
def test_deselect_all_single(driver, pages):
pages.load("formPage.html")
for select in [singleSelectValues1, singleSelectValues2]:
with pytest.raises(NotImplementedError):
Select(driver.find_element(By.NAME, select["name"])).deselect_all()
def test_deselect_all_multiple(driver, pages):
pages.load("formPage.html")
for select in [multiSelectValues1, multiSelectValues2]:
sel = Select(driver.find_element(By.NAME, select["name"]))
sel.deselect_all()
assert len(sel.all_selected_options) == 0
def test_deselect_by_index_single(driver, pages):
pages.load("formPage.html")
for select in [singleSelectValues1, singleSelectValues2]:
with pytest.raises(NotImplementedError):
Select(driver.find_element(By.NAME, select["name"])).deselect_by_index(0)
def test_deselect_by_value_single(driver, pages):
pages.load("formPage.html")
for select in [singleSelectValues1, singleSelectValues2]:
with pytest.raises(NotImplementedError):
Select(driver.find_element(By.NAME, select["name"])).deselect_by_value(select["values"][0].lower())
def test_deselect_by_visible_text_single(driver, pages):
pages.load("formPage.html")
for select in [singleSelectValues1, singleSelectValues2]:
with pytest.raises(NotImplementedError):
Select(driver.find_element(By.NAME, select["name"])).deselect_by_visible_text(select["values"][0])
def test_deselect_by_index_multiple(driver, pages):
pages.load("formPage.html")
for select in [multiSelectValues1, multiSelectValues2]:
sel = Select(driver.find_element(By.NAME, select["name"]))
sel.deselect_all()
sel.select_by_index(0)
sel.select_by_index(1)
sel.select_by_index(2)
sel.select_by_index(3)
sel.deselect_by_index(1)
sel.deselect_by_index(3)
selected = sel.all_selected_options
assert len(selected) == 2
assert selected[0].text == select["values"][0]
assert selected[1].text == select["values"][2]
def test_deselect_by_value_multiple(driver, pages):
pages.load("formPage.html")
for select in [multiSelectValues1, multiSelectValues2]:
sel = Select(driver.find_element(By.NAME, select["name"]))
sel.deselect_all()
sel.select_by_index(0)
sel.select_by_index(1)
sel.select_by_index(2)
sel.select_by_index(3)
sel.deselect_by_value(select["values"][1].lower())
sel.deselect_by_value(select["values"][3].lower())
selected = sel.all_selected_options
assert len(selected) == 2
assert selected[0].text == select["values"][0]
assert selected[1].text == select["values"][2]
def test_deselect_by_visible_text_multiple(driver, pages):
pages.load("formPage.html")
for select in [multiSelectValues1, multiSelectValues2]:
sel = Select(driver.find_element(By.NAME, select["name"]))
sel.deselect_all()
sel.select_by_index(0)
sel.select_by_index(1)
sel.select_by_index(2)
sel.select_by_index(3)
sel.deselect_by_visible_text(select["values"][1])
sel.deselect_by_visible_text(select["values"][3])
selected = sel.all_selected_options
assert len(selected) == 2
assert selected[0].text == select["values"][0]
assert selected[1].text == select["values"][2]
def test_get_options(driver, pages):
pages.load("formPage.html")
for select in [singleSelectValues1, singleSelectValues2, multiSelectValues1, multiSelectValues2]:
opts = Select(driver.find_element(By.NAME, select["name"])).options
assert len(opts) == len(select["values"])
for i in range(len(opts)):
assert opts[i].text == select["values"][i]
def test_get_all_selected_options_single(driver, pages):
pages.load("formPage.html")
for select in [singleSelectValues1, singleSelectValues2, disabledSelect]:
opts = Select(driver.find_element(By.NAME, select["name"])).all_selected_options
assert len(opts) == 1
assert opts[0].text == select["values"][0]
def test_get_all_selected_options_multiple(driver, pages):
pages.load("formPage.html")
opts = Select(driver.find_element(By.NAME, multiSelectValues1["name"])).all_selected_options
assert len(opts) == 2
assert opts[0].text, multiSelectValues1["values"][0]
assert opts[1].text, multiSelectValues1["values"][2]
opts = Select(driver.find_element(By.NAME, multiSelectValues2["name"])).all_selected_options
assert len(opts) == 0
def test_get_first_selected_option_single(driver, pages):
pages.load("formPage.html")
for select in [singleSelectValues1, singleSelectValues2]:
opt = Select(driver.find_element(By.NAME, select["name"])).first_selected_option
assert opt.text == select["values"][0]
def test_get_first_selected_option_multiple(driver, pages):
pages.load("formPage.html")
opt = Select(driver.find_element(By.NAME, multiSelectValues1["name"])).first_selected_option
assert opt.text == multiSelectValues1["values"][0]
opt = Select(driver.find_element(By.NAME, multiSelectValues2["name"])).all_selected_options
assert len(opt) == 0
def test_raises_exception_for_invalid_tag_name(driver, pages):
pages.load("formPage.html")
with pytest.raises(UnexpectedTagNameException):
Select(driver.find_element(By.TAG_NAME, "div"))
def test_deselect_by_index_non_existent(driver, pages):
pages.load("formPage.html")
for select in [multiSelectValues1, multiSelectValues2]:
with pytest.raises(NoSuchElementException):
Select(driver.find_element(By.NAME, select["name"])).deselect_by_index(10)
def test_deselect_by_value_non_existent(driver, pages):
pages.load("formPage.html")
for select in [multiSelectValues1, multiSelectValues2]:
with pytest.raises(NoSuchElementException):
Select(driver.find_element(By.NAME, select["name"])).deselect_by_value("not there")
def test_deselect_by_text_non_existent(driver, pages):
pages.load("formPage.html")
for select in [multiSelectValues1, multiSelectValues2]:
with pytest.raises(NoSuchElementException):
Select(driver.find_element(By.NAME, select["name"])).deselect_by_visible_text("not there")
selenium-selenium-4.18.1/test/selenium/webdriver/common/network.py 0000644 0001750 0001750 00000004076 14564764517 025303 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# module for getting the lan ip address of the computer
import os
import socket
if os.name != "nt":
import fcntl
import struct
def get_interface_ip(ifname):
def _bytes(value, encoding):
try:
return bytes(value, encoding) # Python 3
except TypeError:
return value # Python 2
sckt = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return socket.inet_ntoa(
fcntl.ioctl(sckt.fileno(), 0x8915, struct.pack("256s", _bytes(ifname[:15], "utf-8")))[20:24] # SIOCGIFADDR
)
def get_lan_ip():
if os.environ.get("CI") == "true":
return "0.0.0.0"
try:
ip = socket.gethostbyname(socket.gethostname())
except Exception:
return "0.0.0.0"
if ip.startswith("127.") and os.name != "nt":
interfaces = [
"eth0",
"eth1",
"eth2",
"en0",
"en1",
"en2",
"en3",
"en4",
"wlan0",
"wlan1",
"wifi0",
"ath0",
"ath1",
"ppp0",
]
for ifname in interfaces:
try:
ip = get_interface_ip(ifname)
break
except OSError:
pass
return ip
selenium-selenium-4.18.1/test/selenium/webdriver/common/element_attribute_tests.py 0000644 0001750 0001750 00000026012 14564764517 030542 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.common.by import By
def test_should_return_null_when_getting_the_value_of_an_attribute_that_is_not_listed(driver, pages):
pages.load("simpleTest.html")
head = driver.find_element(By.XPATH, "/html")
attribute = head.get_attribute("cheese")
assert attribute is None
def test_should_return_null_when_getting_src_attribute_of_invalid_img_tag(driver, pages):
pages.load("simpleTest.html")
img = driver.find_element(By.ID, "invalidImgTag")
img_attr = img.get_attribute("src")
assert img_attr is None
def test_should_return_an_absolute_url_when_getting_src_attribute_of_avalid_img_tag(driver, pages):
pages.load("simpleTest.html")
img = driver.find_element(By.ID, "validImgTag")
img_attr = img.get_attribute("src")
assert "icon.gif" in img_attr
def test_should_return_an_absolute_url_when_getting_href_attribute_of_avalid_anchor_tag(driver, pages):
pages.load("simpleTest.html")
img = driver.find_element(By.ID, "validAnchorTag")
img_attr = img.get_attribute("href")
assert "icon.gif" in img_attr
def test_should_return_empty_attribute_values_when_present_and_the_value_is_actually_empty(driver, pages):
pages.load("simpleTest.html")
body = driver.find_element(By.XPATH, "//body")
assert "" == body.get_attribute("style")
def test_should_return_the_value_of_the_disabled_attribute_as_false_if_not_set(driver, pages):
pages.load("formPage.html")
inputElement = driver.find_element(By.XPATH, "//input[@id='working']")
assert inputElement.get_attribute("disabled") is None
assert inputElement.is_enabled()
pElement = driver.find_element(By.ID, "peas")
assert pElement.get_attribute("disabled") is None
assert pElement.is_enabled()
def test_should_return_the_value_of_the_index_attribute_even_if_it_is_missing(driver, pages):
pages.load("formPage.html")
multiSelect = driver.find_element(By.ID, "multi")
options = multiSelect.find_elements(By.TAG_NAME, "option")
assert "1" == options[1].get_attribute("index")
def test_should_indicate_the_elements_that_are_disabled_are_not_is_enabled(driver, pages):
pages.load("formPage.html")
inputElement = driver.find_element(By.XPATH, "//input[@id='notWorking']")
assert not inputElement.is_enabled()
inputElement = driver.find_element(By.XPATH, "//input[@id='working']")
assert inputElement.is_enabled()
def test_elements_should_be_disabled_if_they_are_disabled_using_random_disabled_strings(driver, pages):
pages.load("formPage.html")
disabledTextElement1 = driver.find_element(By.ID, "disabledTextElement1")
assert not disabledTextElement1.is_enabled()
disabledTextElement2 = driver.find_element(By.ID, "disabledTextElement2")
assert not disabledTextElement2.is_enabled()
disabledSubmitElement = driver.find_element(By.ID, "disabledSubmitElement")
assert not disabledSubmitElement.is_enabled()
def test_should_indicate_when_atext_area_is_disabled(driver, pages):
pages.load("formPage.html")
textArea = driver.find_element(By.XPATH, "//textarea[@id='notWorkingArea']")
assert not textArea.is_enabled()
@pytest.mark.xfail_safari
def test_should_throw_exception_if_sending_keys_to_element_disabled_using_random_disabled_strings(driver, pages):
pages.load("formPage.html")
disabledTextElement1 = driver.find_element(By.ID, "disabledTextElement1")
with pytest.raises(WebDriverException):
disabledTextElement1.send_keys("foo")
assert "" == disabledTextElement1.text
disabledTextElement2 = driver.find_element(By.ID, "disabledTextElement2")
with pytest.raises(WebDriverException):
disabledTextElement2.send_keys("bar")
assert "" == disabledTextElement2.text
def test_should_indicate_when_aselect_is_disabled(driver, pages):
pages.load("formPage.html")
enabled = driver.find_element(By.NAME, "selectomatic")
disabled = driver.find_element(By.NAME, "no-select")
assert enabled.is_enabled()
assert not disabled.is_enabled()
def test_should_return_the_value_of_checked_for_acheckbox_even_if_it_lacks_that_attribute(driver, pages):
pages.load("formPage.html")
checkbox = driver.find_element(By.XPATH, "//input[@id='checky']")
assert checkbox.get_attribute("checked") is None
checkbox.click()
assert "true" == checkbox.get_attribute("checked")
def test_should_return_the_value_of_selected_for_radio_buttons_even_if_they_lack_that_attribute(driver, pages):
pages.load("formPage.html")
neverSelected = driver.find_element(By.ID, "cheese")
initiallyNotSelected = driver.find_element(By.ID, "peas")
initiallySelected = driver.find_element(By.ID, "cheese_and_peas")
assert neverSelected.get_attribute("checked") is None
assert initiallyNotSelected.get_attribute("checked") is None
assert "true" == initiallySelected.get_attribute("checked")
initiallyNotSelected.click()
assert neverSelected.get_attribute("selected") is None
assert "true" == initiallyNotSelected.get_attribute("checked")
assert initiallySelected.get_attribute("checked") is None
def test_should_return_the_value_of_selected_for_options_in_selects_even_if_they_lack_that_attribute(driver, pages):
pages.load("formPage.html")
selectBox = driver.find_element(By.XPATH, "//select[@name='selectomatic']")
options = selectBox.find_elements(By.TAG_NAME, "option")
one = options[0]
two = options[1]
assert one.is_selected()
assert not two.is_selected()
assert "true" == one.get_attribute("selected")
assert two.get_attribute("selected") is None
def test_should_return_value_of_class_attribute_of_an_element(driver, pages):
pages.load("xhtmlTest.html")
heading = driver.find_element(By.XPATH, "//h1")
classname = heading.get_attribute("class")
assert "header" == classname
# Disabled due to issues with Frames
# def test_should_return_value_of_class_attribute_of_an_element_after_switching_iframe(driver, pages):
# pages.load("iframes.html")
# driver.switch_to.frame("iframe1")
#
# wallace = driver.find_element(By.XPATH, "//div[@id='wallace']")
# classname = wallace.get_attribute("class")
# assert "gromit" == classname
def test_should_return_the_contents_of_atext_area_as_its_value(driver, pages):
pages.load("formPage.html")
value = driver.find_element(By.ID, "withText").get_attribute("value")
assert "Example text" == value
def test_should_return_the_contents_of_atext_area_as_its_value_when_set_to_non_norminal_true(driver, pages):
pages.load("formPage.html")
e = driver.find_element(By.ID, "withText")
driver.execute_script("arguments[0].value = 'tRuE'", e)
value = e.get_attribute("value")
assert "tRuE" == value
def test_should_treat_readonly_as_avalue(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.NAME, "readonly")
readOnlyAttribute = element.get_attribute("readonly")
textInput = driver.find_element(By.NAME, "x")
notReadOnly = textInput.get_attribute("readonly")
assert readOnlyAttribute != notReadOnly
def test_should_get_numeric_attribute(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.ID, "withText")
assert "5" == element.get_attribute("rows")
def test_can_return_atext_approximation_of_the_style_attribute(driver, pages):
pages.load("javascriptPage.html")
style = driver.find_element(By.ID, "red-item").get_attribute("style")
assert "background-color" in style.lower()
def test_should_correctly_report_value_of_colspan(driver, pages):
pages.load("tables.html")
th1 = driver.find_element(By.ID, "th1")
td2 = driver.find_element(By.ID, "td2")
assert "th1" == th1.get_attribute("id")
assert "3" == th1.get_attribute("colspan")
assert "td2" == td2.get_attribute("id")
assert "2" == td2.get_attribute("colspan")
def test_can_retrieve_the_current_value_of_atext_form_field_text_input(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.ID, "working")
assert "" == element.get_attribute("value")
element.send_keys("hello world")
assert "hello world" == element.get_attribute("value")
def test_can_retrieve_the_current_value_of_atext_form_field_email_input(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.ID, "email")
assert "" == element.get_attribute("value")
element.send_keys("hello@example.com")
assert "hello@example.com" == element.get_attribute("value")
def test_can_retrieve_the_current_value_of_atext_form_field_text_area(driver, pages):
pages.load("formPage.html")
element = driver.find_element(By.ID, "emptyTextArea")
assert "" == element.get_attribute("value")
element.send_keys("hello world")
assert "hello world" == element.get_attribute("value")
def test_should_return_null_for_non_present_boolean_attributes(driver, pages):
pages.load("booleanAttributes.html")
element1 = driver.find_element(By.ID, "working")
assert element1.get_attribute("required") is None
@pytest.mark.xfail_ie
def test_should_return_true_for_present_boolean_attributes(driver, pages):
pages.load("booleanAttributes.html")
element1 = driver.find_element(By.ID, "emailRequired")
assert "true" == element1.get_attribute("required")
element2 = driver.find_element(By.ID, "emptyTextAreaRequired")
assert "true" == element2.get_attribute("required")
element3 = driver.find_element(By.ID, "inputRequired")
assert "true" == element3.get_attribute("required")
element4 = driver.find_element(By.ID, "textAreaRequired")
assert "true" == element4.get_attribute("required")
@pytest.mark.xfail_chrome
@pytest.mark.xfail_firefox
@pytest.mark.xfail_safari
@pytest.mark.xfail_remote
def test_should_get_unicode_chars_from_attribute(driver, pages):
pages.load("formPage.html")
title = driver.find_element(By.ID, "vsearchGadget").get_attribute("title")
assert "Hvad s\xf8ger du?" == title
@pytest.mark.xfail_chrome
@pytest.mark.xfail_firefox
@pytest.mark.xfail_safari
@pytest.mark.xfail_remote
def test_should_get_values_and_not_miss_items(driver, pages):
pages.load("attributes.html")
expected = "4b273a33fbbd29013nN93dy4F1A~"
result = driver.find_element(By.CSS_SELECTOR, "li").get_attribute("value")
assert expected == result
selenium-selenium-4.18.1/test/selenium/webdriver/common/web_components_tests.py 0000644 0001750 0001750 00000005527 14564764517 030060 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.common.exceptions import NoSuchShadowRootException
from selenium.webdriver.common.by import By
from selenium.webdriver.remote.shadowroot import ShadowRoot
from selenium.webdriver.remote.webelement import WebElement
@pytest.mark.xfail_safari
@pytest.mark.xfail_remote
def test_can_get_the_shadow_root_of_an_element(driver, pages):
pages.load("webComponents.html")
shadow_root = driver.find_element(By.CSS_SELECTOR, "custom-checkbox-element").shadow_root
assert isinstance(shadow_root, ShadowRoot)
@pytest.mark.xfail_safari
@pytest.mark.xfail_remote
def test_no_such_shadow_root_thrown_when_no_shadow_root(driver, pages):
with pytest.raises(NoSuchShadowRootException):
pages.load("simpleTest.html")
driver.find_element(By.CSS_SELECTOR, "div").shadow_root
@pytest.mark.xfail_safari
@pytest.mark.xfail_remote
def test_returns_shadow_root_via_execute_script(driver, pages):
pages.load("webComponents.html")
custom_element = driver.find_element(By.CSS_SELECTOR, "custom-checkbox-element")
shadow_root = custom_element.shadow_root
execute_shadow_root = driver.execute_script("return arguments[0].shadowRoot", custom_element)
assert shadow_root == execute_shadow_root
@pytest.mark.xfail_safari
@pytest.mark.xfail_firefox
@pytest.mark.xfail_remote
def test_can_find_element_in_a_shadowroot(driver, pages):
pages.load("webComponents.html")
custom_element = driver.find_element(By.CSS_SELECTOR, "custom-checkbox-element")
shadow_root = custom_element.shadow_root
element = shadow_root.find_element(By.CSS_SELECTOR, "input")
assert isinstance(element, WebElement)
@pytest.mark.xfail_safari
@pytest.mark.xfail_firefox
@pytest.mark.xfail_remote
def test_can_find_elements_in_a_shadow_root(driver, pages):
pages.load("webComponents.html")
custom_element = driver.find_element(By.CSS_SELECTOR, "custom-checkbox-element")
shadow_root = custom_element.shadow_root
elements = shadow_root.find_elements(By.CSS_SELECTOR, "input")
assert len(elements) == 1
assert isinstance(elements[0], WebElement)
selenium-selenium-4.18.1/test/selenium/webdriver/common/element_aria_tests.py 0000644 0001750 0001750 00000003415 14564764517 027455 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.webdriver.common.by import By
@pytest.mark.xfail_firefox
@pytest.mark.xfail_safari
@pytest.mark.xfail_remote
def test_should_return_explicitly_specified_role(driver):
driver.get("data:text/html,Level 1 Header
")
header1 = driver.find_element(By.CSS_SELECTOR, "div")
assert header1.aria_role == "heading"
@pytest.mark.xfail_firefox
@pytest.mark.xfail_safari
@pytest.mark.xfail_remote
def test_should_return_implicit_role_defined_by_tag_name(driver):
driver.get("data:text/html,Level 1 Header
")
header1 = driver.find_element(By.CSS_SELECTOR, "h1")
assert header1.aria_role == "heading"
@pytest.mark.xfail_firefox
@pytest.mark.xfail_safari
@pytest.mark.xfail_remote
def test_should_return_explicit_role_even_if_it_contradicts_tag_name(driver):
driver.get("data:text/html,Level 1 Header
")
header1 = driver.find_element(By.CSS_SELECTOR, "h1")
assert header1.aria_role == "alert"
selenium-selenium-4.18.1/test/selenium/webdriver/common/example2.py 0000644 0001750 0001750 00000002234 14564764517 025321 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
from google_one_box import GoogleOneBox
def test_search(driver):
"""This example shows how to use the page object pattern.
For more information about this pattern, see:
https://github.com/SeleniumHQ/selenium/wiki/PageObjects"""
google = GoogleOneBox(driver, "http://www.google.com")
res = google.search_for("cheese")
assert res.link_contains_match_for("Wikipedia")
selenium-selenium-4.18.1/test/selenium/webdriver/common/results_page.py 0000644 0001750 0001750 00000002650 14564764517 026303 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
from selenium.webdriver.common.by import By
class ResultsPage:
"""This class models a google search result page."""
def __init__(self, driver):
self._driver = driver
def is_loaded(self):
return "/search" in self._driver.get_current_url()
def load(self):
raise Exception("This page shouldn't be loaded directly")
def link_contains_match_for(self, term):
result_section = self._driver.find_element(By.ID, "res")
elements = result_section.find_elements(By.XPATH, ".//*[@class='l']")
for e in elements:
if term in e.get_text():
return True
return False
selenium-selenium-4.18.1/test/selenium/webdriver/common/typing_tests.py 0000644 0001750 0001750 00000032427 14564764517 026347 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
def test_should_fire_key_press_events(driver, pages):
pages.load("javascriptPage.html")
keyReporter = driver.find_element(by=By.ID, value="keyReporter")
keyReporter.send_keys("a")
result = driver.find_element(by=By.ID, value="result")
assert "press:" in result.text
def test_should_fire_key_down_events(driver, pages):
pages.load("javascriptPage.html")
keyReporter = driver.find_element(by=By.ID, value="keyReporter")
keyReporter.send_keys("I")
result = driver.find_element(by=By.ID, value="result")
assert "down" in result.text
def test_should_fire_key_up_events(driver, pages):
pages.load("javascriptPage.html")
keyReporter = driver.find_element(by=By.ID, value="keyReporter")
keyReporter.send_keys("a")
result = driver.find_element(by=By.ID, value="result")
assert "up:" in result.text
def test_should_type_lower_case_letters(driver, pages):
pages.load("javascriptPage.html")
keyReporter = driver.find_element(by=By.ID, value="keyReporter")
keyReporter.send_keys("abc def")
assert keyReporter.get_attribute("value") == "abc def"
def test_should_be_able_to_type_capital_letters(driver, pages):
pages.load("javascriptPage.html")
keyReporter = driver.find_element(by=By.ID, value="keyReporter")
keyReporter.send_keys("ABC DEF")
assert keyReporter.get_attribute("value") == "ABC DEF"
def test_should_be_able_to_type_quote_marks(driver, pages):
pages.load("javascriptPage.html")
keyReporter = driver.find_element(by=By.ID, value="keyReporter")
keyReporter.send_keys('"')
assert keyReporter.get_attribute("value") == '"'
def test_should_be_able_to_type_the_at_character(driver, pages):
pages.load("javascriptPage.html")
keyReporter = driver.find_element(by=By.ID, value="keyReporter")
keyReporter.send_keys("@")
assert keyReporter.get_attribute("value") == "@"
def test_should_be_able_to_mix_upper_and_lower_case_letters(driver, pages):
pages.load("javascriptPage.html")
keyReporter = driver.find_element(by=By.ID, value="keyReporter")
keyReporter.send_keys("me@eXample.com")
assert keyReporter.get_attribute("value") == "me@eXample.com"
def test_arrow_keys_should_not_be_printable(driver, pages):
pages.load("javascriptPage.html")
keyReporter = driver.find_element(by=By.ID, value="keyReporter")
keyReporter.send_keys(Keys.ARROW_LEFT)
assert keyReporter.get_attribute("value") == ""
def test_list_of_arrow_keys_should_not_be_printable(driver, pages):
pages.load("javascriptPage.html")
keyReporter = driver.find_element(by=By.ID, value="keyReporter")
keyReporter.send_keys([Keys.ARROW_LEFT])
assert keyReporter.get_attribute("value") == ""
def test_should_be_able_to_use_arrow_keys(driver, pages):
pages.load("javascriptPage.html")
keyReporter = driver.find_element(by=By.ID, value="keyReporter")
keyReporter.send_keys("Tet", Keys.ARROW_LEFT, "s")
assert keyReporter.get_attribute("value") == "Test"
@pytest.mark.xfail_safari
def test_will_simulate_akey_up_when_entering_text_into_input_elements(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyUp")
element.send_keys("I like cheese")
result = driver.find_element(by=By.ID, value="result")
assert result.text == "I like cheese"
@pytest.mark.xfail_safari
def test_will_simulate_akey_down_when_entering_text_into_input_elements(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyDown")
element.send_keys("I like cheese")
result = driver.find_element(by=By.ID, value="result")
# Because the key down gets the result before the input element is
# filled, we're a letter short here
assert result.text == "I like chees"
@pytest.mark.xfail_safari
def test_will_simulate_akey_press_when_entering_text_into_input_elements(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyPress")
element.send_keys("I like cheese")
result = driver.find_element(by=By.ID, value="result")
# Because the key down gets the result before the input element is
# filled, we're a letter short here
assert result.text == "I like chees"
@pytest.mark.xfail_safari
def test_will_simulate_akey_up_when_entering_text_into_text_areas(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyUpArea")
element.send_keys("I like cheese")
result = driver.find_element(by=By.ID, value="result")
assert result.text == "I like cheese"
@pytest.mark.xfail_safari
def test_will_simulate_akey_down_when_entering_text_into_text_areas(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyDownArea")
element.send_keys("I like cheese")
result = driver.find_element(by=By.ID, value="result")
# Because the key down gets the result before the input element is
# filled, we're a letter short here
assert result.text == "I like chees"
@pytest.mark.xfail_safari
def test_will_simulate_akey_press_when_entering_text_into_text_areas(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyPressArea")
element.send_keys("I like cheese")
result = driver.find_element(by=By.ID, value="result")
# Because the key down gets the result before the input element is
# filled, we're a letter short here
assert result.text == "I like chees"
def test_should_report_key_code_of_arrow_keys_up_down_events(driver, pages):
pages.load("javascriptPage.html")
result = driver.find_element(by=By.ID, value="result")
element = driver.find_element(by=By.ID, value="keyReporter")
element.send_keys(Keys.ARROW_DOWN)
assert "down: 40" in result.text.strip()
assert "up: 40" in result.text.strip()
element.send_keys(Keys.ARROW_UP)
assert "down: 38" in result.text.strip()
assert "up: 38" in result.text.strip()
element.send_keys(Keys.ARROW_LEFT)
assert "down: 37" in result.text.strip()
assert "up: 37" in result.text.strip()
element.send_keys(Keys.ARROW_RIGHT)
assert "down: 39" in result.text.strip()
assert "up: 39" in result.text.strip()
# And leave no rubbish/printable keys in the "keyReporter"
assert element.get_attribute("value") == ""
def test_numeric_non_shift_keys(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyReporter")
numericLineCharsNonShifted = "`1234567890-=[]\\,.'/42"
element.send_keys(numericLineCharsNonShifted)
assert element.get_attribute("value") == numericLineCharsNonShifted
@pytest.mark.xfail_firefox(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1255258")
@pytest.mark.xfail_remote(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1255258")
def test_numeric_shift_keys(driver, pages):
pages.load("javascriptPage.html")
result = driver.find_element(by=By.ID, value="result")
element = driver.find_element(by=By.ID, value="keyReporter")
numericShiftsEtc = '~!@#$%^&*()_+{}:i"<>?|END~'
element.send_keys(numericShiftsEtc)
assert element.get_attribute("value") == numericShiftsEtc
assert "up: 16" in result.text.strip()
def test_lower_case_alpha_keys(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyReporter")
lowerAlphas = "abcdefghijklmnopqrstuvwxyz"
element.send_keys(lowerAlphas)
assert element.get_attribute("value") == lowerAlphas
@pytest.mark.xfail_firefox(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1255258")
@pytest.mark.xfail_remote(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1255258")
def test_uppercase_alpha_keys(driver, pages):
pages.load("javascriptPage.html")
result = driver.find_element(by=By.ID, value="result")
element = driver.find_element(by=By.ID, value="keyReporter")
upperAlphas = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
element.send_keys(upperAlphas)
assert element.get_attribute("value") == upperAlphas
assert "up: 16" in result.text.strip()
@pytest.mark.xfail_firefox(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1255258")
@pytest.mark.xfail_remote(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1255258")
def test_all_printable_keys(driver, pages):
pages.load("javascriptPage.html")
result = driver.find_element(by=By.ID, value="result")
element = driver.find_element(by=By.ID, value="keyReporter")
allPrintable = "!\"#$%&'()*+,-./0123456789:<=>?@ ABCDEFGHIJKLMNOPQRSTUVWXYZ [\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
element.send_keys(allPrintable)
assert element.get_attribute("value") == allPrintable
assert "up: 16" in result.text.strip()
def test_arrow_keys_and_page_up_and_down(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyReporter")
element.send_keys(f"a{Keys.LEFT}b{Keys.RIGHT}{Keys.UP}{Keys.DOWN}{Keys.PAGE_UP}{Keys.PAGE_DOWN}1")
assert element.get_attribute("value") == "ba1"
# def test_home_and_end_and_page_up_and_page_down_keys(driver, pages):
# // FIXME: macs don't have HOME keys, would PGUP work?
# if (Platform.getCurrent().is(Platform.MAC)) {
# return
# }
# pages.load("javascriptPage.html")
# element = driver.find_element(by=By.ID, value="keyReporter")
# element.send_keys("abc" + Keys.HOME + "0" + Keys.LEFT + Keys.RIGHT +
# Keys.PAGE_UP + Keys.PAGE_DOWN + Keys.END + "1" + Keys.HOME +
# "0" + Keys.PAGE_UP + Keys.END + "111" + Keys.HOME + "00")
# assert element.get_attribute("value") == "0000abc1111"
def test_delete_and_backspace_keys(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyReporter")
element.send_keys("abcdefghi")
assert element.get_attribute("value") == "abcdefghi"
element.send_keys(Keys.LEFT, Keys.LEFT, Keys.DELETE)
assert element.get_attribute("value") == "abcdefgi"
element.send_keys(Keys.LEFT, Keys.LEFT, Keys.BACK_SPACE)
assert element.get_attribute("value") == "abcdfgi"
@pytest.mark.xfail_firefox(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1255258")
@pytest.mark.xfail_remote(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1255258")
def test_special_space_keys(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyReporter")
element.send_keys("abcd" + Keys.SPACE + "fgh" + Keys.SPACE + "ij")
assert element.get_attribute("value") == "abcd fgh ij"
@pytest.mark.xfail_firefox(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1255258")
@pytest.mark.xfail_remote(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1255258")
@pytest.mark.xfail_safari
def test_numberpad_and_function_keys(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyReporter")
element.send_keys(
"abcd{}{}{}{}{}{}{}{}{}{}{}{}abcd".format(
Keys.MULTIPLY,
Keys.SUBTRACT,
Keys.ADD,
Keys.DECIMAL,
Keys.SEPARATOR,
Keys.NUMPAD0,
Keys.NUMPAD9,
Keys.ADD,
Keys.SEMICOLON,
Keys.EQUALS,
Keys.DIVIDE,
Keys.NUMPAD3,
)
)
assert element.get_attribute("value") == "abcd*-+.,09+;=/3abcd"
element.clear()
element.send_keys("FUNCTION" + Keys.F2 + "-KEYS" + Keys.F2)
element.send_keys("" + Keys.F2 + "-TOO" + Keys.F2)
assert element.get_attribute("value") == "FUNCTION-KEYS-TOO"
@pytest.mark.xfail_safari
def test_shift_selection_deletes(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyReporter")
element.send_keys("abcd efgh")
assert element.get_attribute("value") == "abcd efgh"
element.send_keys(Keys.SHIFT, Keys.LEFT, Keys.LEFT, Keys.LEFT)
element.send_keys(Keys.DELETE)
assert element.get_attribute("value") == "abcd e"
def test_should_type_into_input_elements_that_have_no_type_attribute(driver, pages):
pages.load("formPage.html")
element = driver.find_element(by=By.ID, value="no-type")
element.send_keys("Should Say Cheese")
assert element.get_attribute("value") == "Should Say Cheese"
def test_should_type_an_integer(driver, pages):
pages.load("javascriptPage.html")
element = driver.find_element(by=By.ID, value="keyReporter")
element.send_keys(1234)
assert element.get_attribute("value") == "1234"
selenium-selenium-4.18.1/test/selenium/webdriver/common/bidi_tests.py 0000644 0001750 0001750 00000006667 14564764517 025753 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.webdriver.common.by import By
from selenium.webdriver.common.log import Log
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
@pytest.mark.xfail_firefox(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1819965")
@pytest.mark.xfail_remote(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1819965")
@pytest.mark.xfail_safari
async def test_check_console_messages(driver, pages):
async with driver.bidi_connection() as session:
log = Log(driver, session)
pages.load("javascriptPage.html")
from selenium.webdriver.common.bidi.console import Console
async with log.add_listener(Console.LOG) as messages:
driver.execute_script("console.log('I love cheese')")
assert messages["message"] == "I love cheese"
@pytest.mark.xfail_firefox(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1819965")
@pytest.mark.xfail_remote(reason="https://bugzilla.mozilla.org/show_bug.cgi?id=1819965")
@pytest.mark.xfail_safari
async def test_check_error_console_messages(driver, pages):
async with driver.bidi_connection() as session:
log = Log(driver, session)
pages.load("javascriptPage.html")
from selenium.webdriver.common.bidi.console import Console
async with log.add_listener(Console.ERROR) as messages:
driver.execute_script('console.error("I don\'t cheese")')
driver.execute_script("console.log('I love cheese')")
assert messages["message"] == "I don't cheese"
@pytest.mark.xfail_firefox
@pytest.mark.xfail_safari
@pytest.mark.xfail_remote
async def test_collect_js_exceptions(driver, pages):
async with driver.bidi_connection() as session:
log = Log(driver, session)
pages.load("javascriptPage.html")
async with log.add_js_error_listener() as exceptions:
driver.find_element(By.ID, "throwing-mouseover").click()
assert exceptions is not None
assert exceptions.exception_details.stack_trace.call_frames[0].function_name == "onmouseover"
@pytest.mark.xfail_firefox
@pytest.mark.xfail_safari
@pytest.mark.xfail_remote
async def test_collect_log_mutations(driver, pages):
async with driver.bidi_connection() as session:
log = Log(driver, session)
async with log.mutation_events() as event:
pages.load("dynamic.html")
driver.find_element(By.ID, "reveal").click()
WebDriverWait(driver, 5).until(EC.visibility_of(driver.find_element(By.ID, "revealed")))
assert event["attribute_name"] == "style"
assert event["current_value"] == ""
assert event["old_value"] == "display:none;"
selenium-selenium-4.18.1/test/selenium/webdriver/common/position_and_size_tests.py 0000644 0001750 0001750 00000011055 14564764517 030547 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.webdriver.common.by import By
def test_should_be_able_to_determine_the_location_of_an_element(driver, pages):
pages.load("xhtmlTest.html")
location = driver.find_element(By.ID, "username").location_once_scrolled_into_view
assert location["x"] > 0
assert location["y"] > 0
@pytest.mark.parametrize(
"page",
(
"coordinates_tests/simple_page.html",
"coordinates_tests/page_with_empty_element.html",
"coordinates_tests/page_with_transparent_element.html",
"coordinates_tests/page_with_hidden_element.html",
),
ids=("basic", "empty", "transparent", "hidden"),
)
@pytest.mark.xfail_safari
def test_should_get_coordinates_of_an_element(page, driver, pages):
pages.load(page)
element = driver.find_element(By.ID, "box")
_check_location(element.location_once_scrolled_into_view, x=10, y=10)
_check_location(element.location, x=10, y=10)
@pytest.mark.xfail_safari
def test_should_get_coordinates_of_an_invisible_element(driver, pages):
pages.load("coordinates_tests/page_with_invisible_element.html")
element = driver.find_element(By.ID, "box")
_check_location(element.location_once_scrolled_into_view, x=0, y=0)
_check_location(element.location, x=0, y=0)
def test_should_scroll_page_and_get_coordinates_of_an_element_that_is_out_of_view_port(driver, pages):
pages.load("coordinates_tests/page_with_element_out_of_view.html")
element = driver.find_element(By.ID, "box")
windowHeight = driver.get_window_size()["height"]
_check_location(element.location_once_scrolled_into_view, x=10)
assert 0 <= element.location_once_scrolled_into_view["y"] <= (windowHeight - 100)
_check_location(element.location, x=10, y=5010)
@pytest.mark.xfail_chrome
@pytest.mark.xfail_chromiumedge
@pytest.mark.xfail_firefox
@pytest.mark.xfail_remote
@pytest.mark.xfail_safari
def test_should_get_coordinates_of_an_element_in_aframe(driver, pages):
pages.load("coordinates_tests/element_in_frame.html")
driver.switch_to.frame(driver.find_element(By.NAME, "ifr"))
element = driver.find_element(By.ID, "box")
_check_location(element.location_once_scrolled_into_view, x=25, y=25)
_check_location(element.location, x=10, y=10)
@pytest.mark.xfail_chrome
@pytest.mark.xfail_chromiumedge
@pytest.mark.xfail_firefox
@pytest.mark.xfail_remote
@pytest.mark.xfail_safari
def test_should_get_coordinates_of_an_element_in_anested_frame(driver, pages):
pages.load("coordinates_tests/element_in_nested_frame.html")
driver.switch_to.frame(driver.find_element(By.NAME, "ifr"))
driver.switch_to.frame(driver.find_element(By.NAME, "ifr"))
element = driver.find_element(By.ID, "box")
_check_location(element.location_once_scrolled_into_view, x=40, y=40)
_check_location(element.location, x=10, y=10)
def test_should_get_coordinates_of_an_element_with_fixed_position(driver, pages):
pages.load("coordinates_tests/page_with_fixed_element.html")
element = driver.find_element(By.ID, "fixed")
_check_location(element.location_once_scrolled_into_view, y=0)
_check_location(element.location, y=0)
driver.find_element(By.ID, "bottom").click()
_check_location(element.location_once_scrolled_into_view, y=0)
assert element.location["y"] > 0
def test_should_correctly_identify_that_an_element_has_width_and_height(driver, pages):
pages.load("xhtmlTest.html")
shrinko = driver.find_element(By.ID, "linkId")
size = shrinko.size
assert size["width"] > 0
assert size["height"] > 0
def _check_location(location, **kwargs):
try:
# python 2.x
expected = kwargs.viewitems()
actual = location.viewitems()
except AttributeError:
# python 3.x
expected = kwargs.items()
actual = location.items()
assert expected <= actual
selenium-selenium-4.18.1/test/selenium/webdriver/common/opacity_tests.py 0000644 0001750 0001750 00000003377 14564764517 026507 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.webdriver.common.by import By
@pytest.mark.xfail_ie
def test_should_be_able_to_click_on_elements_with_opacity_zero(driver, pages):
pages.load("click_jacker.html")
element = driver.find_element(By.ID, "clickJacker")
assert "0" == element.value_of_css_property("opacity"), (
"Precondition failed: clickJacker should be transparent.\
Value was %s"
% element.value_of_css_property("opacity")
)
element.click()
assert "1" == element.value_of_css_property("opacity")
@pytest.mark.xfail_ie
def test_should_be_able_to_select_options_from_an_invisible_select(driver, pages):
pages.load("formPage.html")
select = driver.find_element(By.ID, "invisi_select")
options = select.find_elements(By.TAG_NAME, "option")
apples = options[0]
oranges = options[1]
assert apples.is_selected()
assert not oranges.is_selected()
oranges.click()
assert not apples.is_selected()
assert oranges.is_selected()
selenium-selenium-4.18.1/test/selenium/webdriver/common/webserver.py 0000644 0001750 0001750 00000015227 14564764517 025616 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
"""A simple web server for testing purpose.
It serves the testing html pages that are needed by the webdriver unit tests."""
import contextlib
import logging
import os
import re
import threading
try:
from urllib import request as urllib_request
except ImportError:
import urllib as urllib_request
try:
from http.server import BaseHTTPRequestHandler
from http.server import HTTPServer
from socketserver import ThreadingMixIn
except ImportError:
from BaseHTTPServer import BaseHTTPRequestHandler
from BaseHTTPServer import HTTPServer
from SocketServer import ThreadingMixIn
def updir():
dirname = os.path.dirname
return dirname(dirname(__file__))
LOGGER = logging.getLogger(__name__)
WEBDRIVER = os.environ.get("WEBDRIVER", updir())
HTML_ROOT = os.path.join(WEBDRIVER, "../../../../common/src/web")
if not os.path.isdir(HTML_ROOT):
message = (
"Can't find 'common_web' directory, try setting WEBDRIVER"
" environment variable WEBDRIVER:" + WEBDRIVER + " HTML_ROOT:" + HTML_ROOT
)
LOGGER.error(message)
assert 0, message
DEFAULT_HOST = "localhost"
DEFAULT_HOST_IP = "127.0.0.1"
DEFAULT_PORT = 8000
class HtmlOnlyHandler(BaseHTTPRequestHandler):
"""Http handler."""
def do_GET(self):
"""GET method handler."""
try:
path = self.path[1:].split("?")[0]
if path[:5] == "page/":
html = """Page{page_number}
Page number {page_number}
top
""".format(
page_number=path[5:]
)
html = html.encode("utf-8")
else:
with open(os.path.join(HTML_ROOT, path), encoding="latin-1") as f:
html = f.read().encode("utf-8")
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(html)
except OSError:
self.send_error(404, f"File Not Found: {path}")
def do_POST(self):
"""POST method handler."""
try:
remaining_bytes = int(self.headers["content-length"])
contents = ""
line = self.rfile.readline()
contents += line.decode("utf-8")
remaining_bytes -= len(line)
line = self.rfile.readline()
contents += line.decode("utf-8")
remaining_bytes -= len(line)
fn = re.findall(r'Content-Disposition.*name="upload"; filename="(.*)"', line.decode("utf-8"))
if not fn:
self.send_error(500, f"File not found. {contents}")
return
line = self.rfile.readline()
remaining_bytes -= len(line)
contents += line.decode("utf-8")
line = self.rfile.readline()
remaining_bytes -= len(line)
contents += line.decode("utf-8")
preline = self.rfile.readline()
remaining_bytes -= len(preline)
while remaining_bytes > 0:
line = self.rfile.readline()
remaining_bytes -= len(line)
contents += line.decode("utf-8")
self.send_response(200)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(
f"""
{contents}
""".encode()
)
except Exception as e:
self.send_error(500, f"Error found: {e}")
def log_message(self, format, *args):
"""Override default to avoid trashing stderr"""
pass
class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
pass
class SimpleWebServer:
"""A very basic web server."""
def __init__(self, host=DEFAULT_HOST_IP, port=DEFAULT_PORT):
self.stop_serving = False
host = host
port = port
while True:
try:
self.server = ThreadedHTTPServer((host, port), HtmlOnlyHandler)
self.host = host
self.port = port
break
except OSError:
LOGGER.debug(f"port {port} is in use, trying to next one")
port += 1
self.thread = threading.Thread(target=self._run_web_server)
def _run_web_server(self):
"""Runs the server loop."""
LOGGER.debug("web server started")
while not self.stop_serving:
self.server.handle_request()
self.server.server_close()
def start(self):
"""Starts the server."""
self.thread.start()
def stop(self):
"""Stops the server."""
self.stop_serving = True
with contextlib.suppress(IOError):
_ = urllib_request.urlopen(f"http://{self.host}:{self.port}")
def where_is(self, path, localhost=False) -> str:
# True force serve the page from localhost
if localhost:
return f"http://{DEFAULT_HOST}:{self.port}/{path}"
return f"http://{self.host}:{self.port}/{path}"
def main(argv=None):
from optparse import OptionParser
from time import sleep
if argv is None:
import sys
argv = sys.argv
parser = OptionParser("%prog [options]")
parser.add_option(
"-p", "--port", dest="port", type="int", help=f"port to listen (default: {DEFAULT_PORT})", default=DEFAULT_PORT
)
opts, args = parser.parse_args(argv[1:])
if args:
parser.error("wrong number of arguments") # Will exit
server = SimpleWebServer(port=opts.port)
server.start()
print(f"Server started on port {opts.port}, hit CTRL-C to quit")
try:
while 1:
sleep(0.1)
except KeyboardInterrupt:
pass
if __name__ == "__main__":
main()
selenium-selenium-4.18.1/test/selenium/webdriver/common/print_pdf_tests.py 0000644 0001750 0001750 00000004561 14564764517 027020 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.webdriver.common.print_page_options import PrintOptions
START_INDEX = 0
END_INDEX = 5
PDF_MAGIC_NUMBER = "JVBER"
@pytest.mark.xfail_safari(reason="no endpoint for print in safari")
def test_pdf_with_2_pages(driver, pages):
print_options = PrintOptions()
print_options.page_ranges = ["1-2"]
pages.load("printPage.html")
base64code = driver.print_page(print_options)
assert base64code[START_INDEX:END_INDEX] == PDF_MAGIC_NUMBER
@pytest.mark.xfail_safari(reason="no endpoint for print in safari")
def test_pdf_with_all_pages(driver, pages):
pages.load("printPage.html")
base64code = driver.print_page()
assert base64code[START_INDEX:END_INDEX] == PDF_MAGIC_NUMBER
@pytest.mark.xfail_safari(reason="no endpoint for print in safari")
def test_valid_params(driver, pages):
print_options = PrintOptions()
print_options.page_ranges = ["1-2"]
print_options.orientation = "landscape"
print_options.width = 30
pages.load("printPage.html")
base64code = driver.print_page(print_options)
assert base64code[START_INDEX:END_INDEX] == PDF_MAGIC_NUMBER
@pytest.mark.xfail_safari(reason="no endpoint for print in safari")
def test_session_id_is_not_preserved_after_page_is_printed(driver, pages):
print_options = PrintOptions()
print_options.margin_bottom = print_options.margin_top = print_options.margin_left = print_options.margin_right = 0
assert "sessionId" not in print_options.to_dict()
pages.load("printPage.html")
driver.print_page(print_options=print_options)
assert "sessionId" not in print_options.to_dict()
selenium-selenium-4.18.1/test/selenium/webdriver/common/test_file.txt 0000644 0001750 0001750 00000000033 14564764517 025744 0 ustar carsten carsten lorem ipsum dolor sit amet
selenium-selenium-4.18.1/test/selenium/webdriver/common/text_handling_tests.py 0000644 0001750 0001750 00000016102 14564764517 027655 0 ustar carsten carsten # Licensed to the Software Freedom Conservancy (SFC) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The SFC licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import pytest
from selenium.webdriver.common.by import By
newLine = "\n"
def test_should_return_the_text_content_of_asingle_element_with_no_children(driver, pages):
pages.load("simpleTest.html")
selectText = driver.find_element(by=By.ID, value="oneline").text
assert selectText == "A single line of text"
getText = driver.find_element(by=By.ID, value="oneline").text
assert getText == "A single line of text"
def test_should_return_the_entire_text_content_of_child_elements(driver, pages):
pages.load("simpleTest.html")
text = driver.find_element(by=By.ID, value="multiline").text
assert "A div containing" in text
assert "More than one line of text" in text
assert "and block level elements" in text
@pytest.mark.xfail_safari
def test_should_ignore_script_elements(driver, pages):
pages.load("javascriptEnhancedForm.html")
labelForUsername = driver.find_element(by=By.ID, value="labelforusername")
text = labelForUsername.text
assert len(labelForUsername.find_elements(by=By.TAG_NAME, value="script")) == 1
assert "document.getElementById" not in text
assert text == "Username:"
@pytest.mark.xfail_safari
def test_should_represent_ablock_level_element_as_anewline(driver, pages):
pages.load("simpleTest.html")
text = driver.find_element(by=By.ID, value="multiline").text
assert text.startswith("A div containing" + newLine)
assert "More than one line of text" + newLine in text
assert text.endswith("and block level elements")
@pytest.mark.xfail_safari
def test_should_collapse_multiple_whitespace_characters_into_asingle_space(driver, pages):
pages.load("simpleTest.html")
text = driver.find_element(by=By.ID, value="lotsofspaces").text
assert text == "This line has lots of spaces."
@pytest.mark.xfail_safari
def test_should_trim_text(driver, pages):
pages.load("simpleTest.html")
text = driver.find_element(by=By.ID, value="multiline").text
assert text.startswith("A div containing")
assert text.endswith("block level elements")
@pytest.mark.xfail_safari
def test_should_convert_anon_breaking_space_into_anormal_space_character(driver, pages):
pages.load("simpleTest.html")
text = driver.find_element(by=By.ID, value="nbsp").text
assert text == "This line has a non-breaking space"
@pytest.mark.xfail_safari
def test_should_treat_anon_breaking_space_as_any_other_whitespace_character_when_collapsing_whitespace(driver, pages):
pages.load("simpleTest.html")
element = driver.find_element(by=By.ID, value="nbspandspaces")
text = element.text
assert text == "This line has a non-breaking space and spaces"
@pytest.mark.xfail_safari
def test_having_inline_elements_should_not_affect_how_text_is_returned(driver, pages):
pages.load("simpleTest.html")
text = driver.find_element(by=By.ID, value="inline").text
assert text == "This line has text within elements that are meant to be displayed inline"
@pytest.mark.xfail_safari
def test_should_return_the_entire_text_of_inline_elements(driver, pages):
pages.load("simpleTest.html")
text = driver.find_element(by=By.ID, value="span").text
assert text == "An inline element"
def test_should_be_able_to_set_more_than_one_line_of_text_in_atext_area(driver, pages):
pages.load("formPage.html")
textarea = driver.find_element(by=By.ID, value="withText")
textarea.clear()
expectedText = "I like cheese" + newLine + newLine + "It's really nice"
textarea.send_keys(expectedText)
seenText = textarea.get_attribute("value")
assert seenText == expectedText
def test_should_be_able_to_enter_dates_after_filling_in_other_values_first(driver, pages):
pages.load("formPage.html")
input_ = driver.find_element(by=By.ID, value="working")
expectedValue = "10/03/2007 to 30/07/1993"
input_.send_keys(expectedValue)
seenValue = input_.get_attribute("value")
assert seenValue == expectedValue
@pytest.mark.xfail_safari
def test_should_return_empty_string_when_text_is_only_spaces(driver, pages):
pages.load("xhtmlTest.html")
text = driver.find_element(by=By.ID, value="spaces").text
assert text == ""
def test_should_return_empty_string_when_text_is_empty(driver, pages):
pages.load("xhtmlTest.html")
text = driver.find_element(by=By.ID, value="empty").text
assert text == ""
@pytest.mark.xfail
def test_should_return_empty_string_when_tag_is_self_closing(driver, pages):
pages.load("xhtmlFormPage.xhtml")
text = driver.find_element(by=By.ID, value="self-closed").text
assert text == ""
@pytest.mark.xfail_safari
def test_should_handle_sibling_block_level_elements(driver, pages):
pages.load("simpleTest.html")
text = driver.find_element(by=By.ID, value="twoblocks").text
assert text == "Some text" + newLine + "Some more text"
@pytest.mark.xfail_safari
def test_should_handle_whitespace_in_inline_elements(driver, pages):
pages.load("simpleTest.html")
text = driver.find_element(by=By.ID, value="inlinespan").text
assert text == "line has text"
def test_read_alarge_amount_of_data(driver, pages):
pages.load("macbeth.html")
source = driver.page_source.strip().lower()
assert source.endswith("