def test_export_csv(self):
guest1 = save_guest(EXAMPLE_GUEST_1)
guest2 = save_guest(EXAMPLE_GUEST_2)
exported = self.handler.export_csv().getvalue().split("\r\n")
exploded_exported_list = [list(filter(lambda x:x != '', exp.split(","))) for exp in exported] # explode each line to items, remove empty strings
self.assertCountEqual(list(guest1.get_attributes().keys()), exploded_exported_list[0])
self.assertCountEqual([str(guest_attr) for guest_attr in guest1.attribute_values.values()], exploded_exported_list[1])
self.assertCountEqual([str(guest_attr) for guest_attr in guest2.attribute_values.values()], exploded_exported_list[2])
def test_list_guests(self):
save_guest(EXAMPLE_GUEST_1)
response = self.client.get("/admin/guest/list")
self.assert200(response)
self.assert_template_used("guest_list.html")
self.assertIn(EXAMPLE_GUEST_1["name"], response.data.decode("utf-8"))
self.assertNotIn("FakeUser", response.data.decode("utf-8"))
def test_different_user_id_in_session_and_url(self):
guest = save_guest(EXAMPLE_GUEST_1)
guest2 = save_guest(EXAMPLE_GUEST_2)
self.client.get(f"/rsvp/{str(guest.id)}", follow_redirects=True) # user logs in
response = self.client.get(f"/rsvp/") # user_id from session
self.assert200(response)
self.assert_template_used("rsvp.html")
self.assertIn(EXAMPLE_GUEST_1["name"], response.data.decode("utf-8"))
response = self.client.get(f"/rsvp/{guest2.id}")
self.assertNotIn(EXAMPLE_GUEST_2["name"], response.data.decode("utf-8"))
self.assert404(response)
self.assert_template_used("errors/404.html")
def test_export_guests(self):
guest1 = save_guest(EXAMPLE_GUEST_1)
guest2 = save_guest(EXAMPLE_GUEST_2)
response = self.client.get("/admin/guest/export")
content_lines = response.data.decode("utf-8").split("\r\n")
self.assertIn("text/csv", response.content_type)
for header_name in guest1.get_attributes().keys():
self.assertIn(header_name, content_lines[0])
for table_member in guest1.attribute_values.values():
self.assertIn(str(table_member), content_lines[1])
for table_member in guest2.attribute_values.values():
self.assertIn(str(table_member), content_lines[2])
def test_delete_guest_no_such_guest(self):
guest_data = EXAMPLE_GUEST_1
guest_id = save_guest(guest_data).id
response = self.client.post(f"/admin/guest/delete/{guest_id}XXX")
self.assert404(response)
self.assert_template_used("errors/404.html")
def test_login_to_admin_after_guest(self):
username = "******"
guest_id = save_guest(dict(name=username, email="*****@*****.**")).id
# Admin visits it's owwn guest page
self.browser.get(f"{self.get_server_url()}/rsvp/{guest_id}")
self.assertEqual(f"Wedding RSVP | {username}", self.browser.title)
# now that he has a session cookie, he gets recognized even without the user id in the URL
self.browser.get(f"{self.get_server_url()}/rsvp")
self.assertEqual(f"Wedding RSVP | {username}", self.browser.title)
# He want's to login to the admin page
self.browser.get(f"{self.get_server_url()}/admin")
password_field = self.browser.find_element_by_id("password")
password_field.send_keys(Keys.BACKSPACE)
password_field.send_keys('password')
password_field.send_keys(Keys.ENTER)
# He is redirected to the admin page
WebDriverWait(self.browser, 5, ignored_exceptions=(NoSuchElementException,)) \
.until(expected_conditions.staleness_of(password_field))
self.assertEqual("Admin page", self.browser.title)
# He goes to the Guest list page
link = self.browser.find_element_by_link_text('Guest list')
link.click()
WebDriverWait(self.browser, 5, ignored_exceptions=(NoSuchElementException,)) \
.until(expected_conditions.staleness_of(password_field))
self.assertEqual("Guest list", self.browser.title)
def test_existing_user_found(self):
guest_id = save_guest(EXAMPLE_GUEST_1).id
response = self.client.get(f"/rsvp/{guest_id}", follow_redirects=True)
self.assert200(response)
self.assert_template_used("rsvp.html")
self.assertIn(EXAMPLE_GUEST_1["name"], response.data.decode("utf-8"))
def test_unsubscribe(self):
guest = save_guest(EXAMPLE_GUEST_1)
response = self.client.get(f"/rsvp/unsubscribe/{guest.id}?email={guest.email}", follow_redirects=True)
guests = list_guests()
self.assertNotIn(guest, guests)
self.assert200(response)
self.assert_template_used("unsubscribe.html")
def test_userpage_with_extra_url_parameter(self):
guest_id = save_guest(EXAMPLE_GUEST_1).id
response = self.client.get(f"/rsvp/{guest_id}?fbcid=XXXXXXXXXXXX", follow_redirects=True)
self.assert200(response)
self.assert_template_used("rsvp.html")
self.assertIn(EXAMPLE_GUEST_1["name"], response.data.decode("utf-8"))
def test_delete_guest(self):
guest_data = EXAMPLE_GUEST_1
guest_id = save_guest(guest_data).id
response = self.client.post(f"/admin/guest/delete/{guest_id}")
guests = list_guests()
self.assert_redirects(response, "/admin/guest/list")
self.assertMessageFlashed(f"Guest {EXAMPLE_GUEST_1['name']} removed")
self.assertEqual(len(guests), 0)
def test_form_descriptions(self):
from tests import context
guest = save_guest(EXAMPLE_GUEST_1)
form = context.app.rsvp.forms.GuestForm()
response = self.client.get(f"/rsvp/{guest.id}", follow_redirects=True)
for key in form.data.keys():
if form[key].description:
self.assertIn(str(form[key].description), response.data.decode("utf-8"))
def test_edit_guest_page(self):
guest_data = EXAMPLE_GUEST_1
guest_id = save_guest(guest_data).id
response = self.client.get(f"/admin/guest/edit/{guest_id}")
self.assert200(response)
self.assert_template_used("guest_form.html")
for key, value in guest_data.items():
self.assertIn(f"name=\"{key}\"", html.unescape(response.data.decode("utf-8")))
if type(value) is not bool:
self.assertIn(str(value), html.unescape(response.data.decode("utf-8")))
else:
string_val = "y" if value else "n"
self.assertIn(f"value=\"{string_val}\"", html.unescape(response.data.decode("utf-8")))
def test_rsvp_fill_form_validators(self):
self.app.config["USE_RECAPTCHA_FOR_GUEST"] = False
guest_data = dict(EXAMPLE_GUEST_1)
edited_guest_data = {"food_allergies": "Kartoffel",
"number_of_guests": -1,
"notes": "blahblah",
"favourite_music": "Pink Floyd"}
guest_id = save_guest(guest_data).id
self.client.get(f"/rsvp/{str(guest_id)}", follow_redirects=True) # user logs in
response = self.client.post(f"/rsvp/{guest_id}", data=edited_guest_data)
edited_guest = get_guest(guest_id)
self.assertIn("Number must be between", response.data.decode("utf-8"))
self.assertEqual(edited_guest.number_of_guests, EXAMPLE_GUEST_1["number_of_guests"])
def test_edit_guest(self):
guest_data = dict(EXAMPLE_GUEST_1)
edited_guest_data = dict(EXAMPLE_GUEST_2)
edited_guest_data.pop("will_attend")
guest_id = save_guest(guest_data).id
response = self.client.post(f"/admin/guest/edit/{guest_id}", data=edited_guest_data)
guests = list_guests()
self.assert_redirects(response, "/admin/guest/list")
self.assertEqual(len(guests), 1)
edited_guest_data["filled_by_admin"] = True
edited_guest_data["id"] = guests[0].id
edited_guest_data["will_attend"] = False
edited_guest_data["notes"] = ''
self.assertDictEqual(guests[0].__dict__["attribute_values"], edited_guest_data)
def test_rsvp_auth(self):
username = "******"
guest_id = save_guest(dict(name=username, email="*****@*****.**")).id
# testuser goes to the rsvp page, but gets rejected
self.browser.get(f"{self.get_server_url()}/rsvp")
self.assertEqual("404 - Not found", self.browser.title)
# now he goes to hos special link - he is recognized and accepted
self.browser.get(f"{self.get_server_url()}/rsvp/{guest_id}")
self.assertEqual(f"Wedding RSVP | {username}", self.browser.title)
# now that he has a session cookie, he gets recognized even without the user id in the URL
self.browser.get(f"{self.get_server_url()}/rsvp")
self.assertEqual(f"Wedding RSVP | {username}", self.browser.title)
def test_rsvp_page(self):
edit_allowed = ["will_attend", "favourite_music", "food_allergies", "number_of_guests", "notes"]
guest = save_guest(EXAMPLE_GUEST_1)
response = self.client.get(f"/rsvp/{guest.id}", follow_redirects=True)
self.assert200(response)
self.assert_template_used("rsvp.html")
for key, value in EXAMPLE_GUEST_1.items():
if key in edit_allowed:
if type(value) is str:
self.assertIn(value, html.unescape(response.data.decode("utf-8")))
if type(value) is bool and value is True:
self.assertIn("checked", response.data.decode("utf-8"))
if type(value) is bool and value is False:
self.assertNotIn("checked", response.data.decode("utf-8"))
def test_personalized_data_is_present(self):
self.app.config["USE_RECAPTCHA_FOR_GUEST"] = False
guest_data = dict(EXAMPLE_GUEST_1)
guest_id = save_guest(guest_data).id
response = self.client.get(f"/rsvp/{str(guest_id)}", follow_redirects=True) # user logs in
with open(os.getenv('PERSONALIZE_SRC_FILE'), 'r') as stream:
try:
personalized_data = yaml.safe_load(stream)
except yaml.YAMLError as exc:
print(exc)
self.assertIn(personalized_data["basic_data"]["bride"], response.data.decode("utf-8"))
self.assertIn(personalized_data["basic_data"]["groom"], response.data.decode("utf-8"))
self.assertIn(personalized_data["main_message"], response.data.decode("utf-8"))
for _event in personalized_data["wedding_events"]:
self.assertIn(_event['name'], response.data.decode("utf-8"))
self.assertIn(_event['description'], response.data.decode("utf-8"))
def test_rsvp_fill_form(self):
self.app.config["USE_RECAPTCHA_FOR_GUEST"] = False
guest_data = dict(EXAMPLE_GUEST_1)
edited_guest_data = {"food_allergies": "Kartoffel",
"number_of_guests": 2,
"notes": "blahblah",
"favourite_music": "Pink Floyd"}
guest_id = save_guest(guest_data).id
self.client.get(f"/rsvp/{str(guest_id)}", follow_redirects=True) # user logs in
self.client.post(f"/rsvp/{guest_id}", data=edited_guest_data)
edited_guest = get_guest(guest_id)
edited_guest_data["filled_by_admin"] = False
edited_guest_data["id"] = guest_id
edited_guest_data["will_attend"] = False
edited_guest_data["last_responded"] = edited_guest.last_responded
edited_guest_data["last_viewed"] = edited_guest.last_viewed
self.assertDictEqual(edited_guest.__dict__["attribute_values"], {**EXAMPLE_GUEST_1, **edited_guest_data})
def test_rsvp_last_viewed_updated(self):
guest = save_guest(EXAMPLE_GUEST_1)
self.client.get(f"/rsvp/{guest.id}", follow_redirects=True)
edited_guest = get_guest(guest.id)
self.assertAlmostEqual(edited_guest.last_viewed, datetime.datetime.now(tzutc()),
delta=datetime.timedelta(seconds=5))
def test_rsvp_page(self):
guest_data = dict(EXAMPLE_GUEST_1)
edit_allowed = [
"will_attend", "favourite_music", "food_allergies",
"number_of_guests", "notes"
]
guest_id = save_guest(guest_data).id
# testuser goes to the link he received by e-mail
self.browser.get(f"{self.get_server_url()}/rsvp/{guest_id}")
self.assertEqual(f"Wedding RSVP | {guest_data['name']}",
self.browser.title)
# Verifies that there is no login required message left
page_text = self.browser.find_element_by_tag_name('body').text
self.assertNotIn("Please log in to access this page.", page_text)
# He finds that every value is the same as he left it last time
for key, value in guest_data.items():
if key in edit_allowed:
if type(value) is str or type(value) is int:
self.assertEqual(
str(value),
self.browser.find_element_by_id(key).get_attribute(
"value"))
if type(value) is bool:
self.assertEqual(
"true" if value else None,
self.browser.find_element_by_id(key).get_attribute(
"checked"))
# It occurs to him that he just divorced, so that the ex-wife won't come
number_of_guests = self.browser.find_element_by_id("number_of_guests")
number_of_guests.clear()
number_of_guests.send_keys('4')
number_of_guests.send_keys(Keys.ENTER)
# wait for the refresh to finish
WebDriverWait(self.browser, 5, ignored_exceptions=(NoSuchElementException,)) \
.until(expected_conditions.staleness_of(number_of_guests))
self.wait_for(lambda: self.assertEqual(
self.browser.find_element_by_id("number_of_guests").get_attribute(
"value"), "4"))
self.assertEqual(get_guest(guest_id).number_of_guests,
4) # to the database as well
# But wait! He became vegan since..
food_allergies = WebDriverWait(self.browser, 5,
ignored_exceptions=(NoSuchElementException,StaleElementReferenceException,)) \
.until(expected_conditions.presence_of_element_located((By.ID, "food_allergies")))
food_allergies.clear()
food_allergies.send_keys('I a\'m vegan')
self.browser.find_element_by_id("submit").click()
# issue a browser refresh to make sure, the change is saved
self.browser.get(f"{self.get_server_url()}/rsvp/{guest_id}")
self.wait_for(lambda: self.assertEqual(
self.browser.find_element_by_id("food_allergies").get_attribute(
"value"), 'I a\'m vegan'))
self.assertEqual(get_guest(guest_id).food_allergies,
'I a\'m vegan') # to the database as well
def setUp(self) -> None:
self.guest1 = save_guest(EXAMPLE_GUEST_1)
self.guest2 = save_guest(EXAMPLE_GUEST_2)