def setUp(self) -> None:
default_setup(self)
auth_as_employer_has_comp(self)
self.profile_page = ProfilePage(self.driver)
self.vac_page = CreateVacancyPage(self.driver)
self.vac_list = VacanciesPage(self.driver)
self.vac_form = self.vac_page.form
self.vac_page.open()
def if_subscribe_course_present_in_profile(self):
"""Method for checking presents follow course in profile page"""
self.profile_page = ProfilePage(self.driver)
self.profile_page.go_to()
self.profile_page.click_on_following_courses()
try:
self.find_element_by_xpath(cpl.TEST_COURSE)
except NoSuchElementException:
return False
return True
def setUp(self) -> None:
default_setup(self)
self.incorrect_name = 'name123'
self.incorrect_surname = 'surname123'
self.incorrect_email = 'margot.ru'
self.correct_name = 'margotName'
self.correct_surname = 'margotSurname'
self.correct_email = '*****@*****.**'
self.correct_password = self.PASSWORD_APPL
self.auth_page = AuthPage(self.driver)
self.reg_page = RegistrationPage(self.driver)
self.profile_page = ProfilePage(self.driver)
self.main_page = MainPage(self.driver)
def before_all(context):
context.browser = Browser()
context.home_page = HomePage()
context.search_results_page = SearchResultsPage()
context.croatian_page = CroatianPage()
context.log_in = LogIn()
context.profile_page = ProfilePage()
def setUp(self) -> None:
default_setup(self)
scen = RegistrationEmployerScenario(self)
scen.registration_employer(True)
self.resume_page = ResumePage(self.driver)
self.resume = self.resume_page.form
self.resume_list = ResumesPage(self.driver)
self.resume_list_form = self.resume_list.list
self.profile_page = ProfilePage(self.driver)
self.profile_form = self.profile_page.profile_form
self.resume_list.open()
self.resume_list_form.go_first_resume_page()
def __init__(self, driver):
super().__init__(driver)
self.page = ProfilePage(driver)
self.__fields = [
self.page.right_column.SKILLS, self.page.right_column.INTERESTS,
self.page.right_column.EDUCATION, self.page.right_column.JOB,
self.page.right_column.AIMS
]
def test_login5(self):
login_page = LoginPage(driver=self.driver)
login_page.set_login("dmytro.a.frolov")
login_page.set_password("Froyman98_!")
login_page.click_login_button()
main_page = MainPage(self.driver)
main_page.click_skip_button()
main_page.click_top_menu(Header.MY_PROFILE)
profile_page = ProfilePage(driver=self.driver)
profile_page.click_on_team_profile()
team_page = TeamPage(driver=self.driver)
for people in team_page.get_people():
print(people.name + " " + people.phone + " " + people.position +
" " + people.email)
class Favorite(unittest.TestCase):
data = {
'title': 'My Title',
'description': 'My cool resume',
'place': 'I very good',
'skills': 'My great skills',
}
def setUp(self) -> None:
default_setup(self)
scen = RegistrationEmployerScenario(self)
scen.registration_employer(True)
self.resume_page = ResumePage(self.driver)
self.resume = self.resume_page.form
self.resume_list = ResumesPage(self.driver)
self.resume_list_form = self.resume_list.list
self.profile_page = ProfilePage(self.driver)
self.profile_form = self.profile_page.profile_form
self.resume_list.open()
self.resume_list_form.go_first_resume_page()
def tearDown(self):
self.profile_page.delete_account()
self.driver.quit()
def test_add_to_favorite(self):
self.assertEqual(self.resume.get_text_favorite_btn(),
'Добавить в избранное')
self.resume.add_to_favorite()
self.resume.wait_to_add_favorite()
self.assertEqual(self.resume.get_text_favorite_btn(),
'Убрать из избранного')
self.profile_page.open()
def test_check_added_favorite_in_profile(self):
self.assertEqual(self.resume.get_text_favorite_btn(),
'Добавить в избранное')
self.resume.add_to_favorite()
self.resume.wait_to_add_favorite()
self.profile_page.open()
page_data = self.profile_page.get_my_favorite()
self.assertDictEqual(page_data, {
'title': self.data['title'],
'description': self.data['description'],
})
self.profile_page.click_my_profile_info()
def setUp(self) -> None:
default_setup(self)
auth_as_employer_has_comp(self)
self.vacancy = VacancyScenario(test=self)
self.vacancy.create_vacancy()
self.uri_to_delete = self.vacancy.get_vacancy_uri
self.resume_page = ResumePage(self.driver)
self.resume = self.resume_page.form
self.resume_list = ResumesPage(self.driver)
self.resume_list_form = self.resume_list.list
self.profile_page = ProfilePage(self.driver)
self.profile_form = self.profile_page.profile_form
self.resume_list.open()
self.resume_list_form.go_first_resume_page()
def test_customer_self_registration(self, config, teardown):
global self_reg_mobile
customer = random_user(UserRoles.CUSTOMER)
user = GkrUserSteps(config)
db_user = GkrDbSteps(config)
reg_page = RegistrationPage(config)
profile_page = ProfilePage(config)
main_page = MainPage(config)
dialogs = Dialogs(config)
self_reg_mobile = customer.customers_data.mobile_phone
user.logout()
user.clicks(main_page.top_menu.REG_LINK)
user.fill_registration_form(customer)
user.submit_regform()
user.should_see_dialog_text(dialogs.REG_SUCCESS_DIALOG, Messages.REGISTRATION_SUCCESSFUL)
t_customer = db_user.query_first(TCustomers, TCustomers.mobile_phone == self_reg_mobile)
user.opens(Urls.REGISTRATION.url + '/customer/?code=' + str(t_customer.code) + '&id=' + str(t_customer.id))
customer.password = db_user.query_first(AclUsers, AclUsers.name == customer.customers_data.mobile_phone).pwd
user.should_see_dialog_text(dialogs.EMAIL_SUCCESS_DIALOG, Messages.EMAIL_CONFIRMED)
user.close(dialogs.EMAIL_SUCCESS_DIALOG)
user.login(customer.customers_data.mobile_phone, customer.password)
user.should_see_element(profile_page)
# проверка доступности полей
disabled = 'disabled'
user.should_see_attribute_value(reg_page.NAME, disabled, True)
user.should_see_attribute_value(reg_page.SURNAME, disabled, True)
user.should_see_attribute_value(reg_page.PATRONYMIC, disabled, True)
user.should_see_element_enabled(reg_page.BIRTHDAY)
user.should_see_attribute_value(reg_page.EMAIL, disabled, True)
user.should_see_attribute_value(reg_page.MOBILE, disabled, True)
user.should_see_attribute_value(reg_page.HOME_PHONE, disabled, True)
user.should_see_attribute_value(reg_page.PASSPORT_SERIAL, disabled, True)
user.should_see_attribute_value(reg_page.PASSPORT_NUMBER, disabled, True)
user.should_see_attribute_value(reg_page.ISSUE_DATE, disabled, True)
user.should_see_attribute_value(reg_page.ISSUE, disabled, True)
user.should_see_element_enabled(profile_page.PASSWORD)
user.should_see_element_enabled(profile_page.PASSWORD_CONFIRM)
# проверка значений
app_format = '%d.%m.%Y'
user.should_see_element(profile_page)
user.should_see_field_value(reg_page.NAME, customer.customers_data.name)
user.should_see_field_value(reg_page.SURNAME, customer.customers_data.surname)
user.should_see_field_value(reg_page.PATRONYMIC, customer.customers_data.patronymic)
user.should_see_field_value(reg_page.BIRTHDAY, customer.customers_data.birthday.strftime(app_format))
user.should_see_field_value(reg_page.EMAIL, customer.customers_data.email)
user.should_see_field_value(reg_page.MOBILE, customer.customers_data.mobile_phone)
user.should_see_field_value(reg_page.HOME_PHONE, '')
user.should_see_field_value(reg_page.PASSPORT_SERIAL, customer.customers_data.serial)
user.should_see_field_value(reg_page.PASSPORT_NUMBER, customer.customers_data.no)
user.should_see_field_value(reg_page.ISSUE, customer.customers_data.issue)
user.should_see_field_value(reg_page.ISSUE_DATE,
customer.customers_data.when_at.strftime(app_format))
def test_valid_acc_creation(self, driver):
data = provider.test_data_provider("register", "valid_acc_creation")
homepage = HomePage(driver)
authpage = AuthPage(driver)
createaccpage = CreateAccPage(driver)
profilepage = ProfilePage(driver)
assert_true(homepage.is_page_loaded)
homepage.sign_in_button.click()
assert_true(authpage.is_page_loaded)
authpage.register(data)
assert_true(createaccpage.is_page_loaded)
createaccpage.fill_up_form(data)
assert_true(profilepage.is_page_loaded())
time.sleep(3)
class Response(unittest.TestCase):
data = {
'title': 'My Title',
'description': 'My cool resume',
'place': 'I very good',
'skills': 'My great skills',
}
def setUp(self) -> None:
default_setup(self)
auth_as_employer_has_comp(self)
self.vacancy = VacancyScenario(test=self)
self.vacancy.create_vacancy()
self.uri_to_delete = self.vacancy.get_vacancy_uri
self.resume_page = ResumePage(self.driver)
self.resume = self.resume_page.form
self.resume_list = ResumesPage(self.driver)
self.resume_list_form = self.resume_list.list
self.profile_page = ProfilePage(self.driver)
self.profile_form = self.profile_page.profile_form
self.resume_list.open()
self.resume_list_form.go_first_resume_page()
def tearDown(self):
self.vacancy.delete_vacancy(self.uri_to_delete)
self.driver.quit()
def test_create_response(self):
self.resume.response()
self.assertEqual(self.resume.get_response_done(),
'Ваш отклик успешно отправлен!')
def test_check_created_response_in_profile(self):
data = self.resume.response()
parsed = data.split('\n')
title = parsed[0]
self.profile_page.open()
self.profile_page.click_link_to_myResponses()
self.assertTrue(self.profile_page.find_vacancy_in_responses(title))
def test_redirect_on_click_chat_user(self):
self.chat_steps.open_chat()
expected_name = self.chat_steps.get_chat_user_name(position=0)
self.chat_steps.open_chat_user(position=0)
sender_profile = ProfilePage(self.driver)
actual_name = sender_profile.left_column.get_profile_name_text()
self.assertEqual(
expected_name, actual_name,
f'Sender name {actual_name} doesn\'t match {expected_name}')
def setUp(self) -> None:
default_setup(self)
self.create_resume_page = CreateResumePage(self.driver)
self.create_resume_form = self.create_resume_page.create_form
self.resume_page = ResumePage(self.driver)
self.resume = self.resume_page.form
self.edit_resume_page = EditResumePage(self.driver)
self.edit_resume_form = self.edit_resume_page.edit_form
self.profile_page = ProfilePage(self.driver)
self.scenario = ResumeScenario(self, self.create_resume_form)
setup_auth(self)
self.scenario.create_resume_with_experience(self.data)
self.profile_page.open()
self.profile_page.click_my_first_resume_edit()
self.assertTrue(self.edit_resume_page.is_open())
def test_login_correct_credentials(self, driver):
data = dp.test_data_provider("login", "login_correct_credentials")
page = HomePage(driver)
assert_true(page.is_page_loaded)
actions.click(page.sign_in_button)
page = AuthPage(driver)
assert_true(page.is_page_loaded)
page.login(data)
page = ProfilePage(driver)
assert_true(page.is_page_loaded)
def test_password_change_incorrect(self, config, password,
password_confirm, message):
user = GkrUserSteps(config)
profile_page = ProfilePage(config)
customer = CUSTOMER
user.login(customer.customers_data.mobile_phone, customer.password)
user.waits_for_element_displayed(profile_page)
user.enters_text(profile_page.PASSWORD, password)
user.enters_text(profile_page.PASSWORD_CONFIRM, password_confirm)
user.clicks(profile_page.SUBMIT)
user.waits_for_element_displayed(profile_page.ERROR_MESSAGE)
user.should_see_element_with_text(profile_page.ERROR_MESSAGE, message)
def delete_resume(self):
profile_page = ProfilePage(self.test.driver)
edit_resume_page = EditResumePage(self.test.driver)
edit_resume_form = edit_resume_page.edit_form
profile_page.open()
profile_page.click_my_first_resume_edit()
edit_resume_form.delete_resume()
def setUp(self) -> None:
default_setup(self)
self.main_page = MainPage(self.driver)
self.vacancies = VacanciesPage(self.driver)
self.rec_page = RecommendationPage(self.driver)
self.profile = ProfilePage(self.driver)
self.resume_page = ResumePage(self.driver)
self.resume = self.resume_page.form
self.resume_list = ResumesPage(self.driver)
self.resume_list_form = self.resume_list.list
self.scenario = ResumeScenario(self, self.resume)
self.Applicant = RegistrationApplicantScenario(self)
self.reg_data = self.Applicant.registration_applicant()
def test_birthday_change_successfully(self, config):
user = GkrUserSteps(config)
profile_page = ProfilePage(config)
reg_page = RegistrationPage(config)
customer = CUSTOMER
user.login(customer.customers_data.mobile_phone, customer.password)
user.waits_for_element_displayed(profile_page)
birthday = (datetime.now() - timedelta(weeks=500)).strftime('%d.%m.%Y')
user.enters_text(reg_page.BIRTHDAY, birthday)
user.clicks(profile_page.SUBMIT)
user.waits_for_element_displayed(profile_page.SUCCESS_MESSAGE)
user.should_see_element_with_text(
profile_page.SUCCESS_MESSAGE,
ConfirmationMessages.PROFILE_CHANGED.text)
user.opens(Urls.PROFILE)
user.should_see_field_value(reg_page.BIRTHDAY, birthday)
def test_legal_timeslot(self, config):
user = GkrUserSteps(config)
db_user = GkrDbSteps(config)
queue_page = QueuePage(config)
profile_page = ProfilePage(config)
ticket_data_dialog = TicketDataDialog(config)
for i in legal_timeslot_data:
legal = random_user(UserRoles.CUSTOMER, is_legal=True)
db_user.create_user(legal)
day = (datetime.now() + timedelta(days=random.randrange(0, 2))).strftime('%Y-%m-%d')
service = i[0]
stat_value = i[1]
locality = 'с. Виноградное'
street = 'ул. Горная'
user.login(legal.customers_data.mobile_phone, legal.password)
user.waits_for_element_displayed(profile_page)
user.selects_from_main_menu(MainMenu.QUEUE)
user.waits_for_element_displayed(queue_page)
user.chooses_from_select(queue_page.CITY, Departments.FEO_DEP.short_name)
user.chooses_from_select(queue_page.SERVICE, service)
user.chooses_from_select(queue_page.OBJECT_TYPE, '1')
user.enters_suggest(queue_page.LOCALITY, locality)
user.enters_suggest(queue_page.STREET, street)
user.enters_text(queue_page.HOUSE, 2)
user.set_calendar_date(queue_page.CALENDAR, day)
user.set_calendar_time(queue_page.CALENDAR, None)
user.enters_text(queue_page.CAPTCHA, '11111')
user.clicks(queue_page.SUBMIT)
user.waits_for_element_displayed(ticket_data_dialog)
user.login(legal.customers_data.mobile_phone, legal.password)
user.waits_for_element_displayed(profile_page)
user.selects_from_main_menu(MainMenu.QUEUE)
user.chooses_from_select(queue_page.CITY, Departments.FEO_DEP.short_name)
user.chooses_from_select(queue_page.SERVICE, service)
user.waits_for_ajax()
user.should_see_element_with_text(queue_page.STAT_INDICATOR, stat_value)
db_user.delete_user_by_mobile(legal.customers_data.mobile_phone)
def register_user(self):
# self.click(self._close_privacy_policy_bar_button)
self.clear_field_and_send_keys(self._name_value, self._name_field)
self.clear_field_and_send_keys(self._surname_value, self._surname_field)
self.clear_field_and_send_keys(self._company_name_value, self._company_name_field)
self.clear_field_and_send_keys(self._NIP_value, self._NIP_field)
self.clear_field_and_send_keys(self._phone_value, self._phone_field)
self.clear_field_and_send_keys(self._email_value, self._email_field)
self.clear_field_and_send_keys(self._password_value, self._password1_field)
self.clear_field_and_send_keys(self._password_value, self._password2_field)
self.get_driver().execute_script("arguments[0].click();", self.find_element(self._accept1_checkbox))
# self.click(self._accept1_checkbox)
self.get_driver().execute_script("arguments[0].click();", self.find_element(self._accept2_checkbox))
# self.click(self._accept2_checkbox)
self.get_driver().execute_script("arguments[0].click();", self.find_element(self._accept3_checkbox))
# self.click(self._accept3_checkbox)
self.get_driver().execute_script("arguments[0].click();", self.find_element(self._register_account_submit_button))
# self.click(self._register_account_submit_button)
return ProfilePage(self.get_driver())
def __init__(self, driver):
self.base = Page(driver)
self.onboarding_page = OnboardingPage(driver)
self.popular_page = PopularPage(driver)
self.category_page = CategoryPage(driver)
self.search_page = SearchPage(driver)
self.ticket_page = TicketPage(driver)
self.profile_page = ProfilePage(driver)
self.footer = Footer(driver)
self.popular_detail_page = PopularDetailPage(driver)
self.profile_support_page = ProfileSupportPage(driver)
self.order_place_page = OrderPlacePage(driver)
self.order_category_page = OrderCategoryPage(driver)
self.order_products_page = OrderProductsPage(driver)
self.order_page = OrderPage(driver)
self.errors_pages = ErrorsPages(driver)
def test_password_recovery(self, config, teardown):
user = GkrUserSteps(config)
db_user = GkrDbSteps(config)
login_page = LoginForm(config)
main_page = MainPage(config)
profile_page = ProfilePage(config)
dialogs = Dialogs(config)
db_user.create_user(customer)
user.logout()
user.clicks(main_page.top_menu.LOGIN_LINK)
user.clicks(main_page.login_form.RECOVERY)
user.enters_text(main_page.recovery.EMAIL,
customer.customers_data.email)
user.clicks(main_page.recovery.SUBMIT)
user.waits_for_element_disappeared(main_page.recovery.WAIT,
config.page_load_timeout)
user.should_see_element_with_text(
main_page.recovery.SUCCESS_TEXT,
ConfirmationMessages.PASSWORD_RECOVERY_SUCCESS)
created_c = db_user.query_first(
Customers,
Customers.mobile_phone == customer.customers_data.mobile_phone)
user.opens('/forgot/success/?code=' + created_c.code + '&id=' +
str(created_c.id))
user.should_see_element_matched_to(
dialogs.RESET_PASSWORD_SUCCESS_DIALOG,
contains_string(
ConfirmationMessages.PASSWORD_RECOVERY_CONFIRMED.text))
new_password = db_user.query_first(
AclUsers, AclUsers.name == customer.customers_data.mobile_phone)
user.login(customer.customers_data.mobile_phone, customer.password)
user.should_see_element_with_text(login_page.ERROR,
ErrorMessages.LOGIN_FAILED)
user.login(customer.customers_data.mobile_phone, new_password.pwd)
user.should_see_element(profile_page)
def test_password_change_successfully(self, config, teardown):
user = GkrUserSteps(config)
db_user = GkrDbSteps(config)
profile_page = ProfilePage(config)
customer = random_user(UserRoles.CUSTOMER)
db_user.create_user(customer)
global mobile
mobile = customer.customers_data.mobile_phone
password = '******'
user.login(customer.customers_data.mobile_phone, customer.password)
user.waits_for_element_displayed(profile_page)
user.enters_text(profile_page.PASSWORD, password)
user.enters_text(profile_page.PASSWORD_CONFIRM, password)
user.clicks(profile_page.SUBMIT)
user.waits_for_element_displayed(profile_page.SUCCESS_MESSAGE)
user.should_see_element_with_text(profile_page.SUCCESS_MESSAGE,
ConfirmationMessages.PROFILE_CHANGED)
user.login(customer.customers_data.mobile_phone, password)
user.should_see_element(profile_page)
def sign_in(self, login: str, password: str) -> ProfilePage:
form: AuthForm = self.form
form.login = login
form.password = password
form.submit()
return ProfilePage(self.driver)
def delete_employer(self):
profile_page = ProfilePage(self.test.driver)
profile_page.open()
profile_page.delete_account()
class CheckRegistration(unittest.TestCase):
def setUp(self) -> None:
default_setup(self)
self.incorrect_name = 'name123'
self.incorrect_surname = 'surname123'
self.incorrect_email = 'margot.ru'
self.correct_name = 'margotName'
self.correct_surname = 'margotSurname'
self.correct_email = '*****@*****.**'
self.correct_password = self.PASSWORD_APPL
self.auth_page = AuthPage(self.driver)
self.reg_page = RegistrationPage(self.driver)
self.profile_page = ProfilePage(self.driver)
self.main_page = MainPage(self.driver)
def tearDown(self):
self.driver.quit()
def test_checkout_to_auth(self):
self.reg_page.open()
self.reg_page.go_to_auth()
self.auth_page.check_open_page()
def test_correct_registration_applicant_and_delete(self):
data = registration_applicant(self)
self.main_page.click_profile_page()
self.profile_page.is_open()
self.assertTrue(self.profile_page.check_profile_data(data))
self.profile_page.delete_account()
def test_correct_reg_empl_and_del(self):
scen = RegistrationEmployerScenario(self)
data = scen.registration_employer(True)
self.main_page.click_profile_page()
self.profile_page.is_open()
self.assertTrue(self.profile_page.check_profile_data(data))
self.profile_page.delete_account()
def test_correct_reg_empl_with_company_and_del(self):
scen = RegistrationEmployerScenario(self)
data = scen.registration_employer(True)
self.main_page.click_profile_page()
self.profile_page.is_open()
self.assertTrue(self.profile_page.check_profile_data(data))
self.profile_page.delete_account()
def test_empty_form_apl(self):
empty_form = {
'NAME': '',
'SURNAME': '',
'EMAIL': '',
'PASSWORD': '',
'CONFIRM_PASSWORD': ''
}
self.reg_page.open()
self.reg_page.set_data(empty_form)
self.assertTrue(self.reg_page.errors_empty_data())
def test_empty_form_empl(self):
empty_form = {
'NAME': '',
'SURNAME': '',
'EMAIL': '',
'PASSWORD': '',
'CONFIRM_PASSWORD': ''
}
self.reg_page.open()
self.reg_page.click_checkout_btn()
self.reg_page.set_data(empty_form)
self.assertTrue(self.reg_page.errors_empty_data())
def test_incorrect_name_appl(self):
incorrect_name_data = {
'NAME': self.incorrect_name,
'SURNAME': self.correct_surname,
'EMAIL': self.correct_email,
'PASSWORD': self.correct_password,
'CONFIRM_PASSWORD': self.correct_password
}
self.reg_page.open()
self.reg_page.set_data(incorrect_name_data)
self.assertTrue(
self.reg_page.top_error(
'Неправильные значения полей: имя должно содержать только буквы'
))
def test_incorrect_name_empl(self):
incorrect_name_data = {
'NAME': self.incorrect_name,
'SURNAME': self.correct_surname,
'EMAIL': self.correct_email,
'PASSWORD': self.correct_password,
'CONFIRM_PASSWORD': self.correct_password
}
self.reg_page.open()
self.reg_page.click_checkout_btn()
self.reg_page.select_company()
self.reg_page.set_data(incorrect_name_data)
self.assertTrue(
self.reg_page.top_error(
'Неправильные значения полей: имя должно содержать только буквы'
))
def test_incorrect_surname_appl(self):
incorrect_surname_data = {
'NAME': self.correct_name,
'SURNAME': self.incorrect_surname,
'EMAIL': self.correct_email,
'PASSWORD': self.correct_password,
'CONFIRM_PASSWORD': self.correct_password
}
self.reg_page.open()
self.reg_page.set_data(incorrect_surname_data)
self.assertTrue(
self.reg_page.top_error(
'Неправильные значения полей: фамилия должна содержать только буквы'
))
def test_incorrect_surname_empl(self):
incorrect_surname_data = {
'NAME': self.correct_name,
'SURNAME': self.incorrect_surname,
'EMAIL': self.correct_email,
'PASSWORD': self.correct_password,
'CONFIRM_PASSWORD': self.correct_password
}
self.reg_page.open()
self.reg_page.click_checkout_btn()
self.reg_page.click_to_checkbox()
self.reg_page.set_data(incorrect_surname_data)
self.assertTrue(
self.reg_page.top_error(
'Неправильные значения полей: фамилия должна содержать только буквы'
))
def test_incorrect_email_appl(self):
incorrect_email_data = {
'NAME': self.correct_name,
'SURNAME': self.correct_surname,
'EMAIL': self.incorrect_email,
'PASSWORD': self.correct_password,
'CONFIRM_PASSWORD': self.correct_password
}
self.reg_page.open()
self.reg_page.set_data(incorrect_email_data)
self.assertTrue(self.reg_page.error_email())
def test_not_equal_passwords(self):
different_password_data = {
'NAME': self.correct_name,
'SURNAME': self.correct_surname,
'EMAIL': self.correct_email,
'PASSWORD': self.correct_password,
'CONFIRM_PASSWORD': '******'
}
self.reg_page.open()
self.reg_page.set_data(different_password_data)
self.assertTrue(self.reg_page.errors_in_passwords())
def test_existing_account(self):
data = registration_applicant(self)
self.main_page.click_logout()
self.reg_page.open()
self.reg_page.set_data(data)
self.assertTrue(
self.reg_page.top_error('Пользователь уже существует.'))
setup_auth(self, data)
self.profile_page.open()
self.profile_page.delete_account()
def test_customer_queue_successful(self, config, teardown):
customer = random_user(UserRoles.CUSTOMER)
user = GkrUserSteps(config)
db_user = GkrDbSteps(config)
profile_page = ProfilePage(config)
queue_page = QueuePage(config)
ticket_data_dialog = TicketDataDialog(config)
db_user.create_user(customer)
global queue_mobile
queue_mobile = customer.customers_data.mobile_phone
day = (datetime.now() + timedelta(days=1)).strftime('%Y-%m-%d')
print_day = (datetime.now() + timedelta(days=1)).strftime('%d.%m.%Y')
locality = 'с. Александровка'
street = 'ул. Виноградная'
house = rand_num(2) + '/1a'
flat = rand_num(2) + 'б'
user.login(customer.customers_data.mobile_phone, customer.password)
user.should_see_element(profile_page)
user.selects_from_main_menu(MainMenu.QUEUE)
user.waits_for_element_displayed(queue_page)
user.chooses_from_select(queue_page.SERVICE,
Services.SINGLE_WINDOW.name)
user.chooses_from_select(queue_page.OBJECT_TYPE,
ObjectTypes.DOMOVLADENIE.name)
user.chooses_from_select(queue_page.CITY,
Departments.BEL_DEP.short_name)
user.enters_suggest(queue_page.LOCALITY, locality)
user.enters_suggest(queue_page.STREET, street)
user.enters_text(queue_page.HOUSE, house)
user.enters_text(queue_page.FLAT, flat)
user.enters_text(queue_page.CAPTCHA, '11111')
user.clicks(queue_page.SUBMIT)
user.waits_for_element_displayed(queue_page.CALENDAR)
user.set_calendar_date(queue_page.CALENDAR, day)
user.set_calendar_time(queue_page.CALENDAR, None)
time = queue_page.CALENDAR.time_list[0].text
user.clicks(queue_page.SUBMIT)
user.waits_for_element_displayed(ticket_data_dialog)
ticket_id = ticket_data_dialog.TICKET_NUMBER.element.text
user.should_see_element_with_text(ticket_data_dialog.TICKET_TIME,
(print_day + ' ' + time))
user.should_see_element_with_text(ticket_data_dialog.TICKET_SERVICE,
Services.SINGLE_WINDOW.name)
user.should_see_element_with_text(ticket_data_dialog.TICKET_DEP,
Departments.BEL_DEP.name)
user.should_see_element_with_text(
ticket_data_dialog.TICKET_CUSTOMER,
customer.customers_data.surname + " " +
customer.customers_data.name + " " +
customer.customers_data.patronymic)
user.should_see_element_with_text(
ticket_data_dialog.TICKET_ADDRESS, Departments.BEL_DEP.short_name +
" " + locality + " " + street + " д. " + house + " кв. " + flat)
db_user.should_see_service_group_id(ticket_id, UserTypes.CUSTOMER.id)
user.close(ticket_data_dialog)
user.selects_from_main_menu(MainMenu.QUEUE)
user.waits_for_element_displayed(queue_page)
user.clicks(queue_page.SUBMIT)
user.waits_for_element_displayed = user.waits_for_element_displayed(
queue_page.ERROR_TEXT)
user.should_see_text_in_list(
queue_page.ERROR_TEXT,
ErrorMessages.CUSTOMER_REGISTRATION_LIMIT.text %
(customer.customers_data.serial, customer.customers_data.no,
ticket_id))
user.opens(Urls.PROFILE)
history_item = profile_page.TICKETS_HISTORY.get_history_by_id(
ticket_id)
user.should_see_history_services(history_item, ticket_id,
Services.SINGLE_WINDOW.name,
print_day + ' ' + time)
class CoursesPage(BasePage):
def click_on_search_icon(self):
"""Method for clicking on search icon."""
self.click_on_element_by_css(Locators.SEARCH_ICON)
def go_to(self):
"""Method for redirecting to courses page."""
self.driver.get(base_page.COURSES_PAGE_URL)
def is_page_loaded(self, address):
"""Method to check if courses page is loaded."""
try:
self.wait.until(base_page.EC.url_to_be(address))
return True
except TimeoutException:
return False
def find_search_icon_by_css(self, by_css):
"""Method for finding search icon on the page"""
self.find_element_by_css(Locators.SEARCH_ICON)
def fill_in_text_field_by_css(self, by_css, text):
"""Method for filling in the text field with text"""
self.wait.until(
EC.visibility_of_element_located(by_css)).send_keys(text)
def is_valid_text_on_page(self):
"""Method for finding specific text on the page"""
try:
self.find_element_by_css(Locators.COURSE_DESCRIPTION_CARD)
return True
except TimeoutException:
return False
def click_on_course_header(self):
"""Method for clicking on course header on the course page."""
self.click_on_element_by_css(Locators.COURSE_HEADER)
def find_course_header(self):
"""Method for finding course header."""
self.find_element_by_css(Locators.COURSE_HEADER)
def second_click_on_search_icon(self):
"""Method for second clicking on search icon"""
self.click_on_element_by_css(Locators.SMALL_SEARCH_ICON)
def is_search_fild_active(self):
"""Method for check is search field active"""
try:
self.click_on_element_by_css(Locators.SMALL_SEARCH_ICON)
return True
except WebDriverException:
return False
def is_courses_on_page(self):
"""Method for check is at least 1 course on page"""
try:
self.find_element_by_css(Locators.COURSE_DESCRIPTION_CARD)
return True
except TimeoutException:
return False
def go_to_CourseSearchPage(self):
"""Method for redirecting on the course search page"""
self.driver.get(base_page.COURSES_PAGE_URL)
def click_on_filter_course_button(self):
"""Method for clicking on the filter course button"""
self.click_on_element_by_css(cpl.COURSE_FILTER_BUTTON)
def click_on_filter_music_checkbox(self):
"""Method for choosing music filter category"""
self.click_on_element_by_css(cpl.FILTER_BY_MUSIC_CHECKBOX)
def click_on_filter_sport_checkbox(self):
"""Method for choosing sport filter category"""
self.click_on_element_by_css(cpl.FILTER_BY_SPORT_CHECKBOX)
def click_on_filter_software_checkbox(self):
"""Method for choosing software filter category"""
self.click_on_element_by_css(cpl.FILTER_BY_SOFTWARE_CHECKBOX)
def click_on_filter_status_open(self):
"""Method for choosing opened courses"""
self.click_on_element_by_css(cpl.FILTER_BY_STATUS_OPEN)
def click_on_filter_status_closed(self):
"""Method for choosing closed courses"""
self.click_on_element_by_css(cpl.FILTER_BY_STATUS_CLOSED)
def click_on_filter_cost_free(self):
"""Method for choosing free courses"""
self.click_on_element_by_css(cpl.FREE_COST_FILTER)
def click_on_filter_cost_paid(self):
"""Method for choosing paid courses"""
self.click_on_element_by_css(cpl.PAID_COST_FILTER)
def close_filter_window(self):
"""Method closing filter window"""
self.click_on_element_by_css(cpl.CLOSE_FILTER_WINDOW)
def click_on_first_course_on_page(self):
"""Method for choosing first course on page"""
self.click_on_element_by_css(cpl.FIRST_COURSE_ON_PAGE)
def is_first_course_on_page_of_music_category(self):
"""Method for checking first course on page of music category"""
try:
self.find_element_by_xpath(cpl.MUSIC_COURSE_CATEGORY)
return True
except TimeoutException:
return False
def is_first_course_on_page_of_sport_category(self):
"""Method for checking first course on page of sport category"""
try:
self.find_element_by_xpath(cpl.SPORT_COURSE_CATEGORY)
return True
except TimeoutException:
return False
def is_first_course_on_page_of_software_category(self):
"""Method for checking first course on page of software category"""
try:
self.find_element_by_xpath(cpl.SOFTWARE_COURSE_CATEGORY)
return True
except TimeoutException:
return False
def is_subscribe_button_present_in_course_page(self):
"""Method for checking presents of the subscribe button """
try:
self.find_element_by_css(cpl.SUBSCRIBE_BUTTON)
return True
except TimeoutException:
return False
def is_open_icon_present_in_course_page(self):
"""Method for checking presents of the open course icon """
try:
self.find_element_by_xpath(cpl.OPEN_COURSE_ICON)
return True
except TimeoutException:
return False
def is_closed_icon_present_in_course_page(self):
"""Method for checking presents of the closed course icon """
try:
self.find_element_by_xpath(cpl.CLOSED_COURSE_ICON)
return True
except TimeoutException:
return False
def is_the_course_free(self):
"""Method for checking if the course is costless """
try:
self.find_element_by_xpath(cpl.COURSE_COSTS_ZERO)
return True
except TimeoutException:
return False
def is_course_on_page_of_music_category(self):
"""Method for checking if the music course is present on page """
try:
self.find_element_by_xpath(cpl.MUSIC_COURSE_ON_PAGE)
return True
except TimeoutException:
return False
def is_course_on_page_of_sport_category(self):
"""Method for checking if the sport course is present on page """
try:
self.find_element_by_xpath(cpl.SPORT_COURSE_ON_PAGE)
return True
except TimeoutException:
return False
def is_course_on_page_of_software_category(self):
"""Method for checking if the software course is present on page """
try:
self.find_element_by_xpath(cpl.SOFTWARE_COURSE_ON_PAGE)
return True
except TimeoutException:
return False
def is_course_on_page_of_other_category(self):
"""Method for checking if the other course is present on page """
try:
self.find_element_by_xpath(cpl.OTHER_COURSE_ON_PAGE)
return True
except TimeoutException:
return False
def if_subscribe_course_present_in_profile(self):
"""Method for checking presents follow course in profile page"""
self.profile_page = ProfilePage(self.driver)
self.profile_page.go_to()
self.profile_page.click_on_following_courses()
try:
self.find_element_by_xpath(cpl.TEST_COURSE)
except NoSuchElementException:
return False
return True
def click_on_subscribe_course_button(self):
"""Method for clicking on subscribe course button """
self.click_on_element_by_css(cpl.SUBSCRIBE_BUTTON)
def click_on_first_opened_course(self):
"""Method for clicking on first open course on page """
self.go_to_CourseSearchPage()
self.click_on_filter_course_button()
self.click_on_filter_status_open()
self.close_filter_window()
self.click_on_first_course_on_page()
def subscribe_on_test_course(self):
"""Method for subscribing on the test course """
self.go_to_CourseSearchPage()
self.click_on_filter_course_button()
self.click_on_filter_sport_checkbox()
self.click_on_filter_status_open()
self.close_filter_window()
self.click_on_element_by_link_text("Test_subscribe_course")
self.click_on_subscribe_course_button()
class EditResume(unittest.TestCase):
data = {
'title': 'My Title',
'description': 'My cool resume',
'place': 'I very good',
'skills': 'My great skills',
'position': 'Developer',
'name_job': 'Mail.ru Group',
'start_date': '2010-01-02',
'end_date': '2020-01-02',
}
other_data = {
'title': 'other My Title',
'description': 'other My cool resume',
'place': 'other I very good',
'skills': 'other My great skills',
}
def setUp(self) -> None:
default_setup(self)
self.create_resume_page = CreateResumePage(self.driver)
self.create_resume_form = self.create_resume_page.create_form
self.resume_page = ResumePage(self.driver)
self.resume = self.resume_page.form
self.edit_resume_page = EditResumePage(self.driver)
self.edit_resume_form = self.edit_resume_page.edit_form
self.profile_page = ProfilePage(self.driver)
self.scenario = ResumeScenario(self, self.create_resume_form)
setup_auth(self)
self.scenario.create_resume_with_experience(self.data)
self.profile_page.open()
self.profile_page.click_my_first_resume_edit()
self.assertTrue(self.edit_resume_page.is_open())
def test_save_without_changes(self):
self.edit_resume_form.submit_resume()
self.resume.wait_for_resume_page()
self.assertTrue(self.resume_page.is_open())
self.assertEqual(self.data['place'], self.resume.get_place())
self.assertEqual(self.data['description'],
self.resume.get_description())
self.assertEqual(self.data['skills'], self.resume.get_skills())
def test_save_with_changes(self):
self.edit_resume_form.clear_inputs()
self.scenario.fill_resume(self.other_data)
self.edit_resume_form.submit_resume()
self.resume.wait_for_resume_page()
self.assertTrue(self.resume_page.is_open())
self.assertEqual(self.other_data['place'], self.resume.get_place())
self.assertEqual(self.other_data['description'],
self.resume.get_description())
self.assertEqual(self.other_data['skills'], self.resume.get_skills())
def test_add_experience(self):
self.edit_resume_form.open_popup_add_experience()
self.scenario.create_experience(self.data)
self.edit_resume_form.submit_resume()
self.edit_resume_form.wait_for_resume_page()
position = self.resume.get_position()
name_job = self.resume.get_name_job()
self.assertEqual(self.data['position'], position[1].text)
self.assertEqual(self.data['name_job'], name_job[1].text)
def test_delete_experience(self):
self.edit_resume_form.delete_experience()
self.assertFalse(self.edit_resume_form.check_experience_exist())
def tearDown(self):
self.scenario.delete_resume()
self.driver.quit()
