def test_related_field_owned_by_another_user_forbidden(self):
# GIVEN
user1 = userhelper.given_a_user_exists_and_is_authenticated(
self.client)
user2 = userhelper.given_a_user_exists(username='******',
email='*****@*****.**')
event1 = eventhelper.given_event_exists(user1)
event2 = eventhelper.given_event_exists(user2)
reminder = reminderhelper.given_reminder_exists(user1, event=event1)
course_group2 = coursegrouphelper.given_course_group_exists(user2)
course2 = coursehelper.given_course_exists(course_group2)
homework2 = homeworkhelper.given_homework_exists(course2)
# WHEN
responses = [
self.client.post(reverse('planner_reminders_list'),
json.dumps({'event': event2.pk}),
content_type='application/json'),
self.client.post(reverse('planner_reminders_list'),
json.dumps({'homework': homework2.pk}),
content_type='application/json'),
self.client.put(reverse('planner_reminders_detail',
kwargs={'pk': reminder.pk}),
json.dumps({'event': event2.pk}),
content_type='application/json'),
self.client.put(reverse('planner_reminders_detail',
kwargs={'pk': reminder.pk}),
json.dumps({'homework': homework2.pk}),
content_type='application/json')
]
# THEN
for response in responses:
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_events_feed(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user1.settings.enable_private_slug()
user2 = userhelper.given_a_user_exists(username='******',
email='*****@*****.**')
user2.settings.enable_private_slug()
event1 = eventhelper.given_event_exists(user1)
event2 = eventhelper.given_event_exists(user1)
eventhelper.given_event_exists(user2)
# WHEN
response = self.client.get(
reverse("feed_private_events_ical",
kwargs={"slug": user1.settings.private_slug}))
# THEN
calendar = icalendar.Calendar.from_ical(
response.content.decode('utf-8'))
self.assertEqual(len(calendar.subcomponents), 2)
self.assertEqual(calendar.subcomponents[0]['SUMMARY'], event1.title)
self.assertEqual(calendar.subcomponents[0]['DESCRIPTION'],
"Comments: {}".format(event1.comments))
self.assertEqual(calendar.subcomponents[0]['DTSTART'].dt, event1.start)
self.assertEqual(calendar.subcomponents[0]['DTEND'].dt, event1.end)
self.assertEqual(calendar.subcomponents[1]['SUMMARY'], event1.title)
self.assertEqual(calendar.subcomponents[1]['DTSTART'].dt, event2.start)
self.assertEqual(calendar.subcomponents[1]['DTEND'].dt, event2.end)
self.assertEqual(calendar.subcomponents[1]['DESCRIPTION'],
"Comments: {}".format(event2.comments))
def test_export_success(self):
# GIVEN
user1 = userhelper.given_a_user_exists_and_is_authenticated(self.client)
user2 = userhelper.given_a_user_exists(username='******', email='*****@*****.**')
external_calendar = externalcalendarhelper.given_external_calendar_exists(user1)
event1 = eventhelper.given_event_exists(user1)
event2 = eventhelper.given_event_exists(user1)
eventhelper.given_event_exists(user2)
course_group1 = coursegrouphelper.given_course_group_exists(user1)
course_group2 = coursegrouphelper.given_course_group_exists(user1)
course_group3 = coursegrouphelper.given_course_group_exists(user2)
course1 = coursehelper.given_course_exists(course_group1, room='')
course2 = coursehelper.given_course_exists(course_group2)
course3 = coursehelper.given_course_exists(course_group3)
course_schedule1 = courseschedulehelper.given_course_schedule_exists(course1)
course_schedule2 = courseschedulehelper.given_course_schedule_exists(course2)
courseschedulehelper.given_course_schedule_exists(course3)
category1 = categoryhelper.given_category_exists(course1, title='Uncategorized')
category2 = categoryhelper.given_category_exists(course2)
category3 = categoryhelper.given_category_exists(course3)
material_group1 = materialgrouphelper.given_material_group_exists(user1)
material_group2 = materialgrouphelper.given_material_group_exists(user2)
material1 = materialhelper.given_material_exists(material_group1)
materialhelper.given_material_exists(material_group2)
homework1 = homeworkhelper.given_homework_exists(course1, category=category1, completed=True,
current_grade="20/30", materials=[material1])
homework2 = homeworkhelper.given_homework_exists(course2, category=category2, current_grade="-1/100")
homeworkhelper.given_homework_exists(course3, category=category3, completed=True, current_grade="-1/100")
reminder = reminderhelper.given_reminder_exists(user1, homework=homework1)
# WHEN
response = self.client.get(reverse('importexport_resource_export'))
data = json.loads(response.content.decode('utf-8'))
# THEN
course_group1 = CourseGroup.objects.get(pk=course_group1.pk)
course_group2 = CourseGroup.objects.get(pk=course_group2.pk)
course1 = Course.objects.get(pk=course1.pk)
course2 = Course.objects.get(pk=course2.pk)
category1 = Category.objects.get(pk=category1.pk)
category2 = Category.objects.get(pk=category2.pk)
self.assertEqual(response.status_code, status.HTTP_200_OK)
externalcalendarhelper.verify_externalcalendar_matches_data(self, external_calendar,
data['external_calendars'][0])
eventhelper.verify_event_matches_data(self, event1, data['events'][0])
eventhelper.verify_event_matches_data(self, event2, data['events'][1])
coursegrouphelper.verify_course_group_matches_data(self, course_group1, data['course_groups'][0])
coursegrouphelper.verify_course_group_matches_data(self, course_group2, data['course_groups'][1])
coursehelper.verify_course_matches_data(self, course1, data['courses'][0])
coursehelper.verify_course_matches_data(self, course2, data['courses'][1])
courseschedulehelper.verify_course_schedule_matches(self, course_schedule1, data['course_schedules'][0])
courseschedulehelper.verify_course_schedule_matches(self, course_schedule2, data['course_schedules'][1])
categoryhelper.verify_category_matches_data(self, category1, data['categories'][1])
categoryhelper.verify_category_matches_data(self, category2, data['categories'][0])
homeworkhelper.verify_homework_matches_data(self, homework1, data['homework'][0])
homeworkhelper.verify_homework_matches_data(self, homework2, data['homework'][1])
reminderhelper.verify_reminder_matches_data(self, reminder, data['reminders'][0])
def test_title_search_query(self):
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user, title='test1')
eventhelper.given_event_exists(user, title='test2')
response = self.client.get(
reverse('planner_events_list') + '?search=test1')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['title'], event.title)
def test_access_object_owned_by_another_user(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
event = eventhelper.given_event_exists(user1)
# WHEN
responses = [
self.client.get(
reverse('planner_events_detail', kwargs={'pk': event.pk})),
self.client.put(
reverse('planner_events_detail', kwargs={'pk': event.pk})),
self.client.delete(
reverse('planner_events_detail', kwargs={'pk': event.pk}))
]
# THEN
self.assertTrue(
Event.objects.filter(pk=event.pk, user_id=user1.pk).exists())
for response in responses:
if isinstance(response.data, list):
self.assertEqual(len(response.data), 0)
else:
self.assertEqual(response.status_code,
status.HTTP_404_NOT_FOUND)
def test_create_event_reminder(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
# WHEN
data = {
'title': 'some title',
'message': 'some message',
'offset': 1,
'offset_type': enums.HOURS,
'type': enums.POPUP,
'event': event.pk,
# Read-only fields, unused in the POST but used in the validation of this dict afterward
'start_of_range': (event.start - timedelta(hours=1)).isoformat(),
'sent': False,
'user': user.pk
}
response = self.client.post(reverse('planner_reminders_list'),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(Reminder.objects.count(), 1)
course = Reminder.objects.get(pk=response.data['id'])
reminderhelper.verify_reminder_matches_data(self, course, data)
reminderhelper.verify_reminder_matches_data(self, course,
response.data)
def test_update_event_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
# WHEN
data = {
'title': 'some title',
'all_day': True,
'show_end_time': False,
'start': '2016-05-08T12:00:00Z',
'end': '2016-05-08T14:00:00Z',
'priority': 12,
'comments': 'some comment',
'owner_id': '54321'
}
response = self.client.put(reverse('planner_events_detail',
kwargs={'pk': event.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertDictContainsSubset(data, response.data)
event = Event.objects.get(pk=event.pk)
eventhelper.verify_event_matches_data(self, event, response.data)
def test_patch_assumes_naive_datetime_to_utc(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
user.settings.time_zone = 'America/New_York'
user.settings.save()
event = eventhelper.given_event_exists(user)
# WHEN
data = {
'start': '2016-05-08 12:00:00',
'end': '2016-05-08 14:00:00',
}
response = self.client.patch(reverse('planner_events_detail',
kwargs={'pk': event.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
event = Event.objects.get(pk=event.pk)
start = timezone.make_aware(parser.parse(data['start']), pytz.utc)
end = timezone.make_aware(parser.parse(data['end']), pytz.utc)
self.assertEquals(event.start.isoformat(), start.isoformat())
self.assertEquals(event.end.isoformat(), end.isoformat())
def test_update_reminder_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
reminder = reminderhelper.given_reminder_exists(user, event=event)
# WHEN
data = {
'title': 'some title',
'message': 'some message',
'offset': 1,
'offset_type': enums.HOURS,
'type': enums.POPUP
}
response = self.client.put(reverse('planner_reminders_detail',
kwargs={'pk': reminder.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertDictContainsSubset(data, response.data)
reminder = Reminder.objects.get(pk=reminder.pk)
reminderhelper.verify_reminder_matches_data(self, reminder,
response.data)
def test_get_attachments(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
event1 = eventhelper.given_event_exists(user1)
event2 = eventhelper.given_event_exists(user2)
course_group1 = coursegrouphelper.given_course_group_exists(user1)
course_group2 = coursegrouphelper.given_course_group_exists(user2)
course1 = coursehelper.given_course_exists(course_group1)
course2 = coursehelper.given_course_exists(course_group2)
course3 = coursehelper.given_course_exists(course_group2)
homework1 = homeworkhelper.given_homework_exists(course1)
homework2 = homeworkhelper.given_homework_exists(course2)
attachmenthelper.given_attachment_exists(user1, course=course1)
attachmenthelper.given_attachment_exists(user2, course=course2)
attachmenthelper.given_attachment_exists(user2, course=course3)
attachmenthelper.given_attachment_exists(user2, course=course3)
attachmenthelper.given_attachment_exists(user1, event=event1)
attachmenthelper.given_attachment_exists(user2, event=event2)
attachmenthelper.given_attachment_exists(user2, event=event2)
attachmenthelper.given_attachment_exists(user1, homework=homework1)
attachmenthelper.given_attachment_exists(user2, homework=homework2)
attachmenthelper.given_attachment_exists(user2, homework=homework2)
# WHEN
response1 = self.client.get(reverse('planner_attachments_list'))
response2 = self.client.get(
reverse('planner_attachments_list') +
'?course={}'.format(course3.pk))
response3 = self.client.get(
reverse('planner_attachments_list') +
'?event={}'.format(event2.pk))
response4 = self.client.get(
reverse('planner_attachments_list') +
'?homework={}'.format(homework2.pk))
# THEN
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response2.status_code, status.HTTP_200_OK)
self.assertEqual(response3.status_code, status.HTTP_200_OK)
self.assertEqual(response4.status_code, status.HTTP_200_OK)
self.assertEqual(Attachment.objects.count(), 10)
self.assertEqual(len(response1.data), 7)
self.assertEqual(len(response2.data), 2)
self.assertEqual(len(response3.data), 2)
self.assertEqual(len(response4.data), 2)
def test_get_event_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
# WHEN
response = self.client.get(reverse('planner_events_detail',
kwargs={'pk': event.pk}))
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
eventhelper.verify_event_matches_data(self, event, response.data)
def test_range_query(self):
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
eventhelper.given_event_exists(
user,
start=datetime.datetime(2017, 5, 8, 16, 0, 0, tzinfo=timezone.utc),
end=datetime.datetime(2017, 5, 8, 17, 0, 0, tzinfo=timezone.utc))
event2 = eventhelper.given_event_exists(
user,
start=datetime.datetime(2017, 5, 8, 17, 0, 0, tzinfo=timezone.utc),
end=datetime.datetime(2017, 5, 8, 18, 0, 0, tzinfo=timezone.utc))
eventhelper.given_event_exists(
user,
start=datetime.datetime(2017, 5, 8, 18, 30, 0,
tzinfo=timezone.utc),
end=datetime.datetime(2017, 5, 8, 19, 0, 0, tzinfo=timezone.utc))
event4 = eventhelper.given_event_exists(
user,
start=datetime.datetime(2017, 5, 8, 19, 30, 0,
tzinfo=timezone.utc),
end=datetime.datetime(2017, 5, 8, 21, 0, 0, tzinfo=timezone.utc))
response = self.client.get(
reverse('planner_events_list') +
'?start__gte={}&end__lt={}'.format(quote(event2.start.isoformat()),
quote(event4.end.isoformat())))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 2)
def test_get_reminders(self):
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
event1 = eventhelper.given_event_exists(user1)
event2 = eventhelper.given_event_exists(user2)
course_group1 = coursegrouphelper.given_course_group_exists(user1)
course_group2 = coursegrouphelper.given_course_group_exists(user2)
course1 = coursehelper.given_course_exists(course_group1)
course2 = coursehelper.given_course_exists(course_group2)
course3 = coursehelper.given_course_exists(course_group2)
homework1 = homeworkhelper.given_homework_exists(course1)
homework2 = homeworkhelper.given_homework_exists(course2)
homework3 = homeworkhelper.given_homework_exists(course3)
homework4 = homeworkhelper.given_homework_exists(course3)
reminderhelper.given_reminder_exists(user1, homework=homework1)
reminderhelper.given_reminder_exists(user2, homework=homework2)
reminderhelper.given_reminder_exists(user2, homework=homework3)
reminderhelper.given_reminder_exists(user2, homework=homework4)
reminderhelper.given_reminder_exists(user2, homework=homework4)
reminderhelper.given_reminder_exists(user1, event=event1)
reminderhelper.given_reminder_exists(user2, event=event2)
reminderhelper.given_reminder_exists(user2, event=event2)
# WHEN
response1 = self.client.get(reverse('planner_reminders_list'))
response2 = self.client.get(
reverse('planner_reminders_list') + f'?homework={homework4.pk}')
response3 = self.client.get(
reverse('planner_reminders_list') + f'?event={event2.pk}')
# THEN
self.assertEqual(response1.status_code, status.HTTP_200_OK)
self.assertEqual(response2.status_code, status.HTTP_200_OK)
self.assertEqual(response3.status_code, status.HTTP_200_OK)
self.assertEqual(Reminder.objects.count(), 8)
self.assertEqual(len(response1.data), 6)
self.assertEqual(len(response2.data), 2)
self.assertEqual(len(response3.data), 2)
def test_delete_event_by_id(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
# WHEN
response = self.client.delete(reverse('planner_events_detail',
kwargs={'pk': event.pk}))
# THEN
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertFalse(Event.objects.filter(pk=event.pk).exists())
self.assertEqual(Event.objects.count(), 0)
def test_process_email_reminders(self, mock_send_multipart_email):
# GIVEN
user = userhelper.given_a_user_exists()
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
homework = homeworkhelper.given_homework_exists(course)
event1 = eventhelper.given_event_exists(user)
event2 = eventhelper.given_event_exists(
user,
start=datetime.datetime.now().replace(
tzinfo=pytz.timezone(user.settings.time_zone)) +
datetime.timedelta(days=1),
end=datetime.datetime.now().replace(
tzinfo=pytz.timezone(user.settings.time_zone)) +
datetime.timedelta(days=1, hours=1))
reminder1 = reminderhelper.given_reminder_exists(user,
type=enums.EMAIL,
event=event1)
reminder2 = reminderhelper.given_reminder_exists(user,
type=enums.EMAIL,
homework=homework)
# This reminder is ignored, as we're not yet in its send window
reminder3 = reminderhelper.given_reminder_exists(user,
type=enums.EMAIL,
event=event2)
# Sent reminders are ignored
reminderhelper.given_reminder_exists(user,
type=enums.EMAIL,
sent=True,
event=event1)
# WHEN
reminderservice.process_email_reminders()
# THEN
self.assertEqual(mock_send_multipart_email.call_count, 2)
self.assertTrue(Reminder.objects.get(pk=reminder1.pk).sent)
self.assertTrue(Reminder.objects.get(pk=reminder2.pk).sent)
self.assertFalse(Reminder.objects.get(pk=reminder3.pk).sent)
def test_create_bad_data(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
reminderhelper.given_reminder_exists(user, event=event)
# WHEN
data = {'offset': 'asdf'}
response = self.client.post(reverse('planner_reminders_list'),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('offset', response.data)
def test_update_bad_data(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
# WHEN
data = {
'start': 'not-a-valid-date'
}
response = self.client.put(reverse('planner_events_detail', kwargs={'pk': event.pk}),
json.dumps(data), content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('start', response.data)
def test_events_for_user(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(self.client, username='******',
email='*****@*****.**')
eventhelper.given_event_exists(user1)
eventhelper.given_event_exists(user2)
eventhelper.given_event_exists(user2)
eventhelper.given_event_exists(user2)
self.assertEqual(Event.objects.count(), 4)
# WHEN
response = self.client.delete(reverse('planner_events_resource_delete'))
# THEN
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(Event.objects.count(), 1)
self.assertEqual(Event.objects.for_user(user2.pk).count(), 0)
def test_update_start_before_end_fails(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
# WHEN
data = {
'start': '2016-05-08T12:00:00Z',
'end': '2016-05-07T14:00:00Z',
}
response = self.client.patch(reverse('planner_events_detail',
kwargs={'pk': event.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('must be before', response.data['non_field_errors'][0])
def test_update_read_only_field_does_nothing(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
reminder = reminderhelper.given_reminder_exists(user, event=event)
start_of_range = reminder.start_of_range
# WHEN
data = {'start_of_range': '2014-05-08T12:00:00Z'}
response = self.client.put(reverse('planner_reminders_detail',
kwargs={'pk': reminder.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
reminder = Reminder.objects.get(pk=reminder.id)
self.assertEqual(reminder.start_of_range, start_of_range)
def test_access_object_owned_by_another_user(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
event = eventhelper.given_event_exists(user1)
event_reminder = reminderhelper.given_reminder_exists(user1,
event=event)
course_group = coursegrouphelper.given_course_group_exists(user1)
course = coursehelper.given_course_exists(course_group)
homework = homeworkhelper.given_homework_exists(course)
reminderhelper.given_reminder_exists(user1, homework=homework)
# WHEN
responses = [
self.client.get(
reverse('planner_reminders_list') + f'?event={event.pk}'),
self.client.get(
reverse('planner_reminders_list') +
f'?homework={homework.pk}'),
self.client.get(
reverse('planner_reminders_detail',
kwargs={'pk': event_reminder.pk})),
self.client.put(
reverse('planner_reminders_detail',
kwargs={'pk': event_reminder.pk})),
self.client.delete(
reverse('planner_reminders_detail',
kwargs={'pk': event_reminder.pk}))
]
# THEN
self.assertTrue(
Reminder.objects.filter(pk=event_reminder.pk,
user_id=user1.pk).exists())
for response in responses:
if isinstance(response.data, list):
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 0)
else:
self.assertEqual(response.status_code,
status.HTTP_404_NOT_FOUND)
def test_update_reminder_parent_updates(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
homework = homeworkhelper.given_homework_exists(course)
event = eventhelper.given_event_exists(user)
reminder = reminderhelper.given_reminder_exists(user, event=event)
# WHEN
data = {'homework': homework.pk}
response = self.client.patch(reverse('planner_reminders_detail',
kwargs={'pk': reminder.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['homework'], homework.pk)
self.assertIsNone(response.data['event'])
def test_patch_converts_to_utc(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
# WHEN
data = {
'start': '2016-05-08T12:00:00-0500',
'end': '2016-05-08T14:00:00-0500',
}
response = self.client.patch(reverse('planner_events_detail',
kwargs={'pk': event.pk}),
json.dumps(data),
content_type='application/json')
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
event = Event.objects.get(pk=event.pk)
self.assertEquals(event.start.isoformat(), parser.parse(data['start']).astimezone(timezone.utc).isoformat())
self.assertEquals(event.end.isoformat(), parser.parse(data['end']).astimezone(timezone.utc).isoformat())
def test_get_events(self):
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(self.client, username='******',
email='*****@*****.**')
eventhelper.given_event_exists(user1)
eventhelper.given_event_exists(user2)
eventhelper.given_event_exists(user2)
# WHEN
response = self.client.get(reverse('planner_events_list'))
# THEN
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(Event.objects.count(), 3)
self.assertEqual(len(response.data), 2)
def test_parent_change_triggers_reminder_update(self):
# GIVEN
user = userhelper.given_a_user_exists()
event = eventhelper.given_event_exists(user)
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
homework = homeworkhelper.given_homework_exists(course)
reminder1 = reminderhelper.given_reminder_exists(user, event=event)
reminder2 = reminderhelper.given_reminder_exists(user, homework=homework)
# WHEN
event.start = datetime.datetime(2019, 5, 8, 12, 0, 0, tzinfo=timezone.utc)
event.save()
homework.start = datetime.datetime(2019, 1, 8, 10, 0, 0, tzinfo=timezone.utc)
homework.save()
# THEN
reminder1 = Reminder.objects.get(pk=reminder1.id)
reminder2 = Reminder.objects.get(pk=reminder2.id)
self.assertEqual(reminder1.start_of_range, datetime.datetime(2019, 5, 8, 11, 45, 0, tzinfo=timezone.utc))
self.assertEqual(reminder2.start_of_range, datetime.datetime(2019, 1, 8, 9, 45, 0, tzinfo=timezone.utc))
def test_access_object_owned_by_another_user(self):
# GIVEN
user1 = userhelper.given_a_user_exists()
user2 = userhelper.given_a_user_exists_and_is_authenticated(
self.client, username='******', email='*****@*****.**')
event = eventhelper.given_event_exists(user1)
course_group1 = coursegrouphelper.given_course_group_exists(user1)
course_group2 = coursegrouphelper.given_course_group_exists(user2)
course1 = coursehelper.given_course_exists(course_group1)
coursehelper.given_course_exists(course_group2)
homework = homeworkhelper.given_homework_exists(course1)
attachment1 = attachmenthelper.given_attachment_exists(user1,
course=course1)
attachmenthelper.given_attachment_exists(user1, homework=homework)
attachmenthelper.given_attachment_exists(user1, event=event)
# WHEN
responses = [
self.client.get(
reverse('planner_attachments_list') +
'?course={}'.format(course1.pk)),
self.client.get(
reverse('planner_attachments_list') +
'?event={}'.format(event.pk)),
self.client.get(
reverse('planner_attachments_list') +
'?homework={}'.format(homework.pk)),
self.client.delete(
reverse('planner_attachments_detail',
kwargs={'pk': attachment1.pk}))
]
# THEN
for response in responses:
if isinstance(response.data, list):
self.assertEqual(len(response.data), 0)
else:
self.assertEqual(response.status_code,
status.HTTP_404_NOT_FOUND)
def test_create_reminder_multiple_parents_fails(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
course_group = coursegrouphelper.given_course_group_exists(user)
course = coursehelper.given_course_exists(course_group)
homework = homeworkhelper.given_homework_exists(course)
event = eventhelper.given_event_exists(user)
# WHEN
data = {
'title': 'some title',
'message': 'some message',
'start_of_range': '2014-05-08T12:00:00Z',
'offset': 1,
'offset_type': enums.HOURS,
'type': enums.POPUP,
'homework': homework.pk,
'event': event.pk,
}
response = self.client.post(reverse('planner_reminders_list'), data)
# THEN
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertIn('Only one of', response.data['non_field_errors'][0])
def test_create_event_attachment(self):
# GIVEN
user = userhelper.given_a_user_exists_and_is_authenticated(self.client)
event = eventhelper.given_event_exists(user)
tmp_file = attachmenthelper.given_file_exists()
# WHEN
with open(tmp_file.name) as fp:
data = {'event': event.pk, 'file[]': [fp]}
response = self.client.post(reverse('planner_attachments_list'),
data)
# THEN
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['title'],
os.path.basename(tmp_file.name))
self.assertEqual(response.data[0]['size'],
os.path.getsize(tmp_file.name))
self.assertEqual(response.data[0]['event'], data['event'])
self.assertEqual(Attachment.objects.count(), 1)
attachment = Attachment.objects.get(pk=response.data[0]['id'])
attachmenthelper.verify_attachment_matches_data(
self, attachment, response.data[0])
