def test_is_element_displayed_splinter(self, page, splinter, splinter_strategy):
root_element = MagicMock()
root_element.configure_mock(
**{"find_by_{0}.return_value.first.visible".format(splinter_strategy): True}
)
locator = (splinter_strategy, str(random.random()))
region = Region(page, root=root_element)
assert region.is_element_displayed(*locator)
def test_is_element_displayed_not_present_selenium(self, page, selenium):
root_element = Mock()
locator = (str(random.random()), str(random.random()))
from selenium.common.exceptions import NoSuchElementException
root_element.find_element.side_effect = NoSuchElementException()
region = Region(page, root=root_element)
assert not region.is_element_displayed(*locator)
root_element.find_element.assert_called_once_with(*locator)
root_element.find_element.is_displayed.assert_not_called()
def test_is_element_displayed_hidden_selenium(self, page, selenium):
root_element = Mock()
locator = (str(random.random()), str(random.random()))
hidden_element = root_element.find_element()
hidden_element.is_displayed.return_value = False
region = Region(page, root=root_element)
assert not region.is_element_displayed(*locator)
root_element.find_element.assert_called_with(*locator)
hidden_element.is_displayed.assert_called_once_with()
def test_is_element_displayed_hidden(self, page, selenium):
root_element = Mock()
locator = (str(random.random()), str(random.random()))
hidden_element = root_element.find_element()
hidden_element.is_displayed.return_value = False
region = Region(page, root=root_element)
assert not region.is_element_displayed(locator)
root_element.find_element.assert_called_with(*locator)
hidden_element.is_displayed.assert_called_once_with()
def test_is_element_displayed_not_present(self, page, selenium):
root_element = Mock()
locator = (str(random.random()), str(random.random()))
from selenium.common.exceptions import NoSuchElementException
root_element.find_element.side_effect = NoSuchElementException()
region = Region(page, root=root_element)
assert not region.is_element_displayed(locator)
root_element.find_element.assert_called_once_with(*locator)
root_element.find_element.is_displayed.assert_not_called()
def test_is_element_displayed_not_present_splinter(self, page, splinter,
splinter_strategy):
root_element = Mock()
locator = (splinter_strategy, str(random.random()))
region = Region(page, root=root_element)
from splinter.element_list import ElementList
with patch('pypom.splinter_driver.Splinter.find_element',
new_callable=MagicMock()) as mock_find_element:
mock_find_element.return_value = ElementList([])
assert not region.is_element_displayed(*locator)
def test_is_element_displayed_hidden_splinter(self, page, splinter,
splinter_strategy):
root_element = MagicMock()
root_element.configure_mock(
**{
'find_by_{0}.return_value.first.visible'.format(splinter_strategy):
False
})
locator = (splinter_strategy, str(random.random()))
region = Region(page, root=root_element)
assert not region.is_element_displayed(*locator)
def test_is_element_displayed_hidden_splinter(self, page, splinter,
splinter_strategy):
locator = (splinter_strategy, str(random.random()))
hidden_element = splinter.find_element()
hidden_element.is_displayed.return_value = False
region = Region(page)
with patch('pypom.splinter_driver.Splinter.find_element',
new_callable=Mock()) as mock_find_element:
visible_mock = Mock().visible.return_value = False
first_mock = Mock().first.return_value = visible_mock
mock_find_element.return_value = first_mock
assert not region.is_element_displayed(*locator)
def test_is_element_displayed_not_present_splinter(
self, page, splinter, splinter_strategy
):
root_element = Mock()
locator = (splinter_strategy, str(random.random()))
region = Region(page, root=root_element)
from splinter.element_list import ElementList
with patch(
"pypom.splinter_driver.Splinter.find_element", new_callable=MagicMock()
) as mock_find_element:
mock_find_element.return_value = ElementList([])
assert not region.is_element_displayed(*locator)
def test_is_element_displayed_hidden_splinter(
self, page, splinter, splinter_strategy
):
locator = (splinter_strategy, str(random.random()))
hidden_element = splinter.find_element()
hidden_element.is_displayed.return_value = False
region = Region(page)
with patch(
"pypom.splinter_driver.Splinter.find_element", new_callable=Mock()
) as mock_find_element:
visible_mock = Mock().visible.return_value = False
first_mock = Mock().first.return_value = visible_mock
mock_find_element.return_value = first_mock
assert not region.is_element_displayed(*locator)
def test_no_root_usage_error(self, page, splinter):
root_element = MagicMock()
locator = ("not_valid_strategy", str(random.random()))
from pypom.exception import UsageError
with pytest.raises(UsageError):
Region(page, root=root_element).find_element(*locator)
def test_is_element_displayed_hidden_selenium(self, page, selenium):
locator = (str(random.random()), str(random.random()))
hidden_element = selenium.find_element()
hidden_element.is_displayed.return_value = False
assert not Region(page).is_element_displayed(*locator)
selenium.find_element.assert_called_with(*locator)
hidden_element.is_displayed.assert_called_once_with()
def test_is_element_displayed_not_present(self, page, selenium):
locator = (str(random.random()), str(random.random()))
from selenium.common.exceptions import NoSuchElementException
selenium.find_element.side_effect = NoSuchElementException()
assert not Region(page).is_element_displayed(*locator)
selenium.find_element.assert_called_once_with(*locator)
selenium.find_element.is_displayed.assert_not_called()
def test_find_elements_splinter(self, page, splinter, splinter_strategy):
root_element = MagicMock()
root_element.configure_mock(
**{'find_by_{0}.return_value'.format(splinter_strategy): Mock()})
locator = (splinter_strategy, str(random.random()))
Region(page, root=root_element).find_elements(*locator)
getattr(
root_element,
'find_by_{0}'.format(splinter_strategy)).assert_called_once_with(
locator[1])
def test_is_element_present_not_preset_splinter(self, page, splinter,
splinter_strategy):
root_element = MagicMock()
from splinter.element_list import ElementList
root_element.configure_mock(**{
'find_by_{0}.return_value'.format(splinter_strategy):
ElementList([])
})
locator = (splinter_strategy, str(random.random()))
assert not Region(page, root=root_element).is_element_present(*locator)
def test_is_element_present_splinter(self, page, splinter,
splinter_strategy):
root_element = Mock()
locator = (splinter_strategy, str(random.random()))
from splinter.element_list import ElementList
with patch('pypom.splinter_driver.Splinter.find_element',
new_callable=MagicMock()) as mock_find_element:
mock_find_element.return_value = ElementList([Mock()])
assert Region(page, root=root_element).is_element_present(*locator)
mock_find_element.assert_called_once_with(*locator,
root=root_element)
def test_find_elements_splinter(self, page, splinter, splinter_strategy):
locator = (splinter_strategy, str(random.random()))
from splinter.element_list import ElementList
page.driver.configure_mock(**{
'find_by_{0}.return_value'.format(splinter_strategy):
ElementList([])
})
Region(page).find_elements(*locator)
getattr(
page.driver,
'find_by_{0}'.format(splinter_strategy)).assert_called_once_with(
locator[1])
def test_after_wait_for_page_to_load(page):
log = []
class Plugin:
def pypom_after_wait_for_page_to_load(self, page):
log.append(1)
def pypom_after_wait_for_region_to_load(self, region):
log.append(2)
page.pm.register(Plugin())
page.open()
Region(page)
assert log == [1, 2]
def test_is_element_displayed_splinter(self, page, splinter,
splinter_strategy):
locator = (splinter_strategy, str(random.random()))
from mock import PropertyMock
visible_mock = PropertyMock(return_value=True)
page.driver.configure_mock(
**{
'find_by_{0}.return_value.first.visible'.format(splinter_strategy):
visible_mock
})
type(
getattr(page.driver, 'find_by_{0}'.format(
splinter_strategy)).return_value.first).visible = visible_mock
assert Region(page).is_element_displayed(*locator)
getattr(
page.driver,
'find_by_{0}'.format(splinter_strategy)).assert_called_once_with(
locator[1])
visible_mock.assert_called_with()
def test_find_elements_selenium(self, page, selenium):
root_element = Mock()
locator = (str(random.random()), str(random.random()))
Region(page, root=root_element).find_elements(*locator)
root_element.find_elements.assert_called_once_with(*locator)
selenium.find_elements.assert_not_called()
def region(self, page):
region = Region(page)
region._root_locator = (str(random.random()), str(random.random()))
return region
def test_no_root_usage_error(self, page, splinter):
locator = ('not_valid_strategy', str(random.random()))
from pypom.exception import UsageError
with pytest.raises(UsageError):
Region(page).find_element(*locator)
def test_root(self, page, driver):
element = Mock()
assert Region(page, root=element).root == element
def test_root(self, page):
assert Region(page).root is None
def test_wait_for_region(self, page):
assert isinstance(Region(page).wait_for_region_to_load(), Region)
def test_is_element_displayed_selenium(self, page, selenium):
root_element = Mock()
locator = (str(random.random()), str(random.random()))
assert Region(page, root=root_element).is_element_displayed(*locator)
root_element.find_element.assert_called_once_with(*locator)
selenium.find_element.assert_not_called()
def test_root(self, page, selenium):
element = Mock()
assert Region(page, root=element).root == element
def test_is_element_displayed_selenium(self, page, selenium):
locator = (str(random.random()), str(random.random()))
assert Region(page).is_element_displayed(*locator)
selenium.find_element.assert_called_once_with(*locator)
def test_find_elements_selenium(self, page, selenium):
locator = (str(random.random()), str(random.random()))
Region(page).find_elements(*locator)
selenium.find_elements.assert_called_once_with(*locator)
