def test_event_foreign_key(self):
"""Tests whether the foreign key relationship is working between
Event and User."""
name1 = 'timmy'
name2 = 'johny'
email1 = '*****@*****.**'
email2 = '*****@*****.**'
add_user(name=name1, email=email1)
add_user(name=name2, email=email2)
user1_id = User.query.filter_by(email=email1).first().id
user2_id = User.query.filter_by(email=email2).first().id
start1 = dt.time(6, tzinfo=dt.timezone.utc)
start2 = dt.time(8, tzinfo=dt.timezone.utc)
availability1 = create_availability(start=start1)
availability2 = create_availability(start=start2)
url1 = 'aCleverUrl'
url2 = 'aNotSoCleverUrl'
add_event(url=url1, user_id=user1_id, availability=availability1)
add_event(url=url2, user_id=user2_id, availability=availability2)
db.session.commit()
query1 = User.query.\
filter_by(email=email1).\
join(Event, Availability).\
first()
query2 = User.query.\
filter_by(email=email2).\
join(Event, Availability).\
first()
self.assertEqual(query1.name, name1)
self.assertEqual(query2.name, name2)
self.assertEqual(query1.events[0].url, url1)
self.assertEqual(query2.events[0].url, url2)
self.assertEqual(query1.events[0].availability.start, start1)
self.assertEqual(query2.events[0].availability.start, start2)
def test_user_event_cardinality_1to1(self):
"""Tests whether the User-Event relationship is set up correctly."""
email1 = '*****@*****.**'
email2 = '*****@*****.**'
add_user(email=email1)
add_user(email=email2)
user1_id = User.query.filter_by(email=email1).first().id
user2_id = User.query.filter_by(email=email2).first().id
availability1 = create_availability()
availability2 = create_availability()
add_event(user_id=user1_id, availability=availability1)
add_event(url='anEvent', user_id=user2_id, availability=availability2)
db.session.commit()
query1 = User.query.\
filter_by(email=email1).\
join(Event, Availability).\
all()
query2 = User.query.\
filter_by(email=email2).\
join(Event, Availability).\
all()
self.assertEqual(len(query1), 1)
self.assertEqual(len(query2), 1)
self.assertEqual(len(query1[0].events), 1)
self.assertEqual(len(query2[0].events), 1)
def test_get_all_appointments(self):
"""Test Getting all appointments from a User"""
add_user()
db.session.commit()
user = User.query.first()
# Create 2 events
event1 = add_event(user_id=user.id,
availability=create_availability(),
name="Frist Event",
url="my first url")
event2 = add_event(user_id=user.id,
availability=create_availability(),
name="Frist Second",
url="my second url")
db.session.commit()
start = dt.datetime.now(dt.timezone.utc)
# add appointment to event 1
add_appointment(event_id=event1.id,
participants=[
create_participant(name="John",
email="*****@*****.**")
],
comments="comments",
start=start)
# add appointment to event 2
add_appointment(event_id=event2.id,
participants=[
create_participant(name="Bonnie",
email="*****@*****.**")
],
comments="comments",
start=start + dt.timedelta(days=1))
db.session.commit()
auth_token = user.encode_auth_token(user.id)
resp_with_query_param = self.api.get(
f'/users/{user.public_id}/appointments?event_url={event1.url}',
headers={'x-access-token': auth_token},
content_type='application/json')
data_with_query = json.loads(resp_with_query_param.data.decode())
resp_no_query_param = self.api.get(
f'/users/{user.public_id}/appointments',
headers={'x-access-token': auth_token},
content_type='application/json')
data_no_query_param = json.loads(resp_no_query_param.data.decode())
self.assertEqual(len(data_with_query), 1)
self.assertEqual(len(data_no_query_param), 2)
def test_bad_token(self):
"""Tests whether a request with an invalid token returns a 403
response."""
add_user(email='*****@*****.**')
add_user(email='*****@*****.**')
db.session.commit()
user1 = User.query.filter_by(email='*****@*****.**').first()
user2 = User.query.filter_by(email='*****@*****.**').first()
add_event(user1.id, create_availability())
db.session.commit()
event1 = Event.query.filter_by(user_id=user1.id).first()
add_appointment(event_id=event1.id,
participants=[create_participant()])
db.session.commit()
auth_token2 = user2.encode_auth_token(user2.id)
route = f'/users/{user1.public_id}/events/{event1.url}/appointments'
response = self.api.get(route,
headers={'x-access-token': auth_token2},
content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 403)
self.assertEqual(data['message'],
"You do not have permission to access this content")
def test_get_appointments(self):
"""Tests whether appointments can be successfully requested."""
add_user()
db.session.commit()
user = User.query.first()
add_event(user_id=user.id, availability=create_availability())
db.session.commit()
event = Event.query.first()
name = 'Jimmy Joe'
comments = "OMG I haven't seen you in forever Jimmy how has it been?"
start = dt.datetime.now(dt.timezone.utc)
add_appointment(event_id=event.id,
participants=[create_participant(name=name)],
comments=comments,
start=start)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
response = self.api.get(
f'/users/{user.public_id}/events/{event.url}/'
f'appointments',
headers={'x-access-token': auth_token},
content_type='application/json')
data = json.loads(response.data.decode())
appointment = data[0]
participants = appointment['participants'][0]
self.assertEqual(response.status_code, 200)
self.assertEqual(appointment['comments'], comments)
self.assertEqual(participants['name'], name)
self.assertEqual(parser.isoparse(appointment['start']), start)
def test_many_participants(self):
"""Tests whether an appointment can have many participants."""
add_user()
db.session.commit()
user = User.query.first()
availability = create_availability()
add_event(user_id=user.id, availability=availability)
db.session.commit()
event = Event.query.first()
name = ['User Jeff', 'Jeff User', 'Reff Usej']
email = ['*****@*****.**', '*****@*****.**', '*****@*****.**']
comments = 'I think this whole Jeff and User thing is getting ' \
'confusing.'
add_appointment(event_id=event.id,
participants=[
create_participant(name[i], email[i])
for i in range(2)
],
comments=comments)
db.session.commit()
participants = db.session.query(Participant).\
filter(Appointment.comments == comments)
for j in range(2):
self.assertEqual(participants[j].name, name[j])
self.assertEqual(participants[j].email, email[j])
def test_appointment_not_found(self):
"""Tests whether requesting an appointment that doesn't exist returns
a 404 error."""
add_user()
db.session.commit()
user = User.query.first()
user_public_id = user.public_id
add_event(user.id, create_availability())
db.session.commit()
event = Event.query.first()
event_url = event.url
start = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=30)
add_appointment(event_id=event.id,
participants=[create_participant()],
start=start)
db.session.commit()
route = f'/users/{user_public_id}/events/{event_url}/appointments/' \
f'{(start + dt.timedelta(days=1)).isoformat()}'
status = False
response = self.api.patch(route,
data=json.dumps({'status': status}),
content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 404)
self.assertEqual(data['status'], 'fail')
self.assertEqual(data['message'], 'No appointment was found for that '
'start time.')
def test_bad_value(self):
"""Tests whether attempting to supply an unsupported value is
rejected with a 400 response."""
add_user()
db.session.commit()
user = User.query.first()
user_public_id = user.public_id
add_event(user.id, create_availability())
db.session.commit()
event = Event.query.first()
event_url = event.url
start = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=30)
add_appointment(event_id=event.id,
participants=[create_participant()],
start=start)
db.session.commit()
route = f'/users/{user_public_id}/events/{event_url}/appointments/' \
f'{start.isoformat()}'
status = 'potato'
response = self.api.patch(route,
data=json.dumps({'status': status}),
content_type='application/json')
self.assertEqual(response.status_code, 400)
data = json.loads(response.data.decode())
self.assertEqual(data['errors']['status'],
f"'{status}' is not of type "
f"'boolean'")
self.assertEqual(data['message'], 'Input payload validation failed')
def test_appointment_model(self):
"""Tests whether the appointment model is working correctly."""
add_user()
db.session.commit()
user = User.query.first()
availability = create_availability()
add_event(user_id=user.id, availability=availability)
db.session.commit()
event = Event.query.first()
participant = create_participant()
start = dt.datetime(year=2020,
month=3,
day=1,
hour=8,
tzinfo=dt.timezone.utc)
end = start + dt.timedelta(hours=1)
created = dt.datetime.now(dt.timezone.utc)
add_appointment(event_id=event.id,
participants=[participant],
start=start,
end=end,
created=created)
db.session.commit()
appointment = Appointment.query.filter_by(start=start).first()
self.assertEqual(appointment.end, end)
self.assertEqual(appointment.created, created)
def test_availability_days(self, _mock_email, _mock_event):
"""Tests whether a request outside of the available days is rejected
with a 400 response."""
add_user()
db.session.commit()
user = User.query.first()
user_public_id = user.public_id
add_event(user.id, create_availability()) # Sunday: False
db.session.commit()
event = Event.query.first()
event_url = event.url
start = dt.datetime(
year=2020,
month=3,
day=1, # Sunday
hour=9,
tzinfo=dt.timezone.utc)
route = f'/users/{user_public_id}/events/{event_url}/appointments'
request = create_appointment_json(start=dt.datetime.isoformat(start))
response = self.api.post(route,
data=request,
content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 400)
self.assertEqual(data['status'], 'fail')
self.assertEqual(
data['message'], 'The provided start time and date is '
'not allowed please choose a valid '
'start time and date and resubmit '
'your request.')
def test_updating_to_same_value(self):
"""Tests whether updating a value to its current value is accepted."""
add_user()
db.session.commit()
user = User.query.first()
user_public_id = user.public_id
add_event(user.id, create_availability())
db.session.commit()
event = Event.query.first()
event_url = event.url
start = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=30)
add_appointment(event_id=event.id,
participants=[create_participant()],
start=start,
status=True)
db.session.commit()
route = f'/users/{user_public_id}/events/{event_url}/appointments/' \
f'{start.isoformat()}'
status = True
response = self.api.patch(route,
data=json.dumps({'status': status}),
content_type='application/json')
self.assertEqual(response.status_code, 200)
data = json.loads(response.data.decode())
self.assertEqual(data['message'], 'success')
appointment = Appointment.query.first()
self.assertEqual(appointment.status, status)
def test_get_appointment(self):
"""Tests whether an appointment can be successfully requested."""
add_user()
db.session.commit()
user = User.query.first()
user_public_id = user.public_id
add_event(user.id, create_availability())
db.session.commit()
event = Event.query.first()
event_url = event.url
name = 'Big Bob'
email = '*****@*****.**'
comments = 'What is this appointment for again?'
start = dt.datetime(year=2020,
month=3,
day=2,
hour=9,
tzinfo=dt.timezone.utc)
add_appointment(
event_id=event.id,
participants=[create_participant(name=name, email=email)],
start=start,
comments=comments)
db.session.commit()
route = f'/users/{user_public_id}/events/{event_url}/appointments/' \
f'{start.isoformat()}'
response = self.api.get(route, content_type='application/json')
appointment = json.loads(response.data.decode())
participant = appointment['participants'][0]
self.assertEqual(response.status_code, 200)
self.assertEqual(appointment['comments'], comments)
self.assertEqual(participant['name'], name)
self.assertEqual(participant['email'], email)
def test_timezone_conversion(self, _mock_email, _mock_event):
"""Tests whether non utc timezones are correctly converted to UTC time.
"""
add_user()
db.session.commit()
user = User.query.first()
user_public_id = user.public_id
add_event(user.id, create_availability())
db.session.commit()
event = Event.query.first()
event_url = event.url
start = dt.datetime(year=2020,
month=3,
day=2,
hour=9,
tzinfo=dt.timezone(dt.timedelta(hours=-5)))
route = f'/users/{user_public_id}/events/{event_url}/appointments'
request = create_appointment_json(start=dt.datetime.isoformat(start))
response = self.api.post(route,
data=request,
content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 201)
self.assertEqual(data['message'], 'success')
appointment = db.session.query(Appointment).\
filter(Event.url == event_url).\
first()
self.assertEqual(appointment.start, start.astimezone(dt.timezone.utc))
def test_start_after_next_x_days(self, _mock_email, _mock_event):
"""Tests whether a request made with a start time that is more than
NEXT_X_DAYS is rejected with a 400 response."""
add_user()
db.session.commit()
user = User.query.first()
user_public_id = user.public_id
add_event(user.id, create_availability())
db.session.commit()
event = Event.query.first()
event_url = event.url
start = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=91)
route = f'/users/{user_public_id}/events/{event_url}/appointments'
response = self.api.post(
route,
data=create_appointment_json(start=start.isoformat()),
content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 400)
self.assertEqual(data['status'], 'fail')
self.assertEqual(
data['message'], f"You may only schedule an "
f"appointment within the next "
f"{NEXT_X_DAYS} days in the future.")
def test_bad_params(self):
"""Tests whether a request with both valid and invalid parameters is
accepted and the valid parameters are used."""
add_user()
db.session.commit()
user = User.query.first()
user_public_id = user.public_id
add_event(user.id, create_availability())
db.session.commit()
event = Event.query.first()
event_url = event.url
start = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=30)
add_appointment(event_id=event.id,
participants=[create_participant()],
start=start,
status=True)
db.session.commit()
route = f'/users/{user_public_id}/events/{event_url}/appointments/' \
f'{start.isoformat()}'
status = False
response = self.api.patch(route,
data=json.dumps({
'status':
status,
'potato':
'I love potatoes man.'
}),
content_type='application/json')
self.assertEqual(response.status_code, 200)
data = json.loads(response.data.decode())
self.assertEqual(data['message'], 'success')
def test_availability_model(self):
"""Tests whether the availability model is working correctly."""
sunday = True
start = dt.time(hour=6, tzinfo=dt.timezone.utc)
end = dt.time(hour=9, tzinfo=dt.timezone.utc)
add_user()
user_id = User.query.first().id
availability = create_availability(sunday=sunday, start=start, end=end)
add_event(user_id=user_id, availability=availability)
availability = Availability.query.filter_by(start=start).first()
self.assertEqual(availability.sunday, sunday)
self.assertEqual(availability.end, end)
def test_multiple_appointments(self, _mock_email, _mock_event):
"""Tests whether a single participant can have multiple appointments."""
add_user()
db.session.commit()
user = User.query.first()
user_public_id = user.public_id
add_event(user.id, create_availability())
db.session.commit()
event = Event.query.first()
event_url = event.url
name = 'Fabulous Johnny'
email = '*****@*****.**'
start1 = dt.datetime(year=2020,
month=3,
day=2,
hour=9,
tzinfo=dt.timezone.utc)
start2 = start1 + dt.timedelta(hours=2)
route = f'/users/{user_public_id}/events/{event_url}/appointments'
response1 = self.api.post(route,
data=create_appointment_json(
start=start1.isoformat(),
name=name,
email=email),
content_type='application/json')
response2 = self.api.post(route,
data=create_appointment_json(
start=start2.isoformat(),
name=name,
email=email),
content_type='application/json')
data1 = json.loads(response1.data.decode())
data2 = json.loads(response2.data.decode())
self.assertEqual(response1.status_code, 201)
self.assertEqual(data1['message'], 'success')
self.assertEqual(response2.status_code, 201)
self.assertEqual(data2['message'], 'success')
appointments = db.session.query(Appointment).\
filter(Event.url == event_url).\
all()
self.assertEqual(len(appointments), 2)
for appointment in appointments:
self.assertTrue(appointment.start in [start1, start2])
participant = Participant.query.filter_by(email=email).all()
self.assertEqual(len(participant), 1)
self.assertEqual(participant[0].name, name)
self.assertEqual(participant[0].email, email)
def test_availability_foreign_key(self):
"""Tests whether the foreign key relationship is working between
Availability and Event."""
add_user()
user_id = User.query.first().id
start = dt.time(hour=6, tzinfo=dt.timezone.utc)
availability = create_availability(start=start)
url = 'acleverurl'
add_event(url=url, user_id=user_id, availability=availability)
db.session.commit()
event, availability = db.session.query(Event, Availability).join()\
.first()
self.assertEqual(availability.start, start)
self.assertEqual(event.url, url)
def test_event_model(self):
"""Tests whether the event model is working correctly."""
name = '♪┏(・o･)┛♪┗ ( ･o･) ┓♪'
url = 'myCoolParty'
location = 'da street!'
add_user()
user_id = User.query.first().id
availability = create_availability()
add_event(url=url,
name=name,
location=location,
user_id=user_id,
availability=availability)
event = Event.query.filter_by(url=url).first()
self.assertEqual(event.name, name)
self.assertEqual(event.location, location)
def test_missing_token(self):
"""Tests whether a request with a missing token returns a 401
response"""
add_user(email='*****@*****.**')
db.session.commit()
user = User.query.first()
add_event(user.id, create_availability())
db.session.commit()
event = Event.query.first()
add_appointment(event_id=event.id, participants=[create_participant()])
db.session.commit()
route = f'/users/{user.public_id}/events/{event.url}/appointments'
response = self.api.get(route, content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 401)
self.assertEqual(data['message'], 'Token is missing!')
def seed_event():
result = {}
user = add_user()
cred = add_cred()
user.cred = cred
user_id = User.query.first().id
availability = create_availability()
name = '♪┏(・o･)┛♪┗ ( ･o･) ┓♪'
url = 'myCoolParty'
location = 'da street!'
event = add_event(url=url,
name=name,
location=location,
user_id=user_id,
availability=availability)
result['user'] = user
result['event'] = event
return result
def test_participant_model(self):
"""Tests whether the participant model is working correctly."""
add_user()
db.session.commit()
user = User.query.first()
availability = create_availability()
add_event(user_id=user.id, availability=availability)
db.session.commit()
event = Event.query.first()
name = 'User Jeff'
email = '*****@*****.**'
add_appointment(
event_id=event.id,
participants=[create_participant(name=name, email=email)])
db.session.commit()
participant = Participant.query.filter_by(name=name).first()
self.assertEqual(participant.email, email)
def test_event_marshal(self):
user = add_user()
db.session.commit()
auth_token = user.encode_auth_token(user.id)
start = dt.time(hour=6, tzinfo=dt.timezone.utc)
sunday = True
availability = create_availability(start=start,
sunday=sunday)
url = 'funnyUrl'
color = '#7851a9'
add_event(user.id, availability, url=url, color=color.lstrip('#'))
db.session.commit()
response = self.api.get(f'/users/{user.public_id}/events/{url}',
headers={'x-access-token': auth_token},
content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(data['url'], url)
self.assertEqual(data['availability']['start'], start.isoformat())
self.assertEqual(data['color'], color)
self.assertEqual(data['availability']['days']['sunday'], sunday)
def post(self, public_id, current_user=None):
"""Creates an Event for the specified user."""
if current_user.public_id != public_id:
raise PermissionError
payload = api.payload
if not verify_at_least_1_day_available(payload['availability']):
raise NoDayAvailable
if starttime_after_endtime(payload['availability']):
raise StartAfterEnd
if ' ' in payload['url']:
raise UrlContainsSpace
user_id = current_user.id
availability = create_availability(
sunday=payload['availability']['days']['sunday'],
monday=payload['availability']['days']['monday'],
tuesday=payload['availability']['days']['tuesday'],
wednesday=payload['availability']['days']['wednesday'],
thursday=payload['availability']['days']['thursday'],
friday=payload['availability']['days']['friday'],
saturday=payload['availability']['days']['saturday'],
start=dt.time.fromisoformat(payload['availability']['start']),
end=dt.time.fromisoformat(payload['availability']['end']))
add_event(
user_id=user_id,
availability=availability,
name=payload['name'],
location=payload['location'],
description=payload['description'],
duration=payload['duration'],
url=payload['url'],
color=payload['color'].lstrip('#'))
db.session.commit()
if current_user.role == Role.ON_BOARDING:
promote_to_member(current_user)
return {'message': 'success'}, 201
def test_multiple_participants(self):
"""Tests whether an appointment can have multiple participants."""
add_user()
db.session.commit()
user = User.query.first()
availability = create_availability()
add_event(user_id=user.id, availability=availability)
db.session.commit()
event = Event.query.first()
names = ['Rex', 'Fives', 'Echo', 'Dogma', 'Wolffe']
emails = [f'{name}@trooper.com' for name in names]
participants = [
create_participant(name=names[i], email=emails[i])
for i in range(4)
]
add_appointment(event_id=event.id, participants=participants)
db.session.commit()
appointment = Appointment.query.first()
for i in range(4):
self.assertEqual(appointment.participants[i].name, names[i])
self.assertEqual(appointment.participants[i].email, emails[i])
def test_post_appointments(self, _mock_email, _mock_event):
"""Tests whether an appointment can be successfully created and the
appointment's attributes match what was supplied."""
add_user()
db.session.commit()
user = User.query.first()
user_public_id = user.public_id
add_event(user.id, create_availability())
db.session.commit()
event = Event.query.first()
event_url = event.url
start = '2020-03-20T08:30:00Z'
comments = "I don't know about this appointment man..."
name = 'Little Timmy'
email = '*****@*****.**'
route = f'/users/{user_public_id}/events/{event_url}/appointments'
request = create_appointment_json(start=start,
comments=comments,
name=name,
email=email)
response = self.api.post(route,
data=request,
content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 201)
self.assertEqual(data['message'], 'success')
appointment = db.session.query(Appointment).\
filter(User.public_id == user_public_id,
Event.url == event_url,
Appointment.start == start).\
first()
self.assertEqual(appointment.comments, comments)
participant = appointment.participants[0]
self.assertEqual(participant.name, name)
self.assertEqual(participant.email, email)
def test_default_override(self):
"""Tests whether default setting in the marshal are overriding set
values."""
user = add_user()
db.session.commit()
url = 'iwontfail'
duration = 15
event = add_event(user.id, create_availability(), duration=duration,
url=url)
auth_token = user.encode_auth_token(user.id)
db.session.commit()
response = self.api.put(f'/users/{user.public_id}/events/{event.url}',
headers={'x-access-token': auth_token},
data=json.dumps({'name': "please don't fail"}),
content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 200)
self.assertEqual(data['message'], 'Success')
event = Event.query.filter_by(url=url).first()
self.assertEqual(event.duration, duration)
