class TestForEmployees(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.nicol = profiles.Profile(self.driver, 'nicol')
self.WDWait = WebDriverWait(self.driver, 10)
def tearDown(self):
self.driver.quit()
def test_about_page(self):
""" test_public.py:TestForEmployees.test_about_page """
# assert about page links and forms work as expected
for_employers = self.nicol.for_employers
for_employees = self.nicol.for_employees
about_page = self.nicol.about_public_page
map_page = self.nicol.contact_map_page
for_employers.go()
for_employers.footer.click_link('about us')
# header logo
self.assertTrue(about_page.on())
about_page.header.click_logo()
self.assertTrue(for_employers.on())
for_employers.footer.click_link('about us')
# header employee and employers buttons
self.assertTrue(about_page.on())
about_page.click_employee_button()
self.assertTrue(for_employees.on())
for_employees.footer.click_link('about us')
# page 'employers' learn more button
self.assertTrue(about_page.on())
about_page.click_employer_button()
self.assertTrue(for_employers.on())
for_employers.footer.click_link('about us')
# page invite employer form
self.assertTrue(about_page.on())
about_page.enter_invite_employer_email('')
error_msg = 'Your email address is required to continue'
self.WDWait.until(
EC.text_to_be_present_in_element((By.CLASS_NAME, 'error_textbox'),
error_msg))
num_errors = about_page.number_of_elements
self.assertEqual(1, num_errors('span', error_msg))
about_page.enter_invite_employer_email('*****@*****.**')
self.assertTrue(map_page.on())
def test_contact_us_page(self):
""" test_public.py:TestForEmployees.test_contact_us_page """
# assert Contact Us page links and forms work as expected
for_employers = self.nicol.for_employers
contact_page = self.nicol.contact_us_page
map_page = self.nicol.contact_map_page
for_employers.go()
for_employers.footer.click_link('contact us')
# header logo
self.assertTrue(contact_page.on())
contact_page.header.click_logo()
self.assertTrue(for_employers.on())
for_employers.footer.click_link('contact us')
# header employee and employers buttons
self.assertTrue(contact_page.on())
if main.is_desktop():
contact_page.header.click_for_employers()
self.assertTrue(for_employers.on())
for_employers.footer.click_link('contact us')
self.assertTrue(contact_page.on())
contact_page.header.click_for_employers()
else:
contact_page.header.select_action('employers')
self.assertTrue(for_employers.on())
for_employers.footer.click_link('contact us')
self.assertTrue(contact_page.on())
contact_page.header.select_action('employers')
self.assertTrue(for_employers.on())
for_employers.footer.click_link('contact us')
# page invite employer form
self.assertTrue(contact_page.on())
contact_page.enter_invite_employer_email('')
error_msg = 'Your email address is required to continue'
self.WDWait.until(
EC.text_to_be_present_in_element((By.CLASS_NAME, 'error_textbox'),
error_msg))
num_errors = contact_page.number_of_elements
self.assertEqual(1, num_errors('span', error_msg))
contact_page.enter_invite_employer_email('*****@*****.**')
self.assertTrue(map_page.on())
def test_for_employees_page(self):
""" test_public.py:TestForEmployees.test_for_employees_page """
for_employees = self.nicol.for_employees
contact_page = self.nicol.contact_us_page
for_employers = self.nicol.for_employers
code_page = self.nicol.reset_password_code_page
signin_page = self.nicol.signin_page
reset_page = self.nicol.reset_password_page
about_page = self.nicol.about_public_page
pub_terms_page = self.nicol.pub_terms_page
pub_privacy_page = self.nicol.pub_privacy_page
map_page = self.nicol.contact_map_page
form_page = self.nicol.contact_form_page
credentials = self.nicol.credentials
for_employers.go()
self.assertTrue(for_employers.on())
for_employers.header.click_for_employees()
self.assertTrue(for_employees.on())
# for employers link
if main.is_desktop():
for_employees.header.click_for_employers()
else:
self.assertTrue(for_employees.header.select_action('employers'))
self.assertTrue(for_employers.on())
for_employers.header.click_for_employees()
self.assertTrue(for_employees.on())
# sign in/forgot pw
if main.is_desktop():
self.assertFalse(for_employees.header.sign_in_open())
for_employees.header.sign_in_submit('', '')
for_employees.header.sign_in_submit('asdf', 'asdf2', False)
for_employees.header.forgot_password_submit('7774563334')
else:
self.assertTrue(for_employees.header.select_action("sign in"))
self.assertTrue(signin_page.on())
signin_page.signInForm.submit('asdf', 'asdf2', False)
signin_page.signInForm.forgot_password()
self.assertTrue(reset_page.on())
reset_page.submit('7774563334')
self.assertTrue(code_page.on())
code_page.header.click_logo()
self.assertTrue(for_employers.on())
for_employers.header.click_for_employees()
self.assertTrue(for_employees.on())
# contact us form
email = credentials['email']
for_employees.set_contact_email(email)
self.assertEqual(email, for_employees.get_contact_email())
for_employees.click_contact_continue()
self.assertTrue(map_page.on())
map_page.header.click_logo()
self.assertTrue(for_employers.on())
for_employers.header.click_for_employees()
self.assertTrue(for_employees.on())
# footer links
for_employees.footer.click_link('for employers')
self.assertTrue(for_employers.on())
for_employers.header.click_for_employees()
self.assertTrue(for_employees.on())
for_employees.footer.click_link('sign in')
self.assertTrue(signin_page.on())
signin_page.header.click_logo()
self.assertTrue(for_employers.on())
for_employers.header.click_for_employees()
self.assertTrue(for_employees.on())
for_employees.footer.click_link('about us')
self.assertTrue(about_page.on())
about_page.header.click_for_employees()
self.assertTrue(for_employees.on())
for_employees.footer.click_link('contact us')
self.assertTrue(contact_page.on())
contact_page.header.click_for_employees()
self.assertTrue(for_employees.on())
for_employees.footer.click_link('terms and conditions')
self.assertTrue(pub_terms_page.on())
pub_terms_page.header.click_for_employees()
self.assertTrue(for_employees.on())
for_employees.footer.click_link('privacy policy')
self.assertTrue(pub_privacy_page.on())
pub_privacy_page.header.click_for_employees()
self.assertTrue(for_employees.on())
# waiting: faq is demo page. Build as released
for_employees.footer.click_link('facebook')
for_employees.go_to_tab()
for_employees.footer.click_link('twitter')
for_employees.go_to_tab()
for_employees.footer.click_link('google+')
for_employees.go_to_tab()
for_employees.footer.click_link('linked in')
for_employees.go_to_tab()
@unittest.skipIf(main.get_priority() < 2, "Priority")
def test_for_employees_buttons(self):
""" test_public.py:TestForEmployees.test_for_employees_buttons """
# test buttons on home page behave as expected
for_employers = self.nicol.for_employers
for_employees = self.nicol.for_employees
about_page = self.nicol.about_public_page
# learn more button
for_employers.go()
for_employers.header.click_for_employees()
self.assertTrue(for_employees.on())
for_employees.click_learn_more()
self.assertTrue(for_employees.employer_but.is_displayed())
# button 1: enroll business page
for_employees.click_page_button(1)
self.assertTrue(for_employers.on())
for_employers.header.click_for_employees()
# button 2,3: home page contact form2
self.assertTrue(for_employees.on())
for_employees.click_page_button(2)
self.assertTrue(for_employees.contact_forms[1].is_displayed())
for_employees.click_page_button(3)
self.assertTrue(for_employees.contact_forms[1].is_displayed())
# button 4,5: about page
for_employees.click_page_button(4)
self.assertTrue(about_page.on())
about_page.header.click_logo()
self.assertTrue(for_employers.on())
for_employers.header.click_for_employees()
self.assertTrue(for_employees.on())
for_employees.click_page_button(5)
self.assertTrue(about_page.on())
class TestForgotPassword(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.nicol = profiles.Profile(self.driver, 'nicol')
self.alone1 = profiles.Profile(self.driver, 'alone1')
self.WDWait = WebDriverWait(self.driver, 15)
def tearDown(self):
self.driver.quit()
# @unittest.skipIf(main.get_priority() < 3)
@unittest.skip("S3 - Email input validation. Bug #145647407")
def test_invalid_inputs(self):
""" test_authentication.py:TestForgotPassword.test_invalid_inputs """
# assert inputs on 'Reset Password' page handle invalid credentials
credentials = self.nicol.credentials
signin_page = self.nicol.signin_page
reset_page = self.nicol.reset_password_page
email_page = self.nicol.reset_password_email_page
# go to reset password page
if main.is_web():
self.assertTrue(reset_page.go())
else:
self.assertTrue(signin_page.on())
signin_page.click_password_reset()
self.assertTrue(reset_page.on())
invalid_emails = [
'invalid', 'invalid@', 'invalid.com', '*****@*****.**'
]
error = "Invalid email address"
for email in invalid_emails:
reset_page.submit(email)
time.sleep(.8)
self.assertEqual( # /reset-password validation fails
1, reset_page.number_of_elements(
'div',
error)) #Failed 6/6 3:49pm Accepts invalid inputs. Logged.
invalid_phones = ['1234567890', '801123456']
for phone in invalid_phones:
error = (
"\"{phone}\" is not a valid phone number in the United States."
)
reset_page.submit(email)
time.sleep(.8)
self.assertEqual(
1,
reset_page.number_of_elements('div',
error.format(phone=phone)))
dne_ids = ['(801) 890-1234', '*****@*****.**']
for dne_id in dne_ids:
reset_page.request(dne_id)
time.sleep(.8)
self.assertTrue(reset_page.no_user_found(dne_id))
reset_page.request(credentials['email'])
email_page.load()
email_page.set_passwords('a')
email_page.click_continue()
error = "Shorter than minimum length 8"
self.assertEqual(1, email_page.number_of_elements('div', error))
#No matching passwords check...
'''error = "The passwords must match."
email_page.set_password('ab')
self.assertEqual(1, email_page.number_of_elements('div', error))'''
# 'wrong credential' link removed. Not really worth testing
# @unittest.skipIf(main.get_priority() < 2, "Priority = 2")
# def test_links(self):
# """authentication : Forgot Password . test_links"""
# # assert 'Forgot Password' links are mapped as expected
# credentials = self.nicol.credentials
# signin_page = self.nicol.signin_page
# reset_page = self.nicol.reset_password_page
# code_page = self.nicol.reset_password_code_page
# new_page = self.nicol.reset_password_new_page
# # go to reset password page
# if main.is_web():
# self.assertTrue(reset_page.go())
# else:
# self.assertTrue(signin_page.on())
# signin_page.click_password_reset()
# self.assertTrue(reset_page.on())
# self.assertTrue(reset_page.on())
# reset_page.set_email(credentials['email'])
# reset_page.click_continue()
# self.assertTrue(code_page.on())
# # Don't have wrong link at the moment
# # code_page.click_wrong_link()
# # self.assertTrue(reset_page.on())
# # reset_page.set_email(credentials['email'])
# # reset_page.click_continue()
# # self.assertTrue(code_page.on())
# code_page.enter_code()
# self.assertTrue(code_page.on())
# code_page.click_wrong_link()
# if not reset_page.on():
# # not sure why, sometimes 1st click doesn't work
# code_page.click_wrong_link()
# self.assertTrue(reset_page.on())
# reset_page.set_email(credentials['email'])
# reset_page.click_continue()
# self.assertTrue(code_page.on()) # check your email
# code_page.enter_code()
# self.assertTrue(code_page.on()) # check your phone
# code_page.enter_code()
# self.assertTrue(new_page.on())
@unittest.skipIf(main.get_priority() < 3, "Priority = 3")
def test_required_fields(self):
""" test_authentication.py:TestForgotPassword.test_required_fields """
# Sometimes creates test-specific sendmi error message. Hits backend weird?
credentials = self.nicol.credentials
signin_page = self.nicol.signin_page
reset_page = self.nicol.reset_password_page
code_page = self.nicol.reset_password_code_page
new_page = self.nicol.reset_password_new_page
lobby_page = self.nicol.lobby_page
# assert inputs on public 'Reset Password' page are required as expected
if main.is_web():
self.assertTrue(reset_page.go())
else:
self.assertTrue(signin_page.on())
signin_page.click_password_reset()
self.assertTrue(reset_page.on())
reset_page.submit('')
tag = 'p'
error = "Required"
error_count = reset_page.number_of_elements
self.assertEqual(1, error_count(tag, error))
reset_page.submit('*****@*****.**', False)
# iOS: Sending keys does not remove 'required' error
if not main.is_ios():
self.assertEqual(0, error_count(tag, error))
reset_page.submit(credentials['email'])
self.assertTrue(code_page.on())
code_page.enter_code()
self.assertTrue(code_page.on())
code_page.enter_code()
self.assertTrue(new_page.on())
new_page.click_continue()
self.assertEqual(1, error_count(tag, error))
new_page.set_password(credentials['password'])
# iOS: Sending keys does not remove 'required' error
if not main.is_ios():
self.assertEqual(0, error_count(tag, error))
new_page.click_continue()
WebDriverWait(
self.driver, 15).until(lambda x: EC.visibility_of_element_located(
(By.CLASS_NAME, 'invitations_card'
)) or EC.visibility_of_element_located((By.ID, 'cash-bar')))
#raw_input('page?')
self.assertTrue(lobby_page.on())
def test_success(self):
""" test_authentication.py:TestForgotPassword.test_success """
# assert "Forgot Password" functionality works as expected
credentials = self.alone1.credentials
reset_page = self.alone1.reset_password_page
code_page = self.alone1.reset_password_code_page
new_page = self.alone1.reset_password_new_page
eHome = self.alone1.eHome_page
election_page = self.alone1.pay_election_page
ps_page = self.alone1.ps_page
change_pw_page = self.alone1.ps_change_pw_page
signin_page = self.alone1.signin_page
# go to reset password page
if main.is_web():
reset_page.go()
else:
self.assertTrue(signin_page.on())
signin_page.click_password_reset()
self.assertTrue(reset_page.on())
self.assertTrue(reset_page.on())
reset_page.submit(credentials['email'])
self.assertTrue(code_page.on())
code_page.enter_code()
self.assertTrue(code_page.on())
code_page.enter_code()
self.assertTrue(new_page.on())
new_password = "******"
new_page.enter_password(new_password)
#Backend error here, timed out because of it.
# WebDriverWait(self.driver, 15).until(
# EC.presence_of_element_located((By.ID, 'save_election_button')))
# Reset password through settings page.
self.assertTrue(eHome.on('election'))
eHome.menu.sign_out()
self.assertTrue(self.alone1.login(self.driver, new_password),
messages.login)
# Currently no election for Stand Alone1, should go to eleciton page.
self.assertTrue(election_page.on())
election_page.menu.click_option('settings')
self.assertTrue(ps_page.on())
ps_page.change_password()
self.assertTrue(change_pw_page.on())
change_pw_page.enter_current_pw(new_password)
change_pw_page.enter_new_pw(credentials["password"])
change_pw_page.click_continue()
self.assertTrue(ps_page.on())
test_success.e2e = True
# -test_required_fields
# TestForEmployees - 4
# -test_about_page
# -test_contact_us_page
# -test_for_employees_page
# -test_for_employees_buttons
# TestForEmployers - 6
# -test_demo_form
# -test_for_employers_page
# -test_invalid_inputs
# -test_required_fields
# -test_success_existing
# -test_success_new
@unittest.skipIf(not main.is_web() or main.get_priority() < 3, 'Priority')
class TestContactFlow(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.nicol = profiles.Profile(self.driver, 'nicol')
self.WDWait = WebDriverWait(self.driver, 10) #Timeout after 10 sec.
def tearDown(self):
self.driver.quit()
def test_invalid_inputs(self):
""" test_public.py:TestContactFlow.test_invalid_inputs """
# assert "Contact Flow" fields correctly handle invalid input
credentials = self.nicol.credentials
for_employees = self.nicol.for_employees
map_page = self.nicol.contact_map_page
class TestSettings(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.nicol = profiles.Profile(self.driver, 'nicol')
self.patrick = profiles.Profile(self.driver, 'patrick')
self.krabs = profiles.Profile(self.driver, 'krabs')
self.squid = profiles.Profile(self.driver, 'squid')
self.WDWait = WebDriverWait(self.driver, 10)
def tearDown(self):
self.driver.quit()
@unittest.skipIf(main.get_priority() < 2, "Priority = 2")
def test_business_remove(self):
""" test_business.py:TestSettings.test_business_remove """
# assert owner can remove business
# requisites: "Subway" is removed after test
lobby_page = self.krabs.lobby_page
emp_page = self.krabs.employee_page
add_page = self.krabs.add_business_page
prefilled_page = self.krabs.business_prefilled_page
settings_page = self.krabs.business_settings_page
eHome = self.krabs.eHome_page
default_business = 'Krusty Krab'
self.assertTrue(self.krabs.login(self.driver), messages.login)
business_name = 'Subway Highland Utah'
self.assertTrue(lobby_page.on()) #login failure
lobby_page.menu.add_a_business()
self.assertTrue(add_page.on())
add_page.add(business_name)
self.assertTrue(prefilled_page.on())
prefilled_page.set('ein', '234567847')
prefilled_page.click_details()
prefilled_page.set('business_name', business_name)
prefilled_page.set('line1', 'new line1')
prefilled_page.toggle_agree()
prefilled_page.click_continue()
self.assertTrue(lobby_page.on())
self.assertEqual(business_name, lobby_page.menu.get_current_business())
# Loop to remove all instances of particular business
has_business = lobby_page.menu.has_business(business_name)
while has_business:
# make sure business is selected
if lobby_page.menu.get_current_business() != business_name:
lobby_page.menu.select_business(business_name)
self.assertTrue(lobby_page.on())
# remove business
lobby_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
settings_page.remove_business("REMOVE " + business_name)
# change role
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
# check if another instance of business
has_business = lobby_page.menu.has_business(business_name)
# done removing business. Select default business
self.assertFalse(lobby_page.menu.has_business(business_name))
lobby_page.menu.select_business(default_business)
self.assertTrue(lobby_page.on())
@unittest.skipIf(main.get_priority() < 3, "Priority" or main.is_ios())
def test_invalid_inputs(self):
""" test_business.py:TestSettings.test_invalid_inputs """
# assert 'Business Settings' page handles invalid inputs as expected
lobby_page = self.patrick.lobby_page
emp_page = self.patrick.employee_page
add_page = self.patrick.add_business_page
prefilled_page = self.patrick.business_prefilled_page
settings_page = self.patrick.business_settings_page
eHome = self.patrick.eHome_page
default_business = 'Chum Bucket'
self.assertTrue(self.patrick.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
if lobby_page.menu.get_current_business() != default_business:
lobby_page.menu.select_business(default_business)
self.assertTrue(lobby_page.on())
lobby_page.menu.add_a_business()
self.assertTrue(add_page.on())
business_name = "Nintendo of America"
search_term = business_name + ' WA'
add_page.add(search_term)
prefilled_page.load()
ein = "66787665"
prefilled_page.set('ein', ein)
prefilled_page.toggle_agree()
prefilled_page.click_continue()
self.assertTrue(lobby_page.on())
lobby_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
settings_page.set('postal_code', '123456789012345678901')
self.assertFalse(settings_page.saved())
tag = 'p'
error = "Expected Zip Code format: 12345 or 12345-1234."
error_count = settings_page.number_of_elements
self.assertEqual(1, error_count(tag, error))
settings_page.set('postal_code', 'abc')
self.assertFalse(settings_page.saved())
self.assertEqual(1, error_count(tag, error))
settings_page.set('postal_code', '98051')
self.assertTrue(settings_page.saved())
invalid_phones = ['1234567890', '801123456']
error = " is not a valid phone number in US."
for phone in invalid_phones:
settings_page.set('phone', phone)
self.assertFalse(settings_page.saved())
self.assertEqual(
1, prefilled_page.number_of_elements_containing(tag, error))
settings_page.set('phone', '(425) 882-2040')
settings_page.set('website', 'new site')
self.assertFalse(settings_page.saved())
error = "May not contain spaces."
#time.sleep(1)
self.assertEqual(1, settings_page.number_of_elements('p', error))
site = 'www.nintendo.com'
settings_page.set('website', site)
self.assertTrue(settings_page.saved())
self.assertEqual('http://' + site, settings_page.get('website'))
self.assertTrue(settings_page.saved())
settings_page.remove_business("REMOVE NINTENDO OF AMERICA")
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
# Loop to remove all instances of particular business
has_business = lobby_page.menu.has_business(business_name)
while has_business:
# make sure business is selected
if lobby_page.menu.get_current_business() != business_name:
lobby_page.menu.select_business(business_name)
self.assertTrue(lobby_page.on())
# remove business
lobby_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
settings_page.remove_business("REMOVE " + business_name)
# change role
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
# check if another instance of business
has_business = lobby_page.menu.has_business(business_name)
# done removing business. Select default business
self.assertFalse(lobby_page.menu.has_business(business_name))
lobby_page.menu.select_business(default_business)
self.assertTrue(lobby_page.on())
@unittest.skipIf(main.is_ios(), "Autosave input + iOS = suicide")
def test_persist(self):
""" test_business.py:TestSettings.test_persist """
#Change business settings and assert persistence across logins.
lobby_page = self.nicol.lobby_page
settings_page = self.nicol.business_settings_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
business = 'Multiverse'
if lobby_page.menu.get_current_business() != business:
lobby_page.menu.select_business(business)
self.assertTrue(lobby_page.on())
lobby_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
get = settings_page.get
#change _init args to match Multiverse dictionary data?
hr_init = settings_page.get('hr_email')
dba_init = settings_page.get('dba')
line1_init = settings_page.get('line1')
line2_init = settings_page.get('line2')
city_init = settings_page.get('city')
postal_init = settings_page.get('postal_code')
phone_init = settings_page.get('phone')
site_init = settings_page.get('website')
hr2 = '*****@*****.**'
dba2 = 'New Dba'
line12 = 'new line1'
line22 = 'new line2'
city2 = 'new city'
postal2 = '80987'
phone2 = '(801) 987-6576'
site2 = 'http://new_site'
settings_page.set('hr_email', hr2)
settings_page.set('dba', dba2)
settings_page.set('line1', line12)
settings_page.set('line2', line22)
settings_page.set('city', city2)
settings_page.set('postal_code', postal2)
settings_page.set('phone', phone2)
settings_page.set('website', site2)
self.assertTrue(settings_page.saved())
settings_page.menu.sign_out()
# login and make sure changes persisted
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
hr_final = settings_page.get('hr_email')
dba_final = settings_page.get('dba')
line1_final = settings_page.get('line1')
line2_final = settings_page.get('line2')
city_final = settings_page.get('city')
postal_final = settings_page.get('postal_code')
phone_final = settings_page.get('phone')
site_final = settings_page.get('website')
self.assertEqual(hr2, hr_final)
self.assertEqual(dba2, dba_final)
self.assertEqual(line12, line1_final)
self.assertEqual(line22, line2_final)
self.assertEqual(city2, city_final)
self.assertEqual(postal2, postal_final)
self.assertEqual(phone2, phone_final)
self.assertEqual(site2, site_final)
multiverse_creds = profiles.credentials.get_credentials('multiverse')
settings_page.set('hr_email', multiverse_creds['hr'])
settings_page.set('dba', multiverse_creds['name'])
settings_page.set('line1', multiverse_creds['line1'])
settings_page.set('line2', '')
settings_page.set('city', multiverse_creds['city'])
settings_page.set('postal_code', multiverse_creds['postal_code'])
settings_page.set('phone', multiverse_creds['phone'])
settings_page.set('website', multiverse_creds['website'])
self.assertTrue(settings_page.saved())
@unittest.skipIf(main.get_priority() < 3, "Priority" or main.is_ios())
def test_required_fields(self):
""" test_business.py:TestSettings.test_required_fields """
# assert 'Business Settings' page requires expected fields
lobby_page = self.squid.lobby_page
emp_page = self.squid.employee_page
add_page = self.squid.add_business_page
prefilled_page = self.squid.business_prefilled_page
settings_page = self.squid.business_settings_page
eHome = self.squid.eHome_page
default_business = 'Salty Spitoon'
business_name = "Nintendo of America"
search_term = business_name + ' WA'
ein = "66787665"
self.assertTrue(self.squid.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.add_a_business()
self.assertTrue(add_page.on())
add_page.add(search_term)
self.assertTrue(prefilled_page.on())
prefilled_page.set('ein', ein)
prefilled_page.toggle_agree()
prefilled_page.click_continue()
self.assertTrue(lobby_page.on())
lobby_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
settings_page.set('business_name', '')
settings_page.set('dba', '')
settings_page.set('ein', '')
settings_page.set('hr_email', '')
settings_page.set('line1', '')
settings_page.set('city', '')
settings_page.set('postal_code', '')
settings_page.set('phone', '')
settings_page.set('website', '')
error = 'Required'
tag = 'p'
error_count = settings_page.number_of_elements
self.assertEqual(7, error_count(tag, error))
settings_page.set('business_name', business_name)
self.assertEqual(6, error_count(tag, error))
settings_page.set('ein', ein)
self.assertEqual(5, error_count(tag, error))
settings_page.set('hr_email', "*****@*****.**")
self.assertEqual(4, error_count(tag, error))
settings_page.set('line1', 'my address')
self.assertEqual(3, error_count(tag, error))
settings_page.set('city', 'my city')
self.assertEqual(2, error_count(tag, error))
settings_page.set('postal_code', '86778')
self.assertEqual(1, error_count(tag, error))
settings_page.set('phone', '(801) 756-9876')
self.assertTrue(settings_page.saved())
settings_page.click_remove()
self.assertFalse(settings_page.confirm_remove_button_enabled())
settings_page.set_remove_code('REMOVE NINTENDO OF AMERICA')
self.assertTrue(settings_page.confirm_remove_button_enabled())
settings_page.click_confirm_remove()
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
# Loop to remove all instances of particular business
has_business = lobby_page.menu.has_business(business_name)
while has_business:
# make sure business is selected
if lobby_page.menu.get_current_business() != business_name:
lobby_page.menu.select_business(business_name)
self.assertTrue(lobby_page.on())
# remove business
lobby_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
settings_page.remove_business("REMOVE " + business_name)
# change role
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
# check if another instance of business
has_business = lobby_page.menu.has_business(business_name)
# done removing business. Select default business
self.assertFalse(lobby_page.menu.has_business(business_name))
lobby_page.menu.select_business(default_business)
self.assertTrue(lobby_page.on())
@unittest.skipIf(main.is_ios() or main.get_priority() < 2,
"Autosave input + iOS = suicide")
def test_update(self):
""" test_business.py:TestSettings.test_update """
# assert changes to 'Business Settings' page persist
lobby_page = self.nicol.lobby_page
emp_page = self.nicol.employee_page
settings_page = self.nicol.business_settings_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
name = "Multiverse"
# ein1 = '4896434'
self.assertTrue(lobby_page.on())
# go to Multiverse business settings, select multiverse if needed
if lobby_page.menu.get_current_business() != 'Multiverse':
lobby_page.menu.select_business(name)
self.assertTrue(lobby_page.on())
lobby_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
self.assertFalse(settings_page.has_horizontal_scroll())
get = settings_page.get
hr_init = get('hr_email')
dba_init = get('dba')
line1_init = get('line1')
line2_init = get('line2')
city_init = get('city')
postal_init = get('postal_code')
phone_init = get('phone')
site_init = get('website')
hr2 = '*****@*****.**'
dba2 = 'New Dba'
line12 = 'new line1'
line22 = 'new line2'
city2 = 'new city'
postal2 = '80987'
phone2 = '(801) 987-6576'
site2 = 'http://new_site'
settings_page.set('hr_email', hr2)
settings_page.set('dba', dba2)
settings_page.set('line1', line12)
settings_page.set('line2', line22)
settings_page.set('city', city2)
settings_page.set('postal_code', postal2)
settings_page.set('phone', phone2)
settings_page.set('website', site2)
self.assertTrue(settings_page.saved())
settings_page.menu.click_option('employees')
self.assertTrue(emp_page.on())
emp_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
#Test for persistence
self.assertEqual(hr2, get('hr_email'))
self.assertEqual(dba2, get('dba'))
self.assertEqual(line12, get('line1'))
self.assertEqual(line22, get('line2'))
self.assertEqual(city2, get('city'))
self.assertEqual(postal2, get('postal_code'))
self.assertEqual(phone2, get('phone'))
self.assertEqual(site2, get('website'))
#Revert changes
settings_page.set('hr_email', hr_init)
settings_page.set('dba', dba_init)
settings_page.set('line1', line1_init)
settings_page.set('line2', line2_init)
settings_page.set('city', city_init)
settings_page.set('postal_code', postal_init)
settings_page.set('phone', phone_init)
settings_page.set('website', site_init)
class TestLogin(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.nicol = profiles.Profile(self.driver, 'nicol')
self.WDWait = WebDriverWait(self.driver, 15)
def tearDown(self):
self.driver.quit()
@unittest.skipIf(not main.is_web() or main.is_desktop()
or main.get_priority() < 2,
'Only get action menu on mobile web')
def test_action_success(self):
""" test_authentication.py:TestLogin.test_action_success """
# assert user can login through action menu
credentials = self.nicol.credentials
for_employers = self.nicol.for_employers
signin_page = self.nicol.signin_page
signin_code_page = self.nicol.signin_code_page
lobby_page = self.nicol.lobby_page
for_employers.go()
self.assertTrue(for_employers.on())
for_employers.header.select_action('Sign In')
self.assertTrue(signin_page.on())
signin_page.submit(credentials['email'], credentials['password'])
if signin_code_page.on(): # remember user?
signin_code_page.enter_code()
self.assertTrue(lobby_page.on())
@unittest.skipIf(not main.is_desktop() or main.get_priority() < 2,
'Signin dropdown only on desktop')
def test_dropdown_success(self):
""" test_authentication.py:TestLogin.test_dropdown_success """
# assert can login through signin dropdown
credentials = self.nicol.credentials
for_employers = self.nicol.for_employers
signin_code_page = self.nicol.signin_code_page
lobby_page = self.nicol.lobby_page
for_employers.go()
self.assertTrue(for_employers.on())
for_employers.header.sign_in_submit(credentials['email'],
credentials['password'])
self.assertTrue(signin_code_page.on())
signin_code_page.enter_code()
if signin_code_page.on(): # remember user?
self.assertTrue(signin_code_page.enter_code())
self.assertTrue(lobby_page.on())
@unittest.skipIf(main.get_priority() < 3, "Priority = 3")
def test_invalid_credentials(self):
""" test_authentication.py:TestLogin.test_invalid_credentials """
# assert 'Sign In' page inputs properly handle invalid credentials
credentials = self.nicol.credentials
signin_page = self.nicol.signin_page
if main.is_web():
signin_page.go()
else:
self.assertTrue(signin_page.on())
signin_page.submit(credentials['email'], credentials['password'] + '0')
# self.WDWait.until(EC.presence_of_element_located((By.ID, 'sendmi_error')))
self.WDWait.until(
EC.presence_of_element_located((By.CLASS_NAME, 'alert-danger')))
error = "Incorrect password, email address, or phone number."
self.assertTrue(error in signin_page.read_error())
signin_page.submit('abc' + credentials['email'],
credentials['password'])
# self.WDWait.until(EC.presence_of_element_located((By.ID, 'sendmi_error')))
self.WDWait.until(
EC.presence_of_element_located((By.CLASS_NAME, 'alert-danger')))
self.assertTrue(error in signin_page.read_error())
@unittest.skipIf(main.get_priority() < 3, "Priority = 3")
def test_invalid_inputs(self):
""" test_authentication.py:TestLogin.test_invalid_inputs """
# Running this test > once might put your computer out of commission for
# 15 minutes because it thinks you're trying to hack into accounts
# assert 'Sign In' page handles invalid input as expected
credentials = self.nicol.credentials
signin_page = self.nicol.signin_page
if not main.is_web():
self.assertTrue(signin_page.on())
else:
signin_page.go()
# signin_page.set_password(credentials['password'])
signin_page.submit('', credentials['password'], False)
invalid_emails = ['invalid', 'invalid@', 'invalid.com']
containers = ["div", "p", "div"]
# errors = ["Incorrect password, email address, or phone number.",
# "Please enter a valid email address, mobile phone number, or username.",
# "Incorrect password, email address, or phone number."
# ]
error = "Please enter a valid email address."
# errors = ["Incorrect password, email address, or phone number.",
# "Please enter a valid email address.",
# "Incorrect password, email address, or phone number."
# ]
for i, email in enumerate(invalid_emails):
signin_page.submit(invalid_emails[i], credentials['password'])
signin_page.check_captcha()
# Wait for errors to show up
if i == 1: # email input error
# Validation changed on form at some point 4/10/2018
# Fails to submit, but no error.
pass
# print('i: ' + str(i))
# self.WDWait.until(
# EC.text_to_be_present_in_element((By.ID, 'signin_form_user_helper'),
# errors[i]))
else: # form error
print('i= ' + str(i))
# self.WDWait.until(
# EC.text_to_be_present_in_element((By.ID, 'sendmi_error'), error))
self.WDWait.until(
EC.presence_of_element_located(
(By.CLASS_NAME, 'alert-danger')))
self.assertEqual(1,
signin_page.number_of_elements('span', error))
invalid_phones = ['1234567890', '801123456']
for phone in invalid_phones:
error = "Please enter a valid email address, mobile phone number, or username."
signin_page.submit(phone, credentials['password'])
# Validation changed on form at some point 4/10/2018
# Fails to submit, but no error.
# self.WDWait.until(
# EC.text_to_be_present_in_element((By.ID, 'signin_form_user_helper'),
# error))
# self.assertEqual(1, signin_page.number_of_elements('p', error))
@unittest.skipIf(main.get_priority() < 2, "Priority = 2")
def test_logout_success(self):
""" test_authentication.py:TestLogin.test_logout_success """
# assert menu 'Sign Out' works as expected
credentials = self.nicol.credentials
for_employers = self.nicol.for_employers
signin_page = self.nicol.signin_page
lobby_page = self.nicol.lobby_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.sign_out()
if main.is_web():
self.assertTrue(for_employers.on())
else:
self.assertTrue(signin_page.on())
@unittest.skipIf(main.is_web() or main.get_priority() < 2,
'Test for native only')
def test_native_signin_success(self):
""" test_authentication.py:TestLogin.test_native_signin_success """
credentials = self.nicol.credentials
signin_page = self.nicol.signin_page
signin_code_page = self.nicol.signin_code_page
self.assertTrue(signin_page.on())
signin_page.submit(credentials['email'], credentials['password'])
self.assertTrue(signin_code_page.on())
signin_code_page.enter_code()
# Form validation changed at some point and none of these errors show up anymore
@unittest.skip("Validation removed on signin form")
def test_required_fields(self):
""" test_authentication.py:TestLogin.test_required_fields """
# assert 'Sign In' page inputs are required as expected
credentials = self.nicol.credentials
signin_page = self.nicol.signin_page
if not main.is_web():
self.assertTrue(signin_page.on())
else:
signin_page.go()
signin_page.click_login()
error = 'Required'
num_errors = 2
self.WDWait.until(
EC.text_to_be_present_in_element(
(By.ID, 'signin_form_user_helper'), error))
self.assertEqual(2, signin_page.number_of_elements('p', error))
# ios can't tell that email was updated so there's still 2 errors
if not main.is_ios():
signin_page.set_email(credentials['email'])
self.WDWait.until(
EC.text_to_be_present_in_element(
(By.ID, 'signin_form_pw_helper'), error))
num_errors = 1
self.assertEqual(1, signin_page.number_of_elements('p', error))
signin_page.set_password(credentials['password'])
self.assertEqual(0, signin_page.number_of_elements('p', error))
@unittest.skipIf(not main.is_web() or main.get_priority() < 2,
'Test for web only')
def test_signin_success(self):
""" test_authentication.py:TestLogin.test_signin_success """
# assert can login through footer 'Sign In' link
credentials = self.nicol.credentials
for_employers = self.nicol.for_employers
signin_page = self.nicol.signin_page
signin_code_page = self.nicol.signin_code_page
lobby_page = self.nicol.lobby_page
for_employers.go()
self.assertTrue(for_employers.on()) #scrollTo element.
for_employers.footer.click_link('sign in')
self.assertTrue(signin_page.on())
self.assertTrue(signin_page.is_public())
signin_page.submit(credentials['email'], credentials['password'])
self.assertTrue(signin_code_page.on())
self.assertTrue(signin_code_page.is_public())
signin_code_page.enter_code()
# test_find_success
# test_handle_address
# test_invalid_inputs
# test_non_us
# test_required_fields
# test_success_skip
# test_success_participate
# TestSettings - 5 Edit Business settings
# test_business_remove
# test_invalid_inputs
# test_persist
# test_required_fields
# test_update
@unittest.skipIf(main.get_priority() < 3, "Priority = 3")
class TestDetails(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.nicol = profiles.Profile(self.driver, 'nicol')
self.boss = profiles.Profile(self.driver, 'boss')
self.WDWait = WebDriverWait(self.driver, 10)
def tearDown(self):
self.driver.quit()
@unittest.skipIf(main.is_ios(), "iOS")
def test_invalid_inputs(self):
""" test_business.py:TestDetails.test_invalid_inputs """
# assert 'details' page handles invalid input correctly
lobby_page = self.nicol.lobby_page
class TestPrefilled(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.nicol = profiles.Profile(self.driver, 'nicol')
self.faker = profiles.Profile(self.driver, 'faker')
self.tester = profiles.Profile(self.driver, 'tester')
self.fire = profiles.Profile(self.driver, 'fire')
self.WDWait = WebDriverWait(self.driver, 10)
def tearDown(self):
self.driver.quit()
@unittest.skipIf(main.get_priority() < 2, "Priority = 2")
def test_find_success(self):
""" test_business.py:TestPrefilled.test_find_success """
# assert find business works
credentials = self.nicol.credentials
lobby_page = self.nicol.lobby_page
add_page = self.nicol.add_business_page
prefilled_page = self.nicol.business_prefilled_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.add_a_business()
self.assertTrue(add_page.on())
name = 'Nintendo of America'
search_term = name + ' WA'
add_page.add(search_term)
self.WDWait.until(EC.presence_of_element_located((By.ID, 'ein')))
self.assertTrue(prefilled_page.on())
self.assertFalse(prefilled_page.has_horizontal_scroll())
# assert values are autofilled
prefilled_page.click_details()
get = prefilled_page.get
self.assertEqual(get('ein'), '')
#most of the time fails on hr email (doesn't autofill???)
self.assertEqual(get('hr_email'), credentials['email'])
self.assertEqual(get('business_name'), name)
self.assertEqual(get('dba'), name)
self.assertEqual(get('line1'), '4600 150th Avenue Northeast')
self.assertEqual(get('line2'), '')
self.assertEqual(get('city'), 'Redmond')
self.assertEqual(get('postal_code'), '98052')
self.assertEqual(get('phone'), '(800) 255-3700')
# url gets trimmed. no longer has anything after .com
self.assertEqual(get('website'), 'http://nintendo.com')
self.assertEqual(get('state'), 'Washington')
# @unittest.skipIf(main.get_priority() < 2, "Priority = 2")
@unittest.skip("Busted")
def test_handle_address(self):
""" test_business.py:TestPrefilled.test_handle_address """
# assert 'Add Business' handles selecting an address as expected
lobby_page = self.nicol.lobby_page
add_page = self.nicol.add_business_page
prefilled_page = self.nicol.business_prefilled_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.add_a_business()
self.assertTrue(add_page.on())
address = "115 N Main Street Lehi"
add_page.add(address)
# business & DBA should be blank. Details should be open
self.WDWait.until(EC.presence_of_element_located((By.ID, 'ein')))
self.assertTrue(prefilled_page.on())
self.assertEqual(
"", prefilled_page.business_name_input.get_attribute('value'))
self.assertEqual("", prefilled_page.dba_input.get_attribute('value'))
@unittest.skipIf(main.get_priority() < 3, "Priority")
def test_invalid_inputs(self):
""" test_business.py:TestPrefilled.test_invalid_inputs """
# assert inputs on 'Prefilled' page handle invalid input as expected
lobby_page = self.nicol.lobby_page
add_page = self.nicol.add_business_page
prefilled_page = self.nicol.business_prefilled_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.add_a_business()
self.assertTrue(add_page.on())
# raw_input('adding business')
add_page.add("Nintendo of America WA")
# raw_input('added?')
self.assertTrue(prefilled_page.on())
self.assertFalse(prefilled_page.agreed())
prefilled_page.toggle_agree()
self.assertTrue(prefilled_page.agreed())
prefilled_page.click_details()
prefilled_page.set('ein', '556787898')
invalid_emails = ['invalid', 'invalid@', 'invalid.com']
error = "Invalid email address"
tag = 'p'
for email in invalid_emails:
prefilled_page.set('hr_email', email)
prefilled_page.click_continue()
self.assertEqual(
1, prefilled_page.number_of_elements_containing(tag, error))
prefilled_page.set('postal_code', '123456789012345678901')
prefilled_page.click_continue()
error = "Expected Zip Code format: 12345 or 12345-1234."
self.assertEqual(1, prefilled_page.number_of_elements(tag, error))
prefilled_page.set('postal_code', '98052')
# ios won't know you've updated zip code unless you click continue
if not main.is_ios():
self.assertEqual(0, prefilled_page.number_of_elements(tag, error))
invalid_phones = ['1234567890', '801123456']
'''error = (
'\"{phone}\" is not a valid phone number in the United States.'
)'''
error = " is not a valid phone number in US." #in the United States.
for phone in invalid_phones:
prefilled_page.set('phone', phone)
prefilled_page.click_continue()
#time.sleep(.2)
self.assertEqual(
1, prefilled_page.number_of_elements_containing(tag, error))
prefilled_page.set('phone', '(425) 882-2040')
@unittest.skipIf(main.get_priority() < 2, "Priority = 2")
def test_non_us(self):
""" test_business.py:TestPrefilled.test_non_us """
# assert cannot add non-US business
lobby_page = self.nicol.lobby_page
add_page = self.nicol.add_business_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.add_a_business()
self.assertTrue(add_page.on())
self.assertFalse(
add_page.add("Nintendo of Canada", expectedFailure=True))
# assert error message has expected text
self.assertTrue(add_page.has_error())
@unittest.skipIf(main.get_priority() < 3, "Priority")
def test_required_fields(self):
""" test_business.py:TestPrefilled.test_required_fields """
# assert fields on 'Prefilled' page are required as expected
# Should start and end test w/ ZZ Designs as current business
lobby_page = self.faker.lobby_page
emp_page = self.faker.employee_page
add_page = self.faker.add_business_page
prefilled_page = self.faker.business_prefilled_page
settings_page = self.faker.business_settings_page
eHome = self.faker.eHome_page
default_business = 'ZZ Designs'
new_busName = "Nintendo of America"
tag = 'p'
error = 'Required'
self.assertTrue(self.faker.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.add_a_business()
self.assertTrue(add_page.on())
add_page.add(new_busName + " WA")
self.assertTrue(prefilled_page.on())
# should be 2 required errors before clearing details inputs
prefilled_page.click_continue()
error_count = prefilled_page.number_of_elements
# 1 for EIN, 1 for terms and conditions
self.assertEqual(1, error_count(tag, error))
self.assertEqual(1, error_count('div', error))
self.assertTrue(prefilled_page.on())
prefilled_page.click_details()
prefilled_page.toggle_agree()
self.assertTrue(prefilled_page.agreed())
#Clear form, then check error_counts
prefilled_page.set('business_name', '')
prefilled_page.set('dba', '')
prefilled_page.set('ein', '')
prefilled_page.set('hr_email', '')
prefilled_page.set('line1', '')
prefilled_page.set('city', '')
prefilled_page.set('postal_code', '')
prefilled_page.set('phone', '')
prefilled_page.set('website', '')
prefilled_page.click_continue()
self.assertEqual(7, error_count(tag, error))
prefilled_page.set('ein', '556787898')
prefilled_page.click_continue()
self.assertEqual(6, error_count(tag, error))
prefilled_page.set('hr_email', '*****@*****.**')
prefilled_page.click_continue()
self.assertEqual(5, error_count(tag, error))
prefilled_page.set('business_name', new_busName)
prefilled_page.click_continue()
self.assertEqual(4, error_count(tag, error))
prefilled_page.set('line1', '123 Elm Street')
prefilled_page.click_continue()
self.assertEqual(3, error_count(tag, error))
prefilled_page.set('city', 'Seattle')
prefilled_page.click_continue()
self.assertEqual(2, error_count(tag, error))
# prefilled_page.set('state', 'Nevada')
prefilled_page.set_state('Nevada')
prefilled_page.click_continue()
self.assertEqual(2, error_count(tag, error))
prefilled_page.set('postal_code', '99876')
prefilled_page.click_continue()
self.assertEqual(1, error_count(tag, error))
prefilled_page.set('phone', '(678) 555-8675')
time.sleep(.4) # iOS has weird issue.
# If you change phone# and immediately submit form you get WSOD
# Giving a little bit of time before submitting seems to avoid issue.
prefilled_page.click_continue()
if not lobby_page.on():
raw_input('inspect')
self.assertTrue(lobby_page.on())
# Remove all Nintendo businesses
has_business = lobby_page.menu.has_business(new_busName)
while has_business:
# make sure business is selected
if lobby_page.menu.get_current_business() != new_busName:
lobby_page.menu.select_business(new_busName)
self.assertTrue(lobby_page.on())
# remove business
lobby_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
settings_page.remove_business("REMOVE " + new_busName)
# change role
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
# check if another instance of business
has_business = lobby_page.menu.has_business(new_busName)
# done removing business. Select default business
self.assertFalse(lobby_page.menu.has_business(new_busName))
lobby_page.menu.select_business(default_business)
self.assertTrue(lobby_page.on())
def test_success_skip(self):
""" test_business.py:TestPrefilled.test_success_skip """
# assert adding 'Prefilled' business works as expected
# Skip adding yourself as employee
lobby_page = self.tester.lobby_page
emp_page = self.tester.employee_page
view_page = self.tester.employee_view_page
admin_page = self.tester.admin_page
add_page = self.tester.add_business_page
prefilled_page = self.tester.business_prefilled_page
settings_page = self.tester.business_settings_page
eHome = self.tester.eHome_page
default_business = 'ZZ Designs'
name = 'Tester McTester'
self.assertTrue(self.tester.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.add_a_business()
self.assertTrue(add_page.on())
new_busName = 'Nintendo of America'
ein = '556787898'
hr_email = "*****@*****.**"
add_page.add(new_busName + " WA")
self.assertTrue(prefilled_page.on())
prefilled_page.toggle_agree()
prefilled_page.click_details()
get = prefilled_page.get
self.assertEqual(get('state'), 'Washington')
prefilled_page.set_state("California")
self.assertEqual(get('state'), "California")
self.assertTrue(prefilled_page.set('ein', ein))
prefilled_page.set('hr_email', hr_email)
#prefilled_page.toggle_agree()
self.assertTrue(prefilled_page.agreed())
prefilled_page.click_continue()
self.assertTrue(lobby_page.on())
lobby_page.menu.click_option('employees')
self.assertTrue(emp_page.on())
self.assertEqual(1, emp_page.num_employees())
emp = emp_page.get_employee('name', name)
self.assertEqual(emp['status'], 'Admin')
# should be sole admin in table w/ full privileges
emp_page.menu.click_option('admin')
self.assertTrue(admin_page.on())
self.assertEqual(1, admin_page.num_admins())
admin = admin_page.get_admin(name)
self.assertTrue(admin['members'])
self.assertTrue(admin['org'])
# clicking admin entry should go to employee card
admin_page.click_admin(name)
self.assertTrue(view_page.on())
#self.assertEqual('Admin', view_page.get_status())
self.assertEqual('executive', view_page.get_admin_role())
view_page.header.click_back()
self.assertTrue(admin_page.on())
admin_page.menu.click_option('business settings')
# Business settings should be same as when we created business
self.assertTrue(settings_page.on())
get = settings_page.get
self.assertEqual(get('ein'), ein)
self.assertEqual(get('hr_email'), hr_email)
self.assertEqual(get('business_name'), new_busName)
self.assertEqual(get('dba'), new_busName)
self.assertEqual(get('line1'), '4600 150th Avenue Northeast')
self.assertEqual(get('line2'), '')
self.assertEqual(get('city'), 'Redmond')
self.assertEqual(get('postal_code'), '98052')
self.assertEqual(get('phone'), '(800) 255-3700')
self.assertEqual(get('website'), 'http://nintendo.com')
self.assertEqual(get('state'), 'California')
settings_page.remove_business("REMOVE NINTENDO OF AMERICA")
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
# Loop to remove all instances of particular business
has_business = lobby_page.menu.has_business(new_busName)
while has_business:
# make sure business is selected
if lobby_page.menu.get_current_business() != new_busName:
lobby_page.menu.select_business(new_busName)
self.assertTrue(lobby_page.on())
# remove business
lobby_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
settings_page.remove_business("REMOVE " + new_busName)
# change role
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
# check if another instance of business
has_business = lobby_page.menu.has_business(new_busName)
# done removing business. Select default business
self.assertFalse(lobby_page.menu.has_business(new_busName))
lobby_page.menu.select_business(default_business)
self.assertTrue(lobby_page.on())
@unittest.skip("Participate dialog moved to post-approval")
def test_success_participate(self):
""" test_business.py:TestPrefilled.test_success_participate """
#dependencies: Should have no Nintendo of America business
lobby_page = self.fire.lobby_page
emp_page = self.fire.employee_page
view_page = self.fire.employee_view_page
admin_page = self.fire.admin_page
add_page = self.fire.add_business_page
prefilled_page = self.fire.business_prefilled_page
settings_page = self.fire.business_settings_page
eHome = self.fire.eHome_page
participate_page = self.fire.participate_page
main_election = self.fire.pay_election_page
pending_elections = self.fire.pending_elections_page
default_business = 'ZZ Designs'
name = 'Firefox Boss'
self.assertTrue(self.fire.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.add_a_business()
self.assertTrue(add_page.on())
new_busName = 'Nintendo of America'
ein = '556787898'
hr_email = "*****@*****.**"
add_page.add(new_busName + " WA")
self.assertTrue(prefilled_page.on())
prefilled_page.click_details()
get = prefilled_page.get
self.assertEqual(get('state'), 'Washington')
prefilled_page.set_state("California")
self.assertEqual(get('state'), "California")
prefilled_page.set('ein', ein)
prefilled_page.set('hr_email', hr_email)
prefilled_page.toggle_agree()
prefilled_page.click_continue()
self.assertTrue(emp_page.on())
emp_page.handle_participate_dialog('participate')
self.assertTrue(participate_page.on())
participate_page.set_id('T-000')
participate_page.set_dob('01/01/1984')
participate_page.set_zip('12345')
if participate_page.agreed() is not True:
participate_page.click_agree()
participate_page.click_submit()
self.assertTrue(main_election.on())
main_election.set_election('Nintendo of America', '15.00')
main_election.click_save()
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
lobby_page.menu.click_option('employees')
self.assertTrue(emp_page.on())
self.assertEqual(1, emp_page.num_employees())
emp = emp_page.get_employee('name', name)
self.assertEqual(emp['status'], 'Active')
# should be sole admin in table w/ full privileges
emp_page.menu.click_option('admin')
self.assertTrue(admin_page.on())
self.assertEqual(1, admin_page.num_admins())
admin = admin_page.get_admin(name)
self.assertTrue(admin['members'])
self.assertTrue(admin['org'])
# clicking admin entry should go to employee card
admin_page.click_admin(name)
self.assertTrue(view_page.on())
self.assertEqual('Active', view_page.get_status())
self.assertEqual('executive', view_page.get_admin_role())
view_page.header.click_back()
self.assertTrue(admin_page.on())
admin_page.menu.click_option('pending elections')
self.assertTrue(pending_elections.on())
self.assertEqual(1, pending_elections.num_pending_elections())
test_election = pending_elections.get_election('name', name)
self.assertEqual(test_election['name'], name)
self.assertEqual(test_election['amount'], '15.00')
admin_page.menu.click_option('business settings')
# Business settings should be same as when we created business
self.assertTrue(settings_page.on())
get = settings_page.get
self.assertEqual(get('ein'), ein)
self.assertEqual(get('hr_email'), hr_email)
self.assertEqual(get('business_name'), new_busName)
self.assertEqual(get('dba'), new_busName)
self.assertEqual(get('line1'), '4600 150th Avenue Northeast')
self.assertEqual(get('line2'), '')
self.assertEqual(get('city'), 'Redmond')
self.assertEqual(get('postal_code'), '98052')
self.assertEqual(get('phone'), '(425) 882-2040')
# no longer has stuff after .com (/corp/)
self.assertEqual(get('website'), 'http://nintendo.com')
self.assertEqual(get('state'), 'California')
settings_page.remove_business("REMOVE NINTENDO OF AMERICA")
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
# Loop to remove all instances of particular business
has_business = lobby_page.menu.has_business(new_busName)
while has_business:
# make sure business is selected
if lobby_page.menu.get_current_business() != new_busName:
lobby_page.menu.select_business(new_busName)
self.assertTrue(lobby_page.on())
# remove business
lobby_page.menu.click_option('business settings')
self.assertTrue(settings_page.on())
settings_page.remove_business("REMOVE " + new_busName)
# change role
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
# check if another instance of business
has_business = lobby_page.menu.has_business(new_busName)
# done removing business. Select default business
self.assertFalse(lobby_page.menu.has_business(new_busName))
lobby_page.menu.select_business(default_business)
self.assertTrue(lobby_page.on())
class TestElection(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.cheeks = profiles.Profile(self.driver, 'cheeks')
self.lili = profiles.Profile(self.driver, 'lili')
self.nicol = profiles.Profile(self.driver, 'nicol')
def tearDown(self):
self.driver.quit()
@unittest.skipIf(main.get_priority() < 2, "Priority = 2")
# @unittest.skipIf(main.is_android(), "Manually test Android")
def test_multiple_elections(self):
""" test_profile.py:TestElection.test_multiple_elections """
# dependencies: sandy cheeks works for Dunkin' Donuts and multiverse
eHome = self.cheeks.eHome_page
election_page = self.cheeks.pay_election_page
history_page = self.cheeks.election_history_page
self.assertTrue(self.cheeks.login(self.driver), messages.login)
self.assertTrue(eHome.on())
eHome.setTab('election')
# save button should be disabled and gray until changes are made
self.assertFalse(eHome.is_enabled(eHome.save_button))
disabled_color = 'rgb(170, 170, 170)'
background = eHome.save_button.value_of_css_property('background')
self.assertTrue(disabled_color in background)
# set 2 pay elections
business1 = "Dunkin' Donuts"
business2 = "Multiverse"
new_election1 = self.cheeks.generate_amount()
new_election2 = self.cheeks.generate_amount()
original_elections = eHome.get_elections()
eHome.set_election(business1, new_election1)
# save button should be enabled and blue after changes are made
WDW(self.driver, 10).until(
EC.element_to_be_clickable((By.ID, 'save_election_button')))
self.assertTrue(eHome.is_enabled(eHome.save_button))
background = eHome.save_button.value_of_css_property('background')
enabled_color = 'rgb(105, 214, 241)'
self.assertTrue(enabled_color in background)
eHome.set_election(business2, new_election2)
new_elections = eHome.get_elections()
new_total = str(Decimal(new_election1) + Decimal(new_election2))
self.assertEqual(new_election1, new_elections[business1])
self.assertEqual(new_election2, new_elections[business2])
self.assertEqual(new_total, new_elections['total'])
eHome.click_save_elections()
# deal w/ prompt
self.assertTrue(eHome.on('election'))
self.assertTrue(eHome.has_election_prompt())
self.assertFalse(eHome.has_save_election_button())
# eHome.clear_election_prompt()
# self.assertFalse(eHome.has_election_prompt())
# self.assertTrue(eHome.has_save_election_button())
# checkout history
eHome.view_election_history()
self.assertTrue(history_page.on())
history_entry1 = history_page.get_election(0)
history_entry2 = history_page.get_election(1)
if history_entry1[
'name'] == business1: # history_entry1 = Dunkin' Donuts
elect1 = history_entry1
elect2 = history_entry2
else: # history_entry1 = Multiverse
elect1 = history_entry2
elect2 = history_entry1
self.assertTrue(elect1['amount'] == new_election1)
self.assertTrue(elect1['name'] == business1)
self.assertTrue(elect2['amount'] == new_election2)
self.assertTrue(elect2['name'] == business2)
# Elections should be pending
history_page.header.click_back()
self.assertTrue(eHome.on('election'))
pending_elections = eHome.get_elections()
self.assertTrue(pending_elections[business1 + " pending"])
self.assertTrue(pending_elections[business2 + " pending"])
# Check that custom keyboard stays open when toggling between inputs.
if not main.is_desktop():
pass
# @unittest.skipIf(main.is_android() is True, "Manually test Android")
def test_single_election(self):
""" test_profile.py:TestElection.test_single_election """
# process all pending elections for Multiverse
# Lili needs to be employee of 'Multiverse' w/ emp ID 13313113
business = 'Multiverse'
lobby_page = self.nicol.lobby_page
pe_page = self.nicol.pending_elections_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
# Can't close menu on Android. Checking for business leaves menu open
if not main.is_android():
if lobby_page.menu.get_current_business() != business:
lobby_page.menu.select_business(business)
self.assertTrue(lobby_page.on())
lobby_page.click_link('card', 1)
self.assertTrue(pe_page.on())
if pe_page.num_pending_elections() > 0:
pe_page.mark_all_as_processed()
pe_page.menu.sign_out()
# lili: request new Multiverse election
eHome = self.lili.eHome_page
election_page = self.lili.pay_election_page
history_page = self.lili.election_history_page
self.assertTrue(self.lili.login(self.driver), messages.login)
self.assertTrue(eHome.on())
eHome.setTab('election')
elections = eHome.get_elections()
initial_election = elections[business]
print(initial_election)
# Lili should have single election field (no total)
self.assertEqual(None, elections['total'])
increase = self.lili.generate_amount()
new_election = str(Decimal(initial_election) + Decimal(increase))
print(new_election)
eHome.set_election(business, new_election)
new_elections = eHome.get_elections()
self.assertEqual(new_election, new_elections[business])
self.assertEqual(None, new_elections['total'])
eHome.click_save_elections()
self.assertTrue(eHome.on('election'))
self.assertTrue(eHome.has_election_prompt())
self.assertFalse(eHome.has_save_election_button())
# eHome.clear_election_prompt()
# self.assertFalse(eHome.has_election_prompt())
# self.assertTrue(eHome.has_save_election_button())
# assert change is reflected in lili's election history
eHome.view_election_history()
self.assertTrue(history_page.on())
election = history_page.get_election()
self.assertTrue(election['name'] == business)
self.assertTrue(election['amount'] == new_election)
history_page.header.click_back()
# election should be pending
self.assertTrue(eHome.on('election'))
pending_elections = eHome.get_elections()
self.assertTrue(pending_elections[business + " pending"])
eHome.menu.sign_out()
# assert change is NOT reflected in Multiverse employee table
emp_page = self.nicol.employee_page
view_page = self.nicol.employee_view_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.click_option('employees')
self.assertTrue(emp_page.on())
lili = emp_page.get_employee('id', '13313113')
# should still be initial election
# can fail if multiple elections have been requested w/out being processed.
self.assertEqual(lili['election'], initial_election + " USD")
self.assertNotEqual(lili['election'], new_election + " USD")
self.assertTrue(emp_page.click_employee('id', '13313113'))
self.assertTrue(view_page.on())
self.assertEqual(view_page.election.text, initial_election + " USD")
self.assertNotEqual(view_page.election.text, new_election + " USD")
view_page.header.click_back()
self.assertTrue(emp_page.on())
# process pending election and recheck employee table
emp_page.menu.click_option('pending elections')
self.assertTrue(pe_page.on())
pe_page.mark_all_as_processed()
pe_page.menu.click_option('employees')
self.assertTrue(emp_page.on())
lili = emp_page.get_employee('id', '13313113')
# Doesn't always refresh quickly.
# Force refresh if they're not equal right away
if new_election + ' USD' == lili['election']:
self.assertEqual('Active', lili['status'])
self.assertEqual(new_election + ' USD', lili['election'])
else:
# Refresh and check again
self.driver.refresh()
self.assertTrue(emp_page.on())
lili = emp_page.get_employee('id', '13313113')
self.assertEqual('Active', lili['status'])
self.assertEqual(new_election + ' USD', lili['election'])
emp_page.menu.sign_out()
# lili's election should not be pending
self.assertTrue(self.lili.login(self.driver), messages.login)
# not sure why this is different on native. I'm assuming app remembers which tab you were on
if not main.is_web():
self.assertTrue(eHome.on('election'))
else:
self.assertTrue(eHome.on())
eHome.setTab('election')
elections = eHome.get_elections()
self.assertFalse(elections[business + ' pending'])
test_single_election.e2e = True
@unittest.skipIf(main.get_priority() < 2, "Priority = 2")
# @unittest.skipIf(main.is_android() is True, "Manually test Android")
def test_zero_election(self):
""" test_profile.py:TestElection.test_zero_election """
# reset Lili's multiverse election back to 0
business = 'Multiverse'
eHome = self.lili.eHome_page
election_page = self.lili.pay_election_page
history_page = self.lili.election_history_page
self.assertTrue(self.lili.login(self.driver), messages.login)
# make sure lili has non-zero election
self.assertTrue(eHome.on())
eHome.setTab('election')
elections = eHome.get_elections()
initial_election = elections[business]
if initial_election == '0.00':
new_election = "1.00"
eHome.set_election(business, new_election)
new_elections = eHome.get_elections()
self.assertEqual(new_election, new_elections[business])
eHome.click_save_elections()
eHome.clear_election_prompt()
eHome.view_election_history()
self.assertTrue(history_page.on())
history_page.header.click_back()
self.assertTrue(eHome.on('election'))
eHome.menu.sign_out()
lobby_page = self.nicol.lobby_page
pe_page = self.nicol.pending_elections_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
if lobby_page.menu.get_current_business() != business:
lobby_page.menu.select_business(business)
self.assertTrue(lobby_page.on())
lobby_page.menu.click_option('pending elections')
self.assertTrue(pe_page.on())
pe_page.mark_all_as_processed()
pe_page.menu.sign_out()
self.assertTrue(self.lili.login(self.driver), messages.login)
# Seems like native app saves employeeTab even when you log out
print('logged in')
if main.get_browser() == 'native':
self.assertTrue(eHome.on('election'))
else:
self.assertTrue(eHome.on())
eHome.setTab('election')
print('on eHome')
new_election = "0.00"
eHome.set_election(business, new_election)
new_elections = eHome.get_elections()
self.assertEqual(new_election, new_elections[business])
eHome.click_save_elections()
eHome.view_election_history()
# assert change is reflected in lili's election history
# Loading history page has failed before.
# Seems to take forever for entries to load.
self.assertTrue(history_page.on())
election = history_page.get_election()
self.assertTrue(election['name'] == business)
self.assertTrue(election['amount'] == "0.00")
history_page.header.click_back()
# election should be pending
self.assertTrue(eHome.on('election'))
pending_elections = eHome.get_elections()
self.assertTrue(pending_elections[business + " pending"])
eHome.menu.sign_out()
# Nicol: process election
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
if lobby_page.menu.get_current_business() != business:
lobby_page.menu.select_business(business)
self.assertTrue(lobby_page.on())
lobby_page.menu.click_option('pending elections')
self.assertTrue(pe_page.on())
pe_page.mark_all_as_processed()
class TestATM(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.cheeks = profiles.Profile(self.driver, 'cheeks')
self.nicol = profiles.Profile(self.driver, 'nicol')
def tearDown(self):
self.driver.quit()
def test_add_recipient(self):
""" test_send_to_atm.py:TestATM.test_add_recipient """
eHome = self.cheeks.eHome_page
send_to_atm = self.cheeks.send_to_atm_page
recipient_list = self.cheeks.recipient_page
name_page = self.cheeks.recipient_name_page
recip_card = self.cheeks.recipient_view_page
# Add new recipient. Click back to recipient list. Add account for recipient.
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('atm')
self.assertTrue(send_to_atm.on([0, 'Recipient']))
send_to_atm.add_recipient()
self.assertTrue(name_page.on())
self.assertEqual('Mexico', name_page.get_location())
name_page.set_location('us')
self.assertEqual('United States', name_page.get_location())
name_page.set_location('mx')
self.assertEqual('Mexico', name_page.get_location())
recip = self.cheeks.generate_name()
name_page.enter_name(recip)
# Should be on additional data form
self.assertTrue(send_to_atm.on([0, 'Recipient'], True))
noCarrier = {
'carrier': '',
'phone': '2022221234',
'dob': self.cheeks.generate_rfc_dob()
}
noDOB = {
'carrier': 'telcel',
'phone': '2022221234',
'dob': ''
}
noPhone = {
'carrier': 'at&t',
'phone': '',
'dob': self.cheeks.generate_rfc_dob()
}
allInfo = {
'carrier': 'movistar',
'phone': '(202) 222-1234',
'dob': self.cheeks.generate_rfc_dob()
}
# Shouldn't be able to submit form w/out all info
# Should get 'Required' error (not currently getting one for phone, no identifier on carrier)
send_to_atm.data_form.set_info(noCarrier) # Do noCarrier first (cannot de-select carrier)
send_to_atm.submit_data_form(False)
# raw_input('noCarrier')
self.assertTrue(send_to_atm.on([0, 'Recipient'], True))
# self.assertTrue('Date Format: mm/dd/yyyy' in send_to_atm.data_form.dob_error())
send_to_atm.data_form.set_info(noPhone)
send_to_atm.submit_data_form(False)
# raw_input('noPHone')
self.assertTrue(send_to_atm.on([0, 'Recipient'], True))
send_to_atm.data_form.set_info(noDOB)
# raw_input('noDob')
send_to_atm.submit_data_form(False)
self.assertTrue('Required' in send_to_atm.data_form.dob_error())
send_to_atm.data_form.set_info(allInfo)
returned_info = send_to_atm.data_form.get_info()
self.assertEqual(allInfo['carrier'], returned_info['carrier'])
self.assertEqual(allInfo['phone'], returned_info['phone'])
self.assertEqual(allInfo['dob'], returned_info['dob'])
send_to_atm.submit_data_form()
send_to_atm.set_step(0)
send_to_atm.click_recipient(recip)
self.assertTrue(send_to_atm.on([1, 'Amount']))
if not main.is_desktop():
send_to_atm.header.click_back()
self.assertTrue(send_to_atm.on([0, 'Recipient']))
send_to_atm.header.click_back()
self.assertTrue(eHome.on())
eHome.menu.click_option('recipients')
else:
send_to_atm.menu.click_option('recipients')
self.assertTrue(recipient_list.on())
recipient_list.click_recipient(recip)
self.assertTrue(recip_card.on())
recip_card.remove_recipient()
self.assertTrue(recipient_list.on())
def test_duplicate(self):
""" test_send_to_atm.py:TestATM.test_duplicate """
eHome = self.cheeks.eHome_page
send_to_atm = self.cheeks.send_to_atm_page
recipient_list = self.cheeks.recipient_page
name_page = self.cheeks.recipient_name_page
recip_card = self.cheeks.recipient_view_page
# Trying to send to Jose should go back to send-to-atm and load 2nd step
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('atm')
self.assertTrue(send_to_atm.on([0, 'Recipient']))
send_to_atm.add_recipient()
self.assertTrue(name_page.on())
recip1 = "Jose Ortega"
name_page.enter_name(recip1)
self.assertTrue(name_page.on(True))
self.assertIsNotNone(name_page.duplicate_send)
self.assertIsNotNone(name_page.duplicate_continue)
self.assertIsNone(name_page.duplicate_add)
self.assertIsNone(name_page.duplicate_view)
name_page.click_duplicate_send()
self.assertTrue(send_to_atm.on([1, 'Amount']))
send_to_atm.set_step(0)
# Trying to send to David should go back to send-to-atm w/ addInfo loaded
send_to_atm.add_recipient()
self.assertTrue(name_page.on())
recip2 = "David Castillo"
name_page.enter_name(recip2)
self.assertTrue(name_page.on(True))
name_page.click_duplicate_send()
self.assertTrue(send_to_atm.on([0, 'Recipient'], True))
# Adding duplicate of Rosa should go back to 1st step
# Delete new recipient
send_to_atm.header.click_back()
self.assertTrue(send_to_atm.on([0, 'Recipient']))
send_to_atm.add_recipient()
self.assertTrue(name_page.on())
recip3 = "Rosa Castillo"
name_page.enter_name(recip3)
self.assertTrue(name_page.on(True))
name_page.click_duplicate_continue()
self.assertTrue(send_to_atm.on([0, 'Recipient'], True))
if main.is_desktop():
send_to_atm.menu.click_option('recipients')
else:
send_to_atm.header.click_back()
self.assertTrue(send_to_atm.on([0, 'Recipient'], False))
send_to_atm.header.click_back()
self.assertTrue(eHome.on())
eHome.menu.click_option('recipients')
self.assertTrue(recipient_list.on())
recipient_list.click_recipient(recip3)
self.assertTrue(recip_card.on())
recip_card.remove_recipient()
self.assertTrue(recipient_list.on())
# @unittest.skip("PIN no longer user generated")
# def test_edit_pin(self):
# """ test_send_to_atm.py:TestATM.test_edit_pin """
# # Send 100 MXN to Leticia (atm) with pin1. Send 100 to Leticia w/ pin2.
# # Transfer details page should associate correct pin w/ correct transfer
# eHome = self.cheeks.eHome_page
# recip_list = self.cheeks.recipient_page
# recip_view = self.cheeks.recipient_view_page
# info_page = self.cheeks.recipient_info_page
# send_to_atm = self.cheeks.send_to_atm_page
# td_page = self.cheeks.td_page
# recip = "Leticia Ortega"
# # Read pin #1
# self.assertTrue(self.cheeks.login(self.driver), messages.login)
# eHome.menu.click_option('recipients')
# self.assertTrue(recip_list.on())
# recip_list.click_recipient(recip)
# self.assertTrue(recip_view.on())
# recip_view.edit_additional_info()
# self.assertTrue(info_page.on())
# info = info_page.addInfo.get_info()
# pin1 = info['pin']
# if main.is_desktop():
# info_page.menu.click_option('ehome')
# else:
# info_page.header.click_back()
# self.assertTrue(recip_view.on())
# recip_view.header.click_back()
# self.assertTrue(recip_list.on())
# recip_list.menu.click_option('ehome')
# self.assertTrue(eHome.on())
# eHome.send('atm')
# self.assertTrue(send_to_atm.on())
# send_to_atm.click_recipient(recip)
# self.assertTrue(send_to_atm.on([1, 'Amount']))
# send_to_atm.send_form.set_bbva_amount('100')
# send_to_atm.submit_send_form()
# send_to_atm.disclosure.click_continue()
# self.assertTrue(eHome.on('activity'))
# self.assertEqual(pin1, eHome.get_dialog_pin())
# eHome.clear_confirmation_dialog()
# self.assertTrue(eHome.on('activity'))
# eHome.click_transaction()
# self.assertTrue(td_page.on(True))
# self.assertEqual(pin1, td_page.get_pin())
# td_page.header.click_back()
# self.assertTrue(eHome.on('activity'))
# # Change pin
# eHome.menu.click_option('recipients')
# self.assertTrue(recip_list.on())
# recip_list.click_recipient(recip)
# self.assertTrue(recip_view.on())
# recip_view.edit_additional_info()
# self.assertTrue(info_page.on())
# pin2 = pin1
# while pin1 == pin2:
# pin2 = self.cheeks.generate_number(4)
# info_page.addInfo.set_pin(pin2)
# info_page.addInfo.click_continue()
# self.assertTrue(recip_view.on())
# if main.is_desktop():
# recip_view.menu.click_option('ehome')
# else:
# recip_view.header.click_back()
# self.assertTrue(recip_list.on())
# recip_list.menu.click_option('ehome')
# self.assertTrue(eHome.on('activity'))
# eHome.send('atm')
# # Send again. Verify pin2 is in transfer details
# self.assertTrue(send_to_atm.on())
# send_to_atm.click_recipient(recip)
# self.assertTrue(send_to_atm.on([1, 'Amount']))
# send_to_atm.send_form.set_bbva_amount('100')
# send_to_atm.submit_send_form()
# send_to_atm.disclosure.click_continue()
# self.assertTrue(eHome.on('activity'))
# eHome.clear_confirmation_dialog()
# self.assertTrue(eHome.on('activity'))
# eHome.click_transaction()
# self.assertTrue(td_page.on(True))
# self.assertEqual(pin2, td_page.get_pin())
# td_page.header.click_back()
# self.assertTrue(eHome.on('activity'))
# # Verify transaction1 still has original pin
# eHome.click_transaction(1)
# self.assertTrue(td_page.on(True))
# self.assertEqual(pin1, td_page.get_pin())
def test_learn_more(self):
""" test_send_to_atm.py:TestATM.test_learn_more """
eHome = self.cheeks.eHome_page
send_to_atm = self.cheeks.send_to_atm_page
recipient_list = self.cheeks.recipient_page
name_page = self.cheeks.recipient_name_page
recip_card = self.cheeks.recipient_view_page
self.assertTrue(self.cheeks.login(self.driver), messages.login)
# Action 0: How to send to ATM
eHome.learn_more_action(0)
eHome.how_to_close.click()
time.sleep(1)
eHome.learn_more_action(0)
# Step 1
self.assertTrue(eHome.how_to_close != None)
self.assertTrue(eHome.how_to_next != None)
self.assertTrue(eHome.how_to_done == None)
eHome.click_how_to_next()
# Step 2
self.assertTrue(eHome.how_to_close != None)
self.assertTrue(eHome.how_to_next != None)
self.assertTrue(eHome.how_to_done == None)
eHome.click_how_to_next()
# Step 3
self.assertTrue(eHome.how_to_close != None)
self.assertTrue(eHome.how_to_next != None)
self.assertTrue(eHome.how_to_done == None)
eHome.click_how_to_next()
# Step 4
self.assertTrue(eHome.how_to_close == None)
self.assertTrue(eHome.how_to_next == None)
self.assertTrue(eHome.how_to_done != None)
eHome.how_to_done.click()
time.sleep(1)
# Action 1: Find BBVA
eHome.learn_more_action(1)
eHome.find_atm('Monterrey')
eHome.close_find_atm()
time.sleep(3)
# Action 2: FAQ
# eHome.learn_more_action(2)
# eHome.close_find_atm()
# self.assertTrue(eHome.on('send'))
def test_navigation(self):
""" test_send_to_atm.py:TestATM.test_navigation """
# Check back button and steps for all pages in send flow
eHome = self.cheeks.eHome_page
send_to_atm = self.cheeks.send_to_atm_page
name_page = self.cheeks.recipient_name_page
recip1 = 'David Castillo'
recip2 = 'Jose Ortega'
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('atm')
self.assertTrue(send_to_atm.on())
# Step 0 goes back to eHome
send_to_atm.header.click_back()
self.assertTrue(eHome.on('send'))
eHome.send('atm')
self.assertTrue(send_to_atm.on())
# Cannot skip ahead to steps 1 or 2
send_to_atm.set_step(1, reloadPage=False)
self.assertTrue(send_to_atm.on([0, 'Recipient']))
send_to_atm.set_step(2, reloadPage=False)
self.assertTrue(send_to_atm.on([0, 'Recipient']))
# Clicking back on addInfo screen will go to step 0
send_to_atm.click_recipient(recip1)
self.assertTrue(send_to_atm.on([0, 'Recipient'], True))
send_to_atm.header.click_back()
self.assertTrue(send_to_atm.on([0, 'Recipient']))
# Clicking back on amount step goes to step 0
send_to_atm.click_recipient(recip2)
self.assertTrue(send_to_atm.on([1, 'Amount']))
send_to_atm.header.click_back()
self.assertTrue(send_to_atm.on([0, 'Recipient']))
# Can jump between 1st 2 steps after selecting recipient w/ info
send_to_atm.click_recipient(recip2)
self.assertTrue(send_to_atm.on([1, 'Amount']))
send_to_atm.set_step(1)
send_to_atm.set_step(1)
# Can't jump to last step
send_to_atm.set_step(2, reloadPage=False)
self.assertTrue(send_to_atm.on([1, 'Amount']))
# Can jump between all 3 steps after setting amount and clicking continue
atm_amount = "100"
send_to_atm.send_form.set_bbva_amount(atm_amount)
send_to_atm.submit_send_form()
send_to_atm.set_step(0)
send_to_atm.set_step(1)
self.assertEqual(atm_amount, send_to_atm.send_form.get_bbva_amount())
send_to_atm.set_step(2)
# Clicking back to beginning.
# Clicking back on add recipient goes to 1st step
send_to_atm.header.click_back()
self.assertTrue(send_to_atm.on([1, 'Amount']))
send_to_atm.header.click_back()
self.assertTrue(send_to_atm.on([0, 'Recipient']))
send_to_atm.add_recipient()
self.assertTrue(name_page.on())
name_page.header.click_back()
self.assertTrue(send_to_atm.on([0, 'Recipient']))
@unittest.skipIf(main.get_priority() < 2, "Priority = 2")
def test_no_balance(self):
""" test_send_to_atm.py:TestATM.test_no_balance """
# trying to send w/ no balance works as expected
lobby_page = self.nicol.lobby_page
eHome = self.nicol.eHome_page
send_to_atm = self.nicol.send_to_atm_page
recip = 'David Castillo'
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.set_role('employee')
self.assertTrue(eHome.on())
# menu should be closed on mobile
if not main.is_desktop():
self.assertFalse(eHome.menu.is_drawer_visible())
eHome.send('atm')
self.assertTrue(send_to_atm.on([0, 'Recipient']))
send_to_atm.click_recipient(recip)
self.assertTrue(send_to_atm.on([1, 'Amount']))
# Step 2 - Set amount, check for balance error
self.assertEqual([1, 'Amount'], send_to_atm.currentStep)
mxn_amount = self.nicol.generate_bbva_amount()
print(mxn_amount)
self.assertFalse(send_to_atm.send_form.is_form_enabled())
self.assertTrue(send_to_atm.send_form.has_balance_error())
send_to_atm.send_form.set_bbva_amount(mxn_amount)
self.assertTrue(send_to_atm.send_form.has_balance_error())
send_to_atm.send_form.try_clear_error()
self.assertFalse(send_to_atm.send_form.has_balance_error())
self.assertFalse(send_to_atm.send_form.is_form_enabled())
def test_success(self):
""" test_send_to_atm.py:TestATM.test_success """
# David needs Zions and Wells Fargo bank accounts
#Send and Disclosure pages interact as expected
eHome = self.cheeks.eHome_page
send_to_atm = self.cheeks.send_to_atm_page
td_page = self.cheeks.td_page
recip = 'Jose Ortega'
# Login and select David Castillo
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('atm')
self.assertTrue(send_to_atm.on())
send_to_atm.click_recipient(recip)
send_to_atm.set_step('Recipient')
self.assertTrue(send_to_atm.on([0, 'Recipient']))
send_to_atm.click_recipient(recip)
self.assertTrue(send_to_atm.on([1, 'Amount']))
# send page is setup as expected
self.assertFalse(send_to_atm.send_form.is_form_enabled())
self.assertEqual("0", send_to_atm.send_form.get_bbva_amount())
balance = send_to_atm.send_form.get_balance()
exchange_rate = send_to_atm.send_form.get_exchange_rate()
self.assertNotEqual(None, exchange_rate)
# send page amounts work as expected
mxn = self.cheeks.generate_bbva_amount()
send_to_atm.send_form.set_bbva_amount(mxn)
usd = send_to_atm.send_form.get_usd()
self.assertEqual(mxn, send_to_atm.send_form.get_bbva_amount())
send_to_atm.submit_send_form()
# disclosure page has everything we expect
# check name and totals
self.assertEqual(recip, send_to_atm.disclosure.get_name())
# self.assertEqual(usd_amount, send_to_atm.disclosure.get_transfer_amount())
fee = '1.00'
self.assertEqual(fee, send_to_atm.disclosure.get_transfer_fee())
self.assertEqual(mxn + " MXN", send_to_atm.disclosure.get_total_to_recipient())
total = str(Decimal(usd) + Decimal(fee))
self.assertEqual(total, send_to_atm.disclosure.get_transfer_total())
# check exchange rate and disclosures
self.assertEqual(exchange_rate, send_to_atm.disclosure.get_exchange_rate())
self.assertFalse(send_to_atm.disclosure.has_d_30())
self.assertFalse(send_to_atm.disclosure.has_d_less())
self.assertTrue(send_to_atm.disclosure.has_d_notify())
# send, clear confirmation dialog
send_to_atm.disclosure.click_continue()
self.assertTrue(eHome.on('activity'))
self.assertTrue(eHome.clear_confirmation_dialog())
self.assertTrue(eHome.on('activity'))
# Check transaction
data = eHome.get_transaction()
self.assertEqual(data['amount'], '-' + total)
# self.assertEqual(data['recipient'], recip)
self.assertEqual(data['icon'], 'clock')
self.assertEqual(data['status'], 'Sending') # Available
# check td page
eHome.click_transaction()
self.assertTrue(td_page.on(True))
self.assertEqual('clock', td_page.read_transaction_icon())
self.assertEqual(td_page.send_now_button, None)
self.assertEqual(td_page.cancel_button, None)
td_page.click_continue()
self.assertTrue(eHome.on('activity'))
class TestBank(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.cheeks = profiles.Profile(self.driver, 'cheeks')
self.nicol = profiles.Profile(self.driver, 'nicol')
def tearDown(self):
self.driver.quit()
def test_add_account(self):
""" test_send_to_bank.py:TestBank.test_add_account """
eHome = self.cheeks.eHome_page
send_to_bank = self.cheeks.send_to_bank_page
recipient_list = self.cheeks.recipient_page
recip_card = self.cheeks.recipient_view_page
bank_page = self.cheeks.bank_account_page
recip = 'David Castillo'
# Give David a Wells Fargo account. Delete it.
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('bank')
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
send_to_bank.add_account()
self.assertTrue(recipient_list.on())
recipient_list.click_recipient(recip)
self.assertTrue(bank_page.on())
routing_num = "031000503"
acct_num = self.cheeks.generate_number(8)
bank_page.set_routing(routing_num)
bank_page.set_account(acct_num)
bank_page.set_account_type('savings')
bank_page.click_continue()
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
self.assertTrue(send_to_bank.click_account(recip, 'Wells Fargo Bank'))
if not main.is_desktop():
send_to_bank.header.click_back()
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
send_to_bank.header.click_back()
self.assertTrue(eHome.on())
eHome.menu.click_option('recipients')
else:
send_to_bank.menu.click_option('recipients')
self.assertTrue(recipient_list.on())
recipient_list.click_recipient(recip)
self.assertTrue(recip_card.on())
recip_card.select_destination('bank', 'Wells Fargo')
self.assertTrue(bank_page.on())
bank_page.remove()
self.assertTrue(recip_card.on())
def test_add_mx_recipient(self):
""" test_send_to_bank.py:TestBank.test_add_mx_recipient """
eHome = self.cheeks.eHome_page
send_to_bank = self.cheeks.send_to_bank_page
send_to_atm = self.cheeks.send_to_atm_page
recipient_list = self.cheeks.recipient_page
name_page = self.cheeks.recipient_name_page
bank_page = self.cheeks.bank_account_page
recip_card = self.cheeks.recipient_view_page
recip_1 = self.cheeks.generate_name()
clabe = '032180000118359719'
dob = self.cheeks.generate_rfc_dob()
# Add new US recipient. Click back to recipient list. Add account for recipient.
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('bank')
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
send_to_bank.add_account()
self.assertTrue(recipient_list.on())
recipient_list.add_recipient()
self.assertTrue(name_page.on())
self.assertEqual('Mexico', name_page.get_location())
name_page.set_location('us')
self.assertEqual('United States', name_page.get_location())
name_page.set_location('mx')
self.assertEqual('Mexico', name_page.get_location())
name_page.enter_name(recip_1)
# Should go directly to adding a bank account after adding recipient
# Bank account location should default to location of recipient
self.assertTrue(bank_page.on())
bank_page.header.click_back()
self.assertTrue(recipient_list.on())
recipient_list.click_recipient(recip_1)
self.assertTrue(bank_page.on())
routing_num = "031000503"
acct_num = self.cheeks.generate_number(8)
self.assertEqual('Mexico', bank_page.get_location())
bank_page.set_location('us')
self.assertEqual('United States', bank_page.get_location())
bank_page.set_location('mx')
self.assertEqual('Mexico', bank_page.get_location())
bank_page.set_clabe(clabe)
bank_page.click_continue()
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
# Delete recip_1
send_to_bank.header.click_back()
self.assertTrue(eHome.on())
eHome.menu.click_option('recipients')
self.assertTrue(recipient_list.on())
recipient_list.click_recipient(recip_1)
self.assertTrue(recip_card.on())
recip_card.remove_recipient()
self.assertTrue(recipient_list.on())
def test_add_us_recipient(self):
""" test_send_to_bank.py:TestBank.test_add_us_recipient """
eHome = self.cheeks.eHome_page
send_to_bank = self.cheeks.send_to_bank_page
recipient_list = self.cheeks.recipient_page
name_page = self.cheeks.recipient_name_page
bank_page = self.cheeks.bank_account_page
recip_card = self.cheeks.recipient_view_page
recip_1 = self.cheeks.generate_name()
routing_num = "031000503"
acct_num = self.cheeks.generate_number(8)
# Add new US recipient. Click back to recipient list. Add account for recipient.
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('bank')
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
send_to_bank.add_account()
self.assertTrue(recipient_list.on())
recipient_list.add_recipient()
self.assertTrue(name_page.on())
self.assertEqual('Mexico', name_page.get_location())
name_page.set_location('us')
self.assertEqual('United States', name_page.get_location())
name_page.enter_name(recip_1)
# Should go directly to adding a bank account after adding recipient
# Bank account location should default to location of recipient
self.assertTrue(bank_page.on())
bank_page.header.click_back()
self.assertTrue(recipient_list.on())
recipient_list.click_recipient(recip_1)
self.assertTrue(bank_page.on())
self.assertEqual('United States', bank_page.get_location())
bank_page.set_location('mx')
self.assertEqual('Mexico', bank_page.get_location())
bank_page.set_location('us')
bank_page.set_routing(routing_num)
bank_page.set_account(acct_num)
bank_page.set_account_type('savings')
bank_page.click_continue()
# Shouldn't ask for DOB when sending to US bank account
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
send_to_bank.click_account(recip_1, 0)
self.assertTrue(send_to_bank.on([1, 'Specify Amount']))
# Go to recipients and delete new recipient + any remaining from failed tests
send_to_bank.header.click_back()
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
send_to_bank.header.click_back()
self.assertTrue(eHome.on())
eHome.menu.click_option('recipients')
self.assertTrue(recipient_list.on())
# recipient_list.click_recipient(recip_1)
# self.assertTrue(recip_card.on())
# recip_card.remove_recipient()
# self.assertTrue(recipient_list.on())
# Delete non-Castillo/Ortega recipients
while recipient_list.edit_recipients(
['Sandy Cheeks', 'Castillo', 'Ortega']):
self.assertTrue(recip_card.on())
recip_card.remove_recipient()
self.assertTrue(recipient_list.on())
def test_duplicate(self):
""" test_send_to_bank.py:TestBank.test_duplicate """
eHome = self.cheeks.eHome_page
send_to_bank = self.cheeks.send_to_bank_page
recipient_list = self.cheeks.recipient_page
name_page = self.cheeks.recipient_name_page
bank_page = self.cheeks.bank_account_page
recip_card = self.cheeks.recipient_view_page
# Trying to add account for Jose should redirect to /add-account
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('bank')
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
send_to_bank.add_account()
self.assertTrue(recipient_list.on())
recipient_list.add_recipient()
self.assertTrue(name_page.on())
recip1 = "Jose Ortega"
name_page.enter_name(recip1)
self.assertTrue(name_page.on(True))
# Should only have option to add account or continue adding duplicate
self.assertIsNone(name_page.duplicate_send)
self.assertIsNotNone(name_page.duplicate_continue)
self.assertIsNotNone(name_page.duplicate_add)
self.assertIsNone(name_page.duplicate_view)
name_page.click_duplicate_add()
self.assertTrue(bank_page.on())
bank_page.header.click_back()
self.assertTrue(recipient_list.on())
recipient_list.header.click_back()
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
# Adding duplicate of Rosa should go to /add-account
send_to_bank.add_account()
self.assertTrue(recipient_list.on())
recipient_list.add_recipient()
self.assertTrue(name_page.on())
recip2 = "Rosa Castillo"
name_page.enter_name(recip2)
self.assertTrue(name_page.on(True))
name_page.click_duplicate_continue()
self.assertTrue(bank_page.on())
bank_page.header.click_back()
self.assertTrue(recipient_list.on())
# Delete duplicate
if main.is_desktop():
recipient_list.menu.click_option('recipients')
else:
recipient_list.header.click_back()
self.assertTrue(send_to_bank.on())
send_to_bank.header.click_back()
self.assertTrue(eHome.on())
eHome.menu.click_option('recipients')
self.assertTrue(recipient_list.on())
recipient_list.click_recipient(recip2)
self.assertTrue(recip_card.on())
recip_card.remove_recipient()
self.assertTrue(recipient_list.on())
def test_navigation(self):
""" test_send_to_bank.py:TestBank.test_navigation """
# Check back button and steps for all pages in send flow
eHome = self.cheeks.eHome_page
send_to_bank = self.cheeks.send_to_bank_page
td_page = self.cheeks.td_page
recip = 'David Castillo'
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('bank')
self.assertTrue(send_to_bank.on())
# SendToBank goes back to eHome
send_to_bank.header.click_back()
self.assertTrue(eHome.on('send'))
eHome.send('bank')
self.assertTrue(send_to_bank.on())
# Cannot skip ahead to steps 1 or 2
send_to_bank.set_step(1, reloadPage=False)
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
send_to_bank.set_step(2, reloadPage=False)
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
self.assertTrue(send_to_bank.click_account(recip, 0))
# Amount step: cannot go to step 3
send_to_bank.set_step(2, reloadPage=False)
self.assertTrue(send_to_bank.on([1, 'Specify Amount']))
# Can go forward to last 2 steps after setting amount and clicking continue
usd_amount = self.cheeks.generate_amount()
send_to_bank.send_form.set_usd(usd_amount)
send_to_bank.send_form.click_continue()
self.assertTrue(send_to_bank.on([2, 'Confirm & Send']))
send_to_bank.set_step(0)
send_to_bank.set_step(1)
self.assertEqual(usd_amount, send_to_bank.send_form.get_usd())
send_to_bank.set_step(2)
# check in different order
send_to_bank.set_step(0)
send_to_bank.set_step(2)
send_to_bank.set_step(1)
self.assertEqual(usd_amount, send_to_bank.send_form.get_usd())
# Go back to eHome.
send_to_bank.set_step(2)
send_to_bank.header.click_back()
self.assertTrue(send_to_bank.on([1, 'Specify Amount']))
send_to_bank.header.click_back()
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
send_to_bank.header.click_back()
# Shouldn't be able to skip ahead
self.assertTrue(eHome.on())
eHome.send('bank')
self.assertTrue(send_to_bank.on())
send_to_bank.set_step(1, reloadPage=False)
send_to_bank.set_step(2, reloadPage=False)
self.assertEqual([0, 'Choose Account'],
send_to_bank.stepper.get_current_step())
@unittest.skipIf(main.get_priority() < 2, "Priority = 2")
def test_no_balance(self):
""" test_send_to_bank.py:TestBank.test_no_balance """
# trying to send w/ no balance works as expected
lobby_page = self.nicol.lobby_page
eHome = self.nicol.eHome_page
send_to_bank = self.nicol.send_to_bank_page
recip = 'Lourdes Ortega'
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.set_role('employee')
self.assertTrue(eHome.on())
# menu should be closed on mobile
if not main.is_desktop():
self.assertFalse(eHome.menu.is_drawer_visible())
eHome.send('bank')
self.assertTrue(send_to_bank.on())
self.assertEqual([0, 'Choose Account'], send_to_bank.currentStep)
self.assertTrue(send_to_bank.click_account(recip, 'Wells Fargo Bank'))
# Step 2 - Set amount, check for balance error
self.assertEqual([1, 'Specify Amount'], send_to_bank.currentStep)
usd_amount = self.nicol.generate_amount()
self.assertFalse(send_to_bank.send_form.is_form_enabled())
self.assertTrue(send_to_bank.send_form.has_balance_error())
send_to_bank.send_form.set_usd(usd_amount)
self.assertTrue(send_to_bank.send_form.has_balance_error())
send_to_bank.send_form.try_clear_error()
self.assertFalse(send_to_bank.send_form.has_balance_error())
def test_refund_mx(self):
""" test_send_to_bank.py:TestBank.test_refund_mx """
# Send to Lourdes Ortega's MX bank account (bad clabe)
# STP test server puts non '846' clabes in refund state
eHome = self.cheeks.eHome_page
send_to_bank = self.cheeks.send_to_bank_page
td_page = self.cheeks.td_page
recip_card = self.cheeks.recipient_view_page
recipient = 'Lourdes Ortega'
bank_name = 'BBVA Bancomer'
usd_amount = self.cheeks.generate_amount()
fee = '1.00'
total = str(Decimal(usd_amount) + Decimal(fee))
# Login and select Lourdes Ortega
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('bank')
self.assertTrue(send_to_bank.on())
self.assertTrue(send_to_bank.click_account(recipient, bank_name))
send_to_bank.set_step('Choose Account')
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
self.assertTrue(send_to_bank.click_account(recipient, bank_name))
# send page is setup as expected
self.assertFalse(send_to_bank.send_form.is_form_enabled())
self.assertEqual("0", send_to_bank.send_form.get_usd())
balance = send_to_bank.send_form.get_balance()
self.assertNotEqual(None, send_to_bank.send_form.exchange_rate)
# send page: usd amount
send_to_bank.send_form.set_usd(usd_amount)
self.assertEqual(usd_amount, send_to_bank.send_form.get_usd())
send_to_bank.send_form.click_continue()
# disclosure page: name, amount, fee, total, exchange rate, disclosures
self.assertTrue(send_to_bank.on([2, 'Confirm & Send']))
self.assertEqual(recipient, send_to_bank.disclosure.get_name())
self.assertEqual(usd_amount,
send_to_bank.disclosure.get_transfer_amount())
self.assertEqual(fee, send_to_bank.disclosure.get_transfer_fee())
self.assertEqual(total, send_to_bank.disclosure.get_transfer_total())
self.assertNotEqual(None, send_to_bank.disclosure.get_exchange_rate())
self.assertFalse(send_to_bank.disclosure.has_d_30())
self.assertTrue(send_to_bank.disclosure.has_d_less())
self.assertTrue(send_to_bank.disclosure.has_d_notify())
# Send, confirmation dialog
send_to_bank.disclosure.click_continue()
self.assertTrue(eHome.on('activity'))
self.assertTrue(eHome.clear_confirmation_dialog())
self.assertTrue(eHome.on('activity'))
# HistoryEntry: sending, clock
data = eHome.get_transaction()
self.assertEqual(data['amount'], '-' + total)
self.assertEqual(data['recipient'], recipient)
self.assertEqual(data['icon'], 'clock')
self.assertEqual(data['status'], 'Sending')
# TransferDetails: sending, clock, actions.
eHome.click_transaction()
self.assertTrue(td_page.on())
self.assertEqual('clock', td_page.read_transaction_icon())
self.assertEqual(td_page.send_now_button, None)
self.assertEqual(td_page.cancel_button, None)
self.assertEqual(td_page.delay_disclosure, None)
# Should go into 'delayed' state soon (wait ~5 seconds)
time.sleep(4)
self.driver.refresh() # Works on native app?
self.assertTrue(td_page.on())
self.assertEqual('clock', td_page.read_transaction_icon())
self.assertEqual(td_page.send_now_button, None)
self.assertEqual(td_page.cancel_button, None)
raw_input('disclosure?')
self.assertNotEqual(td_page.delay_disclosure, None)
# Recipient link
td_page.click_recip_link()
self.assertTrue(recip_card.on())
recip_card.header.click_back()
self.assertTrue(td_page.on())
# TransferDetails: Cancel/Refund transfer:
td_page.refund_transaction('cancel')
self.assertTrue(td_page.on())
self.assertEqual('clock', td_page.read_transaction_icon())
self.assertEqual(td_page.send_now_button, None)
self.assertEqual(td_page.cancel_button, None)
self.assertNotEqual(td_page.delay_disclosure, None)
td_page.refund_transaction()
self.assertTrue(td_page.on())
self.assertEqual('x', td_page.read_transaction_icon())
self.assertEqual(td_page.send_now_button, None)
self.assertEqual(td_page.cancel_button, None)
self.assertEqual(td_page.delay_disclosure, None)
self.assertEqual(td_page.cancel_button, None)
td_page.click_continue()
# HistoryEntry: Canceled
# (Will be on send tab instead of activity because of refresh)
self.assertTrue(eHome.on('send'))
eHome.setTab('activity')
self.assertTrue(eHome.on('activity'))
data = eHome.get_transaction()
self.assertEqual(data['amount'], '-' + total)
self.assertEqual(data['recipient'], recipient)
self.assertEqual(data['icon'], 'x')
self.assertEqual(data['status'], 'Canceled')
def test_success_mx(self):
""" test_send_to_bank.py:TestBank.test_success_mx """
# Send to Lourdes Ortega's MX bank account
eHome = self.cheeks.eHome_page
send_to_bank = self.cheeks.send_to_bank_page
td_page = self.cheeks.td_page
recip_card = self.cheeks.recipient_view_page
recip = 'Lourdes Ortega'
bank_name = 'Sistema de Transferencias y Pagos STP'
usd_amount = self.cheeks.generate_amount()
fee = '1.00'
# Login and select Lourdes Ortega
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('bank')
self.assertTrue(send_to_bank.on())
self.assertTrue(send_to_bank.click_account(recip, 'BBVA Bancomer'))
send_to_bank.set_step('Choose Account')
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
self.assertTrue(send_to_bank.click_account(recip, 'BBVA Bancomer'))
# send page is setup as expected
self.assertFalse(send_to_bank.send_form.is_form_enabled())
self.assertEqual("0", send_to_bank.send_form.get_usd())
balance = send_to_bank.send_form.get_balance()
self.assertNotEqual(None, send_to_bank.send_form.exchange_rate)
# send page amounts work as expected
send_to_bank.send_form.set_usd(usd_amount)
self.assertEqual(usd_amount, send_to_bank.send_form.get_usd())
send_to_bank.send_form.click_continue()
# disclosure page: name, amount, fee, totals, exchange rate, disclosures
self.assertTrue(send_to_bank.on([2, 'Confirm & Send']))
self.assertEqual(recip, send_to_bank.disclosure.get_name())
self.assertEqual(usd_amount,
send_to_bank.disclosure.get_transfer_amount())
self.assertEqual(fee, send_to_bank.disclosure.get_transfer_fee())
total = str(Decimal(usd_amount) + Decimal(fee))
self.assertEqual(total, send_to_bank.disclosure.get_transfer_total())
self.assertNotEqual(None, send_to_bank.disclosure.get_exchange_rate())
self.assertFalse(send_to_bank.disclosure.has_d_30())
self.assertTrue(send_to_bank.disclosure.has_d_less())
self.assertTrue(send_to_bank.disclosure.has_d_notify())
# send, clear confirmation dialog
send_to_bank.disclosure.click_continue()
self.assertTrue(eHome.on('activity'))
self.assertTrue(eHome.clear_confirmation_dialog())
self.assertTrue(eHome.on('activity'))
# HistoryEntry: Sending, clock
data = eHome.get_transaction()
self.assertEqual(data['amount'], '-' + total)
self.assertEqual(data['recipient'], recip)
self.assertEqual(data['icon'], 'clock')
self.assertEqual(data['status'], 'Sending')
# TransferDetails: Clock, actions, recipient link, delay disclosure
eHome.click_transaction()
self.assertTrue(td_page.on())
self.assertEqual('clock', td_page.read_transaction_icon())
self.assertEqual(td_page.send_now_button, None)
self.assertEqual(td_page.cancel_button, None)
self.assertEqual(td_page.delay_disclosure, None)
td_page.click_recip_link()
self.assertTrue(recip_card.on())
recip_card.header.click_back()
self.assertTrue(td_page.on())
td_page.click_continue()
self.assertTrue(eHome.on('activity'))
def test_success_us(self):
""" test_send_to_bank.py:TestBank.test_success_us """
# Send to David Castillo's US bank account
eHome = self.cheeks.eHome_page
send_to_bank = self.cheeks.send_to_bank_page
td_page = self.cheeks.td_page
recip = 'David Castillo'
self.assertTrue(self.cheeks.login(self.driver), messages.login)
eHome.send('bank')
self.assertTrue(send_to_bank.on())
self.assertTrue(send_to_bank.click_account(recip, 'Wells Fargo Bank'))
send_to_bank.set_step('Choose Account')
self.assertTrue(send_to_bank.on([0, 'Choose Account']))
self.assertTrue(send_to_bank.click_account(recip, 'Zions Bank'))
# send page is setup as expected
self.assertFalse(send_to_bank.send_form.is_form_enabled())
self.assertEqual("0", send_to_bank.send_form.get_usd())
balance = send_to_bank.send_form.get_balance()
self.assertEqual(None, send_to_bank.send_form.exchange_rate)
# send page amounts work as expected
usd_amount = self.cheeks.generate_amount()
send_to_bank.send_form.set_usd(usd_amount)
self.assertEqual(usd_amount, send_to_bank.send_form.get_usd())
send_to_bank.send_form.click_continue()
# disclosure page has everything we expect
self.assertTrue(send_to_bank.on([2, 'Confirm & Send']))
# check name and totals
self.assertEqual(recip, send_to_bank.disclosure.get_name())
self.assertEqual(usd_amount,
send_to_bank.disclosure.get_transfer_amount())
fee = '0.00'
self.assertEqual(fee, send_to_bank.disclosure.get_transfer_fee())
total = Decimal(usd_amount) + Decimal(fee)
self.assertEqual(str(total),
send_to_bank.disclosure.get_transfer_total())
# check exchange rate and disclosures
self.assertEqual(None, send_to_bank.disclosure.get_exchange_rate())
self.assertFalse(send_to_bank.disclosure.has_d_30())
self.assertFalse(send_to_bank.disclosure.has_d_less())
self.assertTrue(send_to_bank.disclosure.has_d_notify())
# send, clear confirmation dialog
send_to_bank.disclosure.click_continue()
self.assertTrue(eHome.on('activity'))
self.assertTrue(eHome.clear_confirmation_dialog())
self.assertTrue(eHome.on('activity'))
# Check transaction
data = eHome.get_transaction()
self.assertEqual(data['amount'], '-' + usd_amount)
self.assertEqual(data['recipient'], recip)
self.assertEqual(data['icon'], 'clock')
self.assertEqual(data['status'], 'Arriving')
# check td page
eHome.click_transaction()
self.assertTrue(td_page.on())
self.assertEqual('clock', td_page.read_transaction_icon())
self.assertEqual(td_page.send_now_button, None)
self.assertEqual(td_page.cancel_button, None)
td_page.click_continue()
self.assertTrue(eHome.on('activity'))
recip_name = ["Rosa", "Castillo", ""]
name_page.enter_name(recip_name)
name_page.try_load_duplicates()
name_page.click_duplicate_send()
# should go to send form instead of address page
# self.assertTrue(address_page.on())
self.assertTrue(send_page.on())
# todo: need 2 no account tests.
# 1: recip has address, but no account
# 2: recip has no address and no account
# 3: us account??
@unittest.skipIf(main.get_priority() < 2, "Priority = 2")
class TestEdit(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.cheeks = profiles.Profile(self.driver, 'cheeks')
def tearDown(self):
self.driver.quit()
# @unittest.skip("Deprecated. Adding from 'send flows' added to bank and atm tests")
# def test_add_account_redirect(self):
# """recipients : Edit . add_account_redirect"""
# # Adding account from 'send flow' should redirect to send page
# # Yolanda should end test w/ no bank accounts
# eHome = self.cheeks.eHome_page
class TestRoleSwitching(unittest.TestCase):
def setUp(self):
self.driver = browser.start(main.get_env(), main.get_browser())
self.nicol = profiles.Profile(self.driver, 'nicol')
self.tester = profiles.Profile(self.driver, 'test')
# self.WDWait = WebDriverWait(self.driver, 10)
def tearDown(self):
self.driver.quit()
@unittest.skipIf(main.get_priority() < 2, "Priority = 2")
def test_landing_pages(self):
""" test_menu.py:TestRoleSwitching.test_landing_pages """
# Changing roles should land on expected pages
# Employer default: 'employee' page (should eventually get lobby page)
# Employee default: 'account' page
lobby_page = self.nicol.lobby_page
ps_page = self.nicol.ps_page
eHome = self.nicol.eHome_page
recip_page = self.nicol.recipient_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
# Go to 'employee' role
self.assertTrue(lobby_page.on())
lobby_page.menu.click_option('settings')
self.assertTrue(ps_page.on())
self.assertEqual('employer', ps_page.menu.get_role())
ps_page.menu.set_role('employee')
self.assertTrue(eHome.on())
#Desktop: Menu should maintain state
#Mobile: Menu should close after switching
if main.is_desktop():
self.assertEqual('open', eHome.menu.get_menu_status())
else:
self.assertEqual('closed', eHome.menu.get_menu_status())
# Go to 'employer' role
eHome.menu.click_option('recipients')
self.assertTrue(recip_page.on())
recip_page.menu.set_role('employer')
self.assertTrue(lobby_page.on())
if main.is_desktop():
self.assertEqual('open', lobby_page.menu.get_menu_status())
else:
self.assertEqual('closed', lobby_page.menu.get_menu_status())
# repeat steps w/ skinny nav
if main.is_desktop():
lobby_page.menu.toggle()
self.assertEqual('skinny', lobby_page.menu.get_menu_status())
lobby_page.menu.click_option('settings')
self.assertTrue(ps_page.on())
ps_page.menu.set_role('employee')
# menu should stay skinny
self.assertTrue(eHome.on())
self.assertEqual('skinny', eHome.menu.get_menu_status())
# go back to 'employer' role
eHome.menu.click_option('recipients')
self.assertTrue(recip_page.on())
self.assertEqual('skinny', recip_page.menu.get_menu_status())
recip_page.menu.set_role('employer')
self.assertTrue(lobby_page.on())
self.assertEqual('skinny', lobby_page.menu.get_menu_status())
@unittest.skipIf(main.get_priority() < 2, "Priority = 2")
def test_remembers_role(self):
""" test_menu.py:TestRoleSwitching.test_remembers_role """
# User profile defaults to employer role
lobby_page = self.nicol.lobby_page
emp_page = self.nicol.employee_page
eHome = self.nicol.eHome_page
recip_page = self.nicol.recipient_page
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
lobby_page.menu.set_role('employee')
self.assertTrue(eHome.on())
eHome.menu.sign_out()
# asserts remembers 'employee' role when logging back in
# self.nicol.login(self.driver)
# self.assertTrue(acct_page.on())
# # reset back to employer role
# acct_page.menu.set_role('employer')
# self.assertTrue(emp_page.on())
# not remembering role when logging out.
self.assertTrue(self.nicol.login(self.driver), messages.login)
self.assertTrue(lobby_page.on())
