def test_check_results_list_page_header_and_footer_links(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
home_page.search_for_where(u"Москва")
home_page.search_where_input().send_keys(Keys.RETURN)
webdriver.implicitly_wait(20)
results_list_page = PageFactory.create_page(ResultsListPage, webdriver)
self.check_link_active(results_list_page.header_logo_link(), webdriver, URL_PREFIXES.HOME_PAGE_PREFIX)
self.check_link_active(results_list_page.header_leisure_link(), webdriver, SECTION_LINKS_SUFFIX.LEISURE)
self.check_link_active(results_list_page.header_active_link(), webdriver, SECTION_LINKS_SUFFIX.ACTIVE)
self.check_link_active(results_list_page.header_restaurants_link(), webdriver, SECTION_LINKS_SUFFIX.RESTAURANTS)
self.check_link_active(results_list_page.header_hotels_link(), webdriver, SECTION_LINKS_SUFFIX.HOTELS)
self.check_link_nonactive(results_list_page.header_events_link(), webdriver, webdriver.current_url)
self.check_link_active(results_list_page.header_journeys_link(), webdriver, SECTION_LINKS_SUFFIX.JOURNEYS)
self.check_link_nonactive(results_list_page.header_around_link(), webdriver, webdriver.current_url)
self.check_link_nonactive(results_list_page.header_more_link(), webdriver, webdriver.current_url)
self.assertTrue(check_dropdown_menu_for_city(results_list_page.header_change_city_link(), webdriver),
'dropdown is not visible')
self.assertTrue(check_dropdown_menu_for_language(results_list_page.header_language_link(), webdriver),
'dropdown is not visible')
self.assertTrue(check_oops_tooltip_position(results_list_page.header_register_link(), webdriver),
'tooltip in other place')
self.assertTrue(check_oops_tooltip_position(results_list_page.header_login_link(), webdriver),
'tooltip in other place')
self.check_link_active(results_list_page.footer_logo_link(), webdriver, URL_PREFIXES.HOME_PAGE_PREFIX)
self.check_link_active(results_list_page.footer_leisure_link(), webdriver, SECTION_LINKS_SUFFIX.LEISURE)
self.check_link_active(results_list_page.footer_active_link(), webdriver, SECTION_LINKS_SUFFIX.ACTIVE)
self.check_link_active(results_list_page.footer_restaurants_link(), webdriver, SECTION_LINKS_SUFFIX.RESTAURANTS)
self.check_link_active(results_list_page.footer_hotels_link(), webdriver, SECTION_LINKS_SUFFIX.HOTELS)
self.check_link_nonactive(results_list_page.footer_events_link(), webdriver, webdriver.current_url)
self.check_link_active(results_list_page.footer_journeys_link(), webdriver, SECTION_LINKS_SUFFIX.JOURNEYS)
self.check_link_nonactive(results_list_page.footer_around_link(), webdriver, webdriver.current_url)
def test_search_only_with_what(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
home_page.search_for_what(u"Бар")
home_page.click_search_button()
webdriver.implicitly_wait(20)
results_list_page = PageFactory.create_page(ResultsList, webdriver)
self.assertGreater(len(results_list_page.poi_list_articles()), 1)
def test_results_list_briefs(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
home_page.search_for_what(u"Бар")
home_page.click_search_button()
webdriver.implicitly_wait(5)
results_list_page = PageFactory.create_page(ResultsListPage, webdriver)
results_list_page.get_results()
def test_create_page_with_list(self):
self.driver = WTF_WEBDRIVER_MANAGER.new_driver("TestPageFactor.test_create_page_with_list")
self.driver.get("http://www.google.com")
google = PageFactory.create_page([GoogleSearch, YahooSearch], self.driver)
self.assertTrue(type(google) == GoogleSearch)
self.driver.get("http://www.yahoo.com")
yahoo = PageFactory.create_page([GoogleSearch, YahooSearch], self.driver)
self.assertTrue(type(yahoo) == YahooSearch)
def test_search_only_with_what_by_enter(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
home_page.search_for_what(u"Бар")
home_page.search_what_input().send_keys(Keys.RETURN)
webdriver.implicitly_wait(5)
results_list_page = PageFactory.create_page(ResultsListPage, webdriver)
self.assertGreater(len(results_list_page.articles()), 1)
def test_create_page_createsPageWhenExists(self):
self.driver = WTF_WEBDRIVER_MANAGER.new_driver(
"TestPageFactory.test_create_page_createsPageWhenExists")
self.driver.get("http://www.google.com")
google = PageFactory.create_page(SearchPage, self.driver)
self.assertTrue(type(google) == GoogleSearch)
self.driver.get("http://www.yahoo.com")
yahoo = PageFactory.create_page(SearchPage, self.driver)
self.assertTrue(type(yahoo) == YahooSearch)
def test_pagination_existence_true_scenario(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
query = u"Бар"
self.assertGreater(SearchAPI().get_total_count(query), SearchAPI().get_count_on_page(query), 'Need to change the What query')
home_page.search_for_what(query)
home_page.click_search_button()
webdriver.implicitly_wait(20)
results_list_page = PageFactory.create_page(ResultsList, webdriver)
self.assertTrue(results_list_page.pagination_panel().is_displayed())
def test_create_page_with_list(self):
self.driver = WTF_WEBDRIVER_MANAGER.new_driver(
"TestPageFactor.test_create_page_with_list")
self.driver.get("http://www.google.com")
google = PageFactory.create_page([GoogleSearch, YahooSearch],
self.driver)
self.assertTrue(type(google) == GoogleSearch)
self.driver.get("http://www.yahoo.com")
yahoo = PageFactory.create_page([GoogleSearch, YahooSearch],
self.driver)
self.assertTrue(type(yahoo) == YahooSearch)
def test_search_only_with_where_when_found_greater_than_0(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
query = u"Москва"
found_count = YandexAPI().get_found_count(query)
self.assertGreater(found_count, 0)
home_page.search_for_where(query)
home_page.click_search_button()
webdriver.implicitly_wait(20)
results_list_page = PageFactory.create_page(ResultsList, webdriver)
self.assertGreater(len(results_list_page.poi_list_articles()), 1, 'POI list is empty')
def test_pagination_existence_false_scenario(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
query = u"Дельфин"
self.assertLessEqual(SearchAPI.get_total_count(query), SearchAPI.get_count_on_page(query),
'Need to change the What query')
home_page.search_for_what(query)
home_page.click_search_button()
webdriver.implicitly_wait(5)
results_list_page = PageFactory.create_page(ResultsListPage, webdriver)
self.assertFalse(results_list_page.pagination_panel().is_displayed())
def test_search_only_with_where_when_found_equals_0(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
query = 'UNACCEPTABLE'
found_count = YandexAPI.get_found_count(query)
self.assertEqual('0', found_count)
home_page.search_for_where(query)
home_page.click_search_button()
webdriver.implicitly_wait(5)
none_results_page = PageFactory.create_page(NoneResultsList, webdriver)
none_results_page.check_text_presence()
def test_search_only_with_where_when_found_equals_0(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
query = 'UNACCEPTABLE'
found_count = YandexAPI().get_found_count(query)
self.assertEqual('0', found_count)
home_page.search_for_where(query)
home_page.click_search_button()
webdriver.implicitly_wait(20)
results_list_page = PageFactory.create_page(ResultsList, webdriver)
self.assertEqual(u'Ничего не найдено', results_list_page.poi_place_holder().text, 'POI list is not empty. Message \'Nothing found\' is not displayed')
def test_distance_on_brief_card(self):
where_query = u"Москва"
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
home_page.search_for_where(where_query)
home_page.search_where_input().send_keys(Keys.RETURN)
webdriver.implicitly_wait(5)
results_list_page = PageFactory.create_page(ResultsListPage, webdriver)
results = results_list_page.get_results()
items = SearchAPI().get_items('', where_query)
for i, item in enumerate(items):
self.assertTrue(round_distance(item['distanceInMeters']), results['pois'][i]['distance'])
def test_example_using_abstract_interfaces(self):
"Demonstrates creating PageObjects using Abstract Factory pattern."
webdriver = WTF_WEBDRIVER_MANAGER.new_driver()
webdriver.get("http://www.google.com")
# Notice I don't need specify GoogleSearchPage specifically, and
# able to construct a ISearchPage of the correct type.
search_page = PageFactory.create_page(ISearchPage, webdriver)
self.assertEqual(GoogleSearchPage, type(search_page))
webdriver.get("http://www.yahoo.com")
search_page = PageFactory.create_page(ISearchPage, webdriver)
self.assertEqual(YahooSearchPage, type(search_page))
def test_example_using_abstract_interfaces(self):
"Demonstrates creating PageObjects using Abstract Factory pattern."
webdriver = WTF_WEBDRIVER_MANAGER.new_driver()
webdriver.get("http://www.google.com")
# Notice I don't need specify GoogleSearchPage specifically, and
# able to construct a ISearchPage of the correct type.
search_page = PageFactory.create_page(ISearchPage, webdriver)
self.assertEqual(GoogleSearchPage, type(search_page))
webdriver.get("http://www.yahoo.com")
search_page = PageFactory.create_page(ISearchPage, webdriver)
self.assertEqual(YahooSearchPage, type(search_page))
def test_home_page_basic(self):
webdriver = WTF_WEBDRIVER_MANAGER.new_driver()
webdriver.get(ConfigReader('site_credentials').get("default_url"))
home_page = PageFactory.create_page(HomePage, webdriver)
home_page.search_for_what(u"Бар")
home_page.search_for_where(u"Москва")
home_page.click_search_button()
webdriver.implicitly_wait(3000)
results_list_page = PageFactory.create_page(ResultsList, webdriver)
self.assertEqual(webdriver.title, "Localway")
category = results_list_page.category_filter_list()
category_path = PageUtils.get_element_xpath(category)
print category_path
print('test ok')
def test_weight_ranging_view(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
what_query = u"Бар"
where_query = u'Москва Тверская 17'
home_page.search_for_what(what_query)
home_page.search_for_where(where_query)
home_page.click_search_button()
webdriver.implicitly_wait(20)
results_list_page = PageFactory.create_page(ResultsListPage, webdriver)
items = SearchAPI().get_items(what_query, where_query)
names = results_list_page.articles_names()
names_list = [x.text for x in names]
item_names_list = [x[POI_KEYS.NAME] for x in items]
self.assertListEqual(item_names_list, names_list)
def test_check_home_page_header_and_footer_links(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
self.check_link_nonactive(home_page.header_logo_link(), webdriver, webdriver.current_url)
self.check_link_active(home_page.header_leisure_link(), webdriver, SECTION_LINKS_SUFFIX.LEISURE)
self.check_link_active(home_page.header_active_link(), webdriver, SECTION_LINKS_SUFFIX.ACTIVE)
self.check_link_active(home_page.header_restaurants_link(), webdriver, SECTION_LINKS_SUFFIX.RESTAURANTS)
self.check_link_active(home_page.header_hotels_link(), webdriver, SECTION_LINKS_SUFFIX.HOTELS)
self.check_link_nonactive(home_page.header_events_link(), webdriver, webdriver.current_url)
self.check_link_active(home_page.header_journeys_link(), webdriver, SECTION_LINKS_SUFFIX.JOURNEYS)
self.check_link_nonactive(home_page.header_around_link(), webdriver, webdriver.current_url)
self.check_link_nonactive(home_page.header_more_link(), webdriver, webdriver.current_url)
self.assertTrue(check_dropdown_menu_for_city(home_page.header_change_city_link(), webdriver),
'dropdown is not visible')
self.assertTrue(check_dropdown_menu_for_language(home_page.header_language_link(), webdriver),
'dropdown is not visible')
self.assertTrue(check_oops_tooltip_position(home_page.header_register_link(), webdriver),
'tooltip in other place')
self.assertTrue(check_oops_tooltip_position(home_page.header_login_link(), webdriver), 'tooltip in other place')
self.check_link_nonactive(home_page.footer_logo_link(), webdriver, webdriver.current_url)
self.check_link_active(home_page.footer_leisure_link(), webdriver, SECTION_LINKS_SUFFIX.LEISURE)
self.check_link_active(home_page.footer_active_link(), webdriver, SECTION_LINKS_SUFFIX.ACTIVE)
self.check_link_active(home_page.footer_restaurants_link(), webdriver, SECTION_LINKS_SUFFIX.RESTAURANTS)
self.check_link_active(home_page.footer_hotels_link(), webdriver, SECTION_LINKS_SUFFIX.HOTELS)
self.check_link_nonactive(home_page.footer_events_link(), webdriver, webdriver.current_url)
self.check_link_active(home_page.footer_journeys_link(), webdriver, SECTION_LINKS_SUFFIX.JOURNEYS)
self.check_link_nonactive(home_page.footer_around_link(), webdriver, webdriver.current_url)
def test_create_page_uses_page_rank(self):
self.driver = WTF_WEBDRIVER_MANAGER.new_driver(
"TestPageFactory.test_create_page_uses_page_rank")
self.driver.get("http://www.google.com")
google_page = PageFactory.create_page(
[GoogleSearch, GoogleSearch2], self.driver)
self.assertTrue(isinstance(google_page, GoogleSearch2))
def test_locate_me_move_pin(self):
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
home_page.search_for_what(u"Бар")
home_page.click_search_button()
webdriver.implicitly_wait(10)
results_list_page = PageFactory.create_page(ResultsListPage, webdriver)
results_list_page.click_search_locate_me()
needed_text = u'Москва, улица Ильинка'
past_inputted_text = results_list_page.lm_input_address().get_attribute("value")
ActionChains(webdriver).drag_and_drop_by_offset(results_list_page.lm_map_pin(), 50, 50).perform()
WebElementUtils.check_if_text_present_in_element_value(webdriver, (By.ID, LocateMe.lm_location_enabled_locator),
needed_text)
present_inputted_text = results_list_page.lm_input_address().get_attribute("value")
self.assertNotEqual(past_inputted_text, present_inputted_text)
self.assertEqual(results_list_page.lm_location_enabled().text, present_inputted_text)
def test_check_POI_page_header_and_footer_links(self):
webdriver = self.set_up_with_suffix(URL_PREFIXES.POI_ID_PREFIX + '172880af0000000000000000')
poi_page = PageFactory.create_page(POIPage, webdriver)
self.check_link_active(poi_page.header_logo_link(), webdriver, URL_PREFIXES.HOME_PAGE_PREFIX)
self.check_link_active(poi_page.header_leisure_link(), webdriver, SECTION_LINKS_SUFFIX.LEISURE)
self.check_link_active(poi_page.header_active_link(), webdriver, SECTION_LINKS_SUFFIX.ACTIVE)
self.check_link_active(poi_page.header_restaurants_link(), webdriver, SECTION_LINKS_SUFFIX.RESTAURANTS)
self.check_link_active(poi_page.header_hotels_link(), webdriver, SECTION_LINKS_SUFFIX.HOTELS)
self.check_link_nonactive(poi_page.header_events_link(), webdriver, webdriver.current_url)
self.check_link_active(poi_page.header_journeys_link(), webdriver, SECTION_LINKS_SUFFIX.JOURNEYS)
self.check_link_nonactive(poi_page.header_around_link(), webdriver, webdriver.current_url)
self.check_link_nonactive(poi_page.header_more_link(), webdriver, webdriver.current_url)
self.assertTrue(check_dropdown_menu_for_city(poi_page.header_change_city_link(), webdriver),
'dropdown is not visible')
self.assertTrue(check_dropdown_menu_for_language(poi_page.header_language_link(), webdriver),
'dropdown is not visible')
self.assertTrue(check_oops_tooltip_position(poi_page.header_register_link(), webdriver),
'tooltip in other place')
self.assertTrue(check_oops_tooltip_position(poi_page.header_login_link(), webdriver), 'tooltip in other place')
self.check_link_active(poi_page.footer_logo_link(), webdriver, URL_PREFIXES.HOME_PAGE_PREFIX)
self.check_link_active(poi_page.footer_leisure_link(), webdriver, SECTION_LINKS_SUFFIX.LEISURE)
self.check_link_active(poi_page.footer_active_link(), webdriver, SECTION_LINKS_SUFFIX.ACTIVE)
self.check_link_active(poi_page.footer_restaurants_link(), webdriver, SECTION_LINKS_SUFFIX.RESTAURANTS)
self.check_link_active(poi_page.footer_hotels_link(), webdriver, SECTION_LINKS_SUFFIX.HOTELS)
self.check_link_nonactive(poi_page.footer_events_link(), webdriver, webdriver.current_url)
self.check_link_active(poi_page.footer_journeys_link(), webdriver, SECTION_LINKS_SUFFIX.JOURNEYS)
self.check_link_nonactive(poi_page.footer_around_link(), webdriver, webdriver.current_url)
def test_locate_me_enter_unaccepted_address(self):
needed_text = u'Адрес не найден, исправьте адрес или выберите место на карте мышкой'
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
home_page.search_for_what(u"Бар")
home_page.click_search_button()
webdriver.implicitly_wait(10)
results_list_page = PageFactory.create_page(ResultsListPage, webdriver)
results_list_page.click_search_locate_me()
results_list_page.type_address(u'UNACCEPTABLE')
WebElementUtils.check_if_text_present_in_element_value(webdriver,
(By.ID, LocateMe.lm_location_disabled_locator),
needed_text)
self.assertEqual(results_list_page.lm_location_disabled().text, needed_text)
self.assertTrue(results_list_page.lm_save_button_disabled().is_displayed(), 'save button is present')
self.assertFalse(results_list_page.lm_save_button_enabled().is_displayed(), 'save button is present')
def switch_to_window(page_class, webdriver):
"""
Utility method for switching between windows. It will search through currently open
windows, then switch to the window matching the provided PageObject class.
Args:
page_class (PageObject): Page class to search for/instantiate.
webdriver (WebDriver): Selenium webdriver.
usage::
WebUtils.switch_to_window(DetailsPopUpPage, driver) # switches to the pop up window.
"""
window_list = list(webdriver.window_handles)
original_window = webdriver.current_window_handle
for window_handle in window_list:
webdriver.switch_to_window(window_handle)
try:
return PageFactory.create_page(page_class, webdriver)
except:
pass
webdriver.switch_to_window(original_window)
raise WindowNotFoundError(u("Window {0} not found.").format(page_class.__class__.__name__))
def switch_to_window(page_class, webdriver):
"""
Utility method for switching between windows. It will search through currently open
windows, then switch to the window matching the provided PageObject class.
Args:
page_class (PageObject): Page class to search for/instantiate.
webdriver (WebDriver): Selenium webdriver.
usage::
WebUtils.switch_to_window(DetailsPopUpPage, driver) # switches to the pop up window.
"""
window_list = list(webdriver.window_handles)
original_window = webdriver.current_window_handle
for window_handle in window_list:
webdriver.switch_to_window(window_handle)
try:
return PageFactory.create_page(page_class, webdriver)
except:
pass
webdriver.switch_to_window(original_window)
raise WindowNotFoundError("Window {0} not found.")
def test_image_gallery(self):
webdriver = self.set_up_with_suffix(URL_PREFIXES.POI_ID_PREFIX + str(TEST_POI_ID.POI_ID_FOR_PHOTO_GALLERY))
webdriver.implicitly_wait(10)
img_id = lambda: get_image_id_from_src(poi_page.get_center_image().get_attribute('src'))
poi = MongoDB().get_poi_by_id(TEST_POI_ID.POI_ID_FOR_PHOTO_GALLERY)
poi_page = PageFactory.create_page(POIPage, webdriver)
self.assertEqual(len(poi[POI_KEYS.IMAGES]), len(poi_page.get_circles()))
for i, poi_image_id in enumerate(poi[POI_KEYS.IMAGES]):
self.assertEqual(poi_image_id, img_id())
self.assertIn('active', poi_page.get_circles()[i].get_attribute('class'))
self.assertIn('active', poi_page.thumbnails_list()[i].get_attribute('class'))
poi_page.gallery_next().click()
webdriver.implicitly_wait(5)
self.assertEqual(poi[POI_KEYS.IMAGES][0], img_id())
for i, poi_image_id in reversed(list(enumerate(poi[POI_KEYS.IMAGES]))):
poi_page.gallery_previous().click()
self.assertEqual(poi_image_id, img_id())
self.assertIn('active', poi_page.get_circles()[i].get_attribute('class'))
self.assertIn('active', poi_page.thumbnails_list()[i].get_attribute('class'))
webdriver.implicitly_wait(5)
thumbnails_list = poi_page.thumbnails_list()
for i, thumb in list(enumerate(thumbnails_list)):
print i
poi_page.move_to_thumbnails()
webdriver.implicitly_wait(5)
if i % 7 == 0 and i != 0:
poi_page.thumbnails_next().click()
webdriver.implicitly_wait(5)
poi_page.thumbnails_list()[i].click()
webdriver.implicitly_wait(5)
self.assertEqual(poi[POI_KEYS.IMAGES][i], img_id())
def test_yandex_map_existence_false_scenario(self):
poi_id_without_yandex_map = MongoDB().get_random_poi_without_existing_coordinates()[POI_KEYS.ID]
webdriver = self.set_up_with_suffix(URL_PREFIXES.POI_ID_PREFIX + str(poi_id_without_yandex_map))
webdriver.implicitly_wait(10)
poi_page = PageFactory.create_page(POIPage, webdriver)
self.assertIsNone(POI_JSON(str(poi_id_without_yandex_map)).lat)
self.assertIsNone(POI_JSON(str(poi_id_without_yandex_map)).lon)
self.assertFalse(poi_page.yandex_map().is_displayed())
def test_locate_me_enter_valid_address(self):
address = u'Москва, улица Жебрунова'
webdriver = self.set_up()
home_page = PageFactory.create_page(HomePage, webdriver)
home_page.search_for_what(u"Бар")
home_page.click_search_button()
webdriver.implicitly_wait(10)
results_list_page = PageFactory.create_page(ResultsListPage, webdriver)
results_list_page.click_search_locate_me()
results_list_page.type_address(address)
WebElementUtils.check_if_text_present_in_element_value(webdriver, (By.ID, LocateMe.lm_input_address_locator),
address)
self.assertEqual(results_list_page.lm_input_address().get_attribute("value"), address)
self.assertEqual(results_list_page.lm_location_enabled().text, address)
self.assertFalse(results_list_page.lm_save_button_disabled().is_displayed(), 'save button is not present')
self.assertTrue(results_list_page.lm_save_button_enabled().is_displayed(), 'save button is not present')
results_list_page.click_save_location_button()
self.assertEqual(results_list_page.search_where_input().get_attribute("value"), address)
def test_admin_poi_page(self):
webdriver = self.set_up_with_suffix(URL_PREFIXES.ADMIN_POI_ID_PREFIX + '173760')
webdriver.implicitly_wait(10)
admin_poi_page = PageFactory.create_page(AdminPOIPage, webdriver)
payments = admin_poi_page.get_payments()
name = admin_poi_page.get_name()
admin_poi_page.select_section(u'Достопримечательности')
admin_poi_page.select_region(u'Московская область')
admin_poi_page.select_status(u'Архив')
def test_yandex_map_existence_false_scenario(self):
poi_id_without_yandex_map = '161708af0000000000000000'
webdriver = self.set_up()
webdriver.get(webdriver.current_url + '#poi/' + poi_id_without_yandex_map)
webdriver.implicitly_wait(20)
poi_page = PageFactory.create_page(POIPage, webdriver)
self.assertIsNone(POI_JSON(poi_id_without_yandex_map).lat)
self.assertIsNone(POI_JSON(poi_id_without_yandex_map).lon)
self.assertFalse(poi_page.yandex_map().is_displayed())
def test_amenity_links(self):
webdriver = self.set_up()
webdriver.get(ConfigReader('site_credentials').get(
"default_url") + URL_PREFIXES.POI_ID_PREFIX + '175481af0000000000000000')
webdriver.implicitly_wait(20)
poi_page = PageFactory.create_page(POIPage, webdriver)
poi_name = poi_page.name().text
amenities = poi_page.amenities()
chosen_amenity = choice(amenities)
chosen_amenity_text = chosen_amenity.text
chosen_amenity.click()
webdriver.implicitly_wait(20)
self.assertEqual(len(webdriver.window_handles), 1, 'link opened in the new tab or window')
results_list_page = PageFactory.create_page(ResultsListPage, webdriver)
first_result_name = [x.text for x in results_list_page.articles_names()][0]
self.assertEqual(poi_name, first_result_name)
amenities_checked = results_list_page.amenities_checked()
self.assertEqual(len(amenities_checked), 1)
self.assertEqual(amenities_checked[0].text, chosen_amenity_text)
def perform_search(search_term, webdriver):
"""
This flow function groups together a navigation to the search page, and
a search.
"""
webdriver.get("http://www.google.com")
search_page = PageFactory.create_page(ISearchPage, webdriver)
search_page.search(search_term)
return search_page
def perform_search(search_term, webdriver):
"""
This flow function groups together a navigation to the search page, and
a search.
"""
webdriver.get("http://www.google.com")
search_page = PageFactory.create_page(ISearchPage, webdriver)
search_page.search(search_term)
return search_page
def test_viewed_together_data_existence(self):
webdriver = self.set_up_with_suffix(URL_PREFIXES.POI_ID_PREFIX + str(TEST_POI_ID.POI_ID_FOR_VIEWED_TOGETHER))
webdriver.implicitly_wait(10)
poi_page = PageFactory.create_page(POIPage, webdriver)
vt_info = poi_page.get_viewed_together_info()
for v in vt_info['pois']:
self.assertNotEqual(v['name'], '')
self.assertIsNotNone(v['hotel_stars'])
self.assertNotEqual(v['rating'], '')
self.assertNotEqual(v['categories'], '')
self.assertNotEqual(v['address'], '')
def test_around_poi_data_existence(self):
around_poi_info = get_recommendations_for_poi("227774af0000000000000000")
webdriver = self.set_up_with_suffix(URL_PREFIXES.POI_ID_PREFIX + "227774af0000000000000000")
webdriver.implicitly_wait(10)
poi_page = PageFactory.create_page(POIPage, webdriver)
poi_page.click_show_more()
ar_info = poi_page.get_around_poi_info()
for i, poi in enumerate(around_poi_info[4]):
print str(i) + ') ' + poi["name"]
#self.assertEqual(delete_whitespace_edges(poi["name"]), ar_info['pois'][i]['name'])
for i, poi in enumerate(ar_info['pois']):
print str(i) + ') ' + poi["name"]
def test_basic_example(self):
"Displays a simple PageObject instantiation example."
# WTF_WEBDRIVER_MANAGER provides a easy to access to
# the webdriver. A web browser will be instantiated
# according to your config settings.
# - see 'selenium' settings in 'configs/default.yaml'
webdriver = WTF_WEBDRIVER_MANAGER.new_driver()
# Simple navigation
webdriver.get("http://www.google.com")
# Use the PageFactory class to instantiate your page.
google_page = PageFactory.create_page(GoogleSearchPage, webdriver)
# With your PageObject instantiated, you can call it's methods.
google_page.search("hello world")
self.assertTrue(google_page.result_contains("hello world"))
def test_using_the_testdata(self):
"""
Demonstrates getting a setting via testdata package, and WTF_CONFIG_READER
By default it'll use google.com, but you can add this line in the config file
(by default it's default.yaml) You can override this setting.
Insert the line below and run again to see this same test run in Yahoo.
search_provider: http://www.yahoo.com
By creating testdata functions to abstract directly accessing WTF_CONFIG_READER,
we can reduce the number of hard coded strings that needs to be refactored if
configuration settings need to be refactored.
"""
search_url = get_search_provider()
webdriver = WTF_WEBDRIVER_MANAGER.new_driver()
webdriver.get(search_url)
search_page = PageFactory.create_page(ISearchPage, webdriver)
search_page.search("hello world")
self.assertTrue(search_page.result_contains("hello world"))
