class OneConsultantPageTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = OneConsultantPage(self.driver)
self.page.open()
self.page.set_element()
def tearDown(self):
self.driver.quit()
def _test_info(self):
self.assertTrue(ConsultantPlate(self.page.element, self.driver).check_fields())
def _test_question_list(self):
self.assertTrue(QuestionsList(self.driver).is_valid())
def _test_breadcrumbs(self):
self.page.get_breadcrumbs().click()
self.assertEqual(self.page.get_title(), self.page.BREADCRUMBS_TITLE)
def test_open_consult_form(self):
self.page.open_form()
self.assertTrue(self.page.is_consult_form_opened())
class IsOfficialCheckboxTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('TTHA2BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
def tearDown(self):
self.driver.quit()
def test_filter(self):
page = ShowroomPage(self.driver)
page.open()
search_form = page.search_form
search_form.is_official_checkbox_click()
search_form.submit()
showroom_list = page.showroom_list
items_count = showroom_list.get_items_count()
official_dealers_count = len(showroom_list.get_items_official_dealers())
self.assertEqual(official_dealers_count, items_count, "These dealers are not all official")
page.open()
class DropdownListTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = CompanyPage(self.driver)
self.page.open()
self.dropdown_list = self.page.dropdown_list
def test_scroll(self):
list_element = u'Бауманская'
self.page.dropdown_list.open_dropdown_list()
self.assertFalse(self.dropdown_list.element_is_visible(list_element))
self.dropdown_list.scroll(list_element)
self.assertTrue(self.dropdown_list.element_is_visible(list_element))
def test_dropdown_list_value(self):
metro_station = u'Бауманская'
self.assertEquals(u'Любое метро', self.dropdown_list.get_value())
self.page.dropdown_list.open_dropdown_list()
self.dropdown_list.select_metro_station(metro_station)
self.assertEquals(metro_station, self.dropdown_list.get_value())
def test_selection_metro_stations(self):
metro_station = u'Бауманская'
self.page.dropdown_list.open_dropdown_list()
self.dropdown_list.select_metro_station(metro_station)
def tearDown(self):
# self.page.close()
self.driver.quit()
class MedicamentsTestLeadersOfSellsTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = MedicamentsPage(self.driver)
self.page.open()
self.list = self.page.leaders_of_sells
def test_select_one_from_list(self):
drug = self.list.get_drags_name(2)
self.list.go_to_drugs_page(drug)
self.page.wait_for_another_page()
self.assertEquals(drug, self.list.result_drag())
self.driver.back()
drug = self.list.get_drags_name(4)
self.list.go_to_drugs_page(drug)
self.page.wait_for_another_page()
self.assertEquals(drug, self.list.result_drag())
def tearDown(self):
self.page.close()
self.driver.quit()
def __check(self, remote: webdriver.Remote):
first_required = remote.find_element_by_css_selector(
"div.first_block .form-control.first")
second_required = remote.find_element_by_css_selector(
"div.first_block .form-control.second")
third_required = remote.find_element_by_css_selector(
"div.first_block .form-control.third")
required_input = ["Name", "Surname", "*****@*****.**"]
for input_element, test_input in zip(
(first_required, second_required, third_required), required_input):
input_element.send_keys(test_input)
# Отправляем заполненную форму
button = remote.find_element_by_css_selector("button.btn")
button.click()
# Проверяем, что смогли зарегистрироваться
# ждем загрузки страницы
WebDriverWait(remote,
3).until(lambda x: x.find_element_by_tag_name("h1"))
# находим элемент, содержащий текст
welcome_text_elt = remote.find_element_by_tag_name("h1")
# записываем в переменную welcome_text текст из элемента welcome_text_elt
welcome_text = welcome_text_elt.text
expect = "Поздравляем! Вы успешно зарегистировались!"
# с помощью assert проверяем, что ожидаемый текст совпадает с текстом на странице сайта
self.assertEqual(expect, welcome_text,
f"{welcome_text} is not {expect}")
class RubricPageTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = RubricPage(self.driver)
self.page.open()
def tearDown(self):
self.driver.quit()
def test_slider_plate_fields(self):
self.assertTrue(Slider(self.driver).check_plates())
def test_slider_nav(self):
self.assertTrue(Slider(self.driver).check_next_slides_group())
def test_question_list_plate_fields(self):
self.assertTrue(QuestionsList(self.driver, plate_class=QuestionPlateRubric).check_plates())
def test_question_list_nav(self):
question_list = QuestionsList(self.driver, plate_class=QuestionPlateRubric)
question_list.go_to_next_page()
self.assertTrue(question_list.check_plates())
def test_open_consult_form(self):
self.page.open_form()
self.assertTrue(self.page.is_consult_form_opened())
class BasicTestCase(unittest.TestCase):
def setUp(self):
browser = os.environ.get('TTHA2BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self._login()
def tearDown(self):
self.driver.quit()
def _login(self):
auth_page = AuthPage(self.driver)
auth_page.open()
logged_in = auth_page.login(USERNAME, DOMAIN, PASSWORD)
if not logged_in:
raise Exception("Couldn't login")
def _fill_basic_settings(self, ad_page):
base_settings = ad_page.campaign_base_settings
base_settings.set_campaign_name(CAMPAIGN_NAME)
base_settings.set_product_type(PRODUCT_TYPE)
base_settings.set_pad_type(PAD_TYPE)
class QuestionPageTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = QuestionPage(self.driver)
self.page.open()
def tearDown(self):
self.driver.quit()
def test_breadcrumbs(self):
text = self.page.get_breadcrumbs().text
self.page.get_breadcrumbs().click()
self.assertGreater(self.page.get_title().find(text), -1)
def test_consultant_link(self):
self.page.trigger_login()
self.page.try_login()
text = self.page.get_consultant_link().text
self.page.get_consultant_link().click()
self.assertGreater(self.page.get_title().find(text), -1)
def test_open_consult_form(self):
self.page.open_form()
self.assertTrue(self.page.is_consult_form_opened())
class CatalogTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = DrugsPage(self.driver)
self.page.open()
self.catalog = self.page.catalog
def test_check_link(self):
for link in self.catalog.links():
self.assertTrue(self.catalog.check_link(link))
def test_check_redirect(self):
text = u"Витамины"
self.catalog.to_link(text)
#self.page.wait_for_another_page()
self.assertEquals(text, self.page.get_title())
self.driver.back()
text = u"Миорелаксанты"
self.catalog.to_link(text)
#self.page.wait_for_another_page()
self.assertEquals(text, self.page.get_title())
def tearDown(self):
#self.page.close()
self.driver.quit()
def setUp(self):
browser = os.environ.get('BROWSER', 'CHROME')
# browser = os.environ.get('BROWSER', 'FIREFOX')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
def setUp(self, auth=None, with_address=False):
super().__init__()
if not hasattr(self, 'driver'):
browser = os.environ.get('BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities,
browser).copy())
if auth == 'user':
self.login = os.environ.get('LOGIN')
self.password = os.environ.get('PASSWORD')
elif auth == 'admin':
self.login = os.environ.get('ADMIN_LOGIN')
self.password = os.environ.get('ADMIN_PASSWORD')
elif auth == 'support':
self.login = os.environ.get('SUP_LOGIN')
self.password = os.environ.get('SUP_PASSWORD')
if auth is not None:
auth_page = AuthPage(self.driver)
auth_page.open()
auth_page.wait_open()
auth_page.auth(self.login, self.password)
self.isAuthenticated = True
if with_address:
address_page = AddressPage(self.driver)
address_page.open()
address_page.start_address(DatabaseFiller().ADDRESS)
class AddressTest(unittest.TestCase):
DEFAULT_PHOTO = 'data/test_prod_photo.jpg'
PROFILE_PHOTO = 'data/test_rest_photo.jpg'
BIG_PROFILE_PHOTO = 'data/test_big_photo.jpg'
WRONG_PROFILE_PHOTO = 'data/test_non_photo_file'
def setUp(self):
browser = os.environ.get('BROWSER', 'CHROME')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
self.address_page = AddressPage(self.driver)
self.address_page.open()
self.address_form = self.address_page.form
def test_wrong_address_input(self):
self.address_form.wait_open()
self.address_form.set_address('some address')
address_error = self.address_form.get_input_error()
self.assertEqual(address_error, 'с точностью до дома')
def test_help_block(self):
self.address_form.wait_open()
self.address_form.set_address('Маяковская')
self.assertEqual(self.address_form.wait_help_block(), True)
def tearDown(self):
self.driver.quit()
class LinksTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = DrugPage(self.driver, 'vizarsin')
self.page.open()
self.contraindication = self.page.contraindication
self.social_networks = self.page.social_networks
self.instructions = self.page.instructions
def test_contraindications(self):
for link in self.contraindication.links():
self.assertTrue(self.contraindication.check_link(link))
def test_instructions(self):
for link in self.page.instructions.links():
self.assertTrue(self.page.instructions.check_link(link))
def test_social_networks(self):
for link in self.page.social_networks.links():
self.assertTrue(self.page.social_networks.check_link(link))
def tearDown(self):
#self.page.close()
self.driver.quit()
class TargetTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.browser = os.environ.get('TTHA4BROWSER', 'CHROME')
cls.password = os.environ.get('TTHA4PASSWORD', 'password')
cls.login = os.environ.get('TTHA4LOGIN', 'login')
cls.mode = os.environ.get('TTHA4MODE', 'mail')
def setUp(self):
""""
For webdriver
if self.browser == 'CHROME': self.driver = webdriver.Chrome()
else: self.driver = webdriver.Firefox()
"""
"""
This is for grid
"""
self.driver = Remote(
command_executor='http://localhost:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, self.browser).copy()
)
main_page = MainPage(self.driver)
main_page.open()
main_page.login_mail(self.login, self.password)
self.open();
def open(self):
return
def tearDown(self):
self.page.close()
self.driver.quit()
class GroupMessagesTest(unittest.TestCase):
USERS_COUNT = u'3 участника'
def setUp(self):
browser = 'FIREFOX'
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
auth_page = AuthPage(self.driver) # Auth here
auth_page.authorize()
def tearDown(self):
self.driver.quit()
def test(self):
message_page = GroupMessagesPage(self.driver) # Go to messages
message_page.open()
users_count = message_page.messages_menu.get_users_count(
) # проверка на правильное количество участников
self.assertEqual(self.USERS_COUNT, users_count)
message_page.messages_menu.send_message()
self.assertEqual(message_page.messages_menu.get_text_from_input(),
'') # отправка сообщений
message_page.messages_menu.report_msg()
report_window = message_page.messages_menu.get_report_popup()
self.assertTrue(report_window,
not None) # проверка появления попапа о репорте
def _load_family(driver: Remote, url: str) -> Bundle:
builder = Bundle.builder()
driver.get(url)
# todo: compare with store currency
currency = driver.execute_script("return Currency.currentCurrency;")
meta = driver.execute_script("return window.ShopifyAnalytics.meta;")
element = driver.find_element_by_id("product-form-{}".format(
meta["page"]["resourceId"]))
family_json = ujson.loads(element.get_attribute("data-product"))
family = _new_family(url, family_json)
builder.family(family)
for product_json in family_json["variants"]:
product = _new_product(family.id, product_json)
builder.product(product)
image_json = product_json["featured_image"]
if image_json:
builder.image(_new_product_image(family.id, product.id,
image_json))
bundle = builder.build()
logger.debug(
"Loaded product family '%s' with %d products and %d images from '%s'",
bundle.family.name, len(bundle.products), len(bundle.images),
bundle.family.url)
return bundle
def __create_browser_session(self):
options = Options()
if self.__config.get('SELENIUM_HEADLESS'):
options.headless = True
self.__browser = Remote(command_executor=self.__config['SELENIUM_URL'],
options=options)
logging.debug("Connected to remote browser")
def __init__(self, url, usuario, senha):
# Configurar o navegador
profile = FirefoxProfile()
profile.set_preference("browser.download.panel.shown", False)
profile.set_preference("browser.download.folderList", 2)
profile.set_preference("browser.download.manager.showWhenStarting", False)
profile.set_preference("browser.download.dir", DIRETORIO)
profile.set_preference(
"browser.helperApps.neverAsk.saveToDisk",
"text/plain, application/octet-stream, application/binary,\
text/csv, application/csv, application/excel, text/comma-separated-values,\
text/xml, application/xml",
)
profile.accept_untrusted_certs = True
# # Instanciar o navegar firefox e inserir as configurações
browser = Remote(
# command_executor= 'http://127.0.0.1:4444/wd/hub',
desired_capabilities=DesiredCapabilities.FIREFOX,
browser_profile=profile,
)
# browser = Firefox(profile) # Utilizar para teste locais
# Maximizar a tela do navegador
browser.maximize_window()
# Inserir os atributos para classe pai com uma instancia do navegador
super().__init__(url, usuario, senha, browser)
class TestMultipleEnv(unittest.TestCase):
def setUp(self):
self.available_node = {
'hub': ('http://127.0.0.1:4444/wd/hub', 'firefox'),
'node1': ('http://127.0.0.1:5555/wd/hub', 'chrome')
}
self.driver = None
self.base_url = "https://www.baidu.com"
def tearDown(self):
if self.driver is not None:
self.driver.quit()
def test_hub_node(self):
self.driver = Remote(self.available_node['node1'][0],
desired_capabilities={
'platform': 'ANY',
'browserName':
self.available_node['node1'][1],
'version': '',
'javascriptEnabled': True
})
#Rome 的用法如上，被操作的端口，平台，浏览器，平台版本，要通过hub调动node必需是能javascriptEnabled：True
self.driver.implicitly_wait(30)
driver = self.driver
driver.get(self.base_url)
driver.find_element_by_id("kw").send_keys("remote")
driver.find_element_by_id("su").click()
time.sleep(5)
def setUp(self):
browser = os.environ.get('BROWSER', os.environ['BROWSER'])
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
self.driver.maximize_window()
self.BOT_1_LOGIN = "******"
self.PASSWORD = os.environ['PASSWORD']
self.CURRENT_DIALOG_URL = ""
self.dialog_page = DialogPage(self.driver)
self.message_page = MessagePage(self.driver)
self.auth_page = AuthPage(self.driver)
self.auth_page.sign_in(self.BOT_1_LOGIN, self.PASSWORD)
self.main_page = MainPage(self.driver)
self.main_page.open_messages()
self.MESSAGE_TEXT = "testNumber1"
self.RED_POWER = u"☭☭☭☭☭☭"
self.URL_OF_MESSAGES = "https://ok.ru/messages"
self.create_dialog()
self.CURRENT_DIALOG_URL = self.driver.current_url
def setUp(self):
browser = os.environ.get('BROWSER', os.environ['BROWSER'])
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
self.driver.maximize_window()
self.MESSAGE_TEXT = "testNumber1"
self.BOT_1_LOGIN = "******"
self.BOT_2_LOGIN = "******"
self.PASSWORD = os.environ['PASSWORD']
self.CURRENT_DIALOG_URL = ""
self.dialog_page = DialogPage(self.driver)
self.message_page = MessagePage(self.driver)
self.auth_page = AuthPage(self.driver)
self.auth_page.sign_in(self.BOT_1_LOGIN, self.PASSWORD)
self.main_page = MainPage(self.driver)
self.main_page.open_messages()
self.URL_OF_DIALOG_WITH_ME = "https://ok.ru/messages/575662066926"
self.URL_OF_MESSAGES = "https://ok.ru/messages"
self.SEARCH_REQUEST = "happy birthday"
self.APPLICATION_ID = "1241398016"
self.NEED_TO_BLOCK_USER = False
self.NEED_TO_CHANGE_ACC = False
self.create_dialog()
self.CURRENT_DIALOG_URL = self.driver.current_url
class MedicamentsClassificationTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('TTHA2BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = MedicamentsPage(self.driver)
self.page.open()
self.classification_list = self.page.classification
def test_drug_type_selection(self):
text = u"Витамины"
self.classification_list.to_link(text)
self.page.wait_for_another_page()
self.assertEquals(text, self.classification_list.get_title())
self.driver.back()
text = u"Миорелаксанты"
self.classification_list.to_link(text)
self.page.wait_for_another_page()
self.assertEquals(text, self.classification_list.get_title())
def tearDown(self):
self.page.close()
self.driver.quit()
def setUp(self):
browser = os.environ.get(config.PREFERRED_BROWSER_KEY,
config.PREF_FIREFOX)
self.driver = Remote(command_executor=config.SELENIUM_GRID_HUB_ADDRESS,
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
self.auth()
class SimpleMessagesTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('BROWSER', 'FIREFOX')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
auth_page = AuthPage(self.driver) # Auth here
auth_page.authorize()
self.message_page = SimpleMessagesPage(self.driver)
def tearDown(self):
self.driver.quit()
def test_send_simple_message(self):
message = 'test'
self.message_page.open()
self.message_page.messages_menu.set_message(message)
self.message_page.messages_menu.get_button_send()
input_pole = self.message_page.messages_menu.get_message().text
self.assertEqual(input_pole, '')
def test_edit_simple_message(self):
message = 'testEdit'
self.message_page.open()
self.message_page.messages_menu.edit_message()
self.message_page.messages_menu.set_message(message)
self.message_page.messages_menu.get_button_send()
input_pole = self.message_page.messages_menu.get_message().text
self.assertEqual(input_pole, '')
def setUp(self):
self.login = os.environ.get('ADMIN_LOGIN')
self.password = os.environ.get('ADMIN_PASSWORD')
browser = os.environ.get('BROWSER', 'CHROME')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
address_page = AddressPage(self.driver)
address_page.open()
address_page.start_address('Россия, Москва, Знаменская улица, 53')
auth_page = AuthPage(self.driver)
auth_page.open()
auth_page.wait_open()
auth_page.auth(self.login, self.password)
profile_page = ProfilePage(self.driver)
profile_page.wait_open()
self.main_page = MainPage(self.driver)
self.main_page.open()
self.main_form = self.main_page.main_form
class BuyPageTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('TTHA2BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.driver.get("https://cars.mail.ru/sale/msk/all/")
def tearDown(self):
self.driver.quit()
def test_price_sort(self):
page = BuyPage(self.driver)
page.price_sort_btn.click()
cards = page.read_cards()
prices = [x.price for x in cards]
for i in range(0, len(prices) - 1):
self.assertTrue(prices[i] <= prices[i + 1])
def test_region(self):
page = BuyPage(self.driver)
page.region_btn.click()
page.region_input.send_keys(u'Казань')
page.city_first_result.click()
page.submit_region_btn.click()
page.apply_filter_lnk.click()
cards = page.read_cards()
for x in cards:
self.assertTrue(x.region == u'Казань')
def test_grid(self):
hub_url = 'http://127.0.0.1:4444/wd/hub'
capability = DesiredCapabilities.CHROME.copy()
for i in range(1,5):
# 利用Remote远程连接hub,hub将脚本分发给了不同的node
driver = Remote(command_executor=hub_url, desired_capabilities=capability)
driver.get('https://home.testing-studio.com/')
class ExampleTest(unittest.TestCase):
USERNAME = u'Дмитрий Котегов'
USEREMAIL = '*****@*****.**'
PASSWORD = os.environ['TTHA2PASSWORD']
BLOG = 'Флудилка'
TITLE = u'ЗаГоЛоВоК'
MAIN_TEXT = u'Текст под катом! Отображается внутри топика!'
def setUp(self):
browser = os.environ.get('TTHA2BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
def tearDown(self):
self.driver.quit()
def test(self):
auth_page = AuthPage(self.driver)
auth_page.open()
auth_form = auth_page.form
auth_form.open_form()
auth_form.set_login(self.USEREMAIL)
auth_form.set_password(self.PASSWORD)
auth_form.submit()
user_name = auth_page.top_menu.get_username()
self.assertEqual(self.USERNAME, user_name)
create_page = CreatePage(self.driver)
create_page.open()
create_form = create_page.form
create_form.blog_select_open()
create_form.blog_select_set_option(self.BLOG)
create_form.set_title(self.TITLE)
create_form.set_main_text(self.MAIN_TEXT)
create_form.submit()
topic_page = TopicPage(self.driver)
topic_title = topic_page.topic.get_title()
topic_text = topic_page.topic.get_text()
self.assertEqual(self.TITLE, topic_title)
self.assertEqual(self.MAIN_TEXT, topic_text)
topic_page.topic.open_blog()
blog_page = BlogPage(self.driver)
topic_title = blog_page.topic.get_title()
topic_text = blog_page.topic.get_text()
self.assertEqual(self.TITLE, topic_title)
self.assertEqual(self.MAIN_TEXT, topic_text)
blog_page.topic.delete()
topic_title = blog_page.topic.get_title()
topic_text = blog_page.topic.get_text()
self.assertNotEqual(self.TITLE, topic_title)
self.assertNotEqual(self.MAIN_TEXT, topic_text)
class CompanySearchTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = CompaniesPage(self.driver)
self.page.open()
self.search = self.page.search
def test_search_existing_companies(self):
query = u'Аптека'
self.search.input(query)
self.search.submit()
#self.page.wait_for_another_page()
self.assertNotEqual(0, len(self.search.found_companies()))
def test_search_non_existent(self):
query = u'aaaaaaaaaaaa'
self.search.input(query)
self.search.submit()
#self.page.wait_for_another_page()
self.assertEqual(0, len(self.search.found_companies()))
def tearDown(self):
# self.page.close()
self.driver.quit()
class ExampleTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('TTHA2BROWSER', 'FIREFOX')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
def tearDown(self):
self.driver.quit()
def test(self):
USERNAME = '******'
PASSWORD = os.environ['TTHA2PASSWORD']
DOMAIN = '@bk.ru'
auth_page = AuthPage(self.driver)
auth_page.open()
auth_form = auth_page.form
auth_form.set_domain(DOMAIN)
auth_form.set_login(USERNAME)
auth_form.set_password(PASSWORD)
auth_form.submit()
create_page = CreatePage(self.driver)
create_page.open()
email = create_page.top_menu.get_email()
self.assertEqual(USERNAME, email)
class TestChrome(unittest.TestCase):
def setUp(self):
self.capabilities = {}
self.command_executor = "http://192.168.6.23:5555/wd/hub"
#self.command_executor = "http://192.168.5.140:4444/wd/hub"
self.capabilities = DesiredCapabilities.CHROME.copy()
self.capabilities['browserName'] = 'chrome'
self.capabilities['platform'] = "WINDOWS"
self.capabilities['version'] = "7"
self.driver = None
self.base_url = "https://www.baidu.com"
def tearDown(self):
if self.driver is not None:
self.driver.quit()
def test_open_and_search(self):
print self.capabilities
self.driver = Remote(command_executor=self.command_executor,
desired_capabilities=self.capabilities)
self.driver.implicitly_wait(30)
driver = self.driver
driver.get(self.base_url)
driver.find_element_by_id("kw").send_keys("test chrome")
driver.find_element_by_id("su").click()
driver.get_screenshot_as_file("./chrome_capture.jpg")
def con() -> Remote:
_log.info("Starting a browser session. Connect to: %s", grid)
remote = Remote(
command_executor=grid, desired_capabilities=ChromeOptions().to_capabilities()
)
remote.implicitly_wait(5)
return remote
def setUp(self):
browser = os.environ.get('BROWSER', os.environ['BROWSER'])
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
self.driver.maximize_window()
self.BOT_1_LOGIN = "******"
self.PASSWORD = os.environ['PASSWORD']
self.CURRENT_DIALOG_URL = ""
self.USUAL_MESSAGE_TEXT = 'USUAL TEXT'
self.CHINESE_TEXT = u'測試漢字'
self.EMPTY_MESSAGE_TEXT = ''
self.LONG_VALID_MESSAGE = '_123' * 512
self.LONG_INVALID_MESSAGE = '_123' * 1024
self.MESSAGE_EDITED_TEXT = ' IS_EDITED'
self.MESSAGE_ANSWERED_TEXT = ' IS_ANSWERED'
self.dialog_page = DialogPage(self.driver)
self.message_page = MessagePage(self.driver)
self.auth_page = AuthPage(self.driver)
self.auth_page.sign_in(self.BOT_1_LOGIN, self.PASSWORD)
self.main_page = MainPage(self.driver)
self.main_page.open_messages()
self.create_dialog()
self.CURRENT_DIALOG_URL = self.driver.current_url
class CatalogTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
self.page = DrugsPage(self.driver)
self.page.open()
self.catalog = self.page.catalog
def test_check_link(self):
for link in self.catalog.links():
self.assertTrue(self.catalog.check_link(link))
def test_check_redirect(self):
text = u"Витамины"
self.catalog.to_link(text)
#self.page.wait_for_another_page()
self.assertEquals(text, self.page.get_title())
self.driver.back()
text = u"Миорелаксанты"
self.catalog.to_link(text)
#self.page.wait_for_another_page()
self.assertEquals(text, self.page.get_title())
def tearDown(self):
#self.page.close()
self.driver.quit()
class ConsultantsPageTest(unittest.TestCase):
RUBRIC = u'Кардиология'
RUBRIC_URL = 'cardiology'
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = ConsultantsPage(self.driver)
self.page.open()
def tearDown(self):
self.driver.quit()
def test_select_rubric(self):
self.page.select_rubric(self.RUBRIC)
self.assertGreater(self.driver.current_url.find(self.RUBRIC_URL), -1)
def test_select_sort_type(self):
self.page.select_friendly_sort()
self.assertEqual(self.page.get_current_tab_text(), self.page.FRIENDLY)
def test_open_consult_form(self):
self.page.open_form()
self.assertTrue(self.page.is_consult_form_opened())
class WrongTownTest(unittest.TestCase):
WRONG_TOWN_NAME = 'qwertyuiop'
TOP_MESSAGE = 'Некоторые поля заполнены неверно'
TOWN_ERROR = 'Проверьте название города'
def setUp(self):
browser = os.environ.get('BROWSER', 'CHROME')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
def tearDown(self):
self.driver.quit()
def test(self):
auth_page = AuthPage(self.driver)
auth_page.open()
auth_page.authorize()
userinfo_page = UserinfoPage(self.driver)
userinfo_page.open()
userinfo_form = userinfo_page.form
userinfo_form.set_town(self.WRONG_TOWN_NAME)
userinfo_form.wait_for_suggests_invisible()
userinfo_form.save()
self.assertEqual(self.TOP_MESSAGE, userinfo_form.get_top_message())
self.assertEqual(self.TOWN_ERROR, userinfo_form.get_town_message())
class QuestionPageTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
self.page = QuestionPage(self.driver)
self.page.open()
def tearDown(self):
self.driver.quit()
def test_breadcrumbs(self):
text = self.page.get_breadcrumbs().text
self.page.get_breadcrumbs().click()
self.assertGreater(self.page.get_title().find(text), -1)
def test_consultant_link(self):
self.page.trigger_login()
self.page.try_login()
text = self.page.get_consultant_link().text
self.page.get_consultant_link().click()
self.assertGreater(self.page.get_title().find(text), -1)
def test_open_consult_form(self):
self.page.open_form()
self.assertTrue(self.page.is_consult_form_opened())
class CompanyListTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = CompaniesPage(self.driver)
self.page.open()
self.list = self.page.company_list
def test_check_links(self):
for link in self.list.links():
self.assertTrue(self.list.check_link(link))
def test_check_redirect(self):
companies = self.list.get_all_companies()
for i in companies:
self.list.go_to_company_page(i)
#self.page.wait_for_another_page()
expected_title = i + u" в Москве"
self.assertEquals(expected_title, self.page.get_title())
self.driver.back()
def tearDown(self):
# self.page.close()
self.driver.quit()
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
self.page = QuestionPage(self.driver)
self.page.open()
def setUp(self):
browser = os.environ.get('BROWSER', os.environ['BROWSER'])
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.driver.maximize_window()
self.MESSAGE_TEXT = "testNumber1"
self.BOT_1_LOGIN = "******"
self.PASSWORD = os.environ['PASSWORD']
self.CURRENT_DIALOG_URL = ""
self.URL_OF_MESSAGES = "https://ok.ru/messages"
self.ANOTHER_MESSAGE_TEXT = 'new pinned'
self.NEW_ENG_TITLE = "Avengers: Infinity War"
self.NEW_RUS_TITLE = u"Мстители: Война Бесконечности"
self.NEW_CHINE_TITLE = u"复仇者：无穷的战争"
self.NEW_TOO_LONG_TITLE = "Avengers: It is really " + "infinity " * 42 + "War"
self.MAX_TITLE_LENGTH = 200
self.dialog_page = DialogPage(self.driver)
self.message_page = MessagePage(self.driver)
self.auth_page = AuthPage(self.driver)
self.auth_page.sign_in(self.BOT_1_LOGIN, self.PASSWORD)
self.main_page = MainPage(self.driver)
self.main_page.open_messages()
self.create_dialog()
self.dialog_page.add_user_to_chat()
class TestOne(object):
def setup_method(self, method):
self.driver = Remote(desired_capabilities=DesiredCapabilities().FIREFOX)
self.home = HomePage(self.driver).open().wait_until_loaded()
def teardown_method(self, method):
self.driver.quit()
@pytest.mark.pycon
@pytest.mark.shallow
def test_one(self):
assert(self.home.speak_blurb_title == "SPEAK")
@pytest.mark.pycon
@pytest.mark.deep
@pytest.mark.adam
def test_one_b(self):
schedule = self.home.go_to_schedule()
assert(schedule.tuesday_fake_table_venue == "720 Bathurst Street, suite 500")
def _load_family_urls(driver: Remote, url: str):
page_url_pattern = url + "?page={}"
result = []
page_number = 1
page_count = 1
while page_number <= page_count:
page_url = page_url_pattern.format(page_number)
driver.get(page_url)
div_element = driver.find_element_by_css_selector(
"div.breadcrumb-collection div.breadcrumb_text")
page_count = int(
re.match(".*Page \d+ of (?P<page_count>\d+)$",
div_element.get_property("innerText"),
re.IGNORECASE).group("page_count"))
a_elements = driver.find_elements_by_css_selector(
"div.product-list div.product-wrap a.product-info__caption")
for a_element in a_elements:
result.append(a_element.get_attribute("href"))
logger.debug("Loaded %d products family URLs from '%s'",
len(a_elements), page_url)
page_number += 1
return result
class BaseTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('BROWSER', 'CHROME')
options = None
if browser == 'CHROME' and platform.system() == 'Linux':
# fix for unknown error: DevToolsActivePort file doesn't exist
options = Options()
options.add_argument('--no-sandbox')
self.driver = Remote(options=options,
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
self.login = os.environ['LOGIN']
self.password = os.environ['PASSWORD']
def auth(self):
auth_page = AuthSteps(self.driver)
auth_page.open_page()
auth_page.open_login_form()
auth_page.fill_login_form(self.login, self.password)
auth_page.close_login_form_by_submit()
def tearDown(self):
self.driver.quit()
def setUp(self):
browser = os.environ.get('BROWSER', 'CHROME')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
AddressPage(self.driver).open()
storage = LocalStorage(self.driver)
storage.set('deliveryGeo', self.ADDRESS)
storage.set('longitude', self.LONGITUDE)
storage.set('latitude', self.LATITUDE)
self.driver.refresh()
self.driver.maximize_window()
main_page = MainPage(self.driver)
main_page.wait_visible()
main_page.auth(self.LOGIN, self.PASSWORD)
self.filler = DatabaseFiller()
self.filler.admin_auth()
self.filler.create_test_restaurants(1)
self.rest_id = self.filler.get_restaurant_id_by_name(
self.filler.TEST_REST_NAME.format(0))
self.rest_list_page = AdminRestaurantsPage(self.driver)
self.rest_list_page.open()
self.rest_list_page.wait_visible()
class DrugsSearchTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(
DesiredCapabilities, browser).copy())
self.page = DrugsPage(self.driver)
self.page.open()
self.search_form = self.page.search_form
def test_search_for_existent_drug(self):
query = u'ВИЗАРСИН'
self.search_form.input(query)
self.search_form.submit()
drugs = self.search_form.found_drugs()
self.assertIn(query, drugs)
def test_search_by_eng(self):
query = 'VIZARSIN'
self.search_form.input(query)
self.search_form.submit()
drugs = self.search_form.found_drugs()
self.assertIn(u'ВИЗАРСИН', drugs)
def test_search_for_non_existent_drug(self):
query = u'несуществующиетаблетки'
self.search_form.input(query)
self.search_form.submit()
self.assertEquals(None, self.search_form.items())
def tearDown(self):
#self.page.close()
self.driver.quit()
class AlphabeticalCatalogCheck(unittest.TestCase):
def setUp(self):
browser = os.environ.get('TTHA2BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
catalog_page = CatalogPage(self.driver)
catalog_page.open()
alphabetical_catalog = catalog_page.alphabetical_catalog
self.letters = alphabetical_catalog.get_catalog_letter_elements()
def tearDown(self):
self.driver.quit()
def test_visibility_of_tooltips_at_hover(self):
for letter in self.letters:
letter.hover()
self.assertEquals(letter.get_visibility_of_tooltip(), u'visible')
def test_positions_count(self):
for letter in self.letters:
self.assertGreater(letter.get_cars_count(), 0)
def open_url(host, browser):
dc = {"browserName": browser}
driver = Remote(command_executor=host, desired_capabilities=dc)
driver.get("https://www.baidu.com/")
driver.find_element(By.CSS_SELECTOR, ".s_ipt").send_keys("selenium")
driver.find_element(By.CSS_SELECTOR, "span>input#su").click()
driver.close()
class DrugsSearchTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.page = DrugsPage(self.driver)
self.page.open()
self.search_form = self.page.search_form
def test_search_for_existent_drug(self):
query = u'ВИЗАРСИН'
self.search_form.input(query)
self.search_form.submit()
drugs = self.search_form.found_drugs()
self.assertIn(query, drugs)
def test_search_by_eng(self):
query = 'VIZARSIN'
self.search_form.input(query)
self.search_form.submit()
drugs = self.search_form.found_drugs()
self.assertIn(u'ВИЗАРСИН', drugs)
def test_search_for_non_existent_drug(self):
query = u'несуществующиетаблетки'
self.search_form.input(query)
self.search_form.submit()
self.assertEquals(None, self.search_form.items())
def tearDown(self):
#self.page.close()
self.driver.quit()
class Case(TestCase):
def setUp(self):
self.browser = config.get("executor.browser.name", "CHROME")
self.server_url = config["executor.scheme"] + "://" + config[
"executor.server"] + "/wd/hub"
log_d("Try connect " + self.server_url)
self.driver = Remote(command_executor=config["executor.scheme"] +
"://" + config["executor.server"] + "/wd/hub",
desired_capabilities=getattr(
DesiredCapabilities, self.browser).copy())
# self.driver = webdriver.Chrome()
# self.driver = webdriver.Firefox()
self.driver.implicitly_wait(config["timeout"])
self.loginModel = LoginPage(self.driver, os.environ.get('LOGIN'),
os.environ.get('PASSWORD'))
self.loginModel.open()
self.loginModel.auth()
self.pages = []
def tearDown(self):
self.loginModel.close()
for page in self.pages:
page.close()
self.driver.close()
def addPage(self, page):
self.pages.append(page)
class amvr(unittest.TestCase):
def setUp(self):
self.username = os.environ['SAUCE_USERNAME']
self.key = os.environ['SAUCE_ACCESS_KEY']
print os.environ['testenv']
desired_capabilities = DesiredCapabilities.IPHONE
desired_capabilities['version'] = '5.0'
desired_capabilities['platform'] = 'MAC'
desired_capabilities['name'] = 'Testing Selenium 2 in Python at Sauce'
self.driver = Remote(desired_capabilities=desired_capabilities, command_executor="http://" + self.username + ":" + self.key + "@ondemand.saucelabs.com:80/wd/hub")
self.waiting = WebDriverWait(self.driver, 30)
def test_amvr(self):
driver = self.driver
waiting = self.waiting
driver.get("https://apps.tn.gov/amvr-app/login.html")
waiting.until(expected_conditions.title_is("Log In - Motor Vehicle Records Search"))
username_textbox = waiting.until(expected_conditions.visibility_of(driver.find_element_by_id("username")))
password_textbox = waiting.until(expected_conditions.visibility_of(driver.find_element_by_id("password")))
login_button = waiting.until(expected_conditions.visibility_of(driver.find_element_by_name("login")))
waiting.until(expected_conditions.title_is("Log In - Motor Vehicle Records Search"))
self.assertIn("amvr-app/login.html", driver.current_url, "Failed to login")
def tearDown(self):
self.driver.quit()
def setUp(self):
browser = os.environ.get('BROWSER', os.environ['BROWSER'])
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.driver.maximize_window()
self.MESSAGE_TEXT = "testNumber1"
self.LONG_MESSAGE_TEXT = "test" * 100
self.RED_POWER = u"☭☭☭☭☭☭" # special unicode
self.RUSSIAN_ARMENIAN_MESSAGE = u"привет աշխարհ"
self.NOT_VALID_MESSAGE = "?" * 4100
self.EMPTY_MESSAGE = ""
self.BOT_1_LOGIN = "******"
self.BOT_2_LOGIN = "******"
self.PASSWORD = os.environ['PASSWORD']
self.CURRENT_DIALOG_URL = ""
self.dialog_page = DialogPage(self.driver)
self.message_page = MessagePage(self.driver)
self.auth_page = AuthPage(self.driver)
self.auth_page.sign_in(self.BOT_1_LOGIN, self.PASSWORD)
self.main_page = MainPage(self.driver)
self.main_page.open_messages()
self.URL_OF_DIALOG_WITH_ME = "https://ok.ru/messages/575662066926"
self.URL_OF_MESSAGES = "https://ok.ru/messages"
self.NEED_TO_BLOCK_USER = False
self.NEED_TO_CHANGE_ACC = False
self.create_dialog()
self.CURRENT_DIALOG_URL = self.driver.current_url
class RestrictionSuite(unittest.TestCase):
def setUp(self):
browser = os.environ.get('TTHA2BROWSER', common.DEFAULT_BROWSER)
self.driver = Remote(
command_executor=common.GRID_URL,
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.create_page = common.get_create_page(self.driver)
def tearDown(self):
self.driver.quit()
def test_restriction_line_changes(self):
"""
Tests visual changes without creating of campaign
"""
expected_restriction = '18+'
expected_restriction_text = self.create_page.ad_form.set_restriction(expected_restriction)
restriction_line_text = self.create_page.ad_form.get_restriction_line_text()
self.assertEquals(expected_restriction_text, restriction_line_text)
def _test_restriction_saved(self, restriction):
"""
Compares selected restriction on create page with those on edit page
:param restriction: one of ('', '12+', '14+', '16+ '18+')
"""
self.create_page.configure()
expected_restriction_text = self.create_page.ad_form.set_restriction(restriction)
info_page = self.create_page.ad_form.submit()
edit_page = info_page.edit_page()
actual_restriction_text = edit_page.ad_form.get_restriction_line_text()
is_restriction_selected = edit_page.ad_form.is_restriction_selected(restriction)
info_page.delete()
self.assertTrue(is_restriction_selected)
self.assertEquals(expected_restriction_text, actual_restriction_text)
def test_restriction_none_saved(self):
"""
Tests for Not specified restriction
"""
self._test_restriction_saved('')
def test_restriction_16_saved(self):
"""
Tests for 16+ restriction
"""
self._test_restriction_saved('16+')
class Localhost(unittest.TestCase, CookieTest):
def setUp(self):
caps = {"browserName": "chrome",
"name": "Multiple Cookie Bug Test."}
self.browser = Remote('http://127.0.0.1:4444/wd/hub',
desired_capabilities=caps)
def tearDown(self):
self.browser.quit()
class FavouritesTestCase(unittest.TestCase):
USEREMAIL = 'smirnova-a-yu'
USERPASSWORD = os.environ.get('HW4PASSWORD')
OFFER_NUM = 2
def setUp(self):
self.browser = os.environ.get('HW4BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, self.browser).copy()
)
def tearDown(self):
self.driver.quit()
def test(self):
auth_page = AuthPage(self.driver)
auth_page.open()
auth_form = auth_page.form
auth_form.open_form()
auth_form.set_login(self.USEREMAIL)
auth_form.set_password(self.USERPASSWORD)
auth_form.submit()
# основная проверка добавления в избранное
offer_page = PageOffer(self.driver)
favorites_page = FavouritesPage(self.driver)
offer_page.open(self.OFFER_NUM)
offer_page.add_to_favourites()
favorites_page.open()
new_count = favorites_page.get_count()
self.assertEqual(new_count, 1)
# проверка нахождения в избранном добавленного объявления
f_item = FavouriteItem(self.driver)
f_item.open()
check_page = PageOffer(self.driver)
check_page.set_offer_id()
self.assertEqual(offer_page.get_offer_id(), check_page.get_offer_id())
# проверяем, что при повторном нажатии на кнопку "в избранное", элемент удалится
check_page.add_to_favourites()
favorites_page.open()
new_count = favorites_page.get_count()
self.assertEqual(new_count, 0)
# проверка удаления избранного из страницы избранное
offer_page.open(self.OFFER_NUM)
offer_page.add_to_favourites()
favorites_page.open()
favorites_page.clear_list()
favorites_page.open() # обновим страницу
count = favorites_page.get_count()
self.assertEqual(count, 0)
class Sauce(unittest.TestCase, CookieTest):
def setUp(self):
caps = {"platform": "Windows 2003",
"browserName": "firefox",
"version": "21",
"name": "Multiple Cookie Bug Test."}
self.browser = Remote('http://%(SAUCE_USER)s:%(SAUCE_KEY)[email protected]:4445/wd/hub' % os.environ,
desired_capabilities=caps)
def tearDown(self):
self.browser.quit()
class ShowroomListTest(unittest.TestCase):
def setUp(self):
browser = os.environ.get('TTHA2BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
def tearDown(self):
self.driver.quit()
def test_redirect(self):
page = ShowroomPage(self.driver)
page.open()
showroom_list = page.showroom_list
item_titles, item_page_title = showroom_list.get_item_titles()
for i in range(0, len(item_titles)):
self.assertEqual(item_titles[i], item_page_title[i])
def test_short_info(self):
page = ShowroomPage(self.driver)
page.open()
showroom_list = page.showroom_list
addresses = showroom_list.get_items_addresses()
phones = showroom_list.get_items_phones()
self.assertEqual(len(addresses), showroom_list.get_items_count())
self.assertEqual(len(phones), showroom_list.get_items_count())
items_count = showroom_list.get_items_count()
items_ids = [0, items_count / 2 - 4, items_count / 2, items_count / 2 + 4, items_count - 1]
for item_id in items_ids:
address = addresses[item_id]
self.assertIsNotNone(address)
phone = phones[item_id]
self.assertIsNotNone(phone)
def test_pagination(self):
page = ShowroomPage(self.driver)
page.open()
count_params = [20, 40, 100]
showroom_list = page.showroom_list
self.assertEqual(showroom_list.get_items_count(), showroom_list.get_pagination_count_current_param())
for count_param in count_params:
showroom_list.set_pagination_count_params(count_param)
self.assertEqual(showroom_list.get_items_count(), count_param)
def test_scenario_opera(self):
self.driver = Remote(
desired_capabilities=DesiredCapabilities.OPERA,
command_executor="http://{host}:{port}/wd/hub".format(host=Config.server, port=Config.port),
)
dali = Dali(self.driver)
# driver can navigate through himself
self.driver.get(self.page_url("colored"))
self.screenshot1 = dali.take_screenshot(resolution="800x600", path_to_save=self.current_directory)
# and we can use scenario with preset resolution
def scenario(driver):
driver.get(self.page_url("colored"))
self.screenshot2 = dali.take_screenshot(
resolution="800x600", scenario=scenario, scenario_args=self.driver, path_to_save=self.current_directory
)
self.assertTrue(os.path.exists(self.screenshot1))
self.assertTrue(os.path.exists(self.screenshot2))
image1 = Image.open(self.screenshot1)
image2 = Image.open(self.screenshot2)
matrix1 = numpy.asarray(image1)
matrix2 = numpy.asarray(image2)
numpy.testing.assert_array_equal(matrix1, matrix2)
def setUp(self):
browser = os.environ.get('TTHA2BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
self.USERNAME = '******'
self.PASSWORD = os.environ['TTHA2PASSWORD']
self.DOMAIN = '@bk.ru'
self.BANNER_TITLE = u'ololo'
self.BANNER_TEXT = u'Грильяж и куртизанки!'
self.BANNER_URL = u'http://my.mail.ru/v/42'
self.CAMPAIGN_NAME = ''.join(random.choice(string.ascii_letters) for _ in range(6))
self.BANNER_IMG = os.path.abspath('./tests/resourses/img/img.jpg')
auth_page = AuthPage(self.driver)
auth_page.open()
auth_form = auth_page.form
auth_form.set_domain(self.DOMAIN)
auth_form.set_login(self.USERNAME)
auth_form.set_password(self.PASSWORD)
auth_form.submit()
def setUp(self):
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, Data.BROWSER).copy()
)
sign_in(self.driver)
self.create_page = set_base_setting_and_submit_banner_form(self.driver)
def setUp(self):
browser = os.environ.get('TTHA2BROWSER', 'CHROME')
self.driver = Remote(
command_executor='http://127.0.0.1:4444/wd/hub',
desired_capabilities=getattr(DesiredCapabilities, browser).copy()
)
