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 set_speed_toggle(self, speed):
if self.get_speed_toggle() != speed:
if main.is_ios():
el = self.toggle.find_element_by_tag_name('input')
el.click()
else:
self.move_to_el(self.toggle)
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))
def get_el(self, name):
"""Return input element given name. None if invalid name"""
if name == 'business_name':
return self.business_name_input
elif name == 'dba':
return self.dba_input
elif name == 'ein':
return self.ein_input
elif name == 'hr_email':
return self.hr_email_input
elif name == 'line1':
return self.line1_input
elif name == 'line2':
return self.line2_input
elif name == 'city':
return self.city_input
elif name == 'postal_code':
return self.postal_code_input
elif name == 'phone':
return self.phone_input
elif name == 'website':
return self.website_input
elif name == 'state':
if main.is_ios(): # click doesn't regester on self.state_cont
return self.state_dd
return self.state_cont
else:
return None
def load_language_selector(self):
self.language_cont = (
self.form.find_element_by_class_name('settings_locale'))
if main.is_ios():
self.language_selector = (
self.language_cont.find_elements_by_tag_name('div')[3])
else:
self.language_selector = (
self.language_cont.find_element_by_tag_name('div'))
def type_country(self, country):
# probably won't work on mobile (keyboard not open)
el = self.location
if main.is_ios():
el = self.location.find_element_by_tag_name('button')
el.click()
AC(self.driver).send_keys(country).perform()
time.sleep(.4)
AC(self.driver).send_keys(Keys.ENTER).perform()
time.sleep(.4)
def enter_code(self):
self.code_input.clear()
self.code_input.send_keys(self.code)
if main.is_ios():
self.code_input.send_keys('')
if self.code_accepted():
self.continue_button.click()
else:
raise Exception("Took too long to validate login code")
def load(self):
try:
self.nav = NavigationFunctions(self.driver)
self.load_body()
self.header = header.PrivateHeader(self.driver)
self.menu = menu.SideMenu(self.driver)
if main.is_web() and main.is_ios():
self.clear_ios_footer()
return True
except (NoSuchElementException, StaleElementReferenceException) as e:
return False
def click_transaction(self, index=0):
# Possible to load page before transactions show up
if len(self.transactions) == 0:
raw_input("No Transactions found")
if main.is_ios():
el = self.transactions[index].find_elements_by_tag_name('div')[0]
el.click()
else:
self.transactions[index].click()
WDW(self.driver, 10).until(
EC.presence_of_element_located((By.ID, 'transfer_ok_button')))
def scroll_input_into_view(self):
# Mobile: scroll so input in view
if not main.is_desktop():
el_bottom = self.get_el_location(self.code_input, 'bottom')
window_height = self.get_window_height()
# add 48 for continue button. Extra for ios web footer
ios_footer = 0
if main.is_ios() and main.is_web():
ios_footer = 40
scroll_distance = el_bottom - window_height + 48 + ios_footer
self.move('down', scroll_distance)
def get(self, name):
"""Return the text of the element with the given name"""
el = self.get_el(name)
if el is not None:
if name == 'state':
# ignore text in label
if not main.is_ios(): # ios: el is already the child
el = el.find_elements_by_tag_name('div')[0]
return el.text
return el.get_attribute('value')
return None
def ios_scroll(self, direction, pixels):
"""Use TouchActions to scroll given amount up or down (ios)
Note: cannot use TA on android w/out switching to native context"""
if main.is_ios():
prefix = '-'
if direction.lower() == 'up':
prefix = ''
move_amount = int(prefix + str(pixels))
TA(self.driver).press(None, 10, 400).move_to(
None, 0, move_amount).release().perform()
time.sleep(.6)
def type_location(self, location):
self.location_input.clear()
self.location_input.send_keys(location)
if main.is_ios():
self.location_input.click()
# wait up to 5 seconds for options to show up
presence = EC.presence_of_all_elements_located
try:
self.options = WDW(self.driver, 10).until(
presence((By.CLASS_NAME, 'sm-place-menuitem')))
except TimeoutException:
self.options = None
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')
def click_employee(self, find_by, identifier):
emp = self.get_employee(find_by, identifier, False)
if emp is None:
print('no employee found')
return False
else:
if main.is_ios(): # ios needs to click a child div (not menu div)
emp = emp.find_elements_by_tag_name('div')[3]
#elif main.is_desktop():
# emp = emp.find_elements_by_tag_name('td')[1]
self.click_toast()
# move_to_el handles navigating to employee and clicking
self.move_to_el(emp) # emp.click()
time.sleep(.4)
return True
def enter_code(self):
self.scroll_input_into_view()
WDW(self.driver,
10).until(EC.presence_of_element_located((By.ID, 'code')))
self.code_input.clear()
self.code_input.send_keys(self.code)
if main.is_ios():
self.code_input.click()
# no continue button on native app
if main.is_web():
# Don't try and find primary button: Desktop has signin form
WDW(self.driver,
6).until(lambda x: self.is_enabled(self.continue_button))
self.continue_button.click()
def enter_code(self):
self.scroll_to_bottom()
self.code_input.clear()
self.code_input.send_keys(self.code)
if main.is_ios():
self.code_input.send_keys('')
# no continue button on native app
if main.is_web():
# WDW fails on Safari. Not sure why.
if main.get_browser() == 'safari':
time.sleep(1)
else:
WDW(self.driver, 10).until(
EC.element_to_be_clickable(
(By.CLASS_NAME, 'primaryButton')))
self.continue_button.click()
def click_recipient(self, identifier):
"""Given index or name of recipient, find and click 'send' or 'edit'
Can only edit on 'recipient select' page
"""
if type(identifier) is int:
recip = self.get_recipient_by_index(identifier)
else:
recip = self.get_recipient_by_name(identifier)
if recip != None:
# need to grab recip's first div for ios (one with cursor:pointer)
if main.is_ios():
recip = recip.find_elements_by_tag_name('div')[0]
self.move_to_el(recip)
# Not necessarily on next step. Handle reloading in test
else:
raw_input(str(identifier) + '?')
raise Exception("Error: could not find recipient: " + str(identifier))
def click_recipient(self, identifier, action='send'):
"""Given index or name of recipient, find and click 'send' or 'edit'
Can only edit on 'recipient select' page
"""
if action == 'edit':
self.edit_recipient(identifier)
else:
if type(identifier) is int:
recip = self.get_recipient_by_index(identifier)
else:
recip = self.get_recipient_by_name(identifier)
if recip != None:
# need to grab recip's first div for ios (one with cursor:pointer)
if main.is_ios():
recip = recip.find_elements_by_tag_name('div')[0]
self.move_to_el(recip)
else:
raise Exception("Error: could not find recipient: " +
identifier)
def load_recipients(self):
# Grab recipients and info for their bank accounts
self.recipUL = self.driver.find_elements_by_class_name('recipAccounts')
# Should have at least 1. Fail to load page if there aren't any
fail = self.recipUL[0]
self.recipients = {}
try:
for i, recip in enumerate(self.recipUL):
name = self.read_recip_name(i)
bank_accounts = self.recipUL[i].find_elements_by_tag_name('li')
del bank_accounts[0] # 1st li is header crap
# Bank name, account #, clickable element
accounts = []
for i, account in enumerate(bank_accounts):
divs = bank_accounts[i].find_elements_by_tag_name('div')
# Desktop web: divs[1]
# Mobile web: divs[0]
# Mobile native: ?
# for i, div in enumerate(divs):
# print(div.text)
if main.is_web():
text = divs[0].text
else:
text = divs[1].text
info = self.read_account_info(text)
if main.is_ios():
info['element'] = divs[0]
else:
info['element'] = bank_accounts[i]
accounts.append(info)
self.recipients[name] = accounts
except Exception as ex:
template = "An exception of type {0} occurred. Arguments:\n{1!r}"
message = template.format(type(ex).__name__, ex.args)
raw_input(message)
def set_input(self, element, value):
# iOS Native: Click after changing value (otherwise won't recognize new value)
# Get input/textarea el out of element
inputEl = self.find_input(element)
val = inputEl.get_attribute('value')
# Wait for input to be editable (displayed and enabled)
if inputEl:
setValue = False
count = 0
while not setValue and count < 5:
try:
if val:
self.clear_input(inputEl)
inputEl.send_keys(value)
if main.is_ios() and not main.is_web():
time.sleep(.4)
self.click_el(inputEl)
if inputEl.get_attribute('value') == value:
setValue = True
elif inputEl.get_attribute('value') == self.to_phone(
value):
# Check if input formatted value to phone#
setValue = True
else:
print('SetInput: Expected "' + value + '", loaded "' +
str(inputEl.get_attribute('value') + '"'))
except InvalidElementStateException:
print('SetInput: InvalidElementStateException')
if not setValue:
time.sleep(.2)
count += 1
else:
print('SetInput: Could not find inputEl.')
raise WebDriverException('SetInput: Could not find inputEl.')
def set_phone(self, phone):
self.phone_input.clear()
self.phone_input.send_keys(phone)
if main.is_ios():
self.phone_input.send_keys('')
def set_remove_code(self, code):
self.confirm_code_input.clear()
self.confirm_code_input.send_keys(code)
if main.is_ios(): # send_keys doesn't seem to update react component.
self.confirm_code_input.send_keys('')
def enter_code(self):
self.code_input.clear()
self.code_input.send_keys(self.code)
if main.is_ios():
self.code_input.send_keys('')
def set_clabe(self, clabe):
self.clabe_input.clear()
self.clabe_input.send_keys(clabe)
if main.is_ios():
self.clabe_input.send_keys('')
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 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
add_page = self.nicol.add_business_page
details_page = self.nicol.business_details_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.has_horizontal_scroll())
add_page.click_cant_find()
self.assertTrue(details_page.on())
self.assertFalse(details_page.has_horizontal_scroll())
# TODO assert ein input doesn't allow characters or symbols
details_page.set('ein', '556787898')
details_page.set('business_name', "Test Business")
details_page.set('line1', "2093 Main Street")
details_page.set('city', "Winslow")
details_page.set('state', "Arizona")
details_page.set('postal_code', "72561")
details_page.set('phone', "622-746-4454")
details_page.toggle_agree()
self.assertTrue(details_page.agreed())
invalid_emails = ['invalid', 'invalid@', 'invalid.com']
error = "Invalid email address"
tag = 'p'
for email in invalid_emails:
details_page.set('hr_email', email)
details_page.click_continue()
time.sleep(2)
self.assertEqual(
1, details_page.number_of_elements_containing(tag, error))
details_page.set('hr_email', '*****@*****.**')
details_page.set('postal_code', '123456789012345678901')
details_page.click_continue()
error = "Expected Zip Code format: 12345 or 12345-1234."
tag = 'p'
self.assertEqual(1, details_page.number_of_elements(tag, error))
details_page.set('postal_code', '98052')
self.assertEqual(0, details_page.number_of_elements(tag, error))
invalid_phones = ['1234567890', '801123456']
for phone in invalid_phones:
details_page.set('phone', phone)
details_page.click_continue()
error = " is not a valid phone number in US."
#print(details_page.driver.find_element_by_id('phone_cont').text)
#raw_input('did i get error text?')
#self.WDWait.until(lambda x: error in details_page.driver.find_element_by_id("phone_cont").text)
time.sleep(.5) # Hangs up on '801123456' error.
self.assertEqual(
1, details_page.number_of_elements_containing(tag, error))
def test_required_fields(self):
""" test_business.py:TestDetails.test_required_fields """
# assert 'Details' page inputs are required as expected
# start and end test w/ Nintendo as current business
lobby_page = self.boss.lobby_page
emp_page = self.boss.employee_page
add_page = self.boss.add_business_page
details_page = self.boss.business_details_page
settings_page = self.boss.business_settings_page
prefilled_page = self.boss.business_prefilled_page
eHome = self.boss.eHome_page
emp_page = self.boss.employee_page
default_business = 'Nintendo of Guatemala'
new_busName = 'Nintendo of the Multiverse'
self.assertTrue(self.boss.login(self.driver), messages.login)
try:
self.assertTrue(lobby_page.on())
except Exception: # Doesn't have business selected
self.assertTrue(eHome.on())
eHome.menu.set_role('employer')
self.assertTrue(lobby_page.on())
self.WDWait.until_not(
EC.presence_of_element_located((By.CLASS_NAME, 'animated')))
lobby_page.menu.add_a_business()
self.assertTrue(add_page.on())
add_page.click_cant_find()
self.assertTrue(details_page.on())
details_page.click_continue()
self.assertTrue(details_page.on())
tag = 'p'
error = 'Required'
error_count = details_page.number_of_elements
details_page.set('ein', '556787898')
details_page.set('hr_email', '')
details_page.click_continue()
# Won't find 'Required' error for Terms checkbox (in <div>, not <p>)
self.assertEqual(6, error_count(tag, error))
details_page.set('business_name', new_busName)
details_page.click_continue()
self.assertEqual(5, error_count(tag, error))
details_page.set('line1', '4600 150th Avenue Northeast')
details_page.click_continue()
self.assertEqual(4, error_count(tag, error))
details_page.set('city', 'Redmond')
details_page.click_continue()
self.assertEqual(3, error_count(tag, error))
details_page.set('state', 'Washington')
# Failed on next line because it thought state was 'Required'...
self.assertEqual('Washington', details_page.get('state'))
details_page.set('state', "Nevada")
self.assertEqual('Nevada', details_page.get('state'))
details_page.click_continue()
self.assertEqual(3, error_count(tag, error))
details_page.set('postal_code', '98052')
details_page.click_continue()
self.assertEqual(2, error_count(tag, error))
details_page.set('phone', '(425) 882-2040')
details_page.click_continue()
self.assertEqual(1, error_count(tag, error))
self.assertEqual(1, error_count('div', error))
details_page.toggle_agree()
self.assertTrue(details_page.agreed())
self.assertEqual(1, error_count(tag, error))
details_page.click_continue()
self.assertEqual(0, error_count('div', error))
details_page.set('hr_email', "*****@*****.**")
details_page.click_continue()
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())
self.WDWait.until_not(
EC.presence_of_element_located((By.CLASS_NAME, 'animated')))
# 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 set_account(self, number):
self.account_number.clear()
self.account_number.send_keys(number)
if main.is_ios():
self.account_number.click()
def set_email(self, email):
self.email_input.clear()
self.email_input.send_keys(email)
if main.is_ios():
self.email_input.send_keys('')
