def test_element_handles_index_error():
driver = MockDriver()
find = Finder(driver, None)
element = find.element(PageElement(By.CLASS_NAME, ""))
assert_that(element, equal_to(None),
"None should be returned when no elements can be found")
def test_select_by_index(mock_select_by_index):
find = MockFinder()
interact = Interactor(None, find, None, None, None)
page_element = PageElement(By.ID, "test-id")
interact.select_by_index(page_element, "index to check")
mock_select_by_index.assert_called_once_with("index to check")
def test_select_by_visible_text(mock_select_by_visible_text):
find = MockFinder()
interact = Interactor(None, find, None, None, None)
page_element = PageElement(By.ID, "test-id")
interact.select_by_visible_text(page_element, "text to check")
mock_select_by_visible_text.assert_called_once_with("text to check")
def test_is_element_visible():
elements = [MockElement("true")]
finder = MockFinder(list_of_elements_to_return=elements)
test_interrogator = Interrogator("", finder, "logger")
test_interrogator.is_element_visible(PageElement(By.ID, "some_id"))
assert_that(elements[0].is_displayed_called, is_(1),
"is_displayed was not called the expected amount of times")
def test_number_of_elements():
elements_to_return = [MockElement(), MockElement(), MockElement()]
driver = MockDriver(elements_to_return)
find = Finder(driver, None)
num_elements = find.number_of_elements(PageElement(By.CLASS_NAME, ""))
assert_that(num_elements, equal_to(3),
"Incorrect number of elements returned")
class SimpleTestPage(BasePage):
endpoint = ""
expected_element = PageElement(By.XPATH, "//h1[contains(.,'Overview')]")
def go_to_page(self, base_url):
self.interact.open_url(base_url + self.endpoint)
def expected_element_is_visible(self):
return self.interrogate.is_element_visible(self.expected_element)
def test_send_keys():
find = MockFinder()
interact = Interactor(None, find, None, None, None)
page_element = PageElement(By.ID, "test-id")
interact.send_keys(page_element, Keys.ARROW_LEFT)
assert_that(find.mock_element.text, equal_to(""),
"Key not sent to element correctly")
def test_enter_text():
find = MockFinder()
interact = Interactor(None, find, None, None, None)
page_element = PageElement(By.ID, "test-id")
interact.enter_text(page_element, "abcd", False)
assert_that(find.mock_element.text, equal_to("abcd"),
"Text not sent to element correctly")
def test_elements():
driver = MockDriver()
find = Finder(driver, None)
elements = find.elements(PageElement(By.ID, "test-id"))
assert_that(elements[0].info,
equal_to("elements found by 'id' using value 'test-id'"),
"An element list should be found")
def test_add():
page_heading = PageElement(By.XPATH, "//*[@class='heading']")
page_heading_link = page_heading + "//a"
assert_that(
page_heading_link.locator_value, equal_to("//*[@class='heading']//a"),
"Incorrect result when adding "
"value to existing PageElement")
def test_execute_click_with_java_script():
mock_driver = MagicMock(name="driver")
find = MockFinder()
interact = Interactor(mock_driver, find, None, None, None)
page_element = PageElement(By.ID, "test-id")
interact.execute_click_with_java_script(page_element)
mock_driver.execute_script.assert_called_once_with("arguments[0].click();",
find.mock_element)
def test_element():
driver = MockDriver()
find = Finder(driver, None)
element = find.element(PageElement(By.CLASS_NAME, "test-class"))
assert_that(
element.info,
equal_to("elements found by 'class name' using value 'test-class'"),
"An element should be found")
def test_scroll_into_view():
mock_driver = MagicMock(name="driver")
find = MockFinder()
interact = Interactor(mock_driver, find, None, None, MagicMock(name="log"))
page_element = PageElement(By.ID, "test-id")
interact.scroll_into_view(page_element)
mock_driver.execute_script.assert_called_once_with(
"arguments[0].scrollIntoView();", find.mock_element)
def test_enter_text_clears_first():
find = MockFinder()
interact = Interactor(None, find, None, None, None)
page_element = PageElement(By.ID, "test-id")
find.mock_element.text = "1234"
interact.enter_text(page_element, "abcd", True)
assert_that(find.mock_element.text, equal_to("abcd"),
"Text not cleared before sending")
def test_click_element():
find = MockFinder()
interact = Interactor(None, find, None, None, None)
page_element = PageElement(By.ID, "test-id")
interact.click_element(page_element)
assert_that(len(find.mock_element.clicked_elements), equal_to(1),
"The element should have been clicked once")
assert_that(find.mock_element.clicked_elements[0], equal_to(page_element),
"Incorrect element clicked")
def test_is_element_visible():
mock_driver = MagicMock()
elements = [MockElement("true")]
finder = MockFinder(list_of_elements_to_return=elements)
wait_time = 10
test_interrogator = Interrogator(mock_driver, finder, wait_time, "logger")
test_interrogator.is_element_visible(PageElement(By.ID, "some_id"))
assert_that(mock_driver.implicitly_wait.call_count, equal_to(2),
"Expected two calls to implicitly_wait")
assert_that(elements[0].is_displayed_called, is_(1),
"is_displayed was not called the expected amount of times")
def test_elements_logs_out_info():
driver = MockDriver()
logger = MagicMock()
find = Finder(driver, logger)
find.elements(PageElement(By.ID, "test-id"))
assert_that(logger.info.call_count, equal_to(2),
"Two messages should have been logged")
logger.info.assert_any_call(
"Looking for elements matching PageElement id='test-id'")
logger.info.assert_any_call("Found 1 element(s)")
def test_switch_to_frame():
mock_driver = MagicMock(name="driver")
finder = Finder(mock_driver, MagicMock(name="logger"))
interrogator = Interrogator(mock_driver, finder, "logger")
waiter = Waiter(mock_driver, finder, "logger")
test_interactor = Interactor(mock_driver, finder, interrogator, waiter,
"logger")
frame_to_find = PageElement(By.ID, "frame_id")
test_interactor.switch_to_frame(frame_to_find)
mock_driver.switch_to.frame.assert_called_once_with(
finder.element(frame_to_find))
def test_visible_elements_returns_correct_elements():
elements_to_return = [
MockElement("", True, "false"),
MockElement("", False, "false"),
MockElement("", True, "true"),
MockElement("", False, "true")
]
driver = MockDriver(elements_to_return)
find = Finder(driver, None)
visible_elements = find.visible_elements(
PageElement(By.CLASS_NAME, "test-class"))
assert_that(len(visible_elements), equal_to(1),
"Incorrect number of elements returned")
from unittest import mock
from unittest.mock import MagicMock
import requests
from hamcrest import assert_that, equal_to, contains, is_
from selenium.webdriver.common.by import By
from tests.unit.unit_test_utils import check_mocked_functions_called
from uitestcore.finder import Finder
from uitestcore.interrogator import Interrogator
from uitestcore.page_element import PageElement
default_page_element = PageElement(By.ID, "test-id")
class MockDriver(object):
@staticmethod
def get_cookies():
mock_cookies = [{
"name": "nhsuk-cookie-consent",
"value": "%7B%22preferences%22%3Atrue%7D"
}, {
"name": "s_getNewRepeat",
"value": "1564127000350-Repeat"
}]
return mock_cookies
class MockFinder(object):
def __init__(self, list_of_elements_to_return=None):
self.list_of_elements_to_return = list_of_elements_to_return
def elements(self, _page_element):
