def click_link(self, link_type='card', index=0):
"""link_type: 'card', or 'learn_more'. Index: 0, 1, 2"""
# card or learn more link?
if link_type.lower() == 'card':
l = self.cards
else:
l = self.learn_more
try:
el = l[int(index)]
except IndexError:
raise Exception('Invalid card index')
# make sure element is in view
if not main.is_desktop():
el_bottom = self.get_el_location(el, 'bottom')
window_height = self.get_window_height()
scroll_distance = el_bottom - window_height
self.move('down', scroll_distance)
# make sure menu is closed on desktop
if not main.is_desktop():
self.menu.close()
self.nav.click_el(el)
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())
def mark_all_as_processed(self):
# If any pending elections...
# select all and mark as processed
# Desktop: use mass command.
# Mobile: select each individually
if self.empty_msg is None:
if main.is_desktop() and not self.all_selected():
self.toggle_all()
elif not main.is_desktop() and not self.all_selected():
self.select_all_elections()
return self.mark_as_processed()
return True
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 try_clear_error(self):
if self.has_error():
# error not visible on mobile
if not main.is_desktop():
self.scroll_to_bottom()
self.nav.click_el(self.error_button)
time.sleep(.6)
def get_invitation_info(self, table_entry):
"""Given invitation entry parse out info"""
el_input = table_entry.find_element_by_tag_name('input')
if main.is_desktop():
# DESKTOP: get info out of each column
tds = table_entry.find_elements_by_tag_name('td')
info = {
'selected': el_input.is_selected(),
'name': tds[1].text,
'id': tds[2].text,
'phone': tds[3].text,
'email': tds[4].text,
'date': tds[5].text
}
else:
# MOBILE: get info out of each row
rows = table_entry.find_elements_by_class_name('table_entry_row')
info = {
'selected': el_input.is_selected(),
'name': rows[0].text[6:],
'id': rows[1].text[13:],
'phone': rows[2].text[14:],
'email': rows[3].text[7:],
'date': rows[4].text[14:]
}
# print(str(info))
return info
def load_agree_checkbox(self):
if main.is_desktop() and main.get_browser() == 'safari':
# Safari doesn't like clicking the input element
labels = self.driver.find_elements_by_tag_name('label')
self.agree_checkbox = labels[-1]
else:
self.agree_checkbox = self.form.find_element_by_id('agreed')
def get_election_info(self, table_entry):
"""Given election entry parse out info"""
el_input = table_entry.find_element_by_tag_name('input')
if main.is_desktop():
# DESKTOP: get info out of each column
tds = table_entry.find_elements_by_tag_name('td')
info = {
'selected': el_input.is_selected(),
'name': tds[1].text,
'id': tds[2].text,
'amount': tds[3].text,
'routing': tds[4].text,
'account': tds[5].text,
'time_requested': tds[6].text
}
else:
# MOBILE: get info out of each row
rows = table_entry.find_elements_by_class_name('table_entry_row')
info = {
'selected': el_input.is_selected(),
'name': rows[0].text[6:],
'id': rows[1].text[13:],
'amount': rows[2].text[18:],
'routing': rows[3].text[15:],
'account': rows[4].text[15:],
'time_requested': rows[5].text[11:],
}
# print(str(info))
return info
def get_table_entry(self, find_by, identifier):
# find_by: 'index' or name of column header
# identifier: index of election or string we try to match in col[find_by]
if self.empty_msg is None:
table_entry = None
if find_by == 'index':
return self.pending_elections[identifier]
elif main.is_desktop():
# Given find_by, get right column.
# Return entry w/ data in col that matches identifier
column_index = self.get_column_index(find_by)
for i, election in enumerate(self.pending_elections):
tds = election.find_elements_by_tag_name('td')
if tds[column_index].text == identifier:
table_entry = self.pending_elections[i]
else:
# Given find_by, get right row.
# Return entry w/ data in row that matches identifier
row_index = self.get_row_index(find_by)
for i, election in enumerate(self.pending_elections):
rows = election.find_elements_by_class_name(
'table_entry_row')
index = self.get_mobile_row_index(row_index)
if rows[row_index].text[index:].lower(
) == identifier.lower():
table_entry = self.pending_elections[i]
if table_entry is not None:
return table_entry
return None # no pending elections or couldn't find w/ given info
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 load(self):
self.cont = self.load_cont()
find_by = self.cont.find_element_by_id
# Todo: Load Logo, language dd
# ID nightmare...
# self.logo = find_by('public_logo_sm')
self.logo = find_by('public_logo')
# self.language_dd = find_by('locale_dropdown')
self.pre_signed_in = self.load_pre_sign_in()
# desktop only
if main.is_desktop():
# signin dropdown only on desktop when not signed in
# never on signin or signin/code
# Contents of dropdown do not exist when dropdown is closed
try:
self.sign_in_button = (
self.cont.find_element_by_id('signin_dropdown'))
except NoSuchElementException:
self.sign_in_button = None
# forgot pw form loads when 'forgot' link clicked
self.for_employers = self.load_employers_link()
self.for_employees = self.load_employees_link()
# mobile web only
self.hamburger = self.try_load_hamburger()
def set_sort(self, index, direction=True):
# open sort options if not visible (always vis on desktop)
# Index: 0=name, 1=ID, 2=Status, 3=election 4=date changed
if not main.is_desktop() and not self.filters_open():
self.toggle_filter()
cur_sort = self.get_sort()
old_first_emp = self.get_first_emp()
#first_emp = self.get_employee('index', 0)
if cur_sort[0] != int(index) or cur_sort[1] != direction:
if cur_sort[0] != int(index):
self.click_sort(index)
cur_sort = self.get_sort()
if cur_sort[1] != direction:
self.reverse_sort(cur_sort[0])
#raw_input('waiting on...?')
#giving time for page to update. WDW until old_first_el != first_el and first_el is not None?
time.sleep(2)
'''WDW(self.driver, 10).until(lambda x:
EC.presence_of_element_located((By.TAG_NAME , 'tr')) or
EC.visibility_of_element_located((By.CLASS_NAME ,'employeeDiv'))
)'''
# lambda x : old_first_emp != self.get_first_emp() and self.get_first_emp() is not None
# )
self.load()
def set_mxn(self, amount):
# clear current amount and enter given amount
self.clear_currency_input('mxn')
if main.is_desktop():
self.mxn_input.send_keys(str(amount))
# self.mxn_div.send_keys(amount)
else:
self.enter_currency(amount)
def load_form(self):
# on desktop ignore 'sign in' dropdown form
if main.is_desktop():
# Sign In dropdown probably only exists when it's displayed.
# Probably need to check how many forms there are
print('got 2nd form')
return self.driver.find_elements_by_tag_name('form')[-1]
return self.driver.find_element_by_tag_name('form')
def click_for_employees(self):
if main.is_desktop():
if self.for_employees != None:
self.for_employees.click()
WDW(self.driver, 10).until(
EC.presence_of_element_located((By.ID, 'contactEmail2')))
else:
self.select_action('employees')
def click_logo(self):
"""click visible header logo"""
logo = self.logo
if main.is_desktop() and not self.logo.is_displayed():
# scrolled to top on desktop and we need to load other logo
logo = self.cont.find_element_by_id('public_logo')
self.nav.click_el(logo)
def click_invitation(self, find_by, identifier):
invitation = self.get_table_entry(find_by, identifier)
if(main.is_desktop() is False):
row = invitation.find_element_by_class_name('table_entry_row')
else:
row = invitation.find_elements_by_tag_name('td')[1]
self.move_to_el(row)
def open(self):
"""Mobile: make sure drawer is 'open'"""
# desktop: make sure menu is 'open'
if not main.is_desktop() and not self.is_drawer_visible():
self.hamburger.click()
WDW(self.driver, 2).until(
EC.element_to_be_clickable((By.CLASS_NAME, 'drawer_profile')))
# WDW(self.driver, 2).until(
# EC.element_to_be_clickable((By.CLASS_NAME, 'drawer_support')))
self.load(hamburger=False, loading_page=False)
# make sure menu starts at top
self.driver.execute_script("window.scrollTo(0, 0)")
time.sleep(.4)
elif main.is_desktop() and self.get_menu_status() == 'skinny':
self.toggle()
WDW(self.driver, 10).until(lambda x: self.get_menu_status() != 'skinny')
self.load(hamburger=False, loading_page=False)
def click_admin(self, name):
admin = self.get_admin(name, False)
if admin is not None:
#Must click text on mobile. Extend hitbox to left edge?
if not main.is_desktop():
admin = admin.find_elements_by_class_name('table_entry_row')[0]
self.move_to_el(admin)
else:
print('could not find admin with name: ' + name)
def try_load_toggle(self):
"""Should only have menu toggle on desktop"""
if main.is_desktop():
try:
return self.driver.find_element_by_class_name('mini-button')
except NoSuchElementException:
return None
else:
return None
def set_election(self, employer, amount):
employer_row = self.get_employer_row(employer)
if employer_row is not None:
self.clear_pay_election(employer_row)
# should still be focused
if main.is_desktop():
AC(self.driver).send_keys(amount).perform()
else:
self.enter_currency(amount)
def clear_pay_election(self, employer_row):
# set focus and clear out existing election for given employer row el
self.set_focus_on_employer(employer_row)
amount = self.get_election_amount(employer_row)
# desktop: hit backspace until input clear
if main.is_desktop():
for i in xrange(len(amount)):
AC(self.driver).send_keys(Keys.BACKSPACE).perform()
else: # Mobile: hit backspace on custom keyboard
self.clear_currency(amount)
def get_admin_el(self, admin, col_index):
try:
if main.is_desktop():
el = admin.find_elements_by_tag_name('td')[col_index]
else:
el = admin.find_elements_by_class_name(
'table_entry_row')[col_index]
return el
except (NoSuchElementException, IndexError) as e:
return None
def sign_in_open(self):
# is signin dropdown open?
if main.is_desktop() and self.sign_in_button:
try:
el = self.driver.find_element_by_id('forgot_password')
if el.is_displayed():
return True
except NoSuchElementException:
pass
return False
def try_load_elections(self):
try:
if main.is_desktop():
self.table = self.driver.find_element_by_tag_name('table')
self.table_body = self.table.find_element_by_tag_name('tbody')
return self.table_body.find_elements_by_tag_name('tr')
else:
return self.driver.find_elements_by_class_name('table_entry')
except NoSuchElementException:
return None
def sign_in_submit(self, email='', password='', submit=True):
# No sign in dropdown on mobile
if main.is_desktop():
# Make sure dropdown is visible (won't have dropdown on signin page)
if self.sign_in_button:
if not self.sign_in_open():
self.nav.click_el(self.sign_in_button)
self.signInForm = SignInForm(self.driver)
WDW(self.driver, 10).until(lambda x: self.signInForm.load())
self.signInForm.submit(email, password, submit)
def forgot_password_open(self):
# Is forgot password form visible?
if main.is_desktop() and self.sign_in_button:
try:
resetPWform = self.driver.find_element_by_class_name(
'resetPWForm')
if resetPWform.is_displayed():
return True
except NoSuchElementException:
pass
return False
def click_plus(self):
self.add_button.click()
time.sleep(.4)
try:
find_by = self.driver.find_element_by_id
self.add_employee_button = find_by('add_employee')
# only has multiple employees option on desktop
if main.is_desktop():
self.add_multiple_employees = find_by('add_employees')
except NoSuchElementException:
fail = 1 + '2'
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 move_picker(self, direction):
if main.is_desktop():
if direction == 'down':
self.pickerDown.click()
else:
self.pickerUp.click()
else:
if direction == 'down':
self.pickerOptions[self.get_picker_index() + 2].click()
else:
self.pickerOptions[self.get_picker_index() - 2].click()
