def test_empty_password_verification(self):
home_pg = Utilities.open_homepage(self.selenium)
login_pg = LoginPage(self.selenium)
home_pg.go_to_login_page()
login_pg.login_successful(var.test_username, "")
assert login_pg.password_required_message() == "The Password: field is required.", "Message do not match"
def test_change_lead_status_name(self, user, lead, lead_statuses):
login_page = LoginPage(self.driver)
main_page = login_page.log_in(user['email'], user['password'])
leads_page = main_page.navigation_bar.switch_to_leads()
new_lead_page = leads_page.add_new_lead()
new_lead_page.type_first_name(lead['first_name'])
new_lead_page.type_last_name(lead['last_name'])
lead_page = new_lead_page.save_new_lead()
Assert.equal(lead_page.lead_status, lead_statuses['prev_status'])
profile_page = lead_page.navigation_bar.switch_to_settings()
leads_sources_page = profile_page.settings_navigation_bar.customize_leads()
leads_statuses_page = leads_sources_page.lead_settings_bar.switch_to_lead_statuses()
leads_statuses_page.edit_status_name(lead_statuses['prev_status'], lead_statuses['new_status'])
leads_statuses_page.navigation_bar.switch_to_leads()
lead_page = leads_page.select_lead(lead)
Assert.equal(lead_page.lead_status, lead_statuses['new_status'])
# clean up
lead_page.delete_lead()
lead_page.navigation_bar.switch_to_settings()
leads_sources_page = profile_page.settings_navigation_bar.customize_leads()
leads_statuses_page = leads_sources_page.lead_settings_bar.switch_to_lead_statuses()
leads_statuses_page.edit_status_name(lead_statuses['new_status'], lead_statuses['prev_status'])
leads_statuses_page.navigation_bar.log_out()
def test_phantom_login(mozwebqa):
"""https://bugzilla.redhat.com/show_bug.cgi?id=996284"""
login_pg = LoginPage(mozwebqa)
login_pg.go_to_login_page()
next_pg = login_pg.login_and_send_window_size()
Assert.not_equal(next_pg.get_context_current_page(), '/',
"Phantom Login - Got redirected back to the login page after logging in")
def prepare_env(self, selenium_driver, testenv):
self.driver = selenium_driver
self.driver.implicitly_wait(10)
login_page = LoginPage(
self.driver,
'http://%s.test-env.scalr.com' % testenv.te_id).open()
self.admin_dashboard = login_page.login(ADMIN_USER, ADMIN_PASSWORD)
def test_successful_login_verification(self):
home_pg = Utilities.open_homepage(self.selenium)
login_pg = LoginPage(self.selenium)
home_pg.go_to_login_page()
login_pg.login_successful(var.test_username, var.test_password)
assert login_pg.successful_message() == var.test_username, "User do not match"
def home_page_logged_in(mozwebqa):
from pages.login import LoginPage
login_pg = LoginPage(mozwebqa)
login_pg.go_to_login_page()
home_pg = login_pg.login()
Assert.true(home_pg.is_logged_in, "Could not determine if logged in")
return home_pg
def home_page_logged_in(base_url, selenium, variables):
"""Logs in to the server and returns the dashboard page."""
from pages.login import LoginPage
login_pg = LoginPage(base_url, selenium)
login_pg.open()
home_pg = login_pg.login(variables['credentials']['fusor']['username'],
variables['credentials']['fusor']['password'])
return home_pg
def prepare_env(self, selenium, testenv):
self.driver = selenium
self.driver.implicitly_wait(10)
self.container = testenv
login_page = LoginPage(
self.driver,
'http://%s.test-env.scalr.com' % self.container.te_id).open()
self.env_dashboard = login_page.login(DEFAULT_USER, DEFAULT_PASSWORD)
def home_page_logged_in(mozwebqa):
'''Logs in to the application with default credentials and returns the
home page'''
from pages.login import LoginPage
login_pg = LoginPage(mozwebqa)
login_pg.go_to_login_page()
home_pg = login_pg.login()
Assert.true(home_pg.is_logged_in, 'Could not determine if logged in')
return home_pg
def test_wrong_login_verification(self):
home_pg = Utilities.open_homepage(self.selenium)
login_pg = LoginPage(self.selenium)
home_pg.go_to_login_page()
login_pg.login_as_wrong_user()
assert login_pg.error_message() ==\
"Login was unsuccessful. Please correct the errors and try again.",\
"Message do not match"
def home_page_logged_in(duckwebqa):
"""Log in to the appliance and return the home page."""
window_size = duckwebqa.selenium.get_window_size()
Assert.greater_equal(window_size['width'], 1280, _width_errmsg)
from pages.login import LoginPage
login_pg = LoginPage(duckwebqa)
login_pg.go_to_login_page()
home_pg = login_pg.login()
Assert.true(home_pg.is_logged_in, 'Could not determine if logged in')
return home_pg
def prepare_env(self, selenium, request, testenv):
load_timeout = request.config.getoption("load_timeout")
self.driver = selenium
self.driver.implicitly_wait(3)
login_page = LoginPage(
self.driver,
f'http://{testenv.te_id}.test-env.scalr.com',
timeout=load_timeout
).open()
self.account_email = f"selenium-{uuid4().hex[0:8]}@localhost.net"
self.admin_dashboard = login_page.login(
request.config.admin_login,
request.config.admin_pass)
def test_default_ldap_group_roles(browser, group_name, group_data):
"""Basic default LDAP group role RBAC test
Validates expected menu and submenu names are present for default
LDAP group roles
"""
login_pg = LoginPage(testsetup)
login_pg.go_to_login_page()
if group_name not in login_pg.testsetup.credentials:
pytest.fail("No match in credentials file for group '%s'" % group_name)
# login as LDAP user
home_pg = login_pg.login(user=group_name, force_dashboard=False)
Assert.true(home_pg.is_logged_in, "Could not determine if logged in")
validate_menus(home_pg, group_data, group_name)
def test_csrf_post(home_page_logged_in):
"""CSRF should prevent forged POST requests
POST requests use the CSRF token to validate requests, so setting the token
to something invalid should set off the CSRF detector and reject the request
"""
home_pg = home_page_logged_in
home_pg.csrf_token = 'Bogus!'
home_pg.click_on_reset_widgets()
# Bogus CSRF token should mean we get bounced back to the login page
login_pg = LoginPage(home_pg.testsetup)
login_pg._wait_for_visible_element(*login_pg._login_submit_button_locator)
Assert.true(login_pg.is_the_current_page, 'CSRF Attack succeeded!')
def test_access_level_for_fields_with_private_reward(browser):
"""This test will verify that all fields related to catalogues, labels, brands,
tags and categories should disappear for private reward"""
email, password = valid_user
login_page = LoginPage(browser)
login_page.login(email, password)
reward_page = RewardPage(browser)
reward_page.is_logged_in(email)
del input_data['Catalogues']
input_data['Type'] = 'Private'
input_data['Name'] = 'Private_Reward-{}'.format(input_data['Name'])
fields_visibility_status = reward_page.get_field_status(input_data)
assert len(fields_visibility_status) > 3
for field in ['Brands', 'Tags', 'Catalogues', 'Labels', 'Categories']:
if field in fields_visibility_status:
assert not fields_visibility_status[field], "Failed For {}".format(
field)
def logout(self):
self.browser.find_element_by_id("welcome").click()
self.wait.until(
EC.visibility_of_element_located([By.LINK_TEXT,
"Logout"])).click()
LoginPage(self.browser).wait_for_page_to_load()
def test_login(login_page: LoginPage, user: User) -> None:
"""Test for a successful login attempt."""
assert login_page.title == "Login to Redash"
home_page = login_page.login(email=user.email, password=user.password)
assert home_page.profile_dropdown == user.name
assert home_page.title == "Redash"
def logout(self):
options_button = self.selenium.find_element(
*self._user_options_button_locator)
options = self.selenium.find_element(*self._user_options_locator)
logout_link = options.find_element(*self._logout_link_locator)
ActionChains(self.selenium).move_to_element(options_button).click(
).move_to_element(logout_link).click().perform()
from pages.login import LoginPage
return LoginPage(self.testsetup)
def init_driver():
print('begin driver')
driver = webdriver.Chrome()
login_page = LoginPage(driver)
driver.get('http://120.78.128.25:8765/Index/login.html')
yield (driver, login_page) #相当于setup
#生成器，迭代器
driver.quit()
print('quit driver')
def test_successfully_login(setup):
login_page = LoginPage(setup["Driver"])
inventory_page = login_page.actions.login(setup["UserName"], setup["Password"])
element_is_displayed(inventory_page.banner.swag_labs_label)
element_is_displayed(inventory_page.banner.peek_icon)
element_is_displayed(inventory_page.sort_drop_down)
element_is_displayed(inventory_page.banner.cart_icon)
element_is_displayed(inventory_page.footer)
element_list_is_not_empty(inventory_page.product_list)
def test_invalid_login_empty_email():
with pytest.allure.step('Testing invalid login try with empty email'):
logger.info('Start testing login with invalid email')
page = HomePage(driver).logging()
page = LoginPage(driver).input_password().login()
logger.info('Checking proper work of error handler with invalid email')
error_text = page.driver.find_element_by_class_name('alert')
assert 'Warning: No match for E-Mail Address and/or Password' in error_text.text
logger.info(
'Work of error handler with invalid email has been checked')
def test_default_ldap_group_roles(self, mozwebqa, ldap_groups, cfme_data):
"""Basic default LDAP group role RBAC test
Validates expected menu and submenu names are present for default
LDAP group roles
"""
if ldap_groups not in cfme_data.data['group_roles']:
pytest.xfail("No match in cfme_data for group '%s'" % ldap_groups)
_group_roles = cfme_data.data['group_roles'][ldap_groups]
login_pg = LoginPage(mozwebqa)
login_pg.go_to_login_page()
if ldap_groups not in login_pg.testsetup.credentials:
pytest.xfail("No match in credentials file for group '%s'" % ldap_groups)
# login as LDAP user
home_pg = login_pg.login(user=ldap_groups)
Assert.true(home_pg.is_logged_in, "Could not determine if logged in")
for menu in _group_roles["menus"]:
Assert.true(home_pg.header.site_navigation_menu(menu).name == menu)
for item in home_pg.header.site_navigation_menu(menu).items:
Assert.true(item.name in _group_roles["menus"][menu])
def test_search_for_query_only_includes_search_result(
create_queries: typing.Callable[..., None],
login_page: LoginPage,
server_url: str,
selenium,
user: User,
) -> None:
page = login_page.login(email=user.email, password=user.password)
search = page.search("Default Query")
assert len(search.queries) == 2
assert search.queries[0].link.text == "Default Query"
def test_add_goods_to_cart():
with pytest.allure.step('Testing adding goods to cart functional'):
logger.info('Start testing add goods to cart function')
page = HomePage(driver).logging()
page = LoginPage(driver).input_password().input_email().login()
page = HomePage(driver).select_mac_product()
page = ProductPage(driver).add_mac_to_cart().driver.implicitly_wait(5)
logger.info('Checking proper work of adding goods to cart')
success_text = page.driver.find_element_by_class_name('alert')
assert 'Success: You have added' in success_text.text
logger.info('Work of adding goods to cart function has been checked')
def __init__(self, base_url, headless):
driver_path = ChromeDriverManager().install()
options: Options = Options()
options.headless = headless
self.wd = webdriver.Chrome(driver_path, options=options)
self.base_url = base_url
self.login_page = LoginPage(self)
self.main_page = MainPage(self)
self.deposit_page = DepositPage(self)
self.card_page = CardPage(self)
self.payment_page = PaymentPage(self)
def my_set_class():
#只会在某个类里面去执行一次
print('begin my class')
driver = webdriver.Chrome()
driver.get("http://120.78.128.25:8765/Index/login.html")
driver.maximize_window()
login_page = LoginPage(driver)
yield (driver, login_page)
print('finish my class')
driver.quit()
class EdxLogin(unittest.TestCase):
def setUp(self):
#Initialize webdriver
self.driver = webdriver.Chrome()
self.login = LoginPage(self.driver)
self.dashboard = Dashboard(self.driver)
def test_login(self):
# Open the target page
self.driver.get('https://......g/login')
# Assert that 'edX' is present in browser title
self.assertTrue(self.login.is_browser_on_the_page())
# Find and fill the email field
self.login.fill_form()
# Find and click the submit button
self.login.submit_form()
# Assert that 'Dashboard' is present in target pages browser title
self.dashboard.is_browser_on_the_page()
def tearDown(self):
self.driver.close()
def test_query_by_description(
create_queries: typing.Callable[..., None],
login_page: LoginPage,
search_term: str,
description: str,
user: User,
) -> None:
"""Search for query using description."""
page = login_page.login(email=user.email, password=user.password)
search = page.search(description)
query = search.queries[0].click()
assert query.description == description
def test_change_query_description(
create_queries: typing.Callable[..., None],
login_page: LoginPage,
server_url: str,
selenium,
root_user: User,
) -> None:
page = login_page.login(email=root_user.email, password=root_user.password)
search = page.search("Blank Query")
query = search.queries[0].click()
query.edit_description("This is a description")
assert query.description == "This is a description"
def test_search_for_query_by_id(
create_queries: typing.Callable[..., None],
login_page: LoginPage,
server_url: str,
selenium,
user: User,
) -> None:
"""Search for a query by its id."""
page = login_page.login(email=user.email, password=user.password)
search = page.search("2")
query = search.queries[0].click()
assert query.description == "Query created by Ashley."
def test_default_ldap_group_roles(self, mozwebqa, ldap_groups, cfme_data):
"""Basic default LDAP group role RBAC test
Validates expected menu and submenu names are present for default
LDAP group roles
"""
if ldap_groups not in cfme_data.data['group_roles']:
pytest.xfail("No match in cfme_data for group '%s'" % ldap_groups)
_group_roles = cfme_data.data['group_roles'][ldap_groups]
login_pg = LoginPage(mozwebqa)
login_pg.go_to_login_page()
if ldap_groups not in login_pg.testsetup.credentials:
pytest.xfail("No match in credentials file for group '%s'" %
ldap_groups)
# login as LDAP user
home_pg = login_pg.login(user=ldap_groups)
Assert.true(home_pg.is_logged_in, "Could not determine if logged in")
for menu in _group_roles["menus"]:
Assert.equal(home_pg.header.site_navigation_menu(menu).name, menu)
for item in home_pg.header.site_navigation_menu(menu).items:
Assert.contains(item.name, _group_roles["menus"][menu])
def test_product_details(setup):
login_page = LoginPage(setup["Driver"])
inventory_page = login_page.actions.login(setup["UserName"], setup["Password"])
inventory_item_page = inventory_page.actions.click_on_random_product()
element_is_displayed(inventory_item_page.banner.cart_icon)
element_is_displayed(inventory_item_page.banner.burger_button)
element_is_displayed(inventory_item_page.product_title)
element_is_displayed(inventory_item_page.product_image)
element_is_displayed(inventory_item_page.product_description)
element_is_displayed(inventory_item_page.product_price)
element_is_displayed(inventory_item_page.back_button)
element_is_displayed(inventory_item_page.add_to_cart_button)
def init_web():
options = webdriver.ChromeOptions()
options.add_argument('--headless')
options.add_argument('--no-sandbox')
driver = webdriver.Remote(
command_executor='http://192.168.3.48:4444/wd/hub',
desired_capabilities={'browserName': 'chrome'},
options=options)
login_page = LoginPage(driver)
driver.maximize_window()
yield driver, login_page
time.sleep(2)
driver.quit()
def init_driver():
#这是一个函数
print('begin driver')
driver = webdriver.Chrome()
driver.get("http://120.78.128.25:8765/Index/login.html")
driver.maximize_window()
login_page = LoginPage(driver)
#yield出来，才可以在其他页面使用
yield (driver, login_page) #在执行yield的时候会执行测试用例，执行完测试用例在执行quit driver（生成器）
print('quit driver')
driver.quit()
def test_query_archive(
create_queries: typing.Callable[..., None],
login_page: LoginPage,
server_url: str,
selenium,
root_user: User,
variables: typing.Dict,
) -> None:
page = login_page.login(email=root_user.email, password=root_user.password)
search = page.search("Archive Query")
query = search.queries[0].click()
query.click_dropdown_menu(text="Archive")
assert query.query_tag == "Archived"
def test_query_by_weird_capitalization(
create_queries: typing.Callable[..., None],
login_page: LoginPage,
org: str,
user: User,
variables: typing.Dict,
) -> None:
"""Search for query with weird capitalization."""
term = variables[org]["queries"]["capitalization"]
page = login_page.login(email=user.email, password=user.password)
search = page.search(term["name"])
query = search.queries[0].click()
assert query.description == term["description"]
def test_edit_query_source(
create_queries: typing.Callable[..., None],
login_page: LoginPage,
server_url: str,
selenium,
root_user: User,
variables: typing.Dict,
) -> None:
page = login_page.login(email=root_user.email, password=root_user.password)
search = page.search("Default Query")
query = search.queries[0].click()
query.edit_source_button.click()
assert "/source" in selenium.current_url
def test_query_by_special_char(
create_queries: typing.Callable[..., None],
login_page: LoginPage,
org: str,
user: User,
variables: typing.Dict,
) -> None:
"""Search for query wioth special characters in name."""
term = variables[org]["queries"]["special-char"]
page = login_page.login(email=user.email, password=user.password)
search = page.search(term["name"])
query = search.queries[0].click()
assert query.description == term["description"]
def test_query_fork(
create_queries: typing.Callable[..., None],
login_page: LoginPage,
server_url: str,
selenium,
root_user: User,
variables: typing.Dict,
) -> None:
page = login_page.login(email=root_user.email, password=root_user.password)
search = page.search("Default Query")
query = search.queries[0].click()
fork_query = query.click_dropdown_menu(text="Fork")
selenium.switch_to.window(selenium.window_handles[-1])
assert "Copy of (#4)" in fork_query.title
def setUpClass(cls):
cls.driver = webdriver.Chrome()
cls.driver.get("http://120.78.128.25:8765/index/login.html")
cls.driver.implicitly_wait(30)
cls.login_page = LoginPage(cls.driver)
cls.invest_page = InvestPage(cls.driver)
cls.index_page = IndexPage(cls.driver)
cls.login_page.send_phone_element(invest.user_currect_info['phone'])
cls.login_page.send_password_element(
invest.user_currect_info['password'])
cls.login_page.submit_element()
IndexPage(cls.driver).bid()
def my_class_login():
print('Start Test Only Once')
url = "http://120.78.128.25:8765/Index/login.html"
driver = webdriver.Chrome()
driver.get(url)
driver.implicitly_wait(30)
global login_page
login_page = LoginPage(driver)
print(login_page, type(login_page))
yield (driver, login_page)
print('End Test Only Once ')
driver.quit()
def test_csrf_post(home_page_logged_in):
"""CSRF should prevent forged POST requests
POST requests use the CSRF token to validate requests, so setting the token
to something invalid should set off the CSRF detector and reject the request
"""
home_pg = home_page_logged_in
home_pg.csrf_token = 'Bogus!'
home_pg.click_on_reset_widgets()
# Bogus CSRF token should mean we get bounced back to the login page
login_pg = LoginPage(home_pg.testsetup)
Assert.true(login_pg.is_the_current_page, 'CSRF Attack succeeded!')
def test_invalid_login_toomanytries():
with pytest.allure.step(
'Testing too much tries to invalid login with empty email and password'
):
logger.info(
'Start testing too much tries to login with invalid credentials')
page = HomePage(driver).logging()
page = LoginPage(driver).login()
logger.info(
'Checking proper work of error handler for too much tries to login with invalid credentials'
)
error_text = page.driver.find_element_by_class_name('alert')
assert 'Warning: Your account has exceeded allowed number of login attempts' in error_text.text
logger.info(
'Work of error handler for too much tries to login with invalid credentials has been checked'
)
def test_search_for_unpublished_query(
create_queries: typing.Callable[..., None],
login_page: LoginPage,
server_url: str,
selenium,
root_user: User,
) -> None:
"""Publish a query and then search for the unpublished one."""
page = login_page.login(email=root_user.email, password=root_user.password)
search = page.search("Publish Query")
query = search.queries[0].click()
query.publish()
page = HomePage(selenium, server_url).open()
search = page.search("Ashleys Query")
query = search.queries[0].click()
assert query.description == "Query created by Ashley."
def test_edit_query_description(
create_queries: typing.Callable[..., None],
login_page: LoginPage,
server_url: str,
selenium,
root_user: User,
variables: typing.Dict,
) -> None:
default_description = variables["default"]["queries"]["default"][
"description"]
page = login_page.login(email=root_user.email, password=root_user.password)
search = page.search("Default Query")
query = search.queries[0].click()
assert query.description == default_description
query.edit_description(" NEW NEW")
assert query.description == f"{default_description} NEW NEW"
def test_login(self, browser):
login_pg = LoginPage(testsetup)
login_pg.go_to_login_page()
home_pg = login_pg.login()
Assert.true(home_pg.is_logged_in, "Could not determine if logged in")
def do_login(self):
test_page = LoginPage(self.driver)
test_page.enter_login_username(valid_username)
test_page.enter_login_password(valid_password)
test_page.submit_login_form()
def test_login(self, mozwebqa):
login_pg = LoginPage(mozwebqa)
login_pg.go_to_login_page()
home_pg = login_pg.login()
Assert.true(home_pg.is_logged_in, "Could not determine if logged in")
def test_login_admin(base_url, selenium, variables):
login_pg = LoginPage(base_url, selenium)
login_pg.open()
dashboard_pg = login_pg.login(variables['credentials']['fusor']['username'],
variables['credentials']['fusor']['password'])
assert dashboard_pg.is_the_current_page
def test_login(base_url, selenium, variables):
"""Users can log in"""
login_page = LoginPage(base_url, selenium).open()
messages_page = login_page.login(variables['username'], variables['password'])
assert messages_page.notification == 'You were logged in'
def test_invalid_password(mozwebqa, variables):
"""Attempt to log in with an invalid password"""
login_page = LoginPage(mozwebqa)
login_page.open()
login_page.login(variables['username'], 'invalid')
assert login_page.error == 'Error: Invalid password'
def test_log_in(self):
""" test log page """
login_page = LoginPage(self.testSetup)
login_page.go_to_login_page()
login_page.log_in()
def test_invalid_username(mozwebqa, variables):
"""Attempt to log in with an invalid username"""
login_page = LoginPage(mozwebqa)
login_page.open()
login_page.login('invalid', variables['password'])
assert login_page.error == 'Error: Invalid username'
def test_invalid_password(base_url, selenium, variables):
"""Attempt to log in with an invalid password"""
login_page = LoginPage(base_url, selenium).open()
login_page.login(variables['username'], 'invalid')
assert login_page.error == 'Error: Invalid password'
def test_that_checks_for_phantom_login(mozwebqa):
login_pg = LoginPage(mozwebqa)
login_pg.go_to_login_page()
next_pg = login_pg.login_and_send_window_size()
Assert.not_equal(next_pg.get_context_current_page(), "/", "This is still the login page")
def test_login_admin(base_url, selenium, deployment_config):
login_pg = LoginPage(base_url, selenium)
login_pg.open()
dashboard_pg = login_pg.login(deployment_config.credentials['fusor']['username'],
deployment_config.credentials['fusor']['password'])
assert dashboard_pg.is_the_current_page
def test_login(mozwebqa, variables):
"""Users can log in"""
login_page = LoginPage(mozwebqa)
login_page.open()
messages_page = login_page.login(variables['username'], variables['password'])
assert messages_page.notification == 'You were logged in'
