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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_user_model(self):
name = "kenny"
email = "*****@*****.**"
add_user(name=name, email=email)
user = User.query.filter_by(name=name).first()
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertEqual(user.name, name)
self.assertEqual(user.email, email)
self.assertTrue(isinstance(auth_token, bytes))
self.assertTrue(
User.decode_auth_token(auth_token.decode("utf-8")) == 1)
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_bad_token(self):
"""Tests whether a request with an invalid token returns a 403
response."""
user1 = add_user(email='*****@*****.**')
user2 = add_user(email='*****@*****.**')
db.session.commit()
auth_token2 = user2.encode_auth_token(user2.id)
response = self.api.post(f'/users/{user1.public_id}/events',
headers={'x-access-token': auth_token2},
data=create_event_json(),
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_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_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 test_credential_creation(self):
name = "kenny"
email = "*****@*****.**"
user = add_user(name=name, email=email)
cred = add_cred()
user.cred = cred
db.session.commit()
user = User.query.get(user.id)
self.assertEqual(user.cred, cred)
def test_update_user_invalid_permission(self):
user = add_user("Doe", "*****@*****.**")
user2 = add_user("joe", "*****@*****.**")
db.session.commit()
auth_token = user.encode_auth_token(user.id)
response = self.api.put(f'/users/{user2.public_id}',
headers={'x-access-token': auth_token},
data=json.dumps({
'name': "ChangedName",
'email': '*****@*****.**'
}),
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_promote_role_member(self):
user = add_user("Doe", "*****@*****.**")
db.session.commit()
# User is first on boarding
user = User.query.filter_by(name="Doe").first()
self.assertEqual(user.role, Role.ON_BOARDING)
# User is now on Member
promote_to_member(user)
user = User.query.filter_by(name="Doe").first()
self.assertEqual(user.role, Role.MEMBER)
def test_missing_token(self):
"""Tests whether a request with a missing token returns a 401
response."""
user = add_user()
db.session.commit()
response = self.api.post(f'/users/{user.public_id}/events',
data=create_event_json(),
content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 401)
self.assertEqual(data['message'], 'Token is missing!')
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_space_in_url(self):
"""Tests whether a request with a space in the url returns a 400
response."""
user = add_user()
db.session.commit()
auth_token = user.encode_auth_token(user.id)
url = 'look a space'
response = self.api.post(f'/users/{user.public_id}/events',
headers={'x-access-token': auth_token},
data=create_event_json(url=url),
content_type='application/json')
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 400)
