def logout_and_in():
"""Log out and then back in again, using the email and password from the
last registered account. Returns to the initial url after login."""
url = get_current_url()
logout()
login(_LAST_EMAIL, _LAST_PASSWORD)
go_to(url)
def assert_device_preferences_not_displayed():
go_to(urls.EDIT)
fails(assert_element, tag="input", name="twofactor_required", value="True")
fails(assert_element, tag="input", name="twofactor_required",
value="False")
fails(assert_element, tag="input", name="warn_about_backup_device",
checked="checked")
def test_sign_out_link(self):
expected = 'https://avant-qa-screening.herokuapp.com/'
self.verify_landing_dash_page_links(0, expected, False)
# clean up steps (this test only) logs back in
go_to('https://avant-qa-screening.herokuapp.com/users/sign_in')
set_email_field(self.valid_email)
set_password_field(self.valid_pw)
set_log_in_button()
def go_to(url=''):
protocol = os.environ.get('MAGENTO_PROTOCOL', 'http')
domain = os.environ.get('MAGENTO_DOMAIN_SUFFIX', '.localhost')
vtuple = get_version()
hostname = os.environ.get('MAGENTO_HOSTNAME',
'magento-' + '-'.join(str(v) for v in vtuple))
a.go_to('%s://%s%s/%s' % (protocol, hostname, domain, url))
def test_sign_out_link(self):
expected = 'https://avant-qa-screening.herokuapp.com/'
self.verify_landing_dash_page_links(0, expected, False)
# clean up steps (this test only) logs back in
go_to('https://avant-qa-screening.herokuapp.com/users/sign_in')
set_email_field(self.valid_email)
set_password_field(self.valid_pw)
set_log_in_button()
def get_device_preferences_elements():
go_to(urls.EDIT)
always_radio = get_element(tag="input", name="twofactor_required",
value="True")
as_needed_radio = get_element(tag="input", name="twofactor_required",
value="False")
warn_backup_checkbox = get_element(tag="input",
name="warn_about_backup_device")
return always_radio, as_needed_radio, warn_backup_checkbox
def check_2f_for_url(url):
# are we redirected?
go_to(url)
wait_for(assert_title, 'Log in')
login()
go_to(url)
# should be redirected
assert_url('/two_factor_auth?next=%s' % quote(url))
logout()
def cleanup():
go_to(urls.DEVICES)
# cleanup assumes the user is logged in, otherwise we get a circular
# dependency between helpers and devices
msg = 'Can not cleanup devices if user is not logged in.'
assert '+login' not in get_current_url(), msg
while get_elements_by_css('#device-list td.name'):
name = get_elements_by_css('#device-list td.name')[0].text
print 'Deleting a device:', name
delete_device()
def test_YUI3_unit_tests(self):
# Load the page and then wait for #suite to contain
# 'done'. Read the results in '#test_results'.
go_to(self.test_url)
wait_for(assert_text, 'suite', 'done')
results = json.loads(get_element(id='test_results').text)
if results['failed'] != 0:
message = '%d test(s) failed.\n\n%s' % (
results['failed'], yui3.get_failed_tests_message(results))
self.fail(message)
def test_YUI3_unit_tests(self):
# Load the page and then wait for #suite to contain
# 'done'. Read the results in '#test_results'.
go_to(self.test_url)
wait_for(assert_text, 'suite', 'done')
results = json.loads(get_element(id='test_results').text)
if results['failed'] != 0:
message = '%d test(s) failed.\n\n%s' % (
results['failed'], yui3.get_failed_tests_message(results))
self.fail(message)
def test_existing_user(self):
email, pw = create_valid_account()
stop() # cleanup step
go_to(self.chk_url)
set_email_field(email)
set_password_field(pw)
set_password_confirmation_field(pw)
set_sign_up_button()
expected = "1 error prohibited this user from being saved:\nEmail has already been taken"
self.verify_error_explanation(expected)
stop() # cleanup step
def assert_backup_device_warning():
go_to(urls.EDIT)
assert_checkbox_value(get_warn_about_backup_device_checkbox(), True)
warning = get_backup_device_warning_div()
# ensure a single message is shown
messages = warning.find_elements_by_tag_name('p')
assert len(messages) == 1
assert_text_contains(
messages[0], 'We strongly recommend having two authentication devices')
assert_text_contains(
messages[0], 'Click to add a backup device.')
def test_existing_user(self):
email, pw = create_valid_account()
stop() # cleanup step
go_to(self.chk_url)
set_email_field(email)
set_password_field(pw)
set_password_confirmation_field(pw)
set_sign_up_button()
expected = "1 error prohibited this user from being saved:\nEmail has already been taken"
self.verify_error_explanation(expected)
stop() # cleanup step
def _get_paper_device_codes(counter):
url = get_current_url()
restore = False
if not re.match(r'.*/device-print/\d+$', url):
assert_url('/device-list')
click_link(get_element(tag='a', text='View Codes'))
restore = True
codes = [e.text for e in
get_elements_by_css('ol.codelist li')][counter:]
if restore:
go_to('/device-list')
return codes
def register_account(email_address=None, displayname="My Name",
password="******", fetch_email=True, verify=None):
"""Register an account and verify the token by default.
If `register_account` creates the email address for you then it returns
the email address.
If you pass in an `email_address` then the verification token is returned.
"""
global _LAST_EMAIL, _LAST_PASSWORD
if email_address is None:
email_address = mail.make_unique_test_email_address()
vcode = None
create_account = u1testutils.sso.sst.pages.CreateAccount(open_page=True)
user = data.User(displayname, email_address, password)
create_account.create_ubuntu_sso_account(user)
vcode = None
if 'allow_unverified' in config.flags:
u1testutils.sso.sst.pages.YourAccount(user.full_name)
# default is not to verify for ALLOW_UNVERIFIED
if verify is None:
verify = False
if verify:
vlink = sso_mail.get_verification_link_for_address(email_address)
go_to(vlink)
validate_email = \
u1testutils.sso.sst.pages.CompleteEmailValidation()
validate_email.confirm()
else:
mail_sent = u1testutils.sso.sst.pages.AccountCreationMailSent()
# old flow requries verify, usually
if verify is None:
verify = True
if verify:
vcode = sso_mail.get_verification_code_for_address(email_address)
# TODO add the site not recognized parameter and use the right
# public method.
mail_sent._confirm_email(vcode)
_LAST_EMAIL = email_address
_LAST_PASSWORD = password
return email_address
def add_device(name='My device'):
# Go to the authentication devices page
go_to(urls.DEVICES)
# Click on "Add a new authentication device" link
click_add_new_device_link()
# Choose "Generic HOTP device" and click add device
set_radio_value('type_generic')
click_add_device_button()
# Add correctly generated OTP key
aes_key = get_element(name='hex_key').get_attribute('value')
valid_otp = hotp.hotp(aes_key, 0)
write_textfield(get_element(tag='input', name='otp'), valid_otp)
# Add a name
write_textfield(get_element(tag='input', name='name'), name)
# Click "Add device"
click_add_device_button()
store_device(name, aes_key)
return aes_key
def delete_device():
go_to(urls.DEVICES)
# Fetch the name of the device we will be deleting
name = get_elements_by_css('#device-list td.name')[0].text
# Click on the delete button
click_delete_button()
# if we need to 2F auth this action
if exists_element(id='id_oath_token'):
authenticate()
# Click on ok
click_button(get_element(tag='button', text='Delete this device'))
remove_device(name)
# Check we are back on the device-list page
assert_url('/device-list')
# Check that our device has been deleted
fails(get_element, 'device-list')
from acceptance import helpers, urls
config.set_base_url_from_env()
edit_account_anchor = {'data-qa-id': 'edit_account'}
# Create an account and logout.
email_address = helpers.register_account(
displayname="Fred Jones",
verify=True
)
helpers.logout()
# Request the password reset.
go_to(urls.HOME)
assert_title('Log in')
click_link('forgotpw-link')
write_textfield('id_email', email_address)
# Even though the recaptcha field is ignored for our tests, we do
# want to verify that it is on the page.
write_textfield('recaptcha_response_field', 'ignored')
click_button(get_element(name='continue'))
assert_element(**{'data-qa-id': 'forgot_password_step_2'})
# Fetch and verify the confirmation code.
vcode = mail.get_verification_code_for_address(email_address)
write_textfield(get_element(name='confirmation_code'), vcode)
click_button(get_element(css_class='btn'))
from u1testutils import mail
from u1testutils.sst import config
from acceptance import helpers, urls
config.set_base_url_from_env()
# Create an account with multiple emails.
email_address = helpers.register_account(displayname="Fred Jones", verify=True)
other_email_address = mail.make_unique_test_email_address()
helpers.add_email(other_email_address, verify=True)
edit_account_anchor = {'data-qa-id': 'edit_account'}
# Verify the current preferred email and change it.
go_to(urls.EDIT)
assert_element(**edit_account_anchor)
assert_dropdown_value('id_preferred_email', email_address)
set_dropdown_value('id_preferred_email', other_email_address)
click_button(get_element(name='update'))
# Verify that it was changed (we re-load the page to be sure it's not
# some unexpected validation error):
go_to(urls.EDIT)
assert_element(**edit_account_anchor)
assert_dropdown_value('id_preferred_email', other_email_address)
# XXX Julien would also like this test to trigger an email being sent so
# we can verify that the email is actually sent to the preferred
# address.
skip,
skip_production,
)
config.set_base_url_from_env()
skip_production()
# XXX: skip if staging until the test can be made to reliably pass
if is_staging():
skip()
toggled_elements = ast.literal_eval(toggled_elements)
disabled_elements = ast.literal_eval(disabled_elements)
returned_sreg = ast.literal_eval(returned_sreg)
go_to(urls.CONSUMER)
wait_for(assert_title, 'Django OpenID Example Consumer')
toggle_checkbox('id_sreg')
set_radio_value(radio_nickname)
set_radio_value(radio_fullname)
set_radio_value(radio_email)
set_radio_value(radio_language)
click_button(get_element(value='Begin'))
wait_for(assert_title, 'Log in')
write_textfield('id_email', settings.SSO_TEST_ACCOUNT_EMAIL)
write_textfield('id_password', settings.SSO_TEST_ACCOUNT_PASSWORD)
click_button(get_element_by_css('*[data-qa-id="ubuntu_login_button"]'))
wait_for(assert_title_contains, 'Authenticate to')
# Check the elements specified in the .csv list
assert_title_contains,
click_button,
get_element,
go_to,
wait_for,
)
from u1testutils import mail
from u1testutils.sso import mail as sso_mail
from u1testutils.sst import config
from acceptance import helpers, urls
config.set_base_url_from_env()
go_to(urls.NEW_ACCOUNT)
assert_title('Create account')
email_address = mail.make_unique_test_email_address()
helpers.fill_registration_form(email_address)
click_button(get_element(name='continue'))
if 'allow_unverified' not in sst_config.flags:
assert_title_contains('Account creation mail sent')
assert_text_contains(
get_element(id='content'),
r'just emailed .* \(from .*\) to confirm your address\.',
regex=True)
link = sso_mail.get_verification_link_for_address(email_address)
def setUp(self):
# open the sign_up page directly
self.chk_url = 'https://avant-qa-screening.herokuapp.com/users/sign_up'
go_to(self.chk_url)
# The token generated when creating a new account should not be able to
# be used with other email addresses.
from sst.actions import (
assert_element,
go_to,
)
from u1testutils.sst import config
from acceptance import helpers, urls
config.set_base_url_from_env()
email_address_for_token = helpers.register_account(displayname="Fred Stone")
# Now that we're logged in with the new account, we try creating
# another new account...but are redirected back to our details.
go_to(urls.NEW_ACCOUNT)
assert_element(**{'data-qa-id': 'edit_account'})
def setUpClass(self):
self.chk_url = 'https://avant-qa-screening.herokuapp.com/users/sign_in'
go_to(self.chk_url)
set_sign_up_link()
self.valid_email, self.valid_pw = create_valid_account()
stop()
assert_element,
click_button,
get_element,
go_to,
)
from sst import config as sst_config
from u1testutils import mail
from u1testutils.sst import config
from acceptance import helpers, urls
config.set_base_url_from_env()
email_address = helpers.register_account()
# We logout now and verify that we can't create a second email account
# with the same email address.
go_to(urls.LOGOUT)
go_to(urls.NEW_ACCOUNT)
helpers.fill_registration_form(email_address)
click_button(get_element(name='continue'))
if 'allow_unverified' in sst_config.flags:
assert_element(text='Invalid Email')
else:
# In this case, the email sent should be a warning with a link to the
# forgot password page.
email = mail.get_latest_email_sent_to(email_address)
mail.email_subject_includes(email, "Warning")
mail.email_body_includes(email, "/+forgot_password")
__author__ = 'y981821'
from sst import actions, config
config.browser_type = 'firefox'
actions.go_to('https://staging.sem.yellow.co.nz')
def setUpClass(self):
self.chk_url = 'https://avant-qa-screening.herokuapp.com/users/sign_in'
go_to(self.chk_url)
set_sign_up_link()
self.valid_email, self.valid_pw = create_valid_account()
stop()
def setUpClass(self):
go_to('https://avant-qa-screening.herokuapp.com/users/sign_in')
set_sign_up_link()
self.valid_email, self.valid_pw = create_valid_account()
self.h1 = get_h1()
set_edit_profile_link()
from u1testutils.sst import config
from acceptance import helpers, urls
from identityprovider.utils import get_current_brand
if get_current_brand() == 'ubuntuone':
skip(
'The ubuntuone brand does client side validation'
)
config.set_base_url_from_env()
# Create and verify account A
helpers.register_account()
# Add and verify 2nd email
go_to(urls.EMAILS)
wait_for(assert_title_contains, "'s email addresses")
write_textfield('id_newemail', address)
click_button(get_element(name='continue'))
# Check the outcome
if valid:
wait_for(assert_title, 'Validate your email address')
mail.delete_msgs_sent_to(address)
else:
wait_for(assert_title, 'Add an email')
assert_text_contains(get_element(name='newemailform'), 'Invalid email.')
)
from identityprovider.utils import get_current_brand
config.set_base_url_from_env()
# Create account or login, then add a device
helpers.login_or_register_account(device_cleanup=True)
aes_key = add_device('logout_deep_pages')
# Logout and back in so we are no longer 2f-authenticated
helpers.logout_and_in()
# Create a device to get a deep page and then start to delete it
go_to(urls.DEVICES)
click_delete_button()
authenticate()
assert_url_contains('/device-removal/\d+', regex=True)
# logout by clicking on link
click_link('logout-link')
# no link present in ubuntuone brand
if get_current_brand() != 'ubuntuone':
assert_element(href="/+login")
# make sure we're logged out
go_to(urls.HOME)
assert_title('Log in')
write_textfield,
wait_for,
)
from u1testutils.sso import mail
from u1testutils.sst import config
from acceptance import helpers
config.set_base_url_from_env()
# Register a new account and request a password reset.
email_address = helpers.register_account(displayname="Fred Jones", verify=True)
helpers.request_password_reset(email_address)
# Fetch and verify the confirmation code.
link = mail.get_verification_link_for_address(email_address)
go_to(link)
# Reset the password and verify that we're logged in.
assert_title('Reset password')
write_textfield('id_password', "Admin007")
write_textfield('id_passwordconfirm', "Admin007")
click_button(get_element(name='continue'))
assert_element(**{'data-qa-id': 'edit_account'})
# Now try to use the link a second time.
helpers.logout()
go_to(link)
wait_for(assert_title, "Unauthorized confirmation code")
def setUpClass(self):
self.chk_url = "https://avant-qa-screening.herokuapp.com/"
go_to(self.chk_url)
self.h1 = get_h1()
def setUp(self):
# open the sign_up page directly
self.chk_url = 'https://avant-qa-screening.herokuapp.com/users/sign_up'
go_to(self.chk_url)
def setUp(self):
go_to(self.chk_url)
# Create an account
email_address = helpers.register_account()
# Make sure we are not logged in
helpers.logout()
# Authenticate via the api so that an application can be created
url = ('%s/api/1.0/authentications?ws.op=authenticate&token_name=%s' %
(get_base_url(), TOKEN_NAME))
password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_mgr.add_password(None, url, email_address, PASSWORD)
opener = urllib2.build_opener(urllib2.HTTPBasicAuthHandler(password_mgr))
urllib2.install_opener(opener)
req = urllib2.Request(url)
f = urllib2.urlopen(req)
data = f.read()
# now test that the app is there and that we can delete it
helpers.login(email_address, PASSWORD)
go_to(urls.APPLICATIONS)
assert_text_contains('content', TOKEN_NAME)
delete_buttons = get_elements(css_class='btn-sm', name='Delete')
# delete application token
click_button(delete_buttons[0])
# log back in and should have no app
helpers.logout()
helpers.login(email_address, PASSWORD)
go_to(urls.APPLICATIONS)
fails(assert_text_contains, 'content', TOKEN_NAME)
def setUp(self):
go_to(self.chk_url)
# Set to Production, Staging, VPS, Developer etc..
config.set_base_url_from_env()
helpers.skip_unless_staging_or_production()
# We use the base URL to switch the LP version of SSO here
# Will work for Staging/Production/VPS etc
base_url = get_base_url()
lp_base_url = base_url.replace('ubuntu.com', 'launchpad.net')
set_base_url(lp_base_url)
# Goes to LP skinned version of SSO to login then,
# uses the logout button to logout
go_to(urls.HOME)
write_textfield('id_email', settings.SSO_TEST_ACCOUNT_EMAIL)
write_textfield('id_password', settings.SSO_TEST_ACCOUNT_PASSWORD)
click_button(get_element(name='continue'))
click_button(get_element(name='logout'))
assert_element(href="/+login")
go_to(urls.HOME)
assert_title('Log in')
# Goes to LP skinned version of SSO to login then,
# uses the /+logout URL to logout
write_textfield('id_email', settings.SSO_TEST_ACCOUNT_EMAIL)
write_textfield('id_password', settings.SSO_TEST_ACCOUNT_PASSWORD)
click_button(get_element(name='continue'))
go_to(urls.LOGOUT)
assert_element(href="/+login")
