def test_twilio_delete_flow(self, live_server, browser_in, users, smsin,
smsout, driver_wait_time):
"""Test good form submission."""
b = load_page(browser_in, driver_wait_time, live_server + NEW_URI)
n_in = models.SmsInbound.objects.count()
n_out = models.SmsOutbound.objects.count()
sleep(driver_wait_time * 3)
click_and_wait(b.find_element_by_id(f'incoming_sms{smsin["sms1"].pk}'),
driver_wait_time)
click_and_wait(
b.find_element_by_id(f'outgoing_sms{smsout["smsout"].pk}'),
driver_wait_time)
click_and_wait(b.find_element_by_id("deleteButton"), driver_wait_time)
click_and_wait(b.find_element_by_id("confirmButton"), driver_wait_time)
b.find_element_by_id("confirmDeleteInput").send_keys(
"I understand this cannot be undone")
click_and_wait(b.find_element_by_id("finalConfirmButton"),
driver_wait_time)
def _test():
assert "Messages successfully queued for deletion." in b.page_source
assert n_in - 1 == models.SmsInbound.objects.count()
assert n_out - 1 == models.SmsOutbound.objects.count()
assert_with_timeout(_test, 10 * driver_wait_time)
def test_archive_all(self, uri, query_set, live_server, browser_in,
keywords, recipients, groups, smsin,
driver_wait_time):
"""Test archive item buttons."""
# load page
browser_in.get(live_server + uri)
assert uri in browser_in.current_url
# check table is there
sleep(driver_wait_time)
tables = browser_in.find_elements_by_xpath('//table')
assert len(tables) == 1
table = tables[0]
assert 'Archive' in table.text
# toggle a permission
toggle_buttons = browser_in.find_elements_by_id('archiveItemButton')
num_buttons = len(toggle_buttons)
while num_buttons > 0:
click_and_wait(toggle_buttons[0], driver_wait_time)
toggle_buttons = browser_in.find_elements_by_id(
'archiveItemButton')
assert num_buttons - 1 == len(toggle_buttons)
num_buttons = len(toggle_buttons)
for obj in query_set:
assert obj.is_archived
def test_fetch_groups(self, uri, live_server, browser_in, driver_wait_time):
"Test fetch group button." ""
# fetch groups
browser_in.get(live_server + uri)
fetch_button = browser_in.find_element_by_id('fetch_button')
click_and_wait(fetch_button, driver_wait_time)
check_and_close_msg(browser_in, driver_wait_time)
def add_recipient(b, wt):
for x in b.find_elements_by_id('contactItem'):
if x.text == 'John Calvin':
recipient = x
break
click_and_wait(recipient, wt)
return b
def test_api_setup(self, live_server, browser_in, users, driver_wait_time):
"""Test api-setup form."""
no_api_token_txt = 'No API Token'
gen_button_path = '//*[@id="elmContainer"]/div/div[3]/div/div/p/div[2]/button[1]'
del_button_path = '//*[@id="elmContainer"]/div/div[3]/div/div/p/div[2]/button[2]'
b = browser_in
browser_in.get(live_server + URI)
# show key
show_button = b.find_elements_by_xpath(
'//*[@id="elmContainer"]/div/div[3]/div/div/button')[0]
click_and_wait(show_button, driver_wait_time)
# delete token that doesn't exist
del_button = b.find_elements_by_xpath(del_button_path)[0]
click_and_wait(del_button, driver_wait_time)
assert no_api_token_txt in b.page_source
# generate token for first time
regen_button = b.find_elements_by_xpath(gen_button_path)[0]
click_and_wait(regen_button, driver_wait_time)
assert no_api_token_txt not in b.page_source
# regenerate token
regen_button = b.find_elements_by_xpath(gen_button_path)[0]
click_and_wait(regen_button, driver_wait_time)
assert no_api_token_txt not in b.page_source
# delete token
del_button = b.find_elements_by_xpath(del_button_path)[0]
click_and_wait(del_button, driver_wait_time)
assert no_api_token_txt in b.page_source
def test_display_on_wall_toggle(self, live_server, browser_in, smsin, driver_wait_time):
"""Test display on wall buttons."""
sms = models.SmsInbound.objects.get(sid=smsin['sms1'].sid)
sms.display_on_wall = False
uri = '/incoming/curate_wall/'
browser_in.get(live_server + uri)
sleep(driver_wait_time)
tables = browser_in.find_elements_by_tag_name('table')
assert len(tables) == 1
table = tables[0]
assert 'Hidden' in table.text
hidden_buttons = browser_in.find_elements_by_class_name('button-danger')
num_buttons = len(hidden_buttons)
while num_buttons > 0:
click_and_wait(hidden_buttons[0], driver_wait_time)
hidden_buttons = browser_in.find_elements_by_class_name('button-danger')
assert num_buttons - 1 == len(hidden_buttons)
num_buttons = len(hidden_buttons)
sleep(driver_wait_time)
sms.refresh_from_db()
assert sms.display_on_wall
displaying_buttons = browser_in.find_elements_by_class_name('button-success')
num_buttons = len(displaying_buttons)
while len(displaying_buttons) > 0:
click_and_wait(displaying_buttons[0], driver_wait_time)
displaying_buttons = browser_in.find_elements_by_class_name('button-success')
assert num_buttons - 1 == len(displaying_buttons)
num_buttons = len(displaying_buttons)
sleep(driver_wait_time)
sms.refresh_from_db()
assert sms.display_on_wall is False
def test_display_on_wall_toggle(self, live_server, browser_in, smsin, driver_wait_time):
"""Test display on wall buttons."""
sms = models.SmsInbound.objects.get(sid=smsin['sms1'].sid)
sms.display_on_wall = False
uri = '/incoming/curate_wall/'
browser_in.get(live_server + uri)
sleep(driver_wait_time)
tables = browser_in.find_elements_by_class_name('table')
assert len(tables) == 1
table = tables[0]
assert 'Hidden' in table.text
hidden_buttons = browser_in.find_elements_by_class_name('red')
num_buttons = len(hidden_buttons)
while num_buttons > 0:
click_and_wait(hidden_buttons[0], driver_wait_time)
hidden_buttons = browser_in.find_elements_by_class_name('red')
assert num_buttons - 1 == len(hidden_buttons)
num_buttons = len(hidden_buttons)
sleep(driver_wait_time)
sms.refresh_from_db()
assert sms.display_on_wall
displaying_buttons = browser_in.find_elements_by_class_name('green')
num_buttons = len(displaying_buttons)
while len(displaying_buttons) > 0:
click_and_wait(displaying_buttons[0], driver_wait_time)
displaying_buttons = browser_in.find_elements_by_class_name('green')
assert num_buttons - 1 == len(displaying_buttons)
num_buttons = len(displaying_buttons)
sleep(driver_wait_time)
sms.refresh_from_db()
assert sms.display_on_wall is False
def add_recipient(b, wt):
for x in b.find_elements_by_xpath(
'//*[@id="elmContainer"]/div/div[3]/div/div/div/form/div[2]/div/div[2]/div'
):
if x.text == 'John Calvin':
recipient = x
break
click_and_wait(recipient, wt)
return b
def test_unarchive_keyword(self, live_server, browser_in, keywords, driver_wait_time):
"""Test restore from archive button."""
k = models.Keyword.objects.get(keyword='test')
k.is_archived = True
k.save()
browser_in.get(live_server + '/keyword/edit/test/')
sleep(driver_wait_time)
button = browser_in.find_element_by_id('restoreItemButton')
click_and_wait(button, driver_wait_time)
assert 'all' in browser_in.current_url
k.refresh_from_db()
assert k.is_archived is False
def test_unarchive_keyword(self, live_server, browser_in, keywords,
driver_wait_time):
"""Test restore from archive button."""
k = models.Keyword.objects.get(keyword='test')
k.is_archived = True
k.save()
browser_in.get(live_server + '/keyword/edit/test/')
sleep(driver_wait_time)
button = browser_in.find_element_by_id('restoreItemButton')
click_and_wait(button, driver_wait_time)
assert 'all' in browser_in.current_url
k.refresh_from_db()
assert k.is_archived is False
def test_unarchive_keyword(self, live_server, browser_in, keywords, driver_wait_time):
"""Test restore from archive button."""
k = models.Keyword.objects.get(keyword='test')
k.is_archived = True
k.save()
uri = k.get_absolute_url
browser_in.get(live_server + uri)
sleep(driver_wait_time)
wrench = browser_in.find_elements_by_class_name('wrench')[0]
click_and_wait(wrench, driver_wait_time)
button = browser_in.find_elements_by_class_name('positive')[0]
click_and_wait(button, driver_wait_time)
assert 'all' in browser_in.current_url
k.refresh_from_db()
assert k.is_archived is False
def test_archive_without_permission(self, live_server, browser_in, recipients, driver_wait_time):
# remove priveleges:
u = User.objects.get(username='******')
u.is_staff = False
u.is_superuser = False
u.save()
p = u.profile
p.can_archive = False
p.save()
# open page:
uri = '/recipient/all/'
browser_in.get(live_server + uri)
assert uri in browser_in.current_url
sleep(driver_wait_time)
# archive (should fail and show a popup):
toggle_buttons = browser_in.find_elements_by_class_name('grey')
click_and_wait(toggle_buttons[0], driver_wait_time)
check_and_close_msg(browser_in, driver_wait_time)
def test_archive_without_permission(self, live_server, browser_in, recipients, driver_wait_time):
# remove priveleges:
u = User.objects.get(username='******')
u.is_staff = False
u.is_superuser = False
u.save()
p = u.profile
p.can_archive = False
p.save()
# open page:
uri = '/recipient/all/'
browser_in.get(live_server + uri)
assert uri in browser_in.current_url
sleep(driver_wait_time)
# archive (should fail and show a popup):
toggle_buttons = browser_in.find_elements_by_id('archiveItemButton')
click_and_wait(toggle_buttons[0], driver_wait_time)
check_and_close_msg(browser_in, driver_wait_time)
def test_prepopulated(self, live_server, browser_in, users, driver_wait_time, recipients, smsin):
"""Test the reply to button on incoming log."""
# load the incoming log
b = load_page(browser_in, driver_wait_time, live_server + LOG_URI)
# check reply buttons are present
reply_buttons = b.find_elements_by_class_name('fa-reply')
assert len(reply_buttons) == len(smsin)
# test button works
click_and_wait(reply_buttons[0], driver_wait_time)
assert '/send/adhoc/' in browser_in.current_url
assert 'recipients=[' in browser_in.current_url
# check message sent to correct recipient
b = add_content(b, driver_wait_time)
b = click_send(b, driver_wait_time)
assert 'Please check the logs for verification' in b.page_source
assert '/outgoing/' in b.current_url
last_out_sms = SmsOutbound.objects.all()[0]
assert last_out_sms.recipient.pk == recipients['calvin'].pk
def test_email_form(self, live_server, browser, driver_wait_time):
browser.get(live_server + URI)
assert URI in browser.current_url
sleep(driver_wait_time)
email_input_box = browser.find_elements_by_id('email_to')[0]
email_input_box.clear()
for k in '*****@*****.**':
email_input_box.send_keys(k)
body_input_box = browser.find_elements_by_id('email_body')[0]
body_input_box.clear()
for k in 'test message':
body_input_box.send_keys(k)
submit_button = browser.find_elements_by_id('email_send_button')[0]
click_and_wait(submit_button, driver_wait_time)
assert len(mail.outbox) == 1
assert 'test message' in mail.outbox[0].body
def test_sms_form(self, live_server, browser, driver_wait_time,
recipients):
browser.get(live_server + URI)
assert URI in browser.current_url
sleep(driver_wait_time)
to_input_box = browser.find_elements_by_id('sms_to')[0]
to_input_box.clear()
to_input_box.send_keys(str(recipients['calvin'].number))
body_input_box = browser.find_elements_by_id('sms_body')[0]
body_input_box.clear()
body_input_box.send_keys('test')
submit_button = browser.find_elements_by_id('sms_send_button')[0]
click_and_wait(submit_button, driver_wait_time)
assert 'AC00000000000000000000000000000000' in browser.page_source
assert 'Error:' in browser.page_source
assert 'Twilio returned the following information:'
def test_cancel_sms(self, live_server, browser_in, recipients, groups,
driver_wait_time):
"""Test the scheduled messages table."""
# create a couple of scheduled sms
models.QueuedSms.objects.create(recipient=recipients['calvin'],
content="test message",
recipient_group=None,
sent_by="admin",
time_to_send=timezone.make_aware(
datetime.strptime(
'Jun 1 2400 1:33PM',
'%b %d %Y %I:%M%p'),
timezone.get_current_timezone()))
models.QueuedSms.objects.create(recipient=recipients['calvin'],
content="another test message",
recipient_group=groups['test_group'],
sent_by="admin",
time_to_send=timezone.make_aware(
datetime.strptime(
'Jun 1 2400 1:33PM',
'%b %d %Y %I:%M%p'),
timezone.get_current_timezone()))
# verify tasks are shown in table
uri = '/scheduled/sms/'
browser_in.get(live_server + uri)
assert uri in browser_in.current_url
sleep(driver_wait_time)
assert 'test message' in browser_in.page_source
assert 'another test message' in browser_in.page_source
assert 'Calvin' in browser_in.page_source
# delete tasks
cancel_buttons = browser_in.find_elements_by_id('cancelSmsButton')
num_buttons = len(cancel_buttons)
while num_buttons > 0:
click_and_wait(cancel_buttons[0], driver_wait_time)
cancel_buttons = browser_in.find_elements_by_id('cancelSmsButton')
assert num_buttons - 1 == len(cancel_buttons)
num_buttons = len(cancel_buttons)
assert 'test message' not in browser_in.page_source
assert 'another test message' not in browser_in.page_source
assert 'Calvin' not in browser_in.page_source
assert models.QueuedSms.objects.all().count() == 0
def test_pull_groups(self, uri, live_server, browser_in, driver_wait_time):
"""Test toggle syncing of a group and then pull groups."""
# load groups
ElvantoGroup.fetch_all_groups()
# load page
browser_in.get(live_server + uri)
assert uri in browser_in.current_url
# enable a group
sleep(driver_wait_time)
group_button = browser_in.find_element_by_id('elvantoGroupButton')
click_and_wait(group_button, driver_wait_time)
table = browser_in.find_elements_by_xpath('//table')[0]
assert 'Syncing' in table.text
# pull groups
browser_in.get(live_server + uri)
assert uri in browser_in.current_url
sleep(driver_wait_time)
pull_button = browser_in.find_elements_by_id('pull_button')[0]
pull_button.click()
check_and_close_msg(browser_in, driver_wait_time)
def test_cancel_sms(self, live_server, browser_in, recipients, groups, driver_wait_time):
"""Test the scheduled messages table."""
# create a couple of scheduled sms
models.QueuedSms.objects.create(
recipient=recipients['calvin'],
content="test message",
recipient_group=None,
sent_by="admin",
time_to_send=timezone.make_aware(
datetime.strptime('Jun 1 2400 1:33PM', '%b %d %Y %I:%M%p'), timezone.get_current_timezone()
)
)
models.QueuedSms.objects.create(
recipient=recipients['calvin'],
content="another test message",
recipient_group=groups['test_group'],
sent_by="admin",
time_to_send=timezone.make_aware(
datetime.strptime('Jun 1 2400 1:33PM', '%b %d %Y %I:%M%p'), timezone.get_current_timezone()
)
)
# verify tasks are shown in table
uri = '/scheduled/sms/'
browser_in.get(live_server + uri)
assert uri in browser_in.current_url
sleep(driver_wait_time)
assert 'test message' in browser_in.page_source
assert 'another test message' in browser_in.page_source
assert 'Calvin' in browser_in.page_source
# delete tasks
cancel_buttons = browser_in.find_elements_by_id('cancelSmsButton')
num_buttons = len(cancel_buttons)
while num_buttons > 0:
click_and_wait(cancel_buttons[0], driver_wait_time)
cancel_buttons = browser_in.find_elements_by_id('cancelSmsButton')
assert num_buttons - 1 == len(cancel_buttons)
num_buttons = len(cancel_buttons)
assert 'test message' not in browser_in.page_source
assert 'another test message' not in browser_in.page_source
assert 'Calvin' not in browser_in.page_source
assert models.QueuedSms.objects.all().count() == 0
def test_group_membership_buttons(self, live_server, browser_in, recipients, groups, driver_wait_time):
"""Test editing group membership."""
non_member_id = 'nonmembers_item'
member_id = 'members_item'
grp = groups['empty_group']
browser_in.get(live_server + '/group/edit/' + str(grp.pk) + '/')
# check all recipient are displayed
cards = browser_in.find_elements_by_id(non_member_id)
assert len(cards) == models.Recipient.objects.filter(is_archived=False).count()
# move all recipients into membership
while len(cards) > 0:
click_and_wait(cards[0], driver_wait_time)
cards = browser_in.find_elements_by_id(non_member_id)
assert grp.all_recipients.count() == models.Recipient.objects.filter(is_archived=False).count()
# remove them again:
cards = browser_in.find_elements_by_id(member_id)
while len(cards) > 0:
click_and_wait(cards[0], driver_wait_time)
cards = browser_in.find_elements_by_id(member_id)
sleep(driver_wait_time)
assert grp.all_recipients.count() == 0
def test_log_in(self, live_server, browser, driver_wait_time, users):
# login
browser.get(live_server + URI)
email_box = browser.find_elements_by_name('login')[0]
email_box.send_keys(users['staff'].email)
password_box = browser.find_elements_by_name('password')[0]
password_box.send_keys('top_secret')
login_button = browser.find_element_by_id('login_button')
click_and_wait(login_button, 5 * driver_wait_time)
# check we have been redirected
assert 'accounts' not in browser.current_url
# log out again
browser.get(live_server + '/accounts/logout/')
logout_confirm = browser.find_element_by_id('logout_button')
click_and_wait(logout_confirm, driver_wait_time)
def _test():
assert 'accounts/login' in browser.current_url
assert_with_timeout(_test, 10 * driver_wait_time)
def test_group_membership_buttons(self, live_server, browser_in, recipients, groups, driver_wait_time):
"""Test editing group membership."""
non_member_id = "nonmembers_item"
member_id = "members_item"
grp = groups["empty_group"]
browser_in.get(live_server + "/group/edit/" + str(grp.pk) + "/")
# check all recipient are displayed
cards = browser_in.find_elements_by_id(non_member_id)
assert len(cards) == models.Recipient.objects.filter(is_archived=False).count()
# move all recipients into membership
while len(cards) > 0:
click_and_wait(cards[0], driver_wait_time)
cards = browser_in.find_elements_by_id(non_member_id)
assert grp.all_recipients.count() == models.Recipient.objects.filter(is_archived=False).count()
# remove them again:
cards = browser_in.find_elements_by_id(member_id)
while len(cards) > 0:
click_and_wait(cards[0], driver_wait_time)
cards = browser_in.find_elements_by_id(member_id)
sleep(driver_wait_time)
assert grp.all_recipients.count() == 0
def test_user_form(self, live_server, browser, driver_wait_time):
browser.get(live_server + URI)
assert URI in browser.current_url
sleep(driver_wait_time)
email_input_box = browser.find_elements_by_id('admin_email')[0]
email_input_box.clear()
email_input_box.send_keys('*****@*****.**')
pass1_input_box = browser.find_elements_by_id('admin_pass1')[0]
pass1_input_box.clear()
pass1_input_box.send_keys('password')
pass2_input_box = browser.find_elements_by_id('admin_pass2')[0]
pass2_input_box.clear()
pass2_input_box.send_keys('password')
submit_button = browser.find_elements_by_id('create_admin_button')[0]
click_and_wait(submit_button, driver_wait_time)
assert User.objects.count() == 1
browser.get(live_server + URI)
assert URI not in browser.current_url
def test_pull_groups(self, uri, live_server, browser_in, driver_wait_time):
"""Test toggle syncing of a group and then pull groups."""
# load groups
ElvantoGroup.fetch_all_groups()
# load page
browser_in.get(live_server + uri)
assert uri in browser_in.current_url
# enable a group
sleep(driver_wait_time)
group_button = browser_in.find_elements_by_xpath(
'//*[@id="elmContainer"]/div/div[3]/div/div/div[2]/table/tbody/tr[1]/td[3]/a'
)[0]
click_and_wait(group_button, driver_wait_time)
table = browser_in.find_elements_by_class_name('table')[0]
assert 'Syncing' in table.text
# pull groups
browser_in.get(live_server + uri)
assert uri in browser_in.current_url
sleep(driver_wait_time)
pull_button = browser_in.find_elements_by_id('pull_button')[0]
pull_button.click()
check_and_close_msg(browser_in, driver_wait_time)
def test_sign_up(self, live_server, browser, driver_wait_time, users):
"""
Tests the sign up form and checks that the appropriate emails
have been sent afterwards.
"""
# add an office email to test correct email is sent on sign up
config = SiteConfiguration.get_solo()
config.office_email = '*****@*****.**'
config.save()
# signup
uri = '/accounts/signup/'
browser.get(live_server + uri)
email_box = browser.find_elements_by_name('email')[0]
email_box.send_keys('*****@*****.**')
password_box1 = browser.find_elements_by_name('password1')[0]
password_box1.send_keys('top_secret')
password_box2 = browser.find_elements_by_name('password2')[0]
password_box2.send_keys('top_secret')
login_button = browser.find_elements_by_xpath('html/body/div/div/form/button')[0]
click_and_wait(login_button, driver_wait_time)
def _test():
assert '/accounts/confirm-email/' in browser.current_url
assert len(mail.outbox) == 2
assert '[apostello] New User' in mail.outbox[0].subject
assert_with_timeout(_test, 10 * driver_wait_time)
# when we have no office email set
assert 'Please Confirm Your E-mail Address' in mail.outbox[1].subject
for x in mail.outbox[1].body.split():
if x.startswith('http'):
confirm_url = x
browser.get(confirm_url)
confirm_button = browser.find_element_by_class_name('button')
confirm_button.click()
user = User.objects.get(email='*****@*****.**')
assert not user.is_staff
assert not user.is_superuser
def test_group_membership_buttons(self, live_server, browser_in,
recipients, groups, driver_wait_time):
"""Test editing group membership."""
non_member_xpath = '//*[@id="elmContainer"]/div[1]/div[3]/div/div/div/div/div[1]/div/div[2]/div/div'
member_xpath = '//*[@id="elmContainer"]/div[1]/div[3]/div/div/div/div/div[2]/div/div[2]/div/div'
grp = groups['empty_group']
browser_in.get(live_server + grp.get_absolute_url)
# check all recipient are displayed
cards = browser_in.find_elements_by_xpath(non_member_xpath)
assert len(cards) == models.Recipient.objects.filter(
is_archived=False).count()
# move all recipients into membership
while len(cards) > 0:
click_and_wait(cards[0], driver_wait_time)
cards = browser_in.find_elements_by_xpath(non_member_xpath)
assert grp.all_recipients.count() == models.Recipient.objects.filter(
is_archived=False).count()
# remove them again:
cards = browser_in.find_elements_by_xpath(member_xpath)
while len(cards) > 0:
click_and_wait(cards[0], driver_wait_time)
cards = browser_in.find_elements_by_xpath(member_xpath)
sleep(driver_wait_time)
assert grp.all_recipients.count() == 0
def test_api_setup(self, live_server, browser_in, users, driver_wait_time):
"""Test api-setup form."""
no_api_token_txt = "No API Token"
b = browser_in
browser_in.get(live_server + URI)
# show key
show_button = b.find_element_by_id("showKeyButton")
click_and_wait(show_button, driver_wait_time)
# delete token that doesn't exist
def _test():
b.find_element_by_id("delKeyButton").click()
assert no_api_token_txt in b.page_source
assert_with_timeout(_test, driver_wait_time)
# generate token for first time
def _test():
b.find_element_by_id("genKeyButton").click()
assert no_api_token_txt not in b.page_source
assert_with_timeout(_test, driver_wait_time)
# regenerate token
def _test():
b.find_element_by_id("genKeyButton").click()
assert no_api_token_txt not in b.page_source
assert_with_timeout(_test, driver_wait_time)
# delete token
def _test():
b.find_element_by_id("delKeyButton").click()
assert no_api_token_txt in b.page_source
assert_with_timeout(_test, driver_wait_time)
def test_archive_all(
self, uri, query_set, live_server, browser_in, keywords, recipients, groups, smsin, driver_wait_time
):
"""Test archive item buttons."""
# load page
browser_in.get(live_server + uri)
assert uri in browser_in.current_url
# check table is there
sleep(driver_wait_time)
tables = browser_in.find_elements_by_xpath('//table')
assert len(tables) == 1
table = tables[0]
assert 'Archive' in table.text
# toggle a permission
toggle_buttons = browser_in.find_elements_by_id('archiveItemButton')
num_buttons = len(toggle_buttons)
while num_buttons > 0:
click_and_wait(toggle_buttons[0], driver_wait_time)
toggle_buttons = browser_in.find_elements_by_id('archiveItemButton')
assert num_buttons - 1 == len(toggle_buttons)
num_buttons = len(toggle_buttons)
for obj in query_set:
assert obj.is_archived
def test_api_setup(self, live_server, browser_in, users, driver_wait_time):
"""Test api-setup form."""
no_api_token_txt = 'No API Token'
b = browser_in
browser_in.get(live_server + URI)
# show key
show_button = b.find_element_by_id('showKeyButton')
click_and_wait(show_button, driver_wait_time)
# delete token that doesn't exist
def _test():
b.find_element_by_id('delKeyButton').click()
assert no_api_token_txt in b.page_source
assert_with_timeout(_test, driver_wait_time)
# generate token for first time
def _test():
b.find_element_by_id('genKeyButton').click()
assert no_api_token_txt not in b.page_source
assert_with_timeout(_test, driver_wait_time)
# regenerate token
def _test():
b.find_element_by_id('genKeyButton').click()
assert no_api_token_txt not in b.page_source
assert_with_timeout(_test, driver_wait_time)
# delete token
def _test():
b.find_element_by_id('delKeyButton').click()
assert no_api_token_txt in b.page_source
assert_with_timeout(_test, driver_wait_time)
def add_scheduled_time(b, wt):
time_box = b.find_elements_by_name("scheduled_time")[0]
click_and_wait(time_box, wt)
time_box.send_keys("2127-05-25 16:03")
time_box.send_keys(Keys.TAB)
return b
def add_group(b, wt):
group = b.find_elements_by_id("groupItem")[-1]
click_and_wait(group, wt)
return b
def add_recipient(b, wt, pk):
recipient = b.find_element_by_id(f"contact{pk}")
click_and_wait(recipient, wt)
return b
def click_send(b, wt):
send_button = b.find_element_by_id("send_button")
if not send_button.is_enabled():
sleep(wt * 3)
click_and_wait(send_button, wt)
return b
def add_group(b, wt):
group = b.find_elements_by_xpath(
'//*[@id="elmContainer"]/div[1]/div[3]/div/div/div/form/div[2]/div/div[2]/div[1]/div/div[2]'
)[-1]
click_and_wait(group, wt)
return b
def click_send(b, wt):
send_button = b.find_element_by_id('send_button')
click_and_wait(send_button, wt)
return b
def send_form(b, wt):
button = b.find_element_by_id('formSubmitButton')
click_and_wait(button, wt)
return b
def send_form(b, wt):
send_button = b.find_element_by_id("formSubmitButton")
click_and_wait(send_button, wt)
return b
def click_send(b, wt):
send_button = b.find_element_by_id('send_button')
if not send_button.is_enabled():
sleep(wt * 3)
click_and_wait(send_button, wt)
return b
def add_group(b, wt):
group = b.find_elements_by_id('groupItem')[-1]
click_and_wait(group, wt)
return b
def add_scheduled_time(b, wt):
time_box = b.find_elements_by_name('scheduled_time')[0]
click_and_wait(time_box, wt)
time_box.send_keys('2127-05-25 16:03')
time_box.send_keys(Keys.TAB)
return b
