def setUp(self):
super(DirectoryTest, self).setUp()
self.directory_page = DirectoryPage(self.driver)
self.directory_page.open()
self.auth()
self.main_page = MainPage(self.driver)
self.main_page.hide_app_loader()
self.manager = self.main_page.letter_manager
def setUpClass(self):
#self.con = DB.init_connection()
#print('Database connected')
#DB.delete_all_from_db(self.con)
#print('Clear table')
self.driver = webdriver.Chrome()
print('Browser started')
self.driver.maximize_window()
self.MAIN_PAGE = MainPage(self.driver)
self.MAIN_PAGE.open_url(self.url)
def test_should_not_sign_in_unregistered_user(self):
# given
main_page = MainPage(self.driver)
main_page.dismiss_modals()
# when
login_page = main_page.go_to_sign_in_page()
login_page.sign_in("*****@*****.**", "unregistered")
# then
assert login_page.is_not_signed_in(
"This email address or password is incorrect")
def navigate_to_selected_webpage(context):
context.user = random_email_generator()
context.faker = Faker('en_US')
context.driver.get(get_main_page_url())
context.main_page = MainPage(context)
context.authentication_page = AuthenticationPage(context)
context.account_page = AccountPage(context)
def test_should_item_and_total_bag_prices_be_correct(self):
# given
main_page = MainPage(self.driver)
main_page.dismiss_modals()
result_page = main_page.search_for_phrase("Garmin forerunner")
product_page = result_page.get_first_product_result()
# when
product_page.add_product_to_bag()
bag_page = product_page.view_bag()
# and
bag_page.increase_product_quantity()
bag_page.update_bag()
# then
assert bag_page.is_total_price_correct()
def test_edit_and_save_home_address(self):
streetaddress = random.randint()
MainPage(self.driver).navigate_to_contact_information()
contact_info_page = ContactInformationPage(self.driver)
contact_info_page.wait_for_load()
contact_info_page.edit_home_address()
contact_info_page.home_streetaddress().set_value("123 Anywhere")
time.sleep(5)
class SearchMainPage(BaseTest, unittest.TestCase):
def setUp(self):
super(SearchMainPage, self).setUp()
self.page = MainPage(self.driver, root_uri=s['root_url'])
self.page.get(MainPage._page_url)
def testsearchMain(self):
search_term = "lose weight"
self.page._search_query_locator = search_term
self.page._search_submit.click()
# verify we are on Search Page by checking page title
self.assertIn(SearchPage._page_title, self.page.w.title)
# verify that there are any search results (more than 0)
results = self.page.w.find_elements_by_class_name(
SearchPage._search_results_selenium)
self.assertGreater(len(results), 0)
def tearDown(self):
#self.driver.quit()
super(SearchMainPage, self).tearDown()
def test_guest_can_go_to_login_page(self, browser):
link = "http://selenium1py.pythonanywhere.com/"
page = MainPage(browser, link)
page.open()
page.go_to_login_page()
login_page = LoginPage(browser, browser.current_url)
print()
login_page.should_be_login_page()
def test_successful_login(self):
"""
Tests a successful login attempt
"""
#Load the logon page.
login_page = LogonPage(self.driver)
login_page.wait_for_load()
#Pass in a bogus username and password
login_page.username().set_value(Constants.testusername)
login_page.password().set_value(Constants.testpassword)
#Attempt to login
login_page.click_submit_button()
#Verify the main page is loaded and the welcome message
main_page = MainPage(self.driver)
main_page.wait_for_load()
welcome_message = main_page.get_welcome_message()
assert_equal(welcome_message, "Welcome, Art Venere")
def test_successful_login(self):
"""
Tests a successful login attempt
"""
#Load the logon page.
login_page = LogonPage(self.driver)
login_page.wait_for_load()
#Pass in a bogus username and password
login_page.username().set_value(Constants.testusername)
login_page.password().set_value(Constants.testpassword)
#Attempt to login
login_page.click_submit_button()
#Verify the main page is loaded and the welcome message
main_page = MainPage(self.driver)
main_page.wait_for_load()
welcome_message = main_page.get_welcome_message()
assert_equal(welcome_message, "Welcome, Art Venere")
class SearchMainPage(BaseTest, unittest.TestCase):
def setUp(self):
super(SearchMainPage, self).setUp()
self.page = MainPage(self.driver, root_uri=s['root_url'])
self.page.get(MainPage._page_url)
def testsearchMain(self):
search_term = "lose weight"
self.page._search_query_locator = search_term
self.page._search_submit.click()
# verify we are on Search Page by checking page title
self.assertIn(SearchPage._page_title, self.page.w.title)
# verify that there are any search results (more than 0)
results = self.page.w.find_elements_by_class_name(SearchPage._search_results_selenium)
self.assertGreater(len(results), 0)
def tearDown(self):
#self.driver.quit()
super(SearchMainPage, self).tearDown()
def setup_method(self, method):
self.logging_util = LoggingUtil()
self.logging_util.setup_logging()
self.logger = logging.getLogger()
desired_caps = {
'platformName': 'Android',
# 'deviceName': '127.0.0.1:5554', # 手机设备名称，通过adb devices查看
'deviceName': '127.0.0.1:62001', # 手机设备名称，通过adb devices查看
'platformVersion': '5.1.1', # android系统的版本号
'appPackage': 'com.aiosign.dzonesign', # apk包名
# apk的launcherActivity
'appActivity': 'com.aiosign.dzonesign.view.AppStartActivity',
}
self.logger.info('启动app')
try:
self.driver = webdriver.Remote('http://localhost:4723/wd/hub',
desired_caps)
time.sleep(3)
self.base_page = BasePage(self.driver)
self.welcome_page = WelcomePage(self.base_page)
self.login_page = LoginPage(self.base_page)
self.main_page = MainPage(self.base_page)
except Exception:
BasePage.get_screen('screen_shot/')
def test_login_valid(self, login, password):
main_page = MainPage(self.driver)
main_page.open()
main_page.login()
login_page = LoginPage(self.driver)
login_page.wait_for_page_to_load()
login_page.set_email(login)
login_page.set_password(password)
login_page.login()
assert login_page.error_message_visible
dashboard_page = DashboardPage(self.driver)
dashboard_page.wait_for_page_to_load()
assert dashboard_page.dropdown_visible
def test_scenario_2(self):
city = 'Рига'
main_page = MainPage(self.driver)
assert main_page.is_title_matches(), "Title is not matches!"
main_page.choose_city(city)
main_page.click_check_prices_button()
search_page = SearchHotelPage(self.driver)
assert search_page.is_page_opened(city), "Page title is not matches!"
assert search_page.check_pices_presence() is False, "Prices are shown!"
assert search_page.check_calendar_presence(), "Calendar is not opened!"
search_page.close_calendar()
assert search_page.check_calendar_presence() is False, "Calendar is not closed!"
search_page.click_show_prices_button()
assert search_page.check_calendar_presence(), "Calendar is not opened!."
search_page.choose_avaliable_date()
search_page.click_submit_button()
assert search_page.check_pices_presence(), "Prices are not shown!"
assert search_page.check_prices_presence_in_description(), "Prices counter is not equal to hotel articles counter!"
def test_checkLive(self):
MainPage._verify_page(self)
MainPage._login(self)
MainPage._check_if_ticket(self)
MainPage._get_timestamp(self)
def setUp(self):
super(SearchMainPage, self).setUp()
self.page = MainPage(self.driver, root_uri=s['root_url'])
self.page.get(MainPage._page_url)
def test_input(self):
# Enable flash
BestTestCase.navigate_to_page(self, TT_Constants["Flash_URL"])
MainPage._allow_flash(self)
# Open file
f = open("../word.txt", "r")
word = f.read()
# Go to Chinese input website
BestTestCase.navigate_to_page(self, TT_Constants["Base_URL"])
input_word = word
input_ls = MainPage._handle_input(self, input_word)
for i in range(len(input_ls)):
MainPage._input_new_word(self, input_ls[i])
MainPage._customize_click(self)
MainPage._input_line_no(self)
#TODO: Download files automatically (Flash content)
# filename = "screenshot/image_" + BasePage.timestamp(self) + ".png"
# BasePage.screenshot(self, filename)
# MainPage._save_to_pdf(self)
# # Go back to previous main page TODO:判斷是否有page2
BasePage.goback_to_previous_window(self)
# Clear inputted words
MainPage._clear_inputted_words(self)
# Download Manually
time.sleep(2000)
def authorise(remote_chrome):
auth_page = MainPage(remote_chrome)
auth_page.go_to_site()
auth_page.authorise()
return authorise
def test_guest_should_see_login_link(browser):
link = "http://selenium1py.pythonanywhere.com/"
page = MainPage(browser, link)
page.open()
page.should_be_login_link()
def test_guest_can_go_to_login_page(browser):
link = "http://selenium1py.pythonanywhere.com/"
page = MainPage(browser, link)
page.open()
page.go_to_login_page()
class LoginTest(BasicTest):
def setUp(self):
super(LoginTest, self).setUp()
self.login_page = LoginPage(self.driver)
self.login_page.open()
self.main_page = MainPage(self.driver)
def test_correct_login(self):
MAIL_URL = self.MAIL_URL + '/'
self.login_page.sign_in(self.login, self.password)
self.login_page.wait_redirect(MAIL_URL)
self.assertEqual(self.driver.current_url.split('?')[0], MAIL_URL)
def test_wrong_password(self):
WRONG_PASSWORD = '******'
self.login_page.sign_in(self.login, WRONG_PASSWORD)
test_validation = self.login_page.get_validation_message()
EXPECTED_VALIDATION_1 = 'Неверный пароль, попробуйте ещё раз'
EXPECTED_VALIDATION_2 = 'Incorrect password. Try again'
self.assertIn(test_validation,
[EXPECTED_VALIDATION_1, EXPECTED_VALIDATION_2])
def test_yandex_login(self):
TEST_LOGIN = '******'
PASSWORD_YANDEX_URL = 'https://passport.yandex.ru/auth'
self.login_page.enter_login(TEST_LOGIN)
self.login_page.click_continue()
self.login_page.wait_redirect(PASSWORD_YANDEX_URL)
self.assertEqual(
self.driver.current_url.split('?')[0], PASSWORD_YANDEX_URL)
def test_gmail_login(self):
TEST_LOGIN = '******'
GOOGLE_ACCOUNT_URL = 'https://accounts.google.com/signin/oauth/identifier'
self.login_page.enter_login(TEST_LOGIN)
self.login_page.click_continue()
self.login_page.wait_redirect(GOOGLE_ACCOUNT_URL)
self.assertEqual(
self.driver.current_url.split('?')[0], GOOGLE_ACCOUNT_URL)
def test_yahoo_login(self):
TEST_LOGIN = '******'
YAHOO_ACCOUNT_URL = 'https://login.yahoo.com/'
self.login_page.enter_login(TEST_LOGIN)
self.login_page.click_continue()
self.login_page.wait_redirect(YAHOO_ACCOUNT_URL)
self.assertEqual(
self.driver.current_url.split('?')[0], YAHOO_ACCOUNT_URL)
def test_rambler_login(self):
TEST_LOGIN = '******'
self.login_page.sign_in(TEST_LOGIN, self.password)
err = self.login_page.get_protocol_err()
EXPECTED_ERR_1 = 'Вы можете добавить любой почтовый ящик, поддерживающий сбор почты по протоколу POP/IMAP. Если логин введен неверно, авторизуйтесь заново.'
EXPECTED_ERR_2 = 'You can add any mailbox that supports POP/IMAP. If your credentials were entered incorrectly, sign in again.'
self.assertIn(err, [EXPECTED_ERR_1, EXPECTED_ERR_2])
def test_custom_login(self):
CUSTOM_LOGIN = '******'
CUSTOM_PASSWORD = '******'
self.login_page.sign_in(CUSTOM_LOGIN, CUSTOM_PASSWORD)
err = self.login_page.get_domain_err()
POSSIBLE_ERRORS = [
'Try again later.',
'Повторите попытку через некоторое время.',
'Произошла ошибка! Пожалуйста, повторите попытку через некоторое время или введите имя и пароль другого аккаунта.',
'You can add any mailbox that supports POP/IMAP. If your credentials were entered incorrectly, sign in again.',
]
self.assertIn(err, POSSIBLE_ERRORS)
def test_empty_password(self):
EMPTY_PASSWORD = ''
self.login_page.sign_in(self.login, EMPTY_PASSWORD)
test_validation = self.login_page.get_validation_message()
EXPECTED_VALIDATION_1 = 'Поле «Пароль» должно быть заполнено'
EXPECTED_VALIDATION_2 = 'The "Password" field is required'
self.assertIn(test_validation,
[EXPECTED_VALIDATION_1, EXPECTED_VALIDATION_2])
def test_signout(self):
self.login_page.sign_in(self.login, self.password)
self.login_page.wait_redirect(self.MAIL_URL)
self.main_page.click_signout()
self.main_page.wait_redirect(self.MAIN_PAGE_URL)
self.assertEqual(
self.driver.current_url.split('?')[0], self.MAIN_PAGE_URL)
def setUp(self):
super(LoginTest, self).setUp()
self.login_page = LoginPage(self.driver)
self.login_page.open()
self.main_page = MainPage(self.driver)
def setUp(self):
super(MainTest, self).setUp()
self.main_page = MainPage(self.driver)
self.main_page.open()
self.auth()
self.main_page.hide_app_loader()
def __init(self, driver):
MainPage.__init__(self, driver)
def __init(self, driver):
MainPage.__init__(self, driver)
def setUp(self):
super(SearchMainPage, self).setUp()
self.page = MainPage(self.driver, root_uri=s['root_url'])
self.page.get(MainPage._page_url)
class MainPageTests(unittest.TestCase):
maxDiff = None
driver: webdriver
driver = None
con = None
MAIN_PAGE = None
url = 'http://tereshkova.test.kavichki.com'
@classmethod
def setUpClass(self):
#self.con = DB.init_connection()
#print('Database connected')
#DB.delete_all_from_db(self.con)
#print('Clear table')
self.driver = webdriver.Chrome()
print('Browser started')
self.driver.maximize_window()
self.MAIN_PAGE = MainPage(self.driver)
self.MAIN_PAGE.open_url(self.url)
@classmethod
def tearDownClass(self):
self.driver.close()
print('Browser closed')
#DB.close_connection(self.con)
#print('Database disconnected')
def test_add_new_row(self): # тест корректен, ошибка в функционале сайта
# test data set
goods = 'Ангельская пыль'
count = '5'
cost = '20000'
action = 'Удалить'
added_row_expected = (goods, count, cost, action)
# test
self.fill_form(cost, count, goods)
self.MAIN_PAGE.find_element(*MainPageLocators.ADD_BUTTON).click()
added_row_actual = self.get_table_data()[-1]
asserts().assertTupleEqual(
added_row_expected, added_row_actual,
'Error: expected and actual row is not equals')
def test_delete_last_added_row(
self): # тест корректен, ошибка в функционале сайта
# precondition
goods = 'Крошки Зевса'
count = '3'
cost = '5500'
action = 'Удалить'
self.fill_form(cost, count, goods)
self.MAIN_PAGE.find_element(*MainPageLocators.ADD_BUTTON).click()
# test
absent_row = self.get_table_data()[-1]
current_element = self.MAIN_PAGE.find_elements(
*MainPageLocators.DELETE_LINK)[-1]
current_element.click()
rows = self.get_table_data()
asserts().assertNotIn(absent_row, rows,
'Error: deleted row is present in table')
def test_delete_first_row(
self): # тест корректен, ошибка в функционале сайта
# test
absent_row = self.get_table_data()[0]
current_element = self.MAIN_PAGE.find_elements(
*MainPageLocators.DELETE_LINK)[0]
current_element.click()
rows = self.get_table_data()
asserts().assertNotIn(absent_row, rows,
'Error: deleted row is present in table')
def test_reset_form(self): # тест корректен, ошибка в функционале сайта
expected = {'name': '', 'count': '', 'cost': ''}
params = ['100500', '78', 'hello']
self.fill_form(*params)
self.MAIN_PAGE.find_element(*MainPageLocators.RESET_LINK).click()
name = self.MAIN_PAGE.find_element(
*MainPageLocators.NAME_EDIT).get_attribute('value')
count = self.MAIN_PAGE.find_element(
*MainPageLocators.COUNT_EDIT).get_attribute('value')
cost = self.MAIN_PAGE.find_element(
*MainPageLocators.COST_EDIT).get_attribute('value')
actual = {'name': name, 'count': count, 'cost': cost}
asserts().assertDictEqual(
expected, actual, 'Error: name, count, cost edits is not empty')
def compare_tables_data(self):
# copy all records in DB
rows = self.get_table_data()
DB.copy_all_in_table(self.con, rows)
# add new rows in table on GUI
attempts = 3
i = 1
while i <= attempts:
goods = 'bla-bla-bla ' + str(i)
count = '5' + str(i)
cost = '20' + str(i)
self.fill_form(cost, count, goods)
self.MAIN_PAGE.find_element(*MainPageLocators.ADD_BUTTON).click()
i = i + 1
rows_db = DB.select_all_from_db(self.con)
rows_table = self.get_table_data()
asserts().assertGreater(
len(rows_table), len(rows_db),
'Error: count rows in DB > count rows in table')
set_db = set(rows_db)
set_table = set(rows_table)
set_total = set_table - set_db
print('\nDifferent rows:')
for row in set_total:
print(row)
def fill_form(self, cost, count, goods):
self.MAIN_PAGE.find_element(*MainPageLocators.ADD_LINK).click()
self.MAIN_PAGE.find_element(*MainPageLocators.NAME_EDIT).clear()
self.MAIN_PAGE.find_element(
*MainPageLocators.NAME_EDIT).send_keys(goods)
self.MAIN_PAGE.find_element(*MainPageLocators.COUNT_EDIT).clear()
self.MAIN_PAGE.find_element(
*MainPageLocators.COUNT_EDIT).send_keys(count)
self.MAIN_PAGE.find_element(*MainPageLocators.COST_EDIT).clear()
self.MAIN_PAGE.find_element(
*MainPageLocators.COST_EDIT).send_keys(cost)
def get_table_data(self):
table_data_list = []
rows = self.MAIN_PAGE.find_elements(*MainPageLocators.TR)
for row in rows:
cols = row.find_elements(*MainPageLocators.TD)
goods = cols[0].text
count = cols[1].text
cost = cols[2].text
action = cols[3].text
table_data_list.append((goods, count, cost, action))
return table_data_list
class Test_login(object):
'''类注释
详细描述
Attributes:
属性说明
'''
def setup_method(self, method):
self.logging_util = LoggingUtil()
self.logging_util.setup_logging()
self.logger = logging.getLogger()
desired_caps = {
'platformName': 'Android',
# 'deviceName': '127.0.0.1:5554', # 手机设备名称，通过adb devices查看
'deviceName': '127.0.0.1:62001', # 手机设备名称，通过adb devices查看
'platformVersion': '5.1.1', # android系统的版本号
'appPackage': 'com.aiosign.dzonesign', # apk包名
# apk的launcherActivity
'appActivity': 'com.aiosign.dzonesign.view.AppStartActivity',
}
self.logger.info('启动app')
try:
self.driver = webdriver.Remote('http://*****:*****@allure.story('登录-用户不存在')
def test_login_1(self):
self.logger.info('开始测试test_login_1==================================')
self.base_page.swipe_to_left()
self.base_page.swipe_to_left()
self.welcome_page.click_tiyan_button()
self.welcome_page.click_login_button()
self.login_page.input_username('15628811988')
self.login_page.input_passwd('12345678')
self.login_page.click_signin_button()
res = self.base_page.is_toast_exist('用户不存在')
assert res
self.logger.info('测试结束=====================================')
@allure.story('登录-账号或密码错误')
def test_login_2(self):
self.base_page.swipe_to_left()
self.base_page.swipe_to_left()
self.welcome_page.click_tiyan_button()
self.welcome_page.click_login_button()
self.login_page.input_username('15628811989')
self.login_page.input_passwd('123456789')
self.login_page.click_signin_button()
res = self.base_page.is_toast_exist('账号或密码错误')
assert res
@allure.story('登录-正常')
def test_right(self):
self.logger.info('开始测试test_right=====================================')
self.base_page.swipe_to_left()
self.base_page.swipe_to_left()
self.welcome_page.click_tiyan_button()
self.welcome_page.click_login_button()
self.login_page.input_username('15628811989')
self.login_page.input_passwd('12345678')
self.login_page.click_signin_button()
res = self.main_page.is_personal_center_button_exist()
assert res
# self.main_page.click_personal_center_button()
# self.logger.info('测试完成')
@allure.story('登录-未输入密码')
def test_login_3(self):
self.base_page.swipe_to_left()
self.base_page.swipe_to_left()
self.welcome_page.click_tiyan_button()
self.welcome_page.click_login_button()
self.login_page.input_username('15628811989')
# self.login_page.input_passwd('')
self.login_page.click_signin_button()
res = self.base_page.is_toast_exist('请输入密码！')
assert res
@allure.story('登录-账号格式不正确')
def test_login_4(self):
self.base_page.swipe_to_left()
self.base_page.swipe_to_left()
self.welcome_page.click_tiyan_button()
self.welcome_page.click_login_button()
self.login_page.input_username('156288119')
self.login_page.input_passwd('12345678')
self.login_page.click_signin_button()
res = self.base_page.is_toast_exist('账号格式不正确（邮箱、信用代码、手机）')
assert res
@allure.story('登录-未输入账号')
def test_login_5(self):
self.base_page.swipe_to_left()
self.base_page.swipe_to_left()
self.welcome_page.click_tiyan_button()
self.welcome_page.click_login_button()
self.login_page.input_passwd('12345678')
self.login_page.click_signin_button()
res = self.base_page.is_toast_exist('请输入账号！')
assert res
def test_scenario_1(self):
main_page = MainPage(self.driver)
assert main_page.is_title_matches(), "Title is not matches!"
assert main_page.check_guest_field_presence() is False, "Guest field is opend!"
main_page.click_on_guest_field()
assert main_page.check_guest_field_presence(), "Guest field is not opend!"
main_page.add_children_button(3)
assert main_page.check_children_counter(), "Counters are not matching!"
main_page.remove_child_buton(2)
assert main_page.check_children_counter(), "Counters are not matching!"
class MainTest(BasicTest):
def setUp(self):
super(MainTest, self).setUp()
self.main_page = MainPage(self.driver)
self.main_page.open()
self.auth()
self.main_page.hide_app_loader()
def test_receive_new_letter(self):
self.subject = self.add_random_number('Subject_receive_new_letter ')
TEXT = 'Text_receive_new_letter'
letter_manager = self.main_page.letter_manager
letter_manager.write_letter(self.login, self.subject, TEXT)
letter_manager.letter_selector.find_letter_subject_real(self.subject)
def test_receive_new_letter_from_another_account(self):
self.subject = self.add_random_number(
'Subj_receive_from_another_account ')
TEXT = 'Txt_receive_from_another_account'
receiver = User(self.login2, self.password2)
letter_manager = self.main_page.letter_manager
letter_manager.write_letter(receiver.login, self.subject, TEXT)
self.main_page.relogin(receiver.login, receiver.password)
letter_manager.letter_selector.find_letter_subject_real(self.subject)
def test_reading_letter(self):
self.subject = self.add_random_number('Subject_reading_letter ')
TEXT = 'Text_reading_letter'
letter_manager = self.main_page.letter_manager
letter_manager.write_letter(self.login, self.subject, TEXT)
letter_manager.letter_selector.set_letter_read_status(
self.subject, True)
self.assertTrue(
letter_manager.letter_selector.get_letter_read_status(
self.subject))
def test_remove_letter(self):
self.subject = self.add_random_number('Subject_remove_letter ')
TEXT = 'Text_remove_letter'
letter_manager = self.main_page.letter_manager
letter_manager.write_letter(self.login, self.subject, TEXT)
letter_manager.remove_letter(self.subject)
self.main_page.navigation_manager.go_to_trash()
letter_manager.letter_selector.find_letter_subject_real(self.subject)
# tearDown shouldn't remove anything!
self.subject = ''
def test_restore_letter(self):
self.subject = self.add_random_number('Subject_restore_letter ')
TEXT = 'Text_restore_letter'
letter_manager = self.main_page.letter_manager
letter_manager.write_letter(self.login, self.subject, TEXT)
letter_manager.remove_letter(self.subject)
self.main_page.navigation_manager.go_to_trash()
letter_manager.restore_letter(self.subject)
# Go back (to check for a letter in the inbox folder)
self.main_page.navigation_manager.go_to_inbox()
letter_manager.letter_selector.find_letter_subject_real(self.subject)
def test_check_sent_new_letter(self):
self.subject = self.add_random_number('Subject_check_sent_new_letter ')
TEXT = 'Text_check_sent_new_letter'
letter_manager = self.main_page.letter_manager
letter_manager.write_letter(self.login, self.subject, TEXT)
self.main_page.navigation_manager.go_to_sent_letters_folder()
letter_manager.letter_selector.find_letter_subject_real(self.subject)
def test_open_letter(self):
self.subject = self.add_random_number('Subject_opened_letter ')
TEXT = self.add_random_number('Text_opened_letter_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter(self.login, self.subject, TEXT)
letter_manager.letter_selector.open_letter(self.subject)
actual_subject = self.main_page.letter_manager.letter_selector.get_opened_letter_subject(
)
actual_text = self.main_page.letter_manager.letter_selector.get_opened_letter_text(
)
self.assertEqual(self.subject, actual_subject)
self.assertEqual(TEXT, actual_text)
def test_reply_letter(self):
self.subject = self.add_random_number('Subject_reply_letter ')
TEXT = 'Text_reply_letter'
replied_text = self.add_random_number('Replied text ')
first_user = User(self.login, self.password)
receiver = User(self.login2, self.password2)
letter_manager = self.main_page.letter_manager
letter_manager.write_letter(receiver.login, self.subject, TEXT)
self.main_page.relogin(receiver.login, receiver.password)
letter_manager.reply_letter(self.subject, replied_text)
self.main_page.relogin(first_user.login, first_user.password)
letter_manager.letter_selector.open_letter(self.subject)
actual_replied_text = self.main_page.letter_manager.letter_selector.get_replied_letter_text(
)
self.assertEqual(replied_text, actual_replied_text)
self.main_page.navigation_manager.go_to_inbox()
self.main_page.letter_manager.remove_letter(self.subject)
self.main_page.relogin(receiver.login, receiver.password)
def test_write_many_receivers(self):
self.subject = self.add_random_number('Subject_write_many_receivers ')
TEXT = 'Text_write_many_receivers'
receivers = [
User(self.login, self.password),
User(self.login2, self.password2),
]
receivers_emails = [receiver.login for receiver in receivers]
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_many_receivers(receivers_emails,
self.subject, TEXT)
for receiver in receivers:
self.main_page.relogin(receiver.login, receiver.password)
letter_manager.letter_selector.find_letter_subject_real(
self.subject)
# For the last receiver we use tearDown
if receiver != receivers[-1]:
self.main_page.letter_manager.remove_letter(self.subject)
def test_bold_letter(self):
self.subject = self.add_random_number('Subject_bold_letter ')
TEXT = self.add_random_number('Text_bold_letter_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_bold_text()
letter_manager.send_letter()
letter_manager.letter_selector.open_letter(self.subject)
bold_element = letter_manager.letter_selector.get_bold()
self.assertEqual(TEXT, bold_element.text)
def test_font_title1_letter(self):
self.subject = self.add_random_number(
'Subject_font_title1_letter_letter_')
TEXT = self.add_random_number('font title1 letter ')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_font_text_title1()
letter_manager.send_letter()
letter_manager.letter_selector.open_letter(self.subject)
element = letter_manager.letter_selector.get_font_text_title1()
self.assertEqual(TEXT, element.text)
def test_alignment_text_center(self):
self.subject = self.add_random_number('Subject_alignment_text_center_')
TEXT = self.add_random_number('alignment_text_center_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_alignment_text_center()
letter_manager.send_letter()
letter_manager.letter_selector.open_letter(self.subject)
element = letter_manager.letter_selector.get_alignment_text_center()
self.assertEqual(TEXT, element.text)
def test_indent_text_plus(self):
self.subject = self.add_random_number('Subject_alignment_text_center_')
TEXT = self.add_random_number('alignment_text_indent_text_plus_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_indent_text_plus()
letter_manager.send_letter()
letter_manager.letter_selector.open_letter(self.subject)
element = letter_manager.letter_selector.get_indent_text()
self.assertEqual(TEXT, element.text)
def test_indent_text_minus(self):
self.subject = self.add_random_number(
'Subject_alignment_indent_text_minus_')
TEXT = self.add_random_number('alignment_text_indent_text_minus_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_indent_text_minus()
letter_manager.send_letter()
letter_manager.letter_selector.open_letter(self.subject)
element = letter_manager.letter_selector.get_indent_text()
self.assertEqual(TEXT, element.text)
def test_italic_letter(self):
self.subject = self.add_random_number('Subject_italic_letter_')
TEXT = self.add_random_number('Text_italic_letter_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_italic_text()
letter_manager.send_letter()
letter_manager.letter_selector.open_letter(self.subject)
italic_element = letter_manager.letter_selector.get_italic()
self.assertEqual(TEXT, italic_element.text)
def test_underline_letter(self):
self.subject = self.add_random_number('Subject_underline_letter_')
TEXT = self.add_random_number('Text_underline_letter_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_underline_text()
letter_manager.send_letter()
letter_manager.letter_selector.open_letter(self.subject)
underline_element = letter_manager.letter_selector.get_underline()
self.assertEqual(TEXT, underline_element.text)
def test_strike_through_letter(self):
self.subject = self.add_random_number('Subject_strike_through_letter_')
TEXT = self.add_random_number('Text_strike_through_letter_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_strike_through_text()
letter_manager.send_letter()
letter_manager.letter_selector.open_letter(self.subject)
strike_through_element = letter_manager.letter_selector.get_strike_through(
)
self.assertEqual(TEXT, strike_through_element.text)
def test_text_color(self):
self.subject = self.add_random_number('Subject_text_color_')
TEXT = self.add_random_number('Text_color_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_text_color_purple()
letter_manager.send_letter()
letter_manager.letter_selector.open_letter(self.subject)
element = letter_manager.letter_selector.get_text_color_purple()
self.assertEqual(TEXT, element.text)
STYLE = 'color: rgb(231, 0, 145);'
self.assertEqual(
STYLE,
element.get_attribute('style').encode('utf-8', errors='ignore'))
def test_background_color(self):
self.subject = self.add_random_number('Subject_background_color_')
TEXT = self.add_random_number('Background_color_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_background_color_blue()
letter_manager.send_letter()
letter_manager.letter_selector.open_letter(self.subject)
element = letter_manager.letter_selector.get_background_color_blue()
self.assertEqual(TEXT, element.text)
STYLE = 'background-color: rgb(110, 228, 254);'
self.assertEqual(
STYLE,
element.get_attribute('style').encode('utf-8', errors='ignore'))
def test_back_formating(self):
self.subject = self.add_random_number('Subject preview letter ')
TEXT = self.add_random_number('Teeeeext_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_bold_text()
bold_text = letter_manager.letter_selector.get_bold_text()
self.assertEqual(TEXT, bold_text)
letter_manager.letter_writer.click_preview_button()
not_bold_text = letter_manager.letter_selector.get_not_bold_text()
self.assertEqual(TEXT, not_bold_text)
self.subject = ''
def test_clear_formating(self):
self.subject = self.add_random_number('Subject letter ')
TEXT = self.add_random_number('All_kind_formating_')
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.set_italic_text()
letter_manager.letter_writer.set_underline_text()
letter_manager.letter_writer.set_bold_text()
letter_manager.letter_writer.set_strike_through_text()
letter_manager.letter_writer.click_clear_all_button()
unformating_text = letter_manager.letter_selector.get_unformating_text(
)
self.assertEqual(TEXT, unformating_text)
self.subject = ''
def test_insert_link(self):
self.subject = self.add_random_number('Hello ')
TEXT = self.add_random_number(
'Welcome to the 4th semester of Tehnopark MailRu ') + '\n'
letter_manager = self.main_page.letter_manager
letter_manager.write_letter_without_sending(self.login, self.subject,
TEXT)
letter_manager.letter_writer.click_link_button()
txt_link = self.main_page.letter_manager.letter_writer.text_link
link = self.main_page.letter_manager.letter_writer.link
letter_manager.letter_writer.enter_link(link)
letter_manager.letter_writer.enter_text_link(txt_link)
letter_manager.letter_writer.click_confirm_link()
actual_text = letter_manager.letter_selector.get_link_text()
self.assertEqual(txt_link, actual_text)
self.subject = ''
def tearDown(self):
if self.subject != '':
if 'restore' not in self.subject:
self.main_page.navigation_manager.go_to_inbox()
self.main_page.letter_manager.remove_letter(self.subject)
super(MainTest, self).tearDown()
class DirectoryTest(BasicTest):
def setUp(self):
super(DirectoryTest, self).setUp()
self.directory_page = DirectoryPage(self.driver)
self.directory_page.open()
self.auth()
self.main_page = MainPage(self.driver)
self.main_page.hide_app_loader()
self.manager = self.main_page.letter_manager
def test_move_to_archive(self):
self.letter_subject = self.add_random_number('Mail for archive ')
LETTER_TEXT = 'Lorem text for archive'
self.manager.write_letter(config.DEFAULT_MAIL, self.letter_subject, LETTER_TEXT)
self.manager.letter_selector.select_letter(self.letter_subject)
self.directory_page.move_to_archive()
self.directory_page.click_nav_archive_button()
letter_selector = LetterSelector(self.driver)
letter_selector.find_letter_subject_real(self.letter_subject)
def test_move_to_inbox_from_archive(self):
self.letter_subject = self.add_random_number('$$$ Archive ')
LETTER_TEXT = 'Lorem text for archive'
self.manager.write_letter(config.DEFAULT_MAIL, self.letter_subject, LETTER_TEXT)
self.manager.letter_selector.select_letter(self.letter_subject)
self.directory_page.move_to_archive()
self.directory_page.click_nav_archive_button()
self.manager.restore_letter(self.letter_subject)
navigation_manager = NavigationManager(self.driver)
navigation_manager.go_to_inbox()
letter_selector = LetterSelector(self.driver)
letter_selector.find_letter_subject_real(self.letter_subject)
def test_set_important_letter(self):
self.letter_subject = self.add_random_number('The IMPORTANT letter ')
LETTER_TEXT = 'Lorem text lorem lorem lorem'
self.manager.write_letter(config.DEFAULT_MAIL, self.letter_subject, LETTER_TEXT)
self.directory_page.set_check_flag()
self.assertTrue(self.directory_page.get_important_status())
def test_unset_important_letter(self):
self.letter_subject = self.add_random_number('The UNimportant letter ')
LETTER_TEXT = 'Lorem text lorem lorem lorem'
self.manager.write_letter(config.DEFAULT_MAIL, self.letter_subject, LETTER_TEXT)
self.directory_page.set_check_flag()
self.directory_page.unset_check_flag()
self.assertFalse(self.directory_page.get_important_status())
def test_move_to_social(self):
self.letter_subject = self.add_random_number('The SOCIAL letter ')
LETTER_TEXT = 'Lorem text lorem lorem lorem'
self.manager.write_letter(config.DEFAULT_MAIL, self.letter_subject, LETTER_TEXT)
self.manager.letter_selector.select_letter(self.letter_subject)
self.directory_page.move_to_social()
self.directory_page.go_to_social()
letter_selector = LetterSelector(self.driver)
letter_selector.find_letter_subject_real(self.letter_subject)
def test_move_to_inbox_from_social(self):
self.letter_subject = self.add_random_number('not SOCIAL letter ')
LETTER_TEXT = 'Lorem text for archive'
self.manager.write_letter(config.DEFAULT_MAIL, self.letter_subject, LETTER_TEXT)
self.manager.letter_selector.select_letter(self.letter_subject)
self.directory_page.move_to_social()
self.directory_page.go_to_social()
self.manager.restore_letter(self.letter_subject)
navigation_manager = NavigationManager(self.driver)
navigation_manager.go_to_inbox()
letter_selector = LetterSelector(self.driver)
letter_selector.find_letter_subject_real(self.letter_subject)
def test_move_to_newsletters(self):
self.letter_subject = self.add_random_number('The NewsLetter letter ')
LETTER_TEXT = 'Lorem text lorem lorem lorem'
self.manager.write_letter(config.DEFAULT_MAIL, self.letter_subject, LETTER_TEXT)
self.manager.letter_selector.select_letter(self.letter_subject)
self.directory_page.move_to_newsletters()
self.directory_page.go_to_newsletters()
def test_send_empty_letter(self):
self.manager.letter_writer.click_write_letter_button()
self.manager.letter_writer.click_send_letter_button()
self.letter_subject = ''
EXPECTED_MESSAGE = u'Не указан адрес получателя'
self.assertEqual(EXPECTED_MESSAGE, self.directory_page.error_message())
def test_send_letter_without_subject(self):
self.letter_subject = ''
LETTER_TEXT = 'Lorem text lorem lorem lorem'
self.manager.letter_writer.click_write_letter_button()
self.manager.letter_writer.enter_email_receiver(config.DEFAULT_MAIL)
self.manager.letter_writer.enter_textbox(LETTER_TEXT)
self.manager.letter_writer.click_send_letter_button()
self.manager.letter_writer.close_sent_window()
letter_selector = LetterSelector(self.driver)
self.letter_subject = self.directory_page.empty_subject_text
actual_text = letter_selector.get_letter_text(self.letter_subject)
self.assertEqual(LETTER_TEXT, actual_text)
def test_send_letter_without_receiver(self):
self.letter_subject = 'Subject letter'
LETTER_TEXT = 'Lorem text lorem lorem lorem'
self.manager.letter_writer.click_write_letter_button()
self.manager.letter_writer.enter_subject(self.letter_subject)
self.manager.letter_writer.enter_textbox(LETTER_TEXT)
self.manager.letter_writer.click_send_letter_button()
self.letter_subject = ''
EXPECTED_MESSAGE = u'Не указан адрес получателя'
self.assertEqual(EXPECTED_MESSAGE, self.directory_page.error_message())
def test_save_draft_letter(self):
self.letter_subject = self.add_random_number('Draft letter ')
LETTER_TEXT = 'Lorem text lorem lorem lorem'
self.manager.letter_writer.click_write_letter_button()
self.manager.letter_writer.enter_subject(self.letter_subject)
self.manager.letter_writer.enter_textbox(LETTER_TEXT)
self.directory_page.click_save_mail()
self.directory_page.close_writer_window()
self.directory_page.go_to_drafts()
letter_selector = LetterSelector(self.driver)
actual_text = letter_selector.get_mini_letter_text(self.letter_subject)
self.directory_page.close_writer_window()
self.assertEqual(LETTER_TEXT, actual_text)
def test_send_draft_letter(self):
self.letter_subject = self.add_random_number('Send draft letter ')
LETTER_TEXT = 'Lorem text lorem lorem lorem'
self.manager.letter_writer.click_write_letter_button()
self.manager.letter_writer.enter_email_receiver(config.DEFAULT_MAIL)
self.manager.letter_writer.enter_subject(self.letter_subject)
self.manager.letter_writer.enter_textbox(LETTER_TEXT)
self.directory_page.click_save_mail()
self.directory_page.close_writer_window()
self.directory_page.go_to_drafts()
self.directory_page.open_draft()
self.manager.letter_writer.click_send_letter_button()
self.manager.letter_writer.close_sent_window()
def tearDown(self):
if self.letter_subject != '':
cond1 = 'Mail for archive' not in self.letter_subject
cond2 = '$$$ Archive' not in self.letter_subject
cond3 = 'The SOCIAL letter' not in self.letter_subject
cond4 = 'not SOCIAL letter' not in self.letter_subject
cond5 = 'The NewsLetter letter' not in self.letter_subject
cond6 = 'Draft letter ' not in self.letter_subject
if cond1 and cond2 and cond3 and cond4 and cond5 and cond6:
self.main_page.navigation_manager.go_to_inbox()
self.manager.remove_letter(self.letter_subject)
self.driver.quit()
def setup_class(cls):
cls.Pages = MainPage().to_login().login('admin', '111111')
