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)