class TestLogin(unittest.TestCase):
"""
引入unittest测试框架
"""
def setUp(self):
"""
初始化浏览器
:return:
"""
self.driver = webdriver.Chrome()
self.driver.implicitly_wait(20)
self.login_page = LoginPage(self.driver)
self.home_page = HomePage(self.driver)
def tearDown(self):
"""
关闭浏览器
:return:
"""
self.driver.quit()
def test_success(self):
"""
正向用例
:return:
"""
self.login_page.login('18684720553', 'python')
# 断言
user = self.home_page.get_element__user()
self.assertTrue( '我的帐户[python10]' in user.text )
class TestBid(unittest.TestCase):
def setUp(self)-> None:
"""登陆"""
self.driver = webdriver.Chrome()
self.login_page = LoginPage(self.driver)
self.login_page.login(user_info_success["username"], user_info_success["pwd"])
self.bid_page = BidPage(self.driver)
def tearDown(self)-> None: #箭头符号表示函数注解表示返回的是None
self.driver.quit()
def test_bid_success(self):
#在首页选择标的 choice_bid() ,点击投标
IndexPage(self.driver).choice_bid()
#定位投资输入框元素
e = self.bid_page.get_bid_input_element()
expect = e.get_attribute('data-amount')
print(expect)
#发送投资金额
e.send_keys(invest_money)
#点击投标
self.bid_page.click_bid_submit()
#获取可用余额
actual_money_str = UserPage(self.driver).get_user_money()
actual_money = float(actual_money_str)
#断言相关操作
self.assertTrue(int(expect*100)-invest_money == int(actual_money))
def test_logged_register(browser):
home_page = HomePage(browser)
result_page = SearchResultPage(browser)
login_page = LoginPage(browser)
# Given the home page is displayed
home_page.load()
home_page.go_to_login_page()
WebDriverWait(browser, 30).until(
EC.visibility_of_element_located(login_page.EMAIL_INPUT))
login_page.login('*****@*****.**', '*****@*****.**')
WebDriverWait(browser, 30).until(
EC.visibility_of_element_located(home_page.SIGNOUT_MESSAGE))
home_page.search('Erika Running Short')
WebDriverWait(browser,
30).until(EC.visibility_of_element_located(result_page.SIZE))
result_page.add_to_cart()
WebDriverWait(browser, 30).until(
EC.visibility_of_element_located(result_page.PAGEMESSAGE))
assert "You added Erika Running Short to your shopping cart." in result_page.success_message(
)
home_page.load()
home_page.logout()
def test_disable_section_on_ui(browser):
"""This is test will verify that disabling of sections in form reward payload"""
email, password = valid_user
login_page = LoginPage(browser)
login_page.login(email, password)
reward_page = RewardPage(browser)
reward_page.is_logged_in(email)
disable_status = reward_page.check_sections_after_disable_on_ui()
assert disable_status, "Failed to disable the UI Section"
def test_InValidLogin2(self):
self.driver = webdriver.Firefox()
self.driver.maximize_window()
self.driver.implicitly_wait(3)
self.driver.get(self.baseURL)
lp = LoginPage(self.driver)
lp.login(password=self._wrongPassword)
result = lp.verifyLoginWrongPassword()
assert result == True
self.driver.quit()
def class_web2():
'''初始化浏览器并登陆'''
driver = Chrome()
login_page = LoginPage(driver)
login_page.login("18684720553", "python")
bid_page = BidPage(driver)
yield driver, bid_page
driver.quit()
def test_ValidLogin(self):
self.driver = webdriver.Firefox()
self.driver.maximize_window()
self.driver.implicitly_wait(3)
self.driver.get(self.baseURL)
lp = LoginPage(self.driver)
lp.login(self._username, self._password)
result = lp.verifyLoginSuccessful()
assert result == True
self.driver.close()
def test_permissions_bulk_file_upload_for_invalid_user(browser):
""""This test will verify there will no permissions for bulk file upload and read details
for an invalid user.
"""
email, password = invalid_user
login_page = LoginPage(browser)
login_page.login(email, password)
bulk_actions_page = BulkActionsPage(browser)
bulk_actions_page.is_logged_in(email)
permissions = bulk_actions_page.get_permissions()
assert len(permissions) == 0
def test_login_wrong_user_credentials(login_page: LoginPage,
unknown_user: User) -> None:
"""Test for a failed login attempt."""
assert login_page.title == "Login to Redash"
with pytest.raises(TimeoutException):
login_page.login(email=unknown_user.email,
password=unknown_user.password)
assert login_page.alert == "Wrong email or password."
assert login_page.title == "Login to Redash"
def test_permissions_for_rewards_non_authorized_user_ui_navigation(browser):
""""This test will verify non-authorized user do not have permissions for reward create,
update, read permissions. This verification is done from UI navigation.
"""
email, password = invalid_user
login_page = LoginPage(browser)
login_page.login(email, password)
reward_page = RewardPage(browser)
reward_page.is_logged_in(email)
permissions = reward_page.get_permissions()
assert len(permissions) == 0
def test_check_mandatory_information_create_reward(browser):
"""verifies error message to create of public reward without filling all mandatory
information"""
email, password = valid_user
login_page = LoginPage(browser)
login_page.login(email, password)
reward_page = RewardPage(browser)
reward_page.is_logged_in(email)
input_data['Type'] = 'Public'
assertions = reward_page.check_mandatory_information(input_data)
for assertion in assertions:
assert assertion, "No Error Message displayed for mandatory information"
def test_bulk_upload_invalid_input_files(browser, invalid_file):
""""This test will verify that the bulk file upload is not possible for invalid file
formats e.g. .pdf, .gif, .zip ...
"""
email, password = valid_user
login_page = LoginPage(browser)
login_page.login(email, password)
bulk_actions_page = BulkActionsPage(browser)
bulk_actions_page.is_logged_in(email)
with pytest.raises(ErrorMessageException) as error_info:
bulk_actions_page.upload_file(invalid_file)
assert 'Error uploading file.' in str(error_info.value)
def get_login(request, base_url, selenium, user):
"""
Users can log in
@type base_url: string
@type selenium:
@type user:
"""
from pages.login import LoginPage
login_page = LoginPage(base_url, selenium)
login_page.login(user.username, user.password)
file = join(dirname(dirname(__file__)), 'cookies.pkl')
dump(selenium.get_cookies(), open(file, "wb"))
def test_permissions_bulk_file_upload(browser):
""""This test will verify permissions for bulk file upload and read details.
We will be testing this for User has only BulkAction Permission
"""
email, password = valid_user
login_page = LoginPage(browser)
login_page.login(email, password)
bulk_actions_page = BulkActionsPage(browser)
bulk_actions_page.is_logged_in(email)
permissions = bulk_actions_page.get_permissions()
assert permissions['create']
assert len(permissions['read']) > 0
def test_permissions_for_rewards_valid_user(browser):
""""This test will verify permissions for reward create, update, read permissions.
This will be for tested for an valid user has reward role.
"""
email, password = valid_user
login_page = LoginPage(browser)
login_page.login(email, password)
reward_page = RewardPage(browser)
reward_page.is_logged_in(email)
permissions = reward_page.get_permissions()
assert len(permissions) == 3
for permission in permissions:
assert permissions[permission]
def test_create_public_reward(browser):
"""verifies creation of public reward with all mandatory information"""
email, password = valid_user
login_page = LoginPage(browser)
login_page.login(email, password)
reward_page = RewardPage(browser)
reward_page.is_logged_in(email)
input_data['Type'] = 'Public'
input_data['Name'] = 'Public_Reward-{}'.format(input_data['Name'])
reward_info = reward_page.create_reward(input_data)
assert input_data['Name'] in reward_info
assert 'Active' in reward_info
assert input_data['Brands'] in reward_info
def test_successful_create_public_reward_with_search(browser):
"""Create Public Reward and Search that reward in Rewards List"""
email, password = valid_user
login_page = LoginPage(browser)
login_page.login(email, password)
reward_page = RewardPage(browser)
reward_page.is_logged_in(email)
input_data['Type'] = 'Public'
input_data['Name'] = 'Public_Reward-{}'.format(input_data['Name'])
reward_page.create_reward(input_data)
reward_page.search_reward(input_data['Name'])
table = reward_page.read_table()
assert input_data['Name'] in table[0]["Name"]
assert table[0]["Status"] == 'ACTIVE'
def test_bulk_upload_valid_input_files(browser, valid_file, action):
""""This test will verify that the bulk file upload is possible for all valid file
formats and all Actions e.g. .txt, .csv, .xlsx and Status is Processed"""
email, password = valid_user
login_page = LoginPage(browser)
login_page.login(email, password)
bulk_actions_page = BulkActionsPage(browser)
bulk_actions_page.is_logged_in(email)
bulk_actions_page.upload_file(valid_file, action)
table = bulk_actions_page.read_table()
assert (action['action']).lower() in (table[0]['Action Name']).lower()
assert table[0]['File Name'] == get_file_name(valid_file)
assert table[0]['User'] == email
assert table[0]['Status'] in ['PROCESSING', 'INITIAL']
def setup_login(base_url, selenium, user):
from pages.login import LoginPage
login_page = LoginPage(base_url, selenium)
login_page.login(user.username, user.password)
file = join(dirname(dirname(__file__)), 'cookies.pkl')
dump(selenium.get_cookies(), open(file, "wb"))
print(selenium.get_cookies())
selenium.get(base_url)
selenium.delete_all_cookies()
print(__file__)
file = join(dirname(dirname(__file__)), 'cookies.pkl')
cookies = load(open(file, "rb"))
for cookie in cookies:
selenium.add_cookie(cookie)
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 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'
def test_access_api_endpoints_using_rewards_admin_valid_user(browser):
""""This test will verify invalid user do not have permissions for reward create,
update, read permissions. This verification is done from UI navigation.
"""
end_points = ('/loyalties/list', '/campaigns/list', '/merchants/list',
'/settings/users', '/bulkaction')
email, password = valid_user
login_page = LoginPage(browser)
login_page.login(email, password)
reward_page = RewardPage(browser)
reward_page.is_logged_in(email)
status_dict = reward_page.get_api_end_point_status_with_url()
assert len(status_dict) > 5
for end_point in end_points:
if end_point in status_dict:
assert status_dict[end_point] == 'No Access'
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_access_api_endpoints_using_ui_rewards_admin_authorized_user(browser):
""""This test will verify invalid user do not have permissions for reward create,
update, read permissions. This verification is done from UI navigation.
"""
email, password = valid_user
login_page = LoginPage(browser)
login_page.login(email, password)
reward_page = RewardPage(browser)
reward_page.is_logged_in(email)
status_dict = reward_page.get_left_panel_links()
assert len(status_dict) > 5
for key in status_dict:
if 'rewards' in key:
assert status_dict[key] == 'Access', "Failed For {}".format(key)
else:
assert status_dict[key] == 'No Access', "Failed For {}".format(key)
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 test_add_user(self):
self.driver.get('http://127.0.0.1:8000/admin')
login_page = LoginPage(self.driver)
admin_page = login_page.login('admin', 'p@ssword')
add_user_page = admin_page.go_to_add_user_page()
user_page = add_user_page.add_user('testuser', 'dummy_p@ssword')
self.assertIn('testuser</a>" を追加しました。続けて編集できます。</li>',
user_page.driver.page_source)
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(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 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 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 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_logout(base_url, selenium, user):
"""
Users can logout
@type base_url: string
@type selenium:
@type user: strings
"""
login_page = LoginPage(base_url, selenium)
welcome_page = login_page.login(user.username, user.password)
assert welcome_page.is_the_current_page
def test_login_invalid_password_username(base_url, selenium, user):
"""
Users cannot login with wrong password
@type base_url: string
@type selenium:
@type user: strings
"""
login_page = LoginPage(base_url, selenium)
login = login_page.login(user.username + 'x', user.password + 'x')
assert login_page.is_the_current_page
def test_login_invalid_username(base_url, selenium, user):
"""
Attempt to log in with an invalid username
@type base_url: string
@type selenium:
@type user: strings
"""
login_page = LoginPage(base_url, selenium)
login = login_page.login(user.username + 'x', user.password)
assert login_page.is_the_current_page
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_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_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'
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_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_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_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(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_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 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_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'
